# plantandsteal_truthful_fair_allocations_via_predictions__840eba45.pdf

Plant-and-Steal: Truthful Fair Allocations via Predictions

Ilan Reuven Cohen Bar-Ilan University ilan-reuven.cohen@biu.ac.il

Alon Eden The Hebrew University alon.eden@mail.huji.ac.il

Talya Eden Bar-Ilan University talyaa01@gmail.com

Arsen Vasilyan UC Berkeley arsen@berkeley.edu

We study truthful mechanisms for approximating the Maximin-Share (MMS) value of agents with additive valuations for indivisible goods. Algorithmically, constant factor approximations exist for the problem for any number of agents. When adding incentives to the mix, a jarring result by Amanatidis, Birmpas, Christodoulou, and Markakis [EC 2017] shows that the best possible approximation for two agents and m items is m

2 . We adopt a learning-augmented framework to investigate what is possible when a prediction on the input is given. For two agents, we give a truthful mechanism that takes agents ordering over items as prediction. When the prediction is accurate, our mechanism gives a 2-approximation to the MMS (consistency), and when the prediction is off, our mechanism still obtains an m

2 - approximation to the MMS (robustness). We further show that the mechanism s performance degrades gracefully in the number of mistakes in the prediction; i.e., we interpolate between the two extremes: when there are no mistakes, and when there is a maximum number of mistakes. We also show an impossibility result on the obtainable consistency for mechanisms with finite robustness. For the general case of n 2 agents, we give a 2-approximation mechanism for accurate predictions, with relaxed fallback guarantees. Finally, we give experimental results which illustrate when different components of our framework, made to ensure consistency and robustness, come into play.

1 Introduction

Allocating items among self interested agents in a fair" way is an age-old problem, with many applications such as splitting inheritance and allocating courses to students. As a starting point, consider the case of two agents. When the items are divisible, the famous cut-and-choose procedure achieves fairness in two senses. Firstly, no agent wants to switch their allocation with the other; i.e., there is no envy among the agents. Secondly, each agent gets a bundle of items which they value at least as much as their value for all the items divided by 2; that is, each one gets their fair share". When moving to the case of indivisible goods, which is relevant to scenarios such as splitting inheritance and allocating courses, things get trickier. For instance, if there s a single item, the agent that does not receive that item does not get an envy-free allocation, nor do they get their fair share" according to the previous definitions. Therefore, it is clear that some fairness needs to be sacrificed in this case.

The study of fair allocations with indivisible goods has been a fruitful research direction, with many meaningful notions of fairness studied (see survey by Amanatidis et al. [10]). In this paper, we

38th Conference on Neural Information Processing Systems (Neur IPS 2024).

focus on the notion of the Maximin Share, or MMS, introduced by Budish [18]. For two agents, this notion captures the value an agent will ensure if we implement the cut-and-choose procedure. That is, assume Alice splits the items into two bundles, and then Bob takes one of them (adversarially), and Alice gets the second one. The MMS captures exactly how much value Alice can guarantee for herself. Generalizing the notion for n agents is pretty straightforward the MMS is the minimum value Alice can guarantee for herself when she partitions the items into n bundles, assuming n 1 bundles are taken adversarially.

We study the case where agents have additive valuations over goods.1 For the case of two agents, the allocation produced by the cut-and-choose procedure guarantees each of the agents their MMS value. For more than two agents, the existence of such an allocation is not longer guaranteed. Kurokawa et al. [30] show an instance of three agents, where in every allocation, at least one of the agents does not get their MMS value. Since allocating all the agents their MMS value is not always feasible, various papers studied the existence of approximately optimal allocation. An allocation is an α-approximate MMS allocation for α > 1 if every agents gets at least an 1/α fraction of their MMS value. Feige et al. [22] introduce an instance where one cannot find an α-approximate allocation for α < 40

39. On the other hand, [30] show there always exists 3

2-approximation. The 3

2 factor was gradually improved [16, 24, 23, 8, 4, 3, 5], where the state-of-the-art algorithm achieves an approximation of 959/720 < 4/3 [3]. Adding incentives to the mix further complicates matters.

Amanatidis et al. [7] study the case of two additive agents, and m items, where the algorithm (or mechanism) does not know the values of the agents. Thus, the algorithm s designer is faced with the task of devising an allocation rule such that (i) agents will maximize their allocated value by bidding truthfully, and (ii) the resulting allocation is an α-approximate MMS allocation for an α close to 1 as possible. [7] show that no incentive-compatible algorithm can approximate the MMS to a factor better than m

2 , and this is matched by the following trivial mechanism the first agent picks their favorite item, and the second agent gets the rest.

For 2 < n < m,2 a trivial truthful algorithm that lets the first n 1 agents pick a single item in some order and gives the last agent the rest achieves an m n+2

2 -approximation, and no better mechanism is known. It is conjectured that one cannot drop the dependence in m for n > 2. We are left with a stark disparity. On the one hand, assuming agents values are public information, approximate solutions are known to exist. On the other hand, when considering private values, it seems that only trivial approximations are possible. The goal of this paper is to bridge these two regimes using predictions.

We study the problem of truthful allocations that approximate the MMS, taking a learning-augmented point of view. In the learning-augmented framework, the algorithm designer aims to tackle some intrinsic hardness of the problem at hand, which might arise due to computational constraints, space constraints, input arriving piecemeal online, or incentive constraints, among others. To help the designer overcome these constraints, the algorithm is given some side information which is a function of the input, or a prediction, in order to improve the algorithm s performance. The hope is that if the prediction is accurate, then the performance is greatly improved over the performance without the prediction (termed consistency). On the other end, if the prediction is inaccurate then the performance of the algorithm is comparable to the performance of the best algorithm that is not given access to predictions (termed robustness). The learning-augmented framework has proven useful in bypassing impossibilities that arise due to incentive issues [14, 1, 25, 15, 40, 33, 13].

When designing a learning-augmented mechanism, one should think of realistic predictions. For instance, predicting the entire valuation profile of all agents seems to be a strong assumption. A more plausible assumption is to have some ordinal ranking over the items of the agents. Indeed, it seems unlikely that the algorithm can accurately predict Alice s value for a car, but it is plausible that the algorithm can guess that Alice values the car more than she values the table. Ideally, the algorithm s performance should remain robust if the predicted ordering is almost perfect, with only a few pairs of items whose real ordering is swapped in the prediction. Another desired property is to make the prediction as space-efficient as possible, as previous results [20, 31, 32] show that succinct predictions are crucial for learning parameters from few samples and for incorporating a PAC-learnable component in the learning-augmented framework.

1Agent i with an additive valuation has a value vij = vi(j) for every item, and their value for bundle S is vi(S) = P

j S vij. 2For n > m, the MMS of each agent is trivially 0. The problem becomes more interesting for m n.

In this paper we devise learning-augmented truthful mechanisms for the problem of approximate MMS allocations, while taking into considerations the concerns mentioned above.

Our Results. We start by studying the two agent case. We aim at getting: (a) Constant consistency: when the predictions are accurate, we want to get a constant approximation to the MMS. (b) Nearoptimal robustness: when the predictions are off, we want to get as close as possible to the optimal m

2 -approximation we can obtain by truthful mechanisms [7].

Plant-and-Steal Framework. In Section 3 we present a framework for devising learningaugmented mechanisms for approximating the MMS with two agents. As using only predictions does not guarantee any robustness, we use reports to ensure each agent gets at least one valuable item. This is done while maintaining a near-optimal allocation according to predictions. Our framework, which we term Plant-and-Steal, is modular. Along with the set of goods and the agents reports, it also receives a prediction and an allocation procedure. Different combinations of predictions and allocation procedures yields different consistency-robustness tradeoffs. It is worth noting that, although privacy is not the primary focus of this paper, the Plant-and-Steal framework uses agents reports in a minimal way, as they are only required to select (i.e. steal back ) a single item from a predefined set of options, where this set is determined by the predictions, and not the actual reports.

Ordering Predictions. In Section 4, we study learning-augmented mechanisms when the predictions given are preference orders over items of the agents, rather than the values. We instantiate the Plant-and-Steal framework with a Round-Robin-based allocation procedure. We observe that in the case of two agents, Round-Robin obtains 2-approximation to the MMS. The 2-consistency of using Plant-and-Steal with Round-Robin as the allocation procedure almost immediately follows. The m

2 robustness follows two facts: (a) Round-Robin produces allocations that are balanced in the number of items allocated to each agent; and (b) The Plant-and-Steal framework ensures each agent gets one of their 2 favorite items according to reports. In Appendix E, we show how to get an improved 3

2 consistency, while maintaining O(m) robustness when using a modified Round-Robin allocation procedure.

In Sec 5, we then study the performance of the Plant-and-Steal framework when using the Round-Robin procedure, when the prediction given is not fully accurate, but accurate to some degree. To quantify the prediction s accuracy, we adopt the Kendall tau distance measure. The Kendall tau distance counts the number of pairs of elements swapped in the predicted preference order and the order induced by the true valuations. We show that combining the Plant-and-Steal framework with a Round-Robin allocation procedure obtains O(

d)-approximation to the MMS when the Kendall tau distance is d. Since d goes from 0 to m 2 = Θ(m2), we recover the constant consistency when there are no errors, and the O(m) robustness when the number of errors is maximal.

General Predictions. In Appendix G, we study the two-agent case where the mechanism is given access to predictions which are not necessarily the preference order of the agents. We first show that for any prediction given to the learning-augmented mechanism, no mechanism can simultaneously be α-consistent while maintaining finite robustness for α < 6/5. For the proof, we leverage the characterization of two-agent truthful mechanisms by [7].

We then study small-space predictions. The Round-Robin-based mechanisms described above require an Ω(m)-bit prediction (to describe an arbitrary allocation of items). We first notice that we can implement a bag-filling type allocation procedure using O(log m)-bit predictions. This already achieves a constant consistency along with O(m) robustness. We then devise a more refined allocation procedure, which requires O(log m/ϵ)-bit predictions, and achieves 2 + ϵ consistency along with m

2 robustness.

General number of agents n. In Appendix H, we devise a learning-augmented truthful mechanism for n 2 additive agents. We obtain a 2-consistent mechanism, while relaxing the robustness guarantees of the mechanism. We take a similar approach to the work of [18, 27, 28, 2, 5], who compete against a relaxed benchmark of the MMS value for ˆn > n agents, and try to minimize ˆn. We obtain an max{m ˆn 1, 1}-approximation to the MMS for ˆn = 3n

2 agents when the predictions are off. Our mechanism uses the modified Round-Robin procedure from [8] to determine the initial

allocation using the predictions. It then applies a recursive plant-and-steal procedure to determine the final allocation.

Experiments. Finally, In Section 6, we demonstrate how several components in our design come into play when experimenting with synthetic data. We run different variants of mechanism on two player instances, and show that when predictions are accurate, then only using predictions is nearly optimal, if predictions are noisy, then the stealing component ensures robustness, and our Plant-and-Steal framework achieves best-of-both-worlds guarantees.

We summarize the bounds we obtain in Table 1.

Setting Consistency Robustness Reference

Ordering predictions, n = 2

2 m/2 Section 4 3/2 2m/3 Section 4 5/4 Any [6] Arbitrary predictions, n = 2

Any m/2 [7]

6/5 Bounded Section G.1

3 log m + 1 space 4 m 1 Section G.2 O(log(m)/ϵ) space 2 + ϵ m/2 Section G.3 n > 2 2 m 3n/2 1 for ˆn = 3n/2

Table 1: Known bounds for truthful learning-augmented MMS mechanisms.

Further Related Work. In addition to the the studies mentioned above, we give a comprehensive review of further related work in Appendix B.

2 Preliminaries

In the setting we study, there is a set N of n agents and a set M of m indivisible items. Each agent has a private additive valuation over the items, unknown to the mechanism designer, where the value of agent i for item j is vij (also denoted as vi(j)). For a bundle S M of items, vi(S) = P

The fairness notion we focus on is the following. Definition 2.1 (Maximin Share). The Maximin Share (MMS) of agent i with valuation vi and n agents is µn i = max S1 S ... S Sn=M min j [n] vi(Sj);

that is, if i were to partition the items into n bundles, and then n 1 of those bundles are taken adversarially, what is the value i can guarantee for themselves. When clear from the context, we omit n and use µi to denote the MMS of i with n agents.

We are interested in mechanisms that produce approximately optimal allocations, as defined next. Definition 2.2 ((γ, k)-approximate MMS Allocation). An allocation X = (X1, . . . , Xn) is (γ, k)- approximate MMS allocation for γ > 1 and a natural number k if for every agent i,

vi(Xi) µk i /γ.

When k = n, we say the allocation is a γ-approximate MMS allocation.

We study mechanism that get some prediction on the input. Definition 2.3 (Learning-Augmented Mechanism). A learning-augmented mechanism takes agents reports r = (r1, . . . , rn) and predictions p in some prediction space P, and outputs a partition of the items

X(r, p) = (X1(r, p), X2(r, p), . . . , Xn(r, p)), X1(r, p) [ X2(r, p) [ . . . [ Xn(r, p) = M,

where agent i gets Xi(r, p).

For learning-augmented mechanisms, truthfulness should hold for any possible prediction p.

Definition 2.4. A learning-augmented mechanism is truthful if for every agent i and every possible report of other agents r i and every possible prediction p,

vi(Xi(vi, r i, p)) vi(Xi(ri, r i, p))

for every ri.

We next define the consistency and robustness measures according to which we measure the performance of our mechanisms.

Definition 2.5 (α-consistency). Consider a prediction function f P which takes a valuation profile and outputs a prediction in prediction space P. A learning-augmented mechanism is α-consistent for α > 1 and prediction function f P if for every valuation profile v and every prediction p = f P(v), X(v, p) is an α-approximate MMS allocation.

Definition 2.6 ((β, k)-robust). A learning-augmented mechanism is (β, k)-robust for β > 1 and natural number k if for every valuation profile v and every prediction p, X(v, p) is an (β, k)- approximate MMS allocation. If k = n, we say the mechanism is β-robust.

For ease of presentation, for valuation vi, report ri and prediction pi, we use vℓ i, rℓ i, pℓ i to denote both the ℓth highest good according to the valuation/report/prediction and its value. Note that, we may use vℓ i for ℓ> m, in this case, vℓ i = 0. For ℓ= 1, i.e., the highest good we use v i , r i , p i .

Ordering Predictions and Kendall tau Distance. Most of our mechanisms use predictions which take the form of an ordering over agents items. That is, f P(v) outputs a vector of orderings p = (p1, . . . , pn), where pℓ i is the ℓth highest valued item of i in M according to p. Accordingly, for agent i, let vℓ i be the ℓth highest valued item according to v. For two items j = j , We use j pi j to denote that j is higher ranked than j according to p.

When studying imprecise predictions, we want to quantify the degree to which the prediction is inaccurate. For this, we use the following measure. For an agent i, we define our noise level with respect to the Kendall tau distance (also known as bubble-sort distance) between v and p.

Definition 2.7 (Kendall tau distance). The Kendall tau distance counts the number of pairwise disagreements between two orders. For i s valuation vi and predicted preference order pi, we define

Kd(vi, pi) = |{j pi j : vi(j) < vi(j )}.

That is, the number of pairs of items where the prediction got their relative ordering wrong. We also denote Kd(v, p) = max{Kd(v1, p1), Kd(v2, p2)}.

We note that the Kendall tau distance between vi and pi, Kd(vi, pi), can go from 0 to m 2 .

3 Plant-and-Steal Framework

In this section, we present the framework which is used to devise learning-augmented mechanisms for two agents. The ideas presented here also inspire the more complex learning-augmented mechanism for n > 2 agents. Missing proofs of this section appear in Appendix C. Our framework, which we term Plant-and-Steal is given the set of goods, an allocation procedure A, the prediction p and reports v. The framework operates as follows:

1. It first applies A on the predictions p to divide the set of goods into two bundles A1, A2. The procedure A should be an allocation procedure with good MMS guarantees. We use different allocation procedures depending on the type of prediction given and on the consistency-robustness tradeoffs we are aiming for. 2. Planting phase: For each agent i, it picks i s favorite item in set Ai according to prediction, and plants this item in the bundle Aj of the other agent j = i. Let T1, T2 denote the sets that result in this planting phase. 3. Stealing phase: To obtain the final allocation, each agent i now steals back their favorite item from set Tj of agent j = i according to reports. Notice this is the first and only place where we use agents reports.

This procedure is trivially truthful because the only step where we use agents reports is the one where they pick exactly one item to steal back from Tj, and this Tj only depends on predictions, and not reports (Lemma 3.1). To obtain robustness, we notice that each agent gets one of their two favorite items according to their true valuations (Lemma 3.2). This implies a robustness of m 1. We show that for balanced allocations, we get improved robustness guarantees (Lemma 3.4).

For S M, and agent i, let v i (S) (p i (S),r i (S)) be the max valued item in S according to vi (pi, ri). for g M and S M, denote S + g := S {g} and S g = S \ {g}. The Plant-and-Steal framework is presented in Mechanism 1.

MECHANISM 1: Two agent Plant-and-Steal Framework Input :Allocation Procedure A, set of items M, predictions p and reports r Output :Allocations X1 S X2 = M

/* Find an initial allocation by applying A on the predictions */ (A1, A2) := A(M, N, p)

/* Plant favorite items according to predictions */ ˆj1 p 1(A1) ˆj2 p 2(A2) T1 A1 + ˆj2 ˆj1 T2 A2 + ˆj1 ˆj2

/* Steal according to report */ j1 r 1(T2) j2 r 2(T1) X1 T1 + j1 j2 X2 T2 + j2 j1

We show that for any allocation function A and predictions p given to the framework, the resulting mechanism is truthful.

Lemma 3.1 (Truthfulness Lemma). For any allocation procedure A, Plant-and-Steal mechanism using A is truthful.

Since the framework is truthful, from now on, we assume that r = v. Next, we show that the Plant-and-Steal mechanism ensures that for each agent, an item is allocated with a value that is at least as good as their second-best option according to their value.

Lemma 3.2. Consider the allocation (X1, X2) returned by Plant-and-Steal with some allocation procedure A. For any agent i, then v1 i Xi or v2 i Xi.

We next claim that if i gets one of their two favorite items and any k 1 additional items, i s value is an m k-approximation to µi. Lemma 3.3. For any agent i, let S M be a subset of the items of size |S| = k and v1 i S or v2 i S then vi(S) µi/(m k).

We immediately get the following. Lemma 3.4 (Robustness Lemma). Let A be an allocation rule guaranteeing min{|A1|, |A2|} k, then when Plant-and-Steal uses A, the resulting mechanism is (m k)-robust.

Proof. By Lemma 3.2, we are guaranteed that each agent gets one of their two favorite items according to their report. Combining with the condition on A and Lemma 3.3, the proof is finished.

4 Ordering Predictions

In this section, we consider the case of two agents, where the predictions (and in fact, also the reports) given to the mechanism are preference orders of agents over items. Our mechanisms makes use of the Plant-and-Steal framework instantiated by Round-Robin based allocation procedures. We

first present the round-robin allocation procedures we ll use, and give their approximation guarantees when the input is accurate. Next, we prove the robustness and consistency guarantees. Finally, we quantify the accuracy of the predictions using the Kendall tau distance, and obtain fine-grained approximation results, where the approximation smoothly degrades in the accuracy.

Amanatidis et al. [6] studied mechanisms where the preference orders of the agents over items are public (while valuations are private). They showed that no truthful mechanism can achieve a better approximation than 5/4 in this setting. This implies that when the predictions are preference orders, no learning-augmented mechanism can obtain consistency better than 5/4, no matter if the robustness is bounded or not. Proposition 4.1 (Corollary of Amanatidis et al. [6]). For any ϵ > 0, no mechanism that is given preference orders as predictions can obtain consistency 5/4 ϵ.

Round-Robin Allocation Procedures. The two allocation procedures we use to instantiate the Plant-and-Steal framework take as input preference orders of agents over items:

Balanced-Round-Robin: the agents take turns, and at each turn, an agent takes their highest ranked remaining item. This results in a balanced allocation. 1-2-Round-Robin: the agents take turns, where we compensate the second agent, who might not get their favorite item, to take two items each turn.

In this section, we only prove consistency-robustness guarantees when Balanced-Round-Robin is used as the allocation procedure. In Appendix E we show different tradeoffs when 1-2-Round-Robin is used.

ALGORITHM 2: Balanced-Round-Robin Input :Preference orders of agents over items v = (v1, v2). Output :An allocation A1 S A2 = M. Ai for every agent i {1, 2} for r = 1, . . . , |M|/2 do A1 A1 + v 1(M \ A1 \ A2) A2 A2 + v 2(M \ A1 \ A2)

Consider the allocation procedure depicted in Algorithm 2. In order to implement the two allocation procedures, we only needs to receive preference orders over items. Let Ai = (a1 i , . . . , a|Ai| i ) be agent i s allocation by the algorithm, where ak i is the k th choice of agent i. We observe the following. Observation 4.1. The output (A1, A2) of the Balanced-Round-Robin procedure, satisfies:

1. |A1| = m

2 , |A2| = m

2 . 2. For each agent i and round k, ak i {vℓ i}ℓ [2k]; that is, in round k an agent gets one of their top 2k items.

Amanatidis et al. [8] show that first allocating large items to agents, and then using a Round-Robin to allocate the remaining items to the remaining agents, gives a 2-approximation to the MMS. We observe that for two agents, Round-Robin as is, without the initial step, achieves this approximation guarantee. The proof of the following Lemma is deferred to Appendix D. Lemma 4.1. Let (A1, A2) be the allocation of Balanced-Round-Robin. For every agent i, vi(Ai) µi/2.

We next use the allocation procedure to instantiate the Plant-and-Steal framework.

Round-Robin-Based Mechanism. The mechanism we analyze, B-RR-Plant-and-Steal, results from instantiating Plant-and-Steal with Balanced-Round-Robin as A.

We first show that if the predictions correspond to the preference orders of the real valuations, then B-RR-Plant-and-Steal outputs the same allocation as Balanced-Round-Robin. Lemma 4.2. When predictions correspond to actual values, B-RR-Plant-and-Steal outputs the same allocation as Balanced-Round-Robin.

We are now ready to prove the performance guarantees of our mechanisms.

Theorem 4.1. Mechanism B-RR-Plant-and-Steal is truthful, 2-consistent and m

Proof. By Lemma 3.1, the mechanism is truthful. By Observation 4.1, each agent receives at least m/2 items; combining with Lemma 3.4, we get that the mechanism is m

2 -robust. Finally, if predictions correspond to valuations, by Lemma 4.1 and Lemma 4.2, the allocation is a 2-approximation to the MMS. Thus, the mechanism is 2-consistent.

We note that by Amanatidis et al. [7], our robustness guarantee matches the optimal obtainable approximation by any truthful mechanism (up to the rounding).

5 Noisy Predictions

We now analyze Mechanism B-RR-Plant-and-Steal s performance under varying levels of noise. Consider the case where the Kendall tau distance between v and p is at most d. Our main theorem in this section shows that combining the Plant-and-Steal framework with a Round-Robin allocation procedure obtains O(

d)-approximation to the MMS when the Kendall tau distance is d. Missing proofs of this section appear in Appendix F.

To prove the approximation ratio, we relate the value that agent i obtains from the allocation, vi(Xi), to their maximin share, µi, by considering the worst possible set of items that agent i might receive under the Round-Robin procedure when acting on their true preferences. Specifically, we define this worst-case set as Ri = {v2j i }j {1,..., m/2 }. In Eq. (2) of Lemma 4.1, we prove that vi(Ri) µi/2. Therefore, obtaining an allocation that is a factor of c times vi(Ri) ensures a factor of c/2 of the MMS value.

We further simplify the analysis by applying the zero-one principle3. The zero-one principle basically let s us reduce the analysis to instances where the values are either 0 s or 1 s. For threshold τ 0, let hτ(q) = 1 if q τ and 0 otherwise, and let vτ i (S) = P

j S hτ(vi(j)).

By the zero-one principle, for two sets S, T M, in order to show that vi(S) approximates vi(T), it is enough to show that vτ i (S) approximates vτ i (T) for every threshold τ 0.

Lemma 5.1. For c > 1 and for any two sets S, T M, if for every threshold τ 0, vτ i (S) vτ i (T)/c, then vi(S) vi(T)/c.

Thus, we will show that when the Kendall tau distance is d, for every threshold τ 0, vτ i (Xi) vτ i (Ri)/c for some c = O(

d). Recall that Ai is the set of items assigned to i after running the Round-Robin procedure on the predictions p. We first show that for Kendall tau distance d, the additive approximation vτ i (Ai) gives to vτ i (Ri) is

Lemma 5.2. If the Kendall tau distance between p and v is at most d, then for any threshold τ 0, we have that vτ i (Ai) vτ i (Ri)

We note that although vτ i (Ai) gives an additive approximation to vτ i (Ri), it can still be the case that the Kendall tau distance is constant, yet vi(Ai) does not give any multiplicative approximation to µi.4 Therefore, we must use the fact that agent i gets to steal an item according to their true valuation in the Plant-and-Steal procedure in order to get our approximation guarantee. By combining these results, we prove the following theorem concerning the approximation ratio of B-RR-Plant-and-Steal s performance under varying levels of noise, d. 5

Theorem 5.1. Consider a prediction p and valuations v such that Kd(v, p) = d, then Mechanism B-RR-Plant-and-Steal gives a (2

d + 6)-approximation to the MMS.

3Applied in [11], for instance, in the context of packet routing. 4Indeed, consider the case where there are four goods which both agents value at (1, 1, 0, 0). If agent i s prediction orders the last two items higher then the first two items, we will get that vi(Ai) = 0, while µi = 1. 5A similar analysis for Mechanism 1-2-RR-Plant-and-Steal will show a similar dependence on

d (up to constant factors).

6 Experimental Results

In this section6, we give experiments which illustrate the role of different components of our framework for two players under various noise levels of the predictions. The predictions we use for our experiments are the predicted values of the items. The noise we introduce permutes the vectors of values to match the instance s Kendall tau distance, and uses the permuted vector as prediction. We show that our framework is almost optimal for small amounts of noise while still showing resilience for higher noise levels. Moreover, we study the performance of variants which only use specific components of our framework.

When using predictions, our initial allocation procedure is a cut-and-choose procedure, implemented as follows:

We use the first player s prediction to implement a bag-filling algorithm which sorts the items by values, and then partitions the items into two sets using a greedy procedure that assigns each item to the set with current lowest value. We use the second player s prediction to allocate the agent the set with the higher predicted value of the two.

This allocation ensures that the second agent obtains their MMS value according to the prediction. In the data we generates, we observe that in a sampled valuation, the two sets chosen by the bag-filling algorithm gives the two sets the same value, up to 0.5%, which ensures that the lowest valued set obtains a 1.026-approximation to the MMS.

We inspect the following mechanisms:

1. Random: a mechanism that ignores reports and predictions and randomly partitions the items into two sets of size m/2. 2. Random-Steal: a mechanism that ignores predictions, randomly partitions the items into two sets of size m/2, and then implements the stealing phase where each player takes their favorite item from the other player s set according to reports. 3. Partition: a mechanism that ignores reports, and partitions the items according to predictions, using the cut-and-choose procedure described above. 4. Partition-Steal: a mechanism that partitions the items according to predictions, using the cut-and-choose procedure described above, and then implements the stealing phase where each player takes their favorite item from the other player s set according to reports. 5. Partition-Plant-Steal: a mechanism that implements the Plant-and-Steal framework. partitions the items according to predictions, using the cut-and-choose procedure described above, plants each player s favorite item according to predictions, and then steals each player s favorite item from the other player s set according to reports.

Experiments. We consider two-player scenarios with m = 100 items. For each distance measure, we generate 1000 valuation profiles. For each pair of valuation profiles and corresponding Kendall tau distance, we generate 100 predictions based on the distance. We then assess the performance of the mechanisms described earlier on these instances. We examine two distinct cases regarding the relationship between the players preference orders: the Correlated case, where both players have identical preference orders, although their valuation magnitudes differ, and the Uncorrelated case, where the preference orders of the players are generated independently and chosen uniformly at random. Further details on the procedures used to generate the valuations and predictions are provided in Appendix A.

Benchmark. We plot the percentage of these instances where both players get at least (1 ϵ) of their MMS value for ϵ = 0.1, 0.05, 0.02.

Results. The results are shown in Figure 1. We first examine the performance of the two mechanisms that do not use predictions, Random and Random-Steal. Scenarios with correlated values perform significantly worse, as there is a non-negligible probability of an unbalanced partition of the relatively few high and medium valued items in a random partition. For ϵ values of 0.02, 0.05, 0.1, the Random strategy success rate is 11%, 25%, and 43%, respectively, under correlated preferences, compared

6The experiments, reproducible via Matlab (2022b) at https://tinyurl.com/Plant Steal Experiments, were performed on a standard PC (Intel i9, 32GB RAM) in about 30 minutes.

1 5 10 40 160 640 2,560 0

1 5 10 40 160 640 2,560 0

1 5 10 40 160 640 2,560 0

1 5 10 40 160 640 2,560 0

Kendall tau distance

Uncorrelated

1 5 10 40 160 640 2,560 0

Kendall tau distance

1 5 10 40 160 640 2,560 0

Kendall tau distance

Figure 1: Mechanisms: Random (yellow), Random-Steal (cyan), Partition (red), Partition-Steal (green), Partition-Plant-Steal (blue). Data generation: correlated (first row) and uncorrelated (second row). Success rate: the percentage of instances where both players receive at least (1 ϵ)-fraction of their MMS values for different values of ϵ: 0.02 (first column), 0.05 (second column), and 0.1 (third column).

to 33%, 43%, and 60% under uncorrelated preferences. Moreover, adding the stealing component significantly improves the success rate only in the uncorrelated case, as Random-Steal achieves success rates of 66%, 75%, and 87%. In the correlated case, as each player has a highly valuable item stolen, their obtained value is not expected to increase.

In the mechanisms that use predictions, Partition, Partition-Steal and Partition-Plant-Steal, the performance degrades as a function of noise, as expected. When comparing the performance of Partition, which only relies on the prediction component of our framework, and Random-Steal, which only relies on the stealing component of our framework, we notice that in the uncorrelated case, for small amount of noise guarantee a higher success rate, while as the noise increases, the stealing component becomes more instrumental to the performance. This is in tact with the theoretical results, where using the prediction is crucial to achieve the consistency guarantees, which take place when the prediction is accurate, while stealing is important to achieve robustness guarantees in case the prediction is inaccurate. As described above, in the case where the valuations are correlated, stealing is not expected to help. Interestingly, on fully noisy input, even Random outperforms Partition as Partition might partition the items into unequally-sized sets, which performs worse than the equally-sized sets Random outputs.

Our experiments show that Partition-Plant-Steal performs as well as the Partition strategy for small amounts of noise and outperforms it on uncorrelated instances for large amounts of noise. Moreover, for any amount of noise, it outperforms Random-Steal and converges to it for a fully noisy input. This illustrates the best of both worlds tradeoff obtained by our framework.

Finally, when comparing the Partition-Plant-Steal strategy to the Partition-Steal strategy, we observe that Partition-Plant-Steal outperforms Partition-Steal in the correlated case with a small amount of noise (worst-case scenario) for ϵ = 0.02, as planting guarantees your favorite items would not be taken. In other scenarios, Partition-Steal outperforms Partition-Plant-Steal because planting removes a valuable item from the player s set that might be taken otherwise, especially in the uncorrelated case.

Acknowledgments and Disclosure of Funding

Arsen Vasilyan was supported in part by NSF awards CCF-2006664, DMS-2022448, CCF-1565235, CCF-1955217, CCF-2310818, Big George Fellowship and Fintech@CSAIL. The work of A. Vasilyan was partially done while visiting Bar-Ilan university as a part of the MISTI-Israel program, supported by the Zuckerman Institute. Part of this work was conducted while Arsen Vasilyan was visiting the Simons Institute for the Theory of Computing.

The work of I.R. Cohen was supported in part by ISF grant 1737/21. The work of A. Eden was supported by the Israel Science Foundation (grant No. 533/23).

[1] Priyank Agrawal, Eric Balkanski, Vasilis Gkatzelis, Tingting Ou, and Xizhi Tan. Learningaugmented mechanism design: Leveraging predictions for facility location. In David M. Pennock, Ilya Segal, and Sven Seuken, editors, EC 22: The 23rd ACM Conference on Economics and Computation, Boulder, CO, USA, July 11 - 15, 2022, pages 497 528. ACM, 2022. doi: 10.1145/3490486.3538306. URL https://doi.org/10.1145/3490486.3538306.

[2] Elad Aigner-Horev and Erel Segal-Halevi. Envy-free matchings in bipartite graphs and their applications to fair division. Inf. Sci., 587:164 187, 2022. doi: 10.1016/J.INS.2021.11.059. URL https://doi.org/10.1016/j.ins.2021.11.059.

[3] Hannaneh Akrami and Jugal Garg. Breaking the 3/4 barrier for approximate maximin share. Co RR, abs/2307.07304, 2023. doi: 10.48550/ARXIV.2307.07304. URL https://doi.org/ 10.48550/ar Xiv.2307.07304.

[4] Hannaneh Akrami, Jugal Garg, Eklavya Sharma, and Setareh Taki. Simplification and improvement of MMS approximation. In Proceedings of the Thirty-Second International Joint Conference on Artificial Intelligence, IJCAI 2023, 19th-25th August 2023, Macao, SAR, China, pages 2485 2493. ijcai.org, 2023. doi: 10.24963/IJCAI.2023/276. URL https://doi.org/10.24963/ijcai.2023/276.

[5] Hannaneh Akrami, Jugal Garg, and Setareh Taki. Improving approximation guarantees for maximin share. Co RR, abs/2307.12916, 2023. doi: 10.48550/ARXIV.2307.12916. URL https://doi.org/10.48550/ar Xiv.2307.12916.

[6] Georgios Amanatidis, Georgios Birmpas, and Evangelos Markakis. On truthful mechanisms for maximin share allocations. In Subbarao Kambhampati, editor, Proceedings of the Twenty-Fifth International Joint Conference on Artificial Intelligence, IJCAI 2016, New York, NY, USA, 9-15 July 2016, pages 31 37. IJCAI/AAAI Press, 2016. URL http://www.ijcai.org/ Abstract/16/012.

[7] Georgios Amanatidis, Georgios Birmpas, George Christodoulou, and Evangelos Markakis. Truthful allocation mechanisms without payments: Characterization and implications on fairness. In Constantinos Daskalakis, Moshe Babaioff, and Hervé Moulin, editors, Proceedings of the 2017 ACM Conference on Economics and Computation, EC 17, Cambridge, MA, USA, June 26-30, 2017, pages 545 562. ACM, 2017. doi: 10.1145/3033274.3085147. URL https: //doi.org/10.1145/3033274.3085147.

[8] Georgios Amanatidis, Evangelos Markakis, Afshin Nikzad, and Amin Saberi. Approximation algorithms for computing maximin share allocations. ACM Trans. Algorithms, 13(4):52:1 52:28, 2017. doi: 10.1145/3147173. URL https://doi.org/10.1145/3147173.

[9] Georgios Amanatidis, Georgios Birmpas, Federico Fusco, Philip Lazos, Stefano Leonardi, and Rebecca Reiffenhäuser. Allocating indivisible goods to strategic agents: Pure nash equilibria and fairness. In Michal Feldman, Hu Fu, and Inbal Talgam-Cohen, editors, Web and Internet Economics - 17th International Conference, WINE 2021, Potsdam, Germany, December 14-17, 2021, Proceedings, volume 13112 of Lecture Notes in Computer Science, pages 149 166. Springer, 2021. doi: 10.1007/978-3-030-94676-0\_9. URL https://doi.org/10.1007/ 978-3-030-94676-0_9.

[10] Georgios Amanatidis, Haris Aziz, Georgios Birmpas, Aris Filos-Ratsikas, Bo Li, Hervé Moulin, Alexandros A. Voudouris, and Xiaowei Wu. Fair division of indivisible goods: Recent progress and open questions. Artif. Intell., 322:103965, 2023. doi: 10.1016/J.ARTINT.2023.103965. URL https://doi.org/10.1016/j.artint.2023.103965.

[11] Yossi Azar and Yossi Richter. The zero-one principle for switching networks. In László Babai, editor, Proceedings of the 36th Annual ACM Symposium on Theory of Computing, Chicago, IL, USA, June 13-16, 2004, pages 64 71. ACM, 2004. doi: 10.1145/1007352.1007369. URL https://doi.org/10.1145/1007352.1007369.

[12] Moshe Babaioff, Tomer Ezra, and Uriel Feige. Fair and truthful mechanisms for dichotomous valuations. In Thirty-Fifth AAAI Conference on Artificial Intelligence, AAAI 2021, Thirty-Third Conference on Innovative Applications of Artificial Intelligence, IAAI 2021, The Eleventh Symposium on Educational Advances in Artificial Intelligence, EAAI 2021, Virtual Event, February 2-9, 2021, pages 5119 5126. AAAI Press, 2021. doi: 10.1609/AAAI.V35I6.16647. URL https://doi.org/10.1609/aaai.v35i6.16647.

[13] Maria-Florina Balcan, Siddharth Prasad, and Tuomas Sandholm. Bicriteria multidimensional mechanism design with side information. Co RR, abs/2302.14234, 2023. doi: 10.48550/ARXIV. 2302.14234. URL https://doi.org/10.48550/ar Xiv.2302.14234.

[14] Eric Balkanski, Vasilis Gkatzelis, and Xizhi Tan. Strategyproof scheduling with predictions. In Yael Tauman Kalai, editor, 14th Innovations in Theoretical Computer Science Conference, ITCS 2023, January 10-13, 2023, MIT, Cambridge, Massachusetts, USA, volume 251 of LIPIcs, pages 11:1 11:22. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2023. doi: 10.4230/ LIPICS.ITCS.2023.11. URL https://doi.org/10.4230/LIPIcs.ITCS.2023.11.

[15] Eric Balkanski, Vasilis Gkatzelis, Xizhi Tan, and Cherlin Zhu. Online mechanism design with predictions. Co RR, abs/2310.02879, 2023. doi: 10.48550/ARXIV.2310.02879. URL https://doi.org/10.48550/ar Xiv.2310.02879.

[16] Siddharth Barman and Sanath Kumar Krishnamurthy. Approximation algorithms for maximin fair division. ACM Trans. Economics and Comput., 8(1):5:1 5:28, 2020. doi: 10.1145/3381525. URL https://doi.org/10.1145/3381525.

[17] Sylvain Bouveret and Michel Lemaître. Characterizing conflicts in fair division of indivisible goods using a scale of criteria. Auton. Agents Multi Agent Syst., 30(2):259 290, 2016. doi: 10.1007/S10458-015-9287-3. URL https://doi.org/10.1007/s10458-015-9287-3.

[18] Eric Budish. The combinatorial assignment problem: Approximate competitive equilibrium from equal incomes. Journal of Political Economy, 119(6):1061 1103, 2011.

[19] Ioannis Caragiannis and Georgios Kalantzis. Randomized learning-augmented auctions with revenue guarantees. Co RR, abs/2401.13384, 2024. doi: 10.48550/ARXIV.2401.13384. URL https://doi.org/10.48550/ar Xiv.2401.13384.

[20] Ilan Reuven Cohen and Debmalya Panigrahi. A General Framework for Learning-Augmented Online Allocation. In 50th International Colloquium on Automata, Languages, and Programming (ICALP 2023), volume 261 of Leibniz International Proceedings in Informatics (LIPIcs), pages 43:1 43:21, 2023. ISBN 978-3-95977-278-5. doi: 10.4230/LIPIcs.ICALP.2023.43.

[21] Nikhil R. Devanur and Thomas P. Hayes. The adwords problem: online keyword matching with budgeted bidders under random permutations. In John Chuang, Lance Fortnow, and Pearl Pu, editors, Proceedings 10th ACM Conference on Electronic Commerce (EC-2009), Stanford, California, USA, July 6 10, 2009, pages 71 78. ACM, 2009. doi: 10.1145/1566374.1566384. URL https://doi.org/10.1145/1566374.1566384.

[22] Uriel Feige, Ariel Sapir, and Laliv Tauber. A tight negative example for MMS fair allocations. In Michal Feldman, Hu Fu, and Inbal Talgam-Cohen, editors, Web and Internet Economics - 17th International Conference, WINE 2021, Potsdam, Germany, December 14-17, 2021, Proceedings, volume 13112 of Lecture Notes in Computer Science, pages 355 372. Springer, 2021. doi: 10. 1007/978-3-030-94676-0\_20. URL https://doi.org/10.1007/978-3-030-94676-0_ 20.

[23] Jugal Garg, Peter Mc Glaughlin, and Setareh Taki. Approximating maximin share allocations. In Jeremy T. Fineman and Michael Mitzenmacher, editors, 2nd Symposium on Simplicity in Algorithms, SOSA 2019, January 8-9, 2019, San Diego, CA, USA, volume 69 of OASIcs, pages 20:1 20:11. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019. doi: 10.4230/OASICS. SOSA.2019.20. URL https://doi.org/10.4230/OASIcs.SOSA.2019.20.

[24] Mohammad Ghodsi, Mohammad Taghi Hajiaghayi, Masoud Seddighin, Saeed Seddighin, and Hadi Yami. Fair allocation of indivisible goods: Improvements and generalizations. In Éva Tardos, Edith Elkind, and Rakesh Vohra, editors, Proceedings of the 2018 ACM Conference on Economics and Computation, Ithaca, NY, USA, June 18-22, 2018, pages 539 556. ACM, 2018. doi: 10.1145/3219166.3219238. URL https://doi.org/10.1145/3219166.3219238.

[25] Vasilis Gkatzelis, Kostas Kollias, Alkmini Sgouritsa, and Xizhi Tan. Improved price of anarchy via predictions. In David M. Pennock, Ilya Segal, and Sven Seuken, editors, EC 22: The 23rd ACM Conference on Economics and Computation, pages 529 557. ACM, 2022. doi: 10.1145/3490486.3538296. URL https://doi.org/10.1145/3490486.3538296.

[26] Vasilis Gkatzelis, Alexandros Psomas, Xizhi Tan, and Paritosh Verma. Getting more by knowing less: Bayesian incentive compatible mechanisms for fair division. Co RR, abs/2306.02040, 2023. doi: 10.48550/ARXIV.2306.02040. URL https://doi.org/10.48550/ar Xiv.2306. 02040.

[27] Hadi Hosseini and Andrew Searns. Guaranteeing maximin shares: Some agents left behind. In Zhi-Hua Zhou, editor, Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence, IJCAI 2021, Virtual Event / Montreal, Canada, 19-27 August 2021, pages 238 244. ijcai.org, 2021. doi: 10.24963/IJCAI.2021/34. URL https://doi.org/10.24963/ijcai. 2021/34.

[28] Hadi Hosseini, Andrew Searns, and Erel Segal-Halevi. Ordinal maximin share approximation for goods (extended abstract). In Proceedings of the Thirty-Second International Joint Conference on Artificial Intelligence, IJCAI 2023, 19th-25th August 2023, Macao, SAR, China, pages 6894 6899. ijcai.org, 2023. doi: 10.24963/IJCAI.2023/778. URL https://doi.org/10. 24963/ijcai.2023/778.

[29] Tim Kraska, Alex Beutel, Ed H. Chi, Jeffrey Dean, and Neoklis Polyzotis. The case for learned index structures. In Gautam Das, Christopher M. Jermaine, and Philip A. Bernstein, editors, Proceedings of the 2018 International Conference on Management of Data, SIGMOD Conference 2018, Houston, TX, USA, June 10-15, 2018, pages 489 504. ACM, 2018. doi: 10.1145/3183713.3196909. URL https://doi.org/10.1145/3183713.3196909.

[30] David Kurokawa, Ariel D. Procaccia, and Junxing Wang. Fair enough: Guaranteeing approximate maximin shares. J. ACM, 65(2):8:1 8:27, 2018. doi: 10.1145/3140756. URL https://doi.org/10.1145/3140756.

[31] T Lavastida, B Moseley, R Ravi, and C Xu. Learnable and instance-robust predictions for online matching, flows and load balancing. In European Symposium on Algorithms, 2021.

[32] Shi Li and Jiayi Xian. Online unrelated machine load balancing with predictions revisited. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, ICML 2021, 18-24 July 2021, Virtual Event, volume 139 of Proceedings of Machine Learning Research, pages 6523 6532. PMLR, 2021. URL http://proceedings. mlr.press/v139/li21w.html.

[33] Pinyan Lu, Zongqi Wan, and Jialin Zhang. Competitive auctions with imperfect predictions. Co RR, abs/2309.15414, 2023. doi: 10.48550/ARXIV.2309.15414. URL https://doi.org/ 10.48550/ar Xiv.2309.15414.

[34] Thodoris Lykouris and Sergei Vassilvitskii. Competitive caching with machine learned advice. J. ACM, 68(4):24:1 24:25, 2021. doi: 10.1145/3447579. URL https://doi.org/10.1145/ 3447579.

[35] Michael Mitzenmacher. How useful is old information? IEEE Trans. Parallel Distributed Syst., 11(1):6 20, 2000. doi: 10.1109/71.824633. URL https://doi.org/10.1109/71.824633.

[36] Benjamin Plaut and Tim Roughgarden. Almost envy-freeness with general valuations. SIAM J. Discret. Math., 34(2):1039 1068, 2020. doi: 10.1137/19M124397X. URL https://doi. org/10.1137/19M124397X.

[37] Biaoshuai Tao. On existence of truthful fair cake cutting mechanisms. In David M. Pennock, Ilya Segal, and Sven Seuken, editors, EC 22: The 23rd ACM Conference on Economics and Computation, Boulder, CO, USA, July 11 - 15, 2022, pages 404 434. ACM, 2022. doi: 10.1145/3490486.3538321. URL https://doi.org/10.1145/3490486.3538321.

[38] Erik Vee, Sergei Vassilvitskii, and Jayavel Shanmugasundaram. Optimal online assignment with forecasts. In David C. Parkes, Chrysanthos Dellarocas, and Moshe Tennenholtz, editors, Proceedings 11th ACM Conference on Electronic Commerce (EC-2010), Cambridge, Massachusetts, USA, June 7-11, 2010, pages 109 118. ACM, 2010. doi: 10.1145/1807342.1807360. URL https://doi.org/10.1145/1807342.1807360.

[39] Adam Wierman and Misja Nuyens. Scheduling despite inexact job-size information. In Zhen Liu, Vishal Misra, and Prashant J. Shenoy, editors, Proceedings of the 2008 ACM SIGMETRICS International Conference on Measurement and Modeling of Computer Systems, SIGMETRICS 2008, pages 25 36. ACM, 2008. doi: 10.1145/1375457.1375461. URL https://doi.org/ 10.1145/1375457.1375461.

[40] Chenyang Xu and Pinyan Lu. Mechanism design with predictions. In Luc De Raedt, editor, Proceedings of the Thirty-First International Joint Conference on Artificial Intelligence, IJCAI 2022, pages 571 577. ijcai.org, 2022. doi: 10.24963/IJCAI.2022/81. URL https://doi. org/10.24963/ijcai.2022/81.

A Experimental Supplement

Generating valuations. To generate interesting valuations for the players, we use a multi-step function to generate item values, since if the values are close together, any balanced partition obtains good MMS guarantees, without considering reports and predictions. Specifically, we consider a four-step (High/Med/Low/Extra-Low) random valuation function, where an item has a High valuation with probability 8/m, a Medium valuation with probability 1/4, a Low valuation with probability 1/2 and an Extra-Low valuation with the remaining probability. A High valuation is drawn from U[1000, 2000], a Medium valuation is drawn from U[400, 800], a Low valuations is drawn from U[100, 200] and an Extra-Low valuation is sampled from U[1, 2]. Figure 2 shows the value distribution generated by this process for two players. We generate values for m = 100 items.

We generate valuations satisfying one of the two types of relations between players preferences:

Correlated: the two preference orders are identical (but not the values). Uncorrelated: Both preference orders are chosen independently and uniformly at random.

Generating predictions. To generate predictions, we take valuations and permute elements randomly to create noise. We generate predictions under varying noise levels according to the Kendall tau distance between the valuations and the predictions. We very the Kendall tau distance between 1 to 2560, where 2560 corresponds to the expected noise level of a random permutation of 100 items. To randomly choose a permutation of a certain noise level, we start with the ordered permutation and then choose two indices j < k u.a.r. and swap items r and r + 1 for r {j, . . . , k 1} if it increases the Kendall Tau distance by one. We repeat this process until the distance of the resulting permutation equals the desired value.

B Related Work

The notion of the maximin share allocation was introduced by Budish [18] as an ordinal notion, and extended to the notion we adopt by Bouveret and Lemaître [17]. Using machine learning advice in algorithm design was used in theory [21, 38] and practice [29]. The learning-augmented framework of studying consistency-robustness tradeoffs was introduced by Lykouris and Vassilvitskii [34]. [35, 39] studied the performance of algorithms using imprecise predictions.

0 20 40 60 80 100 0

Figure 2: Plotting randomly sampled valuations for two players, where the values are sorted such that lower indexed items have higher values.

Fair division with incentives. The two closest papers to ours are Amanatidis et al. [6, 7]. In [6], they initiate the study of truthful mechanisms for approximating the MMS value for agents with additive valuations. They show that no truthful mechanism can get an approximation better than 1/2 for the MMS in the case of 2 agents and 4 items. They give the best known approximation guarantee for n agents and m items of m n+2

2 . Finally they consider the public ranking model, where the ranking over items is public information. Using this, they are able to obtain a n+1

2 -approximation algorithm. One can view this as an algorithm that is given a prediction over the input, but does not provide robustness guarantees. [7] Fully characterize truthful mechanism for 2 agents with additive valuations. They use this characterization to provide a strong lower bound of m

2 for any truthful mechanism.

[12] design truthful mechanisms for dichotomous submodular valuations that maximize welfare, along with desirable fairness properties such as EFX and NSW. For additive binary valuations, they also maximize the MMS in a truthful manner. [26] bypass the impossibilities imposed by [7, 37] for truthful fair allocations with indivisible and divisible goods by considering Bayesian Incentive Compatible mechanisms with symmetric priors. They are able to obtain EF-1 allocations for indivisible goods and proportional allocations for indivisible goods.

Finally, [9] study the Nash equilibrium for simple mechanisms for agents with additive valuations. They show that for every number of agents, the Pure Nash equilibrium of the Round-Robin procedure produces an EF-1 allocation. For two agents, they show that the Pure Nash equilibrium of Plaut and Roughgarden [36] cut-and-choose procedure produces an EFX and MMS allocation.

1-out-of-k. As stated above, the MMS value of an agent is defined by the highest value an agent can guarantee for themselves when partitioning the items into n different bundles, where n is the number of agents, and then getting the lowest valued bundle. Thus, an agent get a value larger than the worst one-out-of-n bundles that define the MMS.

Noticing that finding an allocation that satisfies the MMS value of each agent is a demanding task (which was shown to be infeasible in some cases by Kurokawa et al. [30]), Budish [18] relaxed the notion and defined the 1-out-of-n + 1 MMS to be the worst bundle out of the bundles that define the MMS when partitioning the items using an additional bundle. [18] showed it is possible to achieve this benchmark when adding a small number of access goods. There has been an effort to find the smallest k for which an allocation that guarantees a 1-out-of-k MMS for each agent exists. [2] were able to show the existence for k = 2n 2, [27, 28] achieved k = 3n

2 , and recently, [5] showed the smallest up-to-date k = 4n

3 . In our n-agent mechanism, our robustness guarantee approximates this relaxed benchmark for k = 3n

Learning-Augmented Mechanisms. Agrawal et al. [1] and Xu and Lu [40] first explored the learning-augmented framework in a mechanism design setting, where [1] studied the facility location problem while [40] applied the framework to several settings such as revenue-maximization, path auctions, scheduling and two-facility games. [14] give nearly optimal consistency-robustness tradeoffs to the strategyproof scheduling with unrelated machines. [25] use predictions to design mechanisms with improved Price of Anarchy bounds. [33, 19] study revenue maximization auctions with predictions, and [13] devise bicriteria mechanisms.

C Deferred proofs from Section 3

Proof of Lemma 3.1. We show that agent 1 is better off reporting their true valuation, a symmetric argument holds for agent 2. First, notice that sets T1 and T2 are determined using predictions, ignoring the reports. Next, notice that the item j2 is chosen only using agent 2 s report. Therefore, the only way agent 1 can affect their allocation is by choosing which item in T2 is allocated to them. agent 1 gets their favorite item in T2 according to their report. Therefore, it is clear that the agent maximize their utility by reporting their true value.

Proof of Lemma 3.2. Consider some agent i. We claim for every partition of the items into two non-empty sets, T1, T2, i is always guaranteed to have one of their two favorite items according to their true valuation vi in Xi. This is because either (1) i has one of their two favorite items in Tℓ, ℓ = i, and i gets their favorite item from Tℓ; or (2) i s two favorite items are in Ti, and in this case, i gets all items from Ti but one, so i is guaranteed one of them.

Proof of Lemma 3.3. Let g S {v1 i , v2 i }, by the definition of S such g exists. Let S = S \ {g}, by the definition of S, we have |S | = k 1 and vi(S) v2 i + vi(S ). Consider a partition

(S1, S2) arg max(T1,T2) : T1 S T2=M min j {1,2} vi(Tj).

By definition, µi = minj {1,2} vi(Sj). We have, µi vi(S) µi v2 i + vi(S )

= minj {1,2} vi(Sj)

v2 i + vi(S )

minj {1,2} vi(Sj) vi(S )

minj {1,2} vi(Sj \ S )

minj {1,2}{|Sj \ S | max{vi(ℓ) : ℓ Sj \ S }}

(m k) minj {1,2} max{vi(ℓ) : ℓ Sj}

where the before last inequality is since if Sj S for some j, then v2 i + vi(S ) µi; therefore S1 \ S and S2 \ S are two disjoint non empty subsets and |S1 \ S | + |S2 \ S | = m k + 1, hence the maximum number of elements in one of these subsets is m k.

D Deferred proofs from Section 4

Proof of Lemma 4.1. By Observation 4.1, we have vi(ak i ) v2k i , therefore

k=1 v2k i . (1)

Since i s favorite item must be absent from some set of the sets defining the MMS value,

k=2 vk i µi.

Since the vk i are ordered, v2k i v2k+1 i , hence P m/2 k=1 v2k i P m/2 k=1 v2k+1 i . Therefore,

k=1 v2k i µi/2 (2)

By Equations (1),(2), we have:

k=1 v2k i µi/2.

Proof of Lemma 4.2. Let j1 be the first item assigned in Balanced-Round-Robin to agent 1. By definition, j1 is agent 1 s favorite item in M according to p1. Clearly, in Plant-and-Steal, j1 is also agent 1 s favorite item in A1 M according to p1. Hence, ˆj1 = j1. By the definition of Plant-and-Steal, j1 T2. Since we assume the prediction corresponds to agent 1 s actual value, j1 is also agent 1 s favorite item in T2 M, which implies j1 = j1.

Similarly Let j2 be the first item assigned in Balanced-Round-Robin to agent 2. By definition, j2 is agent 2 s favorite item in M \ {j1} according to p2. Since j1 A1, A2 M \ {j1}. Therefore, j2 is also agent 2 s favorite item in A2 according to p2. Hence, ˆj2 = j2. Since we established that ˆj1 = j1, we have that T1 M \ {j1} and j2 T1. Since we assume the prediction corresponds to agent 1 s actual value, j2 is also agent 1 s favorite item in T1, implying j2 = j2. We get that X1 = A1 and X2 = A2 as required.

E 1-2-RR-Plant-and-Steal Mechanism: A 3/2-consistent, 2m/3 -robust Mechanism

In this section, we show that using a modified round-robin allocation procedure to instantiate the Plant-and-Steal framework give an improved 3/2 consistency guarantee, while maintaining O(m) robustness. Consider the Balanced-Round-Robinallocation procedure depicted in Algorithm 2. One can show that the agent that picks first actually gets a value at least as large as their MMS, while for the second agent this analysis is indeed tight.7 In order to compensate agent 2, 1-2-Round-Robin lets this agent pick two items each round. See Algorithm 3 for details.

ALGORITHM 3: 1-2-Round-Robin Input :Preference orders of agents over items v = (v1, v2). Output :An allocation A1 S A2 = M. Ai , for every agent i N for r = 1, . . . , |M|/3 : do A1 A1 + v 1(M \ A1 \ A2) A2 A2 + v 2(M \ A1 \ A2) A2 A2 + v 2(M \ A1 \ A2)

Let ak i be agent i s kth choice in 1-2-Round-Robin, we observe the following. Observation E.1. The output (A1, A2) of the 1-2-Round-Robin procedure, satisfies:

1. |A1| = m

3 and |A2| = 2m

3 . 2. ak 1 {vℓ 1}ℓ [3k 2], a2k 1 2 {vℓ 2}ℓ [3k 1] and a2k 2 {vℓ 2}ℓ [3k].

7Consider the case where the agents valuations are (m 1, 1, . . . , 1). According to Round-Robing allocation, the first item will be assigned to agent 1, and agent 2 will have m/2 items of value 1, while µ2 = m 1.

Amanatidis et al. [6] show that 1-2-Round-Robin guarantees each agent 2/3 of their MMS. We provide the proof for completeness.

Lemma E.1 (Amanatidis et al. [6]). Let (A1, A2) be the allocation of 1-2-Round-Robin. For every agent i, vi(Ai) 2µi/3.

Proof. We first prove the approximation for player 1 (the first player to be allocated). First, observe that v1(M) 2µ1. Let I1 = {v3k 2 1 : k = 1, . . . , m/3 } be the worst possible allocation agent 1 might get in the 1-2-Round-Robin allocation. Notice that v1(I1) v1(M)/3 2µ1/3. By Observation E.1, v1(ak 1) v3k 2 1 . Therefore, v1(A1) v1(I1) 2µ1/3.

Now consider player 2. As stated in the proof of Lemma 4.1, v2(M \ v1 2) µ2. Let

Ia 2 = {v3k 1 2 : k N>0 3k 1 m} and Ib 2 = {v3k 2 : k N>0 3k m}.

First, notice that v2(Ia 2 Ib 2) 2v2(M \ v1 2)/3 2µ2/3.

Moreover, by Observation E.1, we have, v2(a2k 1 2 ) v3k 1 2 , and v2(a2k 2 ) v3k 2 . Therefore, v2(A2) v2(Ia 2 Ib 2) 2µ2/3.

The mechanism we consider in this section, 1-2-RR-Plant-and-Steal, results from instantiating Plant-and-Steal with 1-2-Round-Robin as A.

The next lemma states that if the predictions correspond to the preference orders of the real valuations, then 1-2-RR-Plant-and-Steal outputs the same allocation as 1-2-Round-Robin. The proof is omitted as it is identical to the proof of 4.2.

Lemma E.2. When predictions correspond to actual values, 1-2-RR-Plant-and-Stealoutputs the same allocation as 1-2-Round-Robin.

We next show that in 1-2-RR-Plant-and-Steal we are able to achieve a better consistency, while slightly weakening the robustness guarantee.

Theorem E.1. Mechanism 1-2-RR-Plant-and-Steal is truthful, 3/2-consistent and 2m

Proof. By Lemma 3.1, the mechanism is truthful. By Observation E.1, each agent receives at least m/3 items; combining with Lemma 3.4, we get that the mechanism is 2m

3 -robust. Finally, if predictions correspond to valuations, by Lemma E.1 and Lemma E.2, the allocation is 3/2approximation to the MMS. Thus, the mechanism is 2/3-consistent.

F Deferred proofs from Section 5

Proof of Lemma 5.1. Let S = {s1, . . . , sk} (|S| = k) and T = {t1, . . . , tℓ} (|T| = ℓ). We have the following.

j=1 vi(sj) =

0 hτ(vi(sj))dτ = Z

j=1 hτ(vi(sj))dτ = Z

0 vτ i (S)dτ

0 vτ i (T)/c dτ = 1

j=1 hτ(tj)dτ = 1

0 hτ(tj)dτ = 1

where we use the identity R 0 hτ(q)dτ = q.

Proof of Lemma 5.2. Let m

2 be the number of items agent i gets by Mechanism B-RR-Plant-and-Steal. Let Ai = {a1 i , a2 i , . . . , ami i } be the items assigned to agent i in the

Round-Robin according to the predicted orderings p, where aℓ i is the item allocated to i in the ℓth round of Round-Robin. First, by Observation 4.1, we have:

aℓ i {pj i}j {1,...,2ℓ}. (3)

For a fixed τ 0, let Lτ = vτ i (Ri) be the number of values larger than threshold τ in Ri. We show that if the Kendall tau distance is at most d, then it must be the case that vτ i (Ai) Lτ

Note that hτ(vk i ) = 1 for k 2 Lτ since Ri gets every second item by the sorted values of agent i. This implies that if hτ(v1(aℓ i)) = 0 then aℓ i = vk i for k > 2 Lτ. Moreover, if ℓ Lτ then aℓ i = pk i for k 2 Lτ by Eq. (3). Thus, if PLτ k=1 hτ(v1(ak i )) < Lτ

d there are strictly more than

d items whose rank according to the true valuation is at most 2 Lτ, and their rank according to the prediction is at least 2 Lτ + 1. We show that this implies that the Kendall tau distance is larger than d, yielding a contradiction. Formally, let G1 = {vk 1}k {1,...,2 Lτ } \ {pk 1}k {1,...,2 Lτ } be the set of items whose rank is at most 2 Lτ according to the real values but not according to the predictions, and let G2 = {vk 1}k {2 Lτ +1,...,m} \ {pk 1}k {2 Lτ +1,...,m} be the set of items whose rank is strictly larger than 2 Lτ according to the real values but not according to the predictions. By the above, |G1| = |G2| >

d , and for each pair j G1, j G2,

1. j rank according to vi is at most 2 Lτ and j rank according to vi is at least 2 Lτ + 1;

2. j rank according to pi is at most 2 Lτ and j rank according to pi is at least 2 Lτ + 1.

That is, j and j are ordered oppositely in the ordering according to pi and vi. Since there are |G1| |G2| > d such pairs, we get that the Kendall tau distance is strictly greater than d, a contradiction.

Proof of Theorem 5.1. Recall that, in Eq. (2) of Lemma 4.1, we establish that: vi(Ri) µi/2 (5)

In addition, we apply the zero-one principle to show that Lemma 5.1 holds for the sets Xi and Ri with c =

d + 3. The proof follows by combining these two results.

Notice that |Ai \ Xi| 2, because in the stealing phase, agent i might not take the planted item from Ai back, and the other agent might take one item from Ai.8 Moreover, by Lemma 3.2, either v1 i or v2 i are in Xi. Therefore, for every threshold τ 0, vτ i (Xi) max{hτ(v2 i ), vτ i (Ai) 2}

max{hτ(v2 i ), vτ i (Ri)

d 2}, (6) where the inequality follows Lemma 5.2.

If hτ(v2 i ) = 0, then vτ i (Ri) |Ri| hτ(v2 i ) = 0, and Lemma 5.1 holds with c = 0. Therefore, the interesting case is when hτ(v2 i ) = 1. Consider the ratio vτ i (Ri) vτ i (Xi) which we want to bound. Since

vτ i (Xi) hτ(v2 i ) = 1, vτ i (Ri) [1,

d + 3] implies that vτ i (Ri) vτ i (Xi) vτ i (Ri)

On the other hand, by Eq. (6), setting vτ i (Ri) =

d + 3 + δ for δ > 0 implies that vτ i (Xi) vτ i (Ri)

d 2 1 + δ, which yields

vτ i (Ri) vτ i (Xi)

We get that Lemma 5.1 holds for Xi and Ri with c =

d + 3. Thus,

vi(Xi) vi(Ri)/(

d + 3) µi/(2

d + 6), where the last inequality follows Eq. (5).

8In fact, this holds for any noise in the valuations of the other agent.

G Non-ordering Predictions

In this Section, we consider the case where predictions are not necessarily preference orders over items. In Section G.1, we show that for any prediction the mechanism might get, consistency is bounded away from 1. Sections G.2, G.3, we study succinct predictions, i.e. predictions about general structure of the preferences of two agents. Section G.2 presents a 4-consistent and m/2 -robust mechanism, whose consistency relies on the correctness of only a log m-bit prediction about the preferences of the two agents. In Section G.3, we show that a 2 + ϵ-consistent and m/2 -robust mechanism exists, whose consistency relies on correctly predicting only O(log m/ϵ) bit about the preferences of the two agents.

G.1 No Mechanism with < 6/5 Consistency and Bounded Robustness

In [7] they define the following family of mechanisms.

Definition G.1 (Singleton Picking-Exchange Mechanisms [7]). A mechanism X is a singleton picking-exchange mechanism if for each i {1, 2}, there is exactly one of two sets: either Ni M, or Ei = {ℓi} for a single item ℓi M. If Ni is non-empty, then the mechanism lets player j = i pick item ℓ Ni that maximizes vj(ℓ), and i gets Ni \ {ℓ}. If both E1, E2 are non-empty, then the agents exchange the two items ℓ1 E1 and ℓ2 E2 if v1(ℓ2) > v1(ℓ1) and v2(ℓ1) > v1(ℓ2). Notice that if m > 2, either E1 or E2 is empty and there will be no exchange.

[7] showed the following.

Lemma G.1. In order for a mechanism to be truthful and have a bounded approximation, it has to be a singleton picking-exchange mechanism

We make use of this characterization in our impossibility.

Theorem G.1. For any ϵ > 0, there is no truthful a mechanism with consistency 6/5 ϵ and bounded robustness.

Proof. Consider the case where p1 = p2 = (1/2, 1/2, 1/3, 1/3, 1/3). Notice that for the predictions, µ1 = µ2 = 1. We show that for any singleton-picking-exchange mechanism, no agent obtains both large items (of value 1/2). Consider agent 1 (the argument is symmetric for agent 2). If N1 is non-empty, then if both large items are in N1, surely 1 will only get one of them. If both large items are in N2, then agent 2 will surely pick one of them, and agent 1 will only get one of them. If one large item is in N1 and the other is in N2, each agent i will pick the large item in Ni. If agent 2 has a large item in E2, then since N1 is non-empty, E1 is empty and agent 2 will keep the large item. Now consider the case where E1 is non-empty. In this case, E1 contains one item, and N1 is empty. Since E2 can contain at most one item, and there are more than 2 items, in this case, E2 = , and |N2| = 4. Therefore, N2 contains at least one large item. Since agent 2 will always pick the large item, agent one only gets one large item. We conclude that for any singleton picking-exchange mechanism, the large items are split among the agents. Since there are 3 small items, there must be an agent that gets at most one small item, and this agent has an overall value of at most 1/2 + 1/3 = 5/6, while the MMS is 1. Thus the claim follows.

G.2 4-Consistent, (m 1)-Robust Mechanism Using a 3 log m + 1-Space Prediction

Let us formally define a mechanism that uses a space-s prediction

Definition G.2. A learning-augmented mechanism is a space-s mechanism if the prediction space P can be represented by the elements of {0, 1}s.

We first give a simple mechanism that only requires 3 log m + 1 bits of information about the valuations v1 and v2. It will only need to know an index j0 in [m] together with a bit b to produce an approximately-optimal allocation, and an additional 2 log n bits to implement the planting phase. The mechanism will utilize the Plant-and-Steal framework in conjunction with the well-known bag-filling allocation procedure:

We see that, in order to predict the behaviour of the mechanism above, one only needs to predict accurately the index j0 on which the mechanism terminates, as well as a bit b {1, 2} that encodes

MECHANISM 4: Bag-Filling

Input :Preference orders of agents over items v = (v1, v2) on a set of items M = [m] Output :Allocations A1 S A2 = M j 1 for j = 1, . . . , m: do if v1([j]) v1([m]) 1

2 then Output (A1, A2) ([j], [m] \ [j]) and terminate

if v2([j]) v2([m]) 1

2 then Output (A1, A2) ([m] \ [j], [j]) and terminate

whether the algorithm terminates due to the condition v1([j]) v1([m]) 1

2 being satisfied or due to the

condition v2([j])

2 being satisfied. This can be encoded using log m + 1 bits.

We also see that the The Plant-and-Steal framework when used with the Bag-Filling allocation procedure gives a truthful 4-consistent and a m 1-robust9 allocation mechanism. The truthfulness and robustness follow immediately from Lemmas 3.1 and 3.4 respectively.

The 4-consistency holds for the following reason. It is a well-known fact (see i.e. [10]) that the partition (A1, A2) given by the bag-filling algorithm satisfies v1(A1) µ1/2 and v2(A2) µ2/2. By inspecting the Plant-and-Steal framework (Algorithm 1), we see that both agent 1 and agent 2 will either (i) retain their most preferred item in A1 and A2 respectively or (ii) Lose this item, but obtain an item that they prefer even more. Overall, this implies that in the worst case the difference v1(A1) v1(X1) will equal to the value of the second-most favorite item of Agent 1 in A1. This implies that v1(X1) 1

4 . Analogously, we see that v1(X2) 1

G.3 2 + ϵ-Consistent, m

2 -Robust Mechanism Using a O(log m/ϵ)-Space Prediction

We now show that a better consistency of 2 + ϵ can be achieved at the cost predicting O(log m/ϵ) bits of information about the valuations v1 and v2. We will also obtain a better robustness of m

2 . To do this, we will use the Plant-and-Steal framework in conjunction with the Cut-and-Balance allocation procedure. We first explain how the mechanisms above can be implemented by only

ALGORITHM 5: Cut-and-Balance Output :Allocations A1 S A2 = M Consider a partition S1 S S2 = M satisfying |S1| |S2| and

min j {1,2} v1(Sj) (1 ϵ)max T1 S T2=M min j {1,2} v1(Tj) = (1 ϵ)µ1

Let S S1 be a set of m/2 |S2| items satisfying

v1(S ) v1(S1)/2

if |S2| > 1 additionally satisfying v1(S ) v1(S1 \ {ˆj, ˆj })/2, for some ˆj arg maxj S1 v1(j) and ˆj arg maxℓ S1\ˆj v1(ˆj)

Set S1 S1 \ S and S2 S2 S

Let i2 arg maxi {1,2} p2( Si) and let i1 be the index of the other bundle Set A1 Si1 and A2 Si2, and output the allocation (A1, A2)

obtaining O(log m/ϵ) bits of information about the valuations v1 and v2. This follows from the following proposition, the proof of which is given in Appendix G.4. Proposition G.1. Suppose M = [m]. There is a partition M = L1 S L2 S S and indices α1, β1, α2 and β2 with |L1| + |L2| O 1

ϵ , such that the partition M = S1 S S2 defined as S1 = L1 S(S T[α1, β1]) and S2 = L2 S(S T[α2, β2]) satisfies |S1| |S2| and min(v1(S1), v1(S2)) (1 ϵ/4)µ1.

Additionally, there exist integers α3, β3, α4 and β4 such that the set S = S T ([α3, β3] S[α4, β4]) satisfies |S | = m/2 |S2|, S S1, v1(S ) v1(S1)/2 and if |S2| > 1 then S also satisfies v1(S ) v1(S1 \ {ˆj, ˆj })/2, where ˆj arg maxj S1 v1(j) and ˆj arg maxj S1\ˆj v1(j).

9Note that min(|A1|, |A2|) m 1 which implies that the algorithm is (m 1)-robust.

The main ideas for proving Proposition G.1 are: (i) using the sets L1 and L2 to handle elements x whose value v(x) is large, and separate the remaining items into the set S (ii) Showing that the remaining items can be separated into well-behaved subsets of the form S T[αi, βi].

The proposition above implies that the sets S1, S2 and S can be represented exactly via sets L1 and L2, together with the indices {α1, , α4, β1, β4}. We will also need to know the index i2 {1, 2}. Since the sets L1 and L2 have a size of O(1/ϵ), all this information amounts to O(log m/ϵ) bits as claimed.

The following proposition implies the truthfulness, the robustness and the consistency of the mechanism that combines the Cut-and-Balance allocation procedure with the Plant-and-Steal framework. Theorem G.2. The Plant-and-Steal framework, when used with Cut-and-Balance allocation procedure, gives a truthful, 2 + ϵ-consistent and a m/2 -robust allocation mechanism.

Proof. Truthfulness follows from Lemma 3.1. Since the sets A1 and A2 both have size at most m/2 , the robustness follows via Lemma 3.4.

The proof of (2 + ϵ)-consistency is deferred to Appendix G.5. The main challenge for showing the bound on consistency is the fact that both the Cut-and-Balance allocation procedure and the Plant-and-Steal framework can reduce the consistency by a factor of 2. Naively, one would expect the overall consistency to be close to 4, given that each stage can lose a factor of 2 in consistency. However, our insight is that for the instances, on which the Cut-and-Balance allocation procedure loses a factor of 2 in consistency, the Plant-and-Steal framework will have consistency close to 1, and vice versa. This allows us to prove a tighter bound of 2 + ϵ on the consistency of our overall algorithm.

G.4 Proof of Proposition G.1

We first show the following, which implies the first half of Proposition G.1. Proposition G.2. There exists a partition M = L1 S L2 S S and and indices α1, α2, β1, β2 in [m] such that M = [α1, β1] S [α2, β2], for the sets S1 = L1 (S [α1, β1]) and S2 = L2 (S [α2, β2]) we have

min{v1(S1), v1(S2)} (1 ϵ/8)µ1

|L1| + |L2| 8

For every x in L1 and y in S1 we have v1(x) > v1(y). Analogously, for every x in L2 and y in S2 we have v1(x) > v1(y)

There are ˆj, ˆj L1 satisfying ˆj arg maxℓ S1 v1(ℓ) and ˆj arg maxℓ S1\ˆj v1(ℓ),

We do this by inspecting two types of items, large items, with value greater than ϵµ1/4, and small items items with value at most ϵµ1/4. We first show that there are O(1/ϵ) large items, therefore, separating these items into two bundles require at most O(1/ϵ) intervals. Moreover, we can find a separation of the larges items into two sets, L1, L2, and a single index j [m] such that all small items to the left of j (including) together with L1 form S1, and all items to the right of j (excluding) together with L2 form S2, such that S1, S2 satisfy the approximation requirement. It is easy to see that this increases the number of intervals by at most 1.

We start by showing there are not too many large items. Lemma G.2. There are at most 8

ϵ items with value strictly greater than ϵµ1 for agent 1.

Proof. Let items with value greater than ϵµ1/4 be the large items. Suppose there are at least 8

ϵ + 1 large items. If 8

ϵ is even, consider a partition (S1, S2) such that each Si gets at least 8

ϵ /2 large items and the rest are allocated arbitrarily. If 8

ϵ is odd, consider the allocation in which each Si gets ( 8

ϵ + 1)/2 large items and the rest are allocated arbitrarily. In either case, each Si gets at least 8

ϵ large items. Thus, min{v1(S1), v1(S2)} > ϵµ1/4 4

ϵ = µ1, a contradiction.

We are now ready to prove Proposition G.2.

Proof of Proposition G.2. Consider the set of large items, L = {j [m] : v1(j) > ϵµ1/4}, and let S = M \ L be the set of small items.

We give a constructive proof which finds both sets L1, L2 and an index j satisfying the condition stated in the lemma. Let

(L1, L2) arg max(T1,T2) : T1 S T2=L min j {1,2} v1(Sj).

We use the following procedure to find j.

1. Let jℓ= 0 and jr = m.

2. While jℓ = jr:

(a) Let Sℓ= L1 {j S : j jℓ} and Sr = L2 {j S : j > jr}. (b) If v1(Sℓ) < v1(Sr) :

jℓ:= jℓ+ 1. (c) Else:

jr := jr 1.

3. Set j := jℓ= jr.

We consider two cases:

Case 1: j = 0 (or symmetrically, j = m). Without loss of generality, suppose that j = m. We first show that if v1(S1) < v1(S2) then min{v1(S1), v1(S2)} = µ1. Notice that since S1 gets all the small items, it must be the case that v1(L1) < v1(L2). Suppose there s a different partition T1 S T2 such that min{v1(T1), v1(T2)} > min{v1(S1), v1(S2)}. Without loss of generality, let v1(T1 L) v1(T2 L) (otherwise, we can rename both bundles). By the definition of L1, L2, it must be the case that v1(L1) v1(T1 L). Thus, Since T1 \ (T1 L) S, it must be that

v1(S1) = v1(L1)+v1(S) v1(T1 L)+v1(T1 \(T1 L)) = v1(T1) min{v1(T1), v1(T2)},

a contradiction.

On the other hand, if v1(S1) v1(S2) = v1(L2), by condition 2b of the above procedure, it must be the case that when jℓwas equal m 1,

v1(Sℓ) < v1(Sr) = v1(L2) = v1(S2).

Thus, v1(S1) = v1(Sℓ) + v1(m) < v1(S2) + ϵµ1/4.

We get that

v1(S2) v1(S1) ϵµ1/4 2µ1 v1(S2) ϵµ1/4 min{v1(S1), v1(S2)} = v1(S2) (1 ϵ/8)µ1, (7)

where the second inequality follows since 2µ1 v1(S1) + v1(S2).

Case 2: 0 < j < m. In this case, since both jℓand jr were moved, there were some values of jℓ and jr such that v1(Sℓ) v1(Sr) and some values such that v1(Sℓ) > v1(Sr). Assume initially that v1(Sℓ) v1(Sr). Since at each step of the procedure, the the lower-valued bundle can increase by at most ϵµ1/4, when the first item is added to Sℓsuch that v1(Sℓ) > v1(Sr), it must be the case that v1(Sℓ) v(Sr) + ϵµ1/4. It is easy to see that the invariant where |v1(Sℓ) v1(Sr)| ϵµ1/4 is kept throughout the run of the procedure. Therefore, this also holds for the final S1 and S2. Thus, we can use the same reasoning of Eq. (7) to conclude that min{v1(S1), v1(S2)} (1 ϵ/8)µ1.

Thus, the sets S1 and S2 have a form S1 = L1 (S [1, j]) and S2 = L2 (S [j +1, m]) and have the form required. If |S1| < |S2| we can swap our definitions for the sets S1 and S2, thus ensuring that |S1| > |S2|. Due to our definitions of L1 and L2 we have for every x in L1 and y in S1 we have v1(x) > v1(y). Analogously, for every x in L2 and y in S2 we have v1(x) > v1(y).

We can ensure that There are ˆj, ˆj L1 satisfying

ˆj arg max ℓ S1 v1(ℓ) and ˆj arg max ℓ S1\ˆj v1(ℓ),

by adding such values from S [α1, β1] to L1 (we see that after this all other properties still hold). Overall, we see that |L1| + |L2| 8

ϵ + 2, as required.

Now, we proceed to proving the second half of Proposition G.1. We will need the following lemma.

Lemma G.3. Let k1 and k2 be positive integers satisfying k1 > k2, and let f be a function mapping [k1] to non-negative real numbers. Then, there exist a pair of integers α, β, α and β in [k1] such that |[α, β] [α , β ]| = k2 and P i [α,β] [α ,β ] f(i)

P i [k1] f(i)

Proof. We prove the lemma using the probabilistic method. Let j be a uniformly random integer in [k1], and choose α, β, α and β such that

[α, β] [α , β ] = {j, j + 1 mod k1, , j + k2 1 mod k1}.

We see that indeed a set chosen as above can be represented as a union of two intervals. Now, since j is chosen uniformly at random form [k1], we see that for every element i in [k1] we have

Pr j [k1][i {j, j + 1 mod k1, , j + k2 1 mod k1}] = k2

Thus via linearity of expectation we have:

i {j,j+1 mod k1, ,j+k2 1 mod k1}} f(i)}

i [k1] f(i).

Thus, since f(i) is non-negative for all values of i, we see that for some specific choice of j it has to be the case that 1 k2

i {j,j+1 mod k1, ,j+k2 1 mod k1}} f(i)} 1

i [k1] f(i),

which finishes the proof.

Now, we apply the lemma above. If m < 4 t

ϵ + 2 we can satisfy Proposition G.2 by:

1. First choosing a partition M = S1 S S2 such that min(v1(S1), v1(S2)) µ1 and |R1| |R2|.

2. Define L2 := S2, put the smallest m/2 |S2 elements of S1 into S, and define L1 to contain the rest of elements in S1.

3. Define α1 = α3 = 1, β1 = β3 = m, α2 = β2 = α4 = β4 = m + 1.

Overall, this allocates S to be the bottom m/2 elements of S1. We see that this suffices to guarantee the properties that S needs to satisfy in Proposition G.1.

Therefore, henceforth we can assume that m > 4 t

ϵ + 2. Since |S1| m/2 and |L1| 8

ϵ + 2, and S1 = L1 (S [α1, β1]) this implies that |S [α1, β1])| > 3 t

ϵ > m/2 Thus, we can ensure that |S | = m/2 |S2| using a subset S S [α1, β1]).

If |S2| = 1 we only need choose S to satisfy |S | = m/2 |S2| and v1(S ) v1(S1 \ {ˆj, ˆj })/2. First of all, since every element in L1 is larger than any element in S [α1, β1]), we see that this is also true in average P

ℓ S [α1,β1]) v1(ℓ)

|S [α1, β1])| (8)

Then, applying Lemma G.3 to the set S [α1, β1]) we see that there exist disjoint subsets [α3, β3] and [α4, β4] of [α1, β1] such that |S ([α3, β3] S[α4, β4]))| = m/2 |S2| P

ℓ S [α1,β1]) v1(ℓ)

|S [α1, β1])|

ℓ S ([α3,β3] S[α4,β4])) v1(ℓ)

|S ([α3, β3] S[α4, β4]))| (9)

Combing Equations 8 and 9, we see that taking S = S ([α3, β3] S[α4, β4]) satisfies v1(S ) v1(S1)/2 and the other requirements of Proposition G.1.

Now, suppose |S2| > 1. Since by Proposition G.2, the set S does not contain the two largest elements ˆj and ˆj of S1, as well as the fact that every element in L1 is at least as large as any element in S [α1, β1]), we see that every every element in S1 \ {ˆj, ˆj } is either in S [α1, β1]) or greater than every element in S [α1, β1]). this implies that: P

ℓ S1\{ˆj,ˆj } v1(ℓ)

ℓ S [α1,β1]) v1(ℓ)

|S [α1, β1])| (10)

Then, we can again apply applying Lemma G.3 to the set S [α1, β1]) we see that there exist disjoint subsets [α3, β3] and [α4, β4] of [α1, β1] such that |S ([α3, β3] S[α4, β4]))| = m/2 |S2| P ℓ S [α1,β1]) v1(ℓ)

|S [α1, β1])|

P ℓ S ([α3,β3] S[α4,β4])) v1(ℓ)

|S ([α3, β3] S[α4, β4]))| (11)

Combing Equations 10 and 11, we see that taking S = S ([α3, β3] S[α4, β4]) satisfies v1(S ) v1(S1\{ˆj, ˆj })/2 as required in Proposition G.1. Note that this also implies that v1(S ) v1(S1})/2 since ˆj, ˆj have the top two largest values of v1 in S1. Overall, this finishes the proof of Proposition G.1.

G.5 Proof of (2 + ϵ)-consistency.

It remains to show that the algorithm is 2 + ϵ-consistent. We will be referencing the variables ˆj1, ˆj2, j1, j2, T1 and T2 within the Plant-And-Steal framework (Algorithm 1).

We first reason about agent 2. First, notice that since agent 2 has a higher value for Si2,

v2( Si2) µ2.

Since the mechanism had a chance to pick item ˆj2 from T1 as j2, it must be the case that v2( j2) v2(ˆj2) (and possibly j2 = ˆj2). If j1 = ˆj1, then T2 \ j1 = Si2 \ ˆj2, and

µ2 v2( Si2) = v2( Si2 \ ˆj2) + v2(ˆj2) v2(T2 \ j1) + v2( j2) = v2(X2).

Otherwise, j1 Si2, and

Si2 \ ˆj2 \ j1 T2 \ j1 v2( Si2 \ ˆj2 \ j1) v2(T2 \ j1). (12)

Since ˆj2 is the item with the highest value for agent 2 in Si2, v2( j2) v2(ˆj2) v2(k1). Combining with Eq. (12), we get that v2(T2 \ j1 { j2}) v2( Si2 \ ˆj2). Moreover, v2(T2 \ j1 { j2}) v2( j2) v2(ˆj2). Thus, v2(X2) = v2(T2 \ j1 { j2}) v2( Si2)/2 = µ2/2, as desired.

It is left to show that v1(X1) µ1/(2 + ϵ). If i1 = 2, then

v1( Si1) = v1( S2) v1(S2) (1 ϵ/4)µ1.

In this case, the same exact arguments used for agent 2 can be harnessed to show that v1(X1) (1 ϵ/4)µ1/2 µ1/(2 + ϵ). Thus, it is left to consider the case where i1 = 1.

Consider the (S1, S2) partition that is set in the first step of Cut-and-Balance-and-Choose. Since v1(S ) v1(S1)/2, we have

v1( S1) v1(S1)/2 (1 ϵ/4)µ1/2 µ1 2 + ϵ.

If j2 = ˆj2, we have that

v1(X1) = v1( S1 { j1} \ {ˆj1}) v1( S1) µ1 2 + ϵ,

where the first inequality follows since v1( j1) v1(ˆj1).

Note also that if |S2| = 1 i.e., S2 = {a}, if ˆj2 = a then v1(X1) v1(S2) since a T2, similarly if j2 = a then v1(X1) v1(S2), finally we have ˆj2 = k2 = a and v1(X1) µ1/(2 + ϵ) an in the first case.

Therefore, we assume j2 = ˆj2 and |S2| > 1, and let ˆj 1 arg maxj S1\{ˆj1}v1(j)

v1(X1) = v1(T1 { j1} \ { j2})

= v1(T1) + v1( j1) v1(k2)

v1( S1 {ˆj2} \ {ˆj1}) + v1(ˆj1) v1( j2)

v1( S1 \ {ˆj1}) + v1(ˆj1) v1( j2)

= v1(S1 \ S \ {ˆj1}) + v1(ˆj1) v1( j2)

v1(S1 \ S \ {ˆj1}) + v1(ˆj1) v1(ˆj 1)

= v1(S1 \ S \ {ˆj1, ˆj 1}) + v1(ˆj1),

where the first inequality is since, v1 j1 = maxj T2 v1j v1ˆj1. The second inequality is since v1(ˆj2) 0, the third inequality is by ˆj 1 definition since j2 S1 \ ˆj1 by our assumption that k2 = ˆj2. Finally, we have have |S1 \ S \ {ˆj1, ˆj 1}| |S | since

|S1| 2 |S | = |S1| 2 (m/2 |S2|) = |S1| 2 (m/2 (m |S1|)) = m/2 2 |S |,

where the last inequality is since |S2| > 1. Since we handles the case |S2| = 1 earlier, we can here assume |S2| > 1 in which case the set S is required to satisfy v1(S ) v1(S1 \ {ˆj, ˆj })/2. Therefore, we have v1(S1 \ S \ {ˆj1, ˆj 1} v1(S ).

(1 ϵ/4)µ1 v1(S1) = v1(S1 \ S \ {ˆj1, ˆj 1}) + v1(ˆj1) + v1(ˆj 1) + v1(S )

v1(S1 \ S \ {ˆj1, ˆj 1}) + 2 v1(ˆj1) + v1(S )

2 v1(S1 \ S \ {ˆj1, ˆj 1}) + 2 v1(ˆj1) 2 v1(X1),

which implies that v1(X1) µ1 2+ϵ, finishing the proof.

H Mechanisms for n agents

In this section we provide a learning-augmented mechanism for n > 2 agents, Learning Augmented-MMS-for-n-Agents. The mechanism we devise ensures that if the predictions are accurate, then each agent gets an allocation with value at least µn i /2 (2 consistency). On the other hand, we show that for any prediction, every agent gets at least µˆn i /α for ˆn = 3n/2 and α = max{m ˆn 1, 1} (robustness). Theorem H.1. The Learning-Augmented-MMS-for-n-Agents Mechanism (Mechanism 6) is truthful, 2-consistent and (µˆn i /α)-robust for ˆn = 3n/2 and α = max{m ˆn 1, 1}.

H.1 An Overview

The Mechanism. The mechanism works in three phases. In the first phase, it uses the predictions in order to obtain a partial allocation to agents with high predicted items (which are then removed from the set of active agents, so that we can now that for all agents, all predicted values are small). Then, in the second stage, the mechanism uses the predictions in order to obtain a tentative allocation, by running a Round-Robin procedure, where items are tentatively allocated to agents according to their predictions. In the third and final phase, the tentative allocation is used to implement a recursive plant and steal procedure, where the planting is done from the tentative allocations according to predictions, but the stealing is done according to the agents reports and results in a final allocation.

MECHANISM 6: Learning-Augmented-MMS-for-n-Agents Input :Set of agents N, set of items M, reports r N, predictions p N Output : A partition of the items S i N Xi Invoke Algorithm 7, X Allocate-Large(N, M, r N, p N) Invoke Algorithm 9, A Tentative-Allocation-Round-Robin(N, M, p N) Invoke Algorithm 10, X Split-Plant-Steal-Recurse(N, A,first-level-flag = True, X, r N, p N)

Figure 3: Illustration of a single round of the recursive planting and stealing phase (Algorithm 10), for the case where predictions are accurate (so that each agent steals back their planted item). Note that the stealing is done from the union of items of agents in the opposite set (and not just from the corresponding agent).

Consistency. In the case the predictions are accurate, the initial allocation phase will take care of agents with high valued items (of value larger than µn i /2). Then, in the second phase, the tentative allocation will be exactly identical to a Round-Robin allocation (made according to true valuations). Finally, in the third phase, since agents steal in the same order they were allocated the items in the Round-Robin allocation, and since the predictions are accurate, the agents steal back the same item the mechanism plants. Since a Round-Robin allocation achieves µn i /2 when there are no agents with high valued items [8], correctness follows.

Robustness. In the case the predictions are inaccurate, we show that every agent still gets at least µˆn i /α. Here we rely on the plant-and-steal phase to ensure that each agent gets at least their 3n/2 highest-valued item according to their true valuation. This property provides our robustness guarantee. We notice that reversing the order between the first and subsequent rounds of the Round-Robin procedure (and thus, the stealing phases) gives an enhanced robustness guarantee.

Prediction. In the description of the mechanism, we assume the mechanism is given a prediction of agents valuations. We note that in order to implement the mechanism it is enough to be given access to agents preference order over items, and an additional information indicating which items are worth more than µn i /2 for each agent i.

Due to space constraints the proof of Theorem H.1 is deferred to Appendix H.3, and we now provide a detailed description of the different phases.

H.2 Implementation Details

As discussed, in order to utilize the Round-Robin mechanism, we first allocate a single item to each agent with a high predicted value.

ALGORITHM 7: Allocate-Large Input :Set of agents N, set of items M, reports r N, predictions p N Output :A partial allocation S i B Xi, updated sets of agents and items N, M, respectively foreach i N do Compute µn i based on pi while exists i N such that p i (M) µn i /2 do Xi {r1 i (M)} M M \ Xi N N \ {i}

Before describing the tentative allocation mechanism, we first give a procedure, Allocate-Best, which performs a single round of Round-Robin according to a specific order, and preferences (either predictions or reports), denote o.

PROCEDURE 8: Allocate-Best (One-Round-RR) Input : Ordered set of agents N, set of items M, valuation v N Output :|N| singletons Xi M foreach i N do Xi v i (M) M M \ Xi

The tentative allocation mechanism repeatedly invokes Allocate-Best according to given predictions, until all items are tentatively allocated. As previously mentioned, the first round of the tentative allocation is performed according to the given order, and in all subsequent rounds, the order is reversed (recall that reversing the order enhances the robustness guarantees).

ALGORITHM 9: Tentative-Allocation-Round-Robin Input :Ordered set of agents N = (i1, . . . , i|N|), set of items M, predictions p N Output : A tentative allocation S i N Ai = M A Allocate-Best(N, M, p N) M M \ i NAi

/* Reverse the order for the allocation of the rest of the items */ N r = (i|N|, . . . , i1) for k = 2, . . . , m/n do A = Allocate-Best(N r, M, p Nr) Ai Ai Ai for i N M M \ i N Ai

The final phase in the mechanism is a recursive plant and steal algorithm. The input to this algorithm is an ordered set of agents N, along with their predictions, reports, and a tentative allocation for each agent. At each recursive invocation, the algorithm splits the set of agents into two (almost) equal-size ordered sets N0 and N1. Then the mechanism plants for the ith agent in each set Nb their highest (according to predictions) valued item in their tentative allocation in the tentative set of the ith agent in N b. Then we perform one round of Round-Robin, where the items available to the agents of set Nb are those tentatively allocated to the agents of N b (after the planting phase), and the allocations are determined according to agents reports. See Figure 3 for an illustration of a single round of plant and steal. The algorithm then recurses on each of the sets N0 and N1, until all sets are of size 1. At this point, the single agent in the set is further allocated its remaining tentatively allocated items, and the process terminates.

ALGORITHM 10: Split-Plant-Steal-Recurse

Input :Ordered set of agents N = (i1, . . . , i|N|), tentative allocations A, partial allocations XN, first-level-flag indicating if this is the first level of the recursion, reports r N, predictions p N

/* Halting condition - Allocate all remaining items */ if N = {i} then set Xi = Xi Ai and halt

/* Split the agents into two almost-equal parts */ par = |N| mod 2 N0 (i1, i3, . . . , i|N| 1+par) N1 (i2, i4, . . . , i|N| par)

/* Plant according to predictions */ for i = 1,..., |N|/2 do Let i0, i1 denote the ith agent in N0, N1 respectively. j 0 = p i0(Ai0) j 1 = p i1(Ai1) Ai0 = Ai0 + j 1 j 0 Ai1 = Ai1 + j 0 j 1 /* Plant in s favorite item in a tentative set */ if par = 1 then i0 = in,i1 = i2 j 0 = p i0(Ai0) Ai1 = Ai1 + j 0, Ai0 = Ai0 j 0 /* Steal from the opposite set according to reports */ foreach b {0, 1} do ˆ X=Allocate-Best(Nb, AN b, r) foreach i N do Xi Xi ˆ Xi /* Reverse the order after the first level of recursion */ if first-level-flag then N0 (i|N| 1+par, . . . , i3, i1) N1 (i|N| par, . . . i4, i2)

/* Recursively invoke Split-Plant-Steal-Recurse on each set */ foreach b {0, 1} do Split-Plant-Steal-Recurse(Nb, ANb, XNb,first-level-flag = False)

Given the above implementation details, it remains to prove Theorem H.1 regarding truthfulness, consistency and robustness of the mechanism. The proof is given in Appendix H.3.

H.3 Missing Details from Section H

In this section we prove Theorem H.1, which we now recall.

Theorem H.1. The Learning-Augmented-MMS-for-n-Agents Mechanism (Mechanism 6) is truthful, 2-consistent and (µˆn i /α)-robust for ˆn = 3n/2 and α = max{m ˆn 1, 1}.

First, we give a simple observation regarding Algorithm 7.

Observation H.1. The followings hold for Algorithm Allocate-Large.

1. If the reports equal the true valuations, and agent i is allocated an item j, then vi(j) vn i /2.

2. After the algorithm completes its run, there are no remaining agents in N with large predicted values for the remaining items in M.

We continue to prove each of the properties specified in Theorem H.1 separately, starting with truthfulness.

Lemma H.1 (Truthfulness). Mechanism Learning-Augmented-MMS-for-n-agents (Mechanism 6) is truthful.

Proof. Algorithm Tentative-Allocation-Round-Robin (Algorithm 9) only depends on agents predictions and not their reports. Hence, we only need to consider the use of the reports in Algorithms 9 and 10.

For every agent i, either they are allocated a single item in Algorithms 9, or i participates in the recursive plant ant steal, and this is determined according to the predictions, so in particular ri has no affect on this. Thus, we can consider the two independent events separately. In the first case, where i is allocated a single item, it is the item that maximizes their report over remaining items at that point, so that i has no incentive to lie.

In the second case, i participates in the plant and steal phase. Observe that in this case, whenever i chooses an item from some set A , it will have no future interaction with this set. That is, fix a recursive call and assume without loss of generality that i N0. Then after the planting step, i is allocated the item in AN1 that maximizes their reports. Then, in following recursive steps, i only continues to interact with items in AN0, so i s choice does not affect the identity of the items from which i will be able to choose from in future rounds. Hence, i s only incentive is to maximize the value of its allocated value in each round, implying truthfulness.

Due to the above lemma, from now on we assume agents report truthfully, i.e., that for every agent i, ri = vi. We turn to show the mechanism is consistent, we rely on the following theorem.

Theorem H.2 (Lemma 2 in [10] (based on Theorem 3.5 in [8])). If for every i N and j M, vi(j) 1

2µn i , then the Round-Robin algorithm returns an allocation that is a 2-approximation to the MMS.

Furthermore, their analysis holds when changing the order of allocation between the different rounds of the Round-Robin.

We are now ready to prove the mechanism is consistent.

Lemma H.2 (Consistency). If the set of predictions is accurate, then for every i, vi(Xi) µn i /2.

Proof. First consider agents that were allocated an item in Algorithm Allocate-Large (Algorithm 7). If the predictions are accurate, then each such agent i is allocated an item j such that vi(j) µn i /2 and so the statement holds. Moreover, at the end of this step, there are no remaining agents with large predicted values, hence, no agents with large values remain.

If the set of predictions is accurate, then the tentative allocation determined according to agents predictions in Algorithm Tentative-Allocation-Round-Robin ( Algorithm 9) is identical to a Round-Robin mechanism according to valuations, with reversing the order between the first and all subsequent rounds. Furthermore, by the above, there are no agents with large values when the Round-Robin is invoked. Therefore, by Theorem H.2, it holds that for every i, vi(Ai) µn i /2. We shall prove that for every agent i, its final allocation equals its tentative allocation, Xi = Ai, concluding the proof.

We prove that in depth k of the recursion, every agent i is allocated the kth item in Ai. We prove the claim by induction on the depth k of the recursion, and the ℓth agent in that round that is allocated some value.

We first prove for k = 1, ℓ= 1. In the plant phase, ℓ0(= 1) plants j = p ℓ0(Aℓ0) in Aℓ1. Then, in the stealing phase, during the invocation of Algorithm 8, agent ℓ0 is the first to choose an item from AN1,

which in particular contains j. Hence, the first item in A1 is allocated into X1. We now assume the claim holds for k = 1 and ℓ 1 and prove it for ℓ. Assume without loss of generality that ℓis odd so that iℓ N0.

In step ℓof the planting phase, the mechanism plants ℓ0 s (the proof for ℓ1 is identical) first (according to value pℓ0) item in Aℓ0. Then, during the tentative allocation phase, agent ℓ0 is the ℓth to choose among the items in AN1 minus the items that were allocated to the ℓ 1 agents that were before her in the tentative Round-Robin. By the induction hypothesis, every agent preceding her chose the item the mechanism planted for them previously in that round. Therefore, the item j that the mechanism planted for agent ℓ0 is still available. Moreover, let M ℓ 1 denote the set of items after ℓ 1 rounds of the tentative Round-Robin in Algorithm 9. Further let Aℓ 1 N1 denote the set of items after ℓ 1 rounds of the Allocate-Best algorithm invoked in the stealing phase with the set N0, i.e., Aℓ 1 N1 = AN1 \ S j N0,j<ℓ{Xj}. Since the order in which the agents plant and steal in each round of the recursion is equivalent to the order in which the corresponding tentative allocation round was performed, it holds that Aℓ 1 N1 M ℓ 1. Since j = p ℓ0(M ℓ 1), and pℓ0 = rℓ0, it holds that r ℓ0(Aℓ 1 N1 ) equals j. Therefore ℓ0 will choose j to Xℓ0 as claimed.

Proving the claim for a general k is almost identical. At the planting phase of the kth round, the mechanism plants for every agent ℓ0 N k 0 their kth item of Ai in AN k 1 and vice versa. A similar argument to the one above, shows that this item will remain available until its their turn to choose an item for allocation, as by the recursion hypothesis, all agents preceding i in the Round-Robin will select the items the mechanism planted for them. Hence, the kth item in Aℓ0 will be allocated to Xℓ0.

Finally, once the set agent i belongs to becomes a singleton, by our halting condition, Xi Xi Ai, so together with the previous argument, we get that for every ℓ, Xi = Ai as needed.

We continue to prove that the mechanism is robust. Since when m < ˆn, µˆn i = 0 for every agent i, and each agent trivially gets their MMS value, we assume from now on that m ˆn and show the mechanism achieves (m ˆn 1)-robustness for µˆn i . We first prove in Lemma H.3 that for each agent i, vi(Xi) v 3n/2 i , and then prove in Lemma H.5 that the value of this item is not too small compared to µ 3n/2 i .

Lemma H.3. For every agent i, vi(Xi) v 3n/2 i .

Proof. We first prove the claim for agents that were allocated a value during the invocation of Algorithm 7. By the definition of the algorithm and its truthfulness when agent i is allocated an item, at most n 1 items were previously allocated to other agents. Hence, she can always choose her nth

highest valued item. Therefore, we have vi(Xi) vn i v 3n/2 i , as claimed.

We continue to prove the claim for the set of agents with no large predicted values. Consider the ℓth agent in N, iℓ, and consider the following coloring process. Initially, color all items in M black. We will then color all items iℓwas able to choose from green, and items allocated before she had the chance to choose from gray (note that these colors are unrelated to the ones in the figure). Note that an item turns green when it belongs to the tentative allocation of opposite set to iℓ s and has not been taken by agents preceding her in the allocation order. We claim that by the time no black items remain, at most 3n/2 1 have turned gray, implying that at some point during the recursion, iℓ could have chosen their 3n

2 th highest valued item (according to riℓ).

We let N k denote the set of agents to which iℓbelongs to at depth k of the recursion, starting with N 1 = N. At each recursive call, N k is partitioned into N k 0 , N k 1 . We further let bk {0, 1} denote the index of the set to which iℓbelongs to: iℓ N k bk. We will separately bound the number of items turned gray due to agents in N k bk and N k bk.

In the first iteration, for k = 1, let A1 N1 b0, A1 N 1 b0 denote the tentative sets allocated to the agents of

N 1 0 and N 1 1 after the planting phase (i.e., at the beginning of the stealing phase).

The number of items that turn gray due to agents in N 1 b1 is G1 b1 = ℓ/2 1, since iℓhas access to all items in A1 N b1 excluding the ℓ/2 1 items that were allocated to the agents in her set preceding her in the ordering. (The rest of the items in A1 N b1 turn green.)

Turning to G1 b1, each agent in the opposite set to hers, N 1 b1, is allocated a single item (from A1 N1 b1 )

before continuing to the next round of the recursion. Therefore, G1 b1 = |N 1 b1| (and no item turns green).

The recursion then continues with N 2 = N 1 b1 and in reversed order (due to the order being reversed). Therefore, at the beginning of the second iteration, iℓis in location |N 1 b1| ℓ/2 in N 2. After the

partition phase, iℓis in set N 2 b2 and in location |N1 b1| ℓ

2 2 . Hence, G1 b1 = |N1 b1| ℓ

2 2 1 due to agents in her set preceding here in the ordering. Also, G1 b1 = |N 1 b1| due to allocations to agents in the opposite set to hers.

From now on, the order is preserved, so for every k 3, Gk bk = |N k bk| and Gk bk = |N 1 b1| ℓ/2

We continue by bounding P log n k=1 Gk bk = P log n k=1 |N k bk|. Observe that if N k is even then N k bk = N k bk = N k/2, and if N k is odd, then either N k bk is odd and N k bk is even or vice versa. In the first case, Gk bk = N k/2 and we recurse with N k bk which is of size N K/2 . In the second case, Gk bk = N K/2 and we recurse with N k bk of size N k/2 . Hence, we have the following recursion formula. For even ℓ, T(ℓ) = ℓ/2 + T(ℓ/2), and for odd ℓ, either (a) T(ℓ) = ℓ/2 + T( ℓ/2 ) or (b) T(ℓ) = ℓ/2 + T( ℓ/2 ). In Claim H.4 below, we prove that for such a function, if it also holds that T(1) = 0 and T(2) = 1, then T(ℓ) ℓ 1. Therefore, we get that P log n k=1 Gk bk n 1.

We continue to bound P log n k=2 Gk bk = P log n k=2 |N 1 b1| ℓ/2

2k 1 1. The sum P log X k=1 X

bounded by P log X k=1 X 2k + L, where L is the number of indices k for which the fraction X/2k is rounded up. Observe that for every X, L can be bounded above by log X as L exactly equals the number of 1 bits in the binary representation of X. Hence, the overall number of items that turn gray can be bounded as follows:

Gk bk + Gk bk

n 1 + ℓ/2 1 +

n 1 + ℓ/2 1 + n/2 ℓ/2 + log n log n + 1 3n/2 1.

Therefore, the number of items that turn gray by the end of the recursion is at most 3n/2 1, and so iℓget their 3n/2 highest valued item v 3n/2 iℓ .

We now prove the claim regarding the cost of the recursion that was used in the previous lemma.

Lemma H.4. Let T(n) be such that T(n) = n/2 + T(n/2) if n is even and either (a) T(n) = n/2 + T( n/2 ) or (b) T(n) = n/2 + T( n/2 ) for odd n. Also assume T(1) = 0, T(2) = 1. Then T(n) n 1.

Proof. We prove the claim by induction on n. By T(1) = 0 and T(2) = 1 so the induction basis holds. We now assume correctness for all values smaller than n and prove for n.

If n is even then T(n) = n/2 + T(n/2) n/2 + n/2 1 = n 1, so the claim holds.

If n is odd, then in case (a), T(n) = n/2 + T( n/2 ) n/2 + n/2 1 = n 1, and in case (b), T(n) = n/2 + T( n/2 ) 1 n/2 + n/2 1 = n 1.

Finally, we prove that the highest valued item allocated to each agent i is not too small compared to their MMS.

Lemma H.5. Consider an MMS for agent i, and let j be the highest valued item of i in her allocation. Then vi(j ) µ 3n/2 i /α for α = m 3n/2 1.

Proof. Consider an MMS allocation of M for k = 3n/2 , and let Ai be the set such that vi(Ai) = µk i . By the assumption on j , its value is higher then the highest valued item in Ai, vi(j ) v1 i (Ai). Therefore, vi(Ai) |Ai| vi(j ), implying vi(j ) vi(Ai)/|Ai| = µk i /|Ai|. Since |Ai| m k 1 (as at least k 1 items must be allocated to the k 1 additional agents, it holds that vi(j ) µ3n/2 i /(m 3n/2 1).

Proof of Theorem H.1. The theorem follows by Lemmas H.1, H.2, H.3, and H.5.

Neur IPS Paper Checklist

The checklist is designed to encourage best practices for responsible machine learning research, addressing issues of reproducibility, transparency, research ethics, and societal impact. Do not remove the checklist: The papers not including the checklist will be desk rejected. The checklist should follow the references and follow the (optional) supplemental material. The checklist does NOT count towards the page limit.

Please read the checklist guidelines carefully for information on how to answer these questions. For each question in the checklist:

You should answer [Yes] , [No] , or [NA] . [NA] means either that the question is Not Applicable for that particular paper or the relevant information is Not Available. Please provide a short (1 2 sentence) justification right after your answer (even for NA).

The checklist answers are an integral part of your paper submission. They are visible to the reviewers, area chairs, senior area chairs, and ethics reviewers. You will be asked to also include it (after eventual revisions) with the final version of your paper, and its final version will be published with the paper.

The reviewers of your paper will be asked to use the checklist as one of the factors in their evaluation. While "[Yes] " is generally preferable to "[No] ", it is perfectly acceptable to answer "[No] " provided a proper justification is given (e.g., "error bars are not reported because it would be too computationally expensive" or "we were unable to find the license for the dataset we used"). In general, answering "[No] " or "[NA] " is not grounds for rejection. While the questions are phrased in a binary way, we acknowledge that the true answer is often more nuanced, so please just use your best judgment and write a justification to elaborate. All supporting evidence can appear either in the main paper or the supplemental material, provided in appendix. If you answer [Yes] to a question, in the justification please point to the section(s) where related material for the question can be found.

IMPORTANT, please:

Delete this instruction block, but keep the section heading Neur IPS paper checklist", Keep the checklist subsection headings, questions/answers and guidelines below. Do not modify the questions and only use the provided macros for your answers.

Question: Do the main claims made in the abstract and introduction accurately reflect the paper s contributions and scope? Answer: [Yes] Justification: The abstract is a high-level description of the results of the paper. The intro introduces a more detailed dive into the results, with a our results and techniques" section, where we try to give a detailed overview of our technical contributions. Moreover, Table 1 is given to provide an easy-to-understand summary of our theoretical results. Guidelines:

The answer NA means that the abstract and introduction do not include the claims made in the paper. The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers. The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings. It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper. 2. Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [No]

Justification: This is mainly a theoretical paper, and all the assumptions are clearly stated.

Guidelines:

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper. The authors are encouraged to create a separate "Limitations" section in their paper. The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be. The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated. The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon. The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size. If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness. While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren t acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

3. Theory Assumptions and Proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [Yes]

Justification: The paper contains a detailed preliminary section where the model is fully described. The theorems and complete, and the ones not appearing in the body appear in the appendix.

Guidelines:

The answer NA means that the paper does not include theoretical results. All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced. All assumptions should be clearly stated or referenced in the statement of any theorems. The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition. Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material. Theorems and Lemmas that the proof relies upon should be properly referenced.

4. Experimental Result Reproducibility

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [Yes]

Justification: Using the code provided, it is possible to reproduce the main experimental results.

Guidelines:

The answer NA means that the paper does not include experiments. If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not. If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable. Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed. While Neur IPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example (a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm. (b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully. (c) If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset). (d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.

5. Open access to data and code

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [Yes]

Justification: The code can be accessed via the link: https://tinyurl.com/Plant Steal Experiments.

Guidelines:

The answer NA means that paper does not include experiments requiring code. Please see the Neur IPS code and data submission guidelines (https://nips.cc/ public/guides/Code Submission Policy) for more details. While we encourage the release of code and data, we understand that this might not be possible, so No is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark). The instructions should contain the exact command and environment needed to run to reproduce the results. See the Neur IPS code and data submission guidelines (https: //nips.cc/public/guides/Code Submission Policy) for more details. The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.

The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why. At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable). Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.

6. Experimental Setting/Details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [Yes]

Justification: We describe how the data is generated and provide the code.

Guidelines:

The answer NA means that the paper does not include experiments. The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them. The full details can be provided either with the code, in appendix, or as supplemental material.

7. Experiment Statistical Significance

Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?

Answer: [Yes]

Justification: The paper experiments with Bernoulli variables (indicating either success or failure) with non-negligible p values, which are known to be very highly concentrated.

Guidelines:

The answer NA means that the paper does not include experiments. The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper. The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions). The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.) The assumptions made should be given (e.g., Normally distributed errors). It should be clear whether the error bar is the standard deviation or the standard error of the mean. It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified. For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates). If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.

8. Experiments Compute Resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [Yes]

Justification: The experiments were done on a standard PC (Intel i9, 32GB memory), and it took approximately 30 minutes. Guidelines:

The answer NA means that the paper does not include experiments. The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage. The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute. The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn t make it into the paper). 9. Code Of Ethics

Question: Does the research conducted in the paper conform, in every respect, with the Neur IPS Code of Ethics https://neurips.cc/public/Ethics Guidelines? Answer: [Yes]

Justification: The paper studies a mechanism design problem with the objective of outputting a fair allocation, which is a highly desirable goal. We study a generalization of the widely studied proportionality objective for discrete settings. We note that this objective is well motivated in settings like course-allocation [18], but might be inappropriate in other settings. The techniques in this paper should be used with appropriate care. Moreover, over paper suggests that using past data might increase fairness, but every usage of data should be taken with extra precautions, as these might introduce implicit biases, as shown in the past. Guidelines:

The answer NA means that the authors have not reviewed the Neur IPS Code of Ethics. If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics. The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction). 10. Broader Impacts

Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed? Answer: [Yes] Justification: Introducing a learning-augmented framework is shown to obtain stronger theoretical fairness guarantees than other mechanisms studied in the literature. Elements in the design might improve the performance of fair allocation mechanisms in settings such as course allocation, which is of course a positive societal impact. On the other hand, using past data can also result in introducing biases to the allocation, thus, using data should be done with awareness to such potential biases. Guidelines:

The answer NA means that there is no societal impact of the work performed. If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.

The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML). 11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)? Answer: [NA] Justification: Guidelines:

The answer NA means that the paper poses no such risks. Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters. Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images. We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort. 12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected? Answer: [NA] Justification: No third-party packages are used, and the data used for experiments is synthetic. Guidelines:

The answer NA means that the paper does not use existing assets. The authors should cite the original paper that produced the code package or dataset. The authors should state which version of the asset is used and, if possible, include a URL. The name of the license (e.g., CC-BY 4.0) should be included for each asset. For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided. If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset. For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided. If this information is not available online, the authors are encouraged to reach out to the asset s creators. 13. New Assets

Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets? Answer: [Yes]

Justification: Experimental details are described and documented code is provided. Guidelines:

The answer NA means that the paper does not release new assets. Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc. The paper should discuss whether and how consent was obtained from people whose asset is used. At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file. 14. Crowdsourcing and Research with Human Subjects

Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)? Answer: [NA] Justification: [NA] Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects. Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper. According to the Neur IPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector. 15. Institutional Review Board (IRB) Approvals or Equivalent for Research with Human Subjects Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained? Answer: [NA] Justification: [NA] Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects. Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper. We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the Neur IPS Code of Ethics and the guidelines for their institution. For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.