Deterministic, Strategyproof, and Fair Cake Cutting
Vijay Menon, Kate Larson

TL;DR
This paper investigates the limitations of deterministic, strategyproof, and fair mechanisms in cake cutting, revealing several impossibility results and proposing improvements to existing algorithms under specific conditions.
Contribution
It provides new impossibility results for strategyproof and approximately proportional cake cutting mechanisms and offers a modified algorithm with better incentive properties for small agent groups.
Findings
No strategyproof, approximately proportional, non-wasteful mechanisms for piecewise constant valuations.
Contiguous allocations cannot be strategyproof and approximately proportional.
Modified Even-Paz algorithm improves incentive compatibility for two or three agents.
Abstract
We study the classic cake cutting problem from a mechanism design perspective, in particular focusing on deterministic mechanisms that are strategyproof and fair. We begin by looking at mechanisms that are non-wasteful and primarily show that for even the restricted class of piecewise constant valuations there exists no direct-revelation mechanism that is strategyproof and even approximately proportional. Subsequently, we remove the non-wasteful constraint and show another impossibility result stating that there is no strategyproof and approximately proportional direct-revelation mechanism that outputs contiguous allocations, again, for even the restricted class of piecewise constant valuations. In addition to the above results, we also present some negative results when considering an approximate notion of strategyproofness, show a connection between direct-revelation mechanisms and…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Deterministic, Strategyproof, and Fair Cake Cutting
Vijay Menon
Kate Larson
Abstract
We study the classic cake cutting problem from a mechanism design perspective, in particular focusing on deterministic mechanisms that are strategyproof and fair. We begin by looking at mechanisms that are non-wasteful and primarily show that for even the restricted class of piecewise constant valuations there exists no direct-revelation mechanism that is strategyproof and even approximately proportional. Subsequently, we remove the non-wasteful constraint and show another impossibility result stating that there is no strategyproof and approximately proportional direct-revelation mechanism that outputs contiguous allocations, again, for even the restricted class of piecewise constant valuations. In addition to the above results, we also present some negative results when considering an approximate notion of strategyproofness, show a connection between direct-revelation mechanisms and mechanisms in the Robertson-Webb model when agents have piecewise constant valuations, and finally also present a (minor) modification to the well-known Even-Paz algorithm that has better incentive-compatible properties for the cases when there are two or three agents.
1 Introduction
Imagine a scenario where there is heterogeneous divisible good that is to be divided among a certain set of agents. For an appropriately chosen notion of fairness, ideally, we would like this resource to be divided fairly among these agents and so a natural question that arises is on how one would accomplish this. The cake-cutting problem metaphorically refers to this very scenario and it represents a fundamental problem in the theory of fair division. More formally, in the cake cutting problem, the cake is modelled as the interval and each of the agents is assumed to have a valuation function over the cake. The goal, as described above, is to partition the cake so that it is fair according to some chosen notion of fairness. Starting with the work of Steinhaus [1948], it has been studied over the last several decades by mathematicians, economists, and political scientists (see e.g. the books by Brams and Taylor [1996] and Robertson and Webb [1998]), and more recently has attracted the attention of computer scientists (see e.g. the survey by Procaccia [2016]) partly due to the nature of the challenges involved—that often require an algorithm design or complexity point of view—and partly due to its relevance in the design of multiagent systems [Chevaleyre et al., 2006].
Most work in the cake cutting literature focuses on addressing the above described scenario and so most of it is concerned with computing a fair allocation using proportionality or envy-freeness as the main fairness criterion (see [Aziz and Mackenzie, 2016] and also [Procaccia, 2016] for a recent survey). While addressing the above scenario is indeed the core part of the problem, the fact that the valuation functions of the agents may be their private information entails that the designed protocols or mechanisms be strategyproof—meaning that there is no incentive to misreport one’s valuation function—for if otherwise the agents can lie about their valuation functions and potentially benefit from it. Therefore, the focus of this paper, like in [Chen et al., 2010, 2013; Mossel and Tamuz, 2010; Maya and Nisan, 2012; Aziz and Ye, 2014; Brânzei and Miltersen, 2015], is to look at mechanisms that are not only fair, but also strategyproof.
In this paper, we look at deterministic mechanisms and we are primarily focused on the direct-revelation model—one where the agents reveal their entire valuation function. Our main objective is to better understand the limits of determinism when it comes to imposing strategyproofness and fairness (or approximate notions of either of them)—i.e., to see what is or is not achievable with deterministic mechanisms—and to this end we make the following contributions.
- a)
In Section 3 we begin by looking at non-wasteful mechanisms and we show the following strong impossibility which in turn strengthens an impossibility result given Aziz and Ye [2014, Theorem 7].
For any and such that , there is no deterministic and non-wasteful mechanism for agents with piecewise constant valuations that is -strategyproof and -proportional. 2. b)
In Section 4 we remove the non-wasteful constraint and provide the following results. The first one addresses a special case (one where the allocations are restricted to contiguous allocations) of an open question posed by Chen et al. [2010, 2013]. The second result establishes a connection between direct-revelation mechanisms and mechanisms in the Robertson-Webb model for the case when agents have piecewise constant valuations. And finally, the third one is a positive result where we present a (minor) modification to the well-known Even-Paz algorithm that has better incentive-compatible properties for the cases when there are two or three agents.
For any and , there is no deterministic mechanism for agents with piecewise constant valuations that makes contiguous allocations and is strategyproof and -proportional. 2. 3.
Let denote the property of strategyproofness, proportionality, and envy-freeness, respectively, and let . Given , an upper bound on the maximum number of breakpoints in any agent’s valuation function, and any , if there exists a (finite) deterministic direct-revelation mechanism for agents with piecewise constant valuations that satisfies , , then, for any , there exists a mechanism in the Robertson-Webb model for agents with piecewise constant valuations that asks at most queries on each input and is -, . 3. 4.
*There exists a mechanism that is deterministic, proportional, and -strategyproof, where or depending on whether is even or odd, respectively. This mechanism achieves a better worst-case bound (as compared to the Even-Paz algorithm) in terms of -strategyproofness for the cases when there are two or three agents. *
1.1 Related Work
The cake cutting problem has been studied using two input models. The first, and in fact the most ubiquitously used model in the literature, is the Robertson-Webb model where the mechanism proceeds through a sequence of queries on the valuation functions of the agents. The second is the direct-revelation model where the input to the mechanism is the complete valuation functions of the agents. Given this, we can classify the work on strategic aspects of cake cutting into two classes based on the input model used and look at each of them separately. (Note that there is a large body of literature on cake cutting that does not consider strategic issues. For this, we refer the reader to a very recent survey by Procaccia [2016].)
There are mainly five related papers [Chen et al., 2010, 2013; Mossel and Tamuz, 2010; Maya and Nisan, 2012; Aziz and Ye, 2014; Li et al., 2015; Alijani et al., 2017] that operate in the direct-revelation model and at the same time look at strategic issues in cake cutting. Among them, the ones that are most relevant to results in this paper are the works of Chen et al. [2010, 2013] and Aziz and Ye [2014]. Chen et al. [2010, 2013] were the first to look at strategyproof cake cutting. In particular, they considered piecewise uniform, piecewise constant, and piecewise linear valuations, and their main result was a deterministic, strategyproof, envy-free, proportional, and Pareto-optimal mechanism for the case when the agents have piecewise uniform valuations. In addition to their main result, they also presented randomized algorithms that are truthful in expectation, proportional, and envy free for piecewise linear valuations. One of our results here (Theorem 4) addresses a special case of an open question they had posed in their paper regarding deterministic and strategyproof mechanisms for the case when the agents have piecewise constant valuations.
The other most relevant work that operates in the direct-revelation model is that of Aziz and Ye [2014]. They present two mechanisms, CCEA and MEA, for piecewise constant valuations, where CCEA is deterministic, robust envy-free111Robust envy-freeness and robust proportionality are much stronger notions than envy-freeness and proportionality, respectively; see [Aziz and Ye, 2014] for more details., and non-wasteful, and MEA is deterministic, Pareto-optimal, and envy-free. Although both of them generalize the mechanism proposed by Chen et al. [2010, 2013] when restricted to piecewise uniform valuations, they do not remain strategyproof for piecewise constant valuations. Additionally, they also showed that there is no mechanism that is strategyproof, robust proportional111Robust envy-freeness and robust proportionality are much stronger notions than envy-freeness and proportionality, respectively; see [Aziz and Ye, 2014] for more details., and non-wasteful for piecewise constant valuations. One of our results here (Theorem 1) strengthens the latter impossibility result.
Besides the two papers mentioned above, Mossel and Tamuz [2010] provided an impossibility result regarding the existence of deterministic mechanisms that guarantee when all the agents have the same valuation function and greater than otherwise. They also showed the existence of a randomized mechanism that is strategyproof in expectation and is proportional and envy-free (this existence result was also shown by Chen et al. [2010]). The work of Maya and Nisan [2012] considers the goals of strategyproofness and Pareto efficiency for two agents with piecewise uniform valuations and their main result shows that any strategyproof mechanism achieves at most fraction of the optimal welfare. Li et al. [2015] study the problem of designing strategyproof cake-cutting mechanisms in the presence of externalities when the agents have piecewise uniform valuations. They propose a way to model externalities and show some results on the existence of strategyproof mechanisms. Finally, Alijani et al. [2017] study the problem of designing strategyproof and envy-free mechanisms with the goal of minimizing the number of pieces in the final allocation. They primarily focus on the case when the agents’ valuations are constant over a single interval and they provide a mechanism that is strategyproof, envy-free, and cuts the cake into at most pieces for this setting.
Among papers that use the Robertson-Webb model, the two that are most related to this paper are the works of Kurokawa et al. [2013] and Brânzei and Miltersen [2015]. Kurokawa et al. [2013] looked at the problem of envy-free cake cutting and their main result was a parameterized protocol for piecewise linear valuations. Additionally, they also showed that there is no mechanism of complexity bounded only by a function of the number of agents and the total number of breakpoints that is strategyproof and envy-free for piecewise constant valuations.
The other most relevant paper that uses the Robertson-Webb model is that of Brânzei and Miltersen [2015]. Brânzei and Miltersen [2015] showed that any deterministic and strategyproof protocol is a dictatorship when there are only two hungry agents and for the case when there are more than two hungry agents they show that there is at least one agent who gets an empty piece. Additionally, they also provided a randomized mechanism that is strategyproof in expectation and -proportional for any . Although our impossibility results here are not quite as strong as that of Brânzei and Miltersen’s, we believe that it complements the same by considering a much more permissive input model.
Finally, we also briefly remark on the predefined divisible goods setting which has been extensively studied in fair division (see, for instance, Cheung [2016] and the references therein). In the predefined goods setting, the task is to fairly allocate divisible items among agents, where the private information of an agent is the value she has for each of the items. So, in effect, the predefined goods setting can be considered as a special case of the setting of cake cutting with piecewise constant valuations—i.e., one where the valuation functions of all the agents have the same set of breakpoints—and therefore all the negative results in that setting carry over to the cake cutting setting. However, some of the nice positive results with regards to strategyproof mechanisms in this setting (see, e.g., Cole et al. [2013] and Cheung [2016]) do not carry over to the cake cutting setting as here, informally, the difficulty in achieving strategyproofness arises from the fact that a mechanism has to guard against two types of manipulations: i) with regards to the breakpoints in the valuation functions and ii) with regards to the values assigned to the pieces between two consecutive breakpoints.
2 Preliminaries
The cake—which is a heterogeneous divisible good—is modelled as the unit interval . A piece of cake is a finite union of disjoint (except at the boundaries of the intervals) subintervals of . An interval is denoted by and the length of an interval is given by . In any cake cutting instance, there are agents who want a share of the cake and we denote them by . Each agent has a non-negative, integrable, and private value density function (also referred to as their utility/valuation function), , that indicates how agent values different parts of the cake, and given a piece of cake , the value for is defined by . (Note that the fact that the valuation functions are integrable implies additivity—meaning for two disjoint intervals and , .) Without loss of generality, we assume that the valuation functions are normalized, i.e., for all . Additionally, we say that agent is hungry if for all .
2.1 Input models
The way we have defined the valuation functions above, it is not necessary that they have a discrete representation. Therefore, most of the work in cake cutting assumes a query model—commonly known as the Robertson-Webb query model—that allows only the following two types of queries.
Eval query: given an interval , eval asks agent for its value for , i.e., eval = . 2. 2.
Cut query: given a point and , cut asks agent for the minimum (i.e., the leftmost) point such that .
Here we note that there exists an alternative formalization of the Robertson-Webb model where essentially it is required that all the cut points be defined by the agents and not by the center (see, e.g., [Woeginger and Sgall, 2007] and [Brânzei and Miltersen, 2015] where this formalization is used). However, here we use the slightly more permissive formalization as given by Procaccia [2013, 2016] and as defined above, where (if necessary) the center can make additional cuts once it has finished asking all the queries.
While the Robertson-Webb model is the most widely studied, there is recent work (e.g., Chen et al. [2010, 2013], Bei et al. [2012], Aziz and Ye [2014]) which restricts the agents’ valuation functions to ones that have a concise representation, thus in turn giving rise to another model (which we will refer to as the direct-revelation model) where the entire valuation functions of the agents are given as input to a mechanism. In this paper, we consider one fundamental class of restricted valuations, namely, piecewise constant valuations. An agent is said to have a piecewise constant valuation if can be partitioned into a finite number of intervals such that is a constant over each interval (i.e., it is a step function). A special case of piecewise constant valuations are the piecewise uniform valuations where, for some constant , the function can only take the values [math] or . One of the reasons why piecewise constant valuations are interesting is because they are expressive enough to be able to approximate any general valuation function.
In this paper, we make use of both input models. All our negative (impossibility) results are in the direct-revelation model, while the algorithm we present is in the Robertson-Webb model. Note that the existence of a mechanism in the Robertson-Webb model implies an existence in the direct-revelation model, but the converse is not necessarily true, and hence our negative results, in particular, are strong. Also, all our negative results are true for even the restricted class of piecewise constant valuations and hence naturally carry over to anything more general (like piecewise linear valuations).
2.2 Properties of cake cutting mechanisms
A direct-revelation cake cutting mechanism takes the valuation functions of the agents (which we refer to as a profile) as input and it outputs an allocation , where is the allocation to agent , and , and are disjoint (except at the boundaries of the intervals). While in general can be any arbitrary piece of cake, sometimes we concern ourselves only with contiguous allocations where each is a single interval. Throughout, we assume that the mechanism allocates (to some agent) all the pieces of cake that are valued at greater than zero by at least one of the agents. Additionally, we often use to denote , where denotes the valuation functions of all the agents except .
A mechanism is said to be non-wasteful if it allocates every piece that is desired—meaning that the piece is assigned a value greater than zero—by at least one agent to an agent who desires it. More formally, if is a subinterval of and , then a mechanism is non-wasteful if it always makes an allocation such that . In this paper, we consider both non-wasteful and wasteful mechanisms. Additionally, for all our negative results we assume free disposal, meaning that the mechanism can throw away pieces of cake that aren’t valued (at greater than zero) by any of the agents without incurring a cost. Note that the existence of a mechanism without the free disposal assumption implies the existence of a mechanism with the free disposal assumption, but the converse is not necessarily true. Hence, in the context of negative results, such an assumption only makes them stronger.
In this paper, we use (approximate) proportionality as our main fairness criterion. In the definition below, proportionality refers to the special case when . And so, throughout, when we say that a mechanism is proportional it implies that it is [math]-proportional.
Definition 1** (-proportionality).**
For any , a mechanism is said to be -proportional if it always returns an allocation such that .
Along with (approximate) proportionality, the other major property we are concerned with is (approximate) strategyproofness. Informally, for any , a cake cutting mechanism is said to be -strategyproof if an agent can gain a utility of at most by misreporting her valuation function. More formally, we have the following definition.
Definition 2** (-strategyproofness).**
For any , a mechanism is said to be -strategyproof if for every agent , and for all , .
Strategyproofness refers to the special case in the above definition when . And so, throughout, when we say that a mechanism is strategyproof (or truthful) it implies that it is [math]-strategyproof, or, in other words, that for every agent truth telling is a (weakly) dominant strategy. Here we note that this is not the first time the notion of approximate strategyproofness has been considered. For instance, Birrell and Pass [2011] considered it in context of voting and Schummer [2004] considered it in the context of two agent two-good exchange economies. We refer the reader to a paper by Lubin and Parkes [2012] for a detailed discussion on approximate-strategyproofness.
In addition to the above mentioned properties, we also talk about (approximate) envy-freeness and Pareto-efficiency (mainly in the context of results pertaining to previous work). For an , a cake cutting mechanism is said to be -envy-free if it always returns an allocation such that . Envy-freeness refers to the special case in the above definition when . A cake cutting mechanism is said to be Pareto-efficient if it always returns an allocation that is not Pareto-dominated—meaning that there is no other allocation such that , with the inequality being strict for at least one agent. Note that non-wastefulness, as defined above, can be considered as a weak form of efficiency where essentially all it is doing is restricting a mechanism from allocating a piece of zero value to an agent if there is some other agent who has a non-zero value for it.
3 Non-wasteful mechanisms
Chen et al. [2010, 2013] were the first to consider direct-revelation mechanisms for cake cutting and they proposed a polynomial-time deterministic mechanism that is strategyproof, proportional, envy-free, and Pareto-efficient for piecewise uniform valuations. In light of such a result, one natural question that arises is if there exists a mechanism for at least the more general class of piecewise constant valuations that is strategyproof, Pareto-efficient, and fair (for some notion of fairness). We already have an answer to this question due to Schummer [1996] who considered the predefined divisible goods setting and showed that the only mechanism that is strategyproof and Pareto-efficient is a dictatorship. And since this predefined goods setting is a special case of the setting with piecewise constant valuations, we know that there is no hope for achieving strategyproofness, Pareto-efficiency, and any notion of fairness. Therefore, in this context, another notion to consider is non-wastefulness which, as defined in Section 2, is a weaker notion of efficiency. In fact, Aziz and Ye [2014] considered this notion and showed an impossibility result saying that there is no strategyproof, robust proportional (which is a much stronger notion of proportionality; see [Aziz and Ye, 2014]), and non-wasteful mechanism [Aziz and Ye, 2014, Theorem 7]. Below, we show a stronger impossibility which says that there is no deterministic and non-wasteful mechanism that is even -strategyproof and -proportional for such that .
Theorem 1**.**
For any and such that , there is no deterministic and non-wasteful mechanism for agents with piecewise constant valuations that is -strategyproof and -proportional.
Proof.
Let us assume that there exists a deterministic, -strategyproof, -proportional, and non-wasteful mechanism for agents. First, consider the profile , where
[TABLE]
Let make an allocation , to agent 1 and agent 2, respectively. Without loss of generality, we can assume that . Now, since is non-wasteful, , and so this implies that (since both cannot be less than ).
Next, let us consider the profile , where
[TABLE]
Since is non-wasteful and -strategyproof, agent 1 has to get a utility of at least from the allocation in this profile, because if it allocates anything less, then agent 1 will deviate to Profile 1. Therefore, if allocates and to agent 1 and 2, respectively, then and so .
Finally, consider the profile , where
[TABLE]
Now, here, since is non-wasteful and because agent 1 does not desire any part of , agent 2 gets at least . However, agent 2 has a total utility of only for , and since we assumed that is also -proportional, it has to get a piece of length, say, , of , where
[TABLE]
If allocates and to agent 1 and 2, respectively, in this profile, then . Also, from the profile we know that . Therefore, if , then agent 2 can deviate from to and as a result gain strictly more than . So, considering this inequality, we have,
[TABLE]
This in turn implies that for every such that , we can always find a to fit in the definition of the function such that the inequality—and hence our theorem—will be true. ∎
With respect to the above theorem, we highlight the following corollaries which are basically special cases when and are zero, respectively. The first one rules out the possibility of guaranteeing some value (however small) to all the agents if the mechanism has to be non-wasteful and strategyproof. The second one, on the other hand, provides a lower bound for the natural question on whether we can come up with mechanisms that can guarantee proportionality and non-wastefulness and at the same time allow only a maximum gain of , where , to an agent from misreporting (note that we require since in any proportional mechanism the maximum an agent can gain by misreporting is equal to ). Unfortunately, we do not have an accompanying upper bound result for this and so the question of an upper bound remains open.
Corollary 2**.**
For any and , there is no deterministic, strategyproof, -proportional, and non-wasteful mechanism for agents with piecewise constant valuations.
Corollary 3**.**
For any and , there is no deterministic, -strategyproof, proportional, and non-wasteful mechanism for agents with piecewise constant valuations.
4 Removing non-wastefulness
While non-wastefulness is certainly a desirable property (more so when, as mentioned in Section 3, due to a result by Schummer [1996], we know that Pareto-efficiency along with strategyproofness and fairness cannot be achieved), it seems like the negative results in the previous section were largely driven by this constraint as it severely restricts the kind of allocations that a mechanism can make. So, what if we remove this constraint? Do similar impossibilities still hold, or are there mechanisms that satisfy some of those properties? These are the questions we try to answer in this section.
Chen et al. [2010, 2013] provided a deterministic mechanism for piecewise uniform valuations and one of the main open questions they had posed was on generalizing their mechanism for piecewise constant valuations. Subsequently, Aziz and Ye [2014] and Brânzei and Miltersen [2015] had posed the same question regarding the existence of mechanisms that are strategyproof and proportional for piecewise constant valuations. Here we address a special case of this question when the mechanism makes contiguous allocations and show that there exists no deterministic direct-revelation mechanism that is strategyproof and -proportional, for any . Additionally, we also prove a stronger result (Proposition 5) for the case of two agents. Informally, at a high-level, the proofs of both of these results follow the same theme as in the proof of Theorem 1 where we construct valuation profiles with an aim of arriving at a contradiction. However, unlike in Theorem 1, we now no longer have the non-wasteful constraint, and so this requires some additional arguments which use the fact that the allocations are contiguous.
Theorem 4**.**
For any and , there is no deterministic mechanism for agents with piecewise constant valuations that makes contiguous allocations and is strategyproof and -proportional.
Before we prove this, we prove the following stronger proposition which handles the two agent case.
Proposition 5**.**
For any such that , there exists no deterministic mechanism for two hungry agents with piecewise constant valuations that makes contiguous allocations and is -strategyproof and -proportional.
Proof.
Let us assume that there exists such a mechanism . Now, consider the preference profile of the agents, where both agents 1 and 2 have a valuation function that is uniform over , and let make an allocation , where is the cake allocated to agent , in this profile. Since outputs contiguous allocations, there is a point where the cut is made. As a result, we have a left piece () and a right piece (), and without loss of generality let us assume that agent 1 gets the left piece in the profile . Throughout, we refer to an allocation as being of LR-type (and correspondingly of being RL-type) if agent 1 gets the left (right) piece (for some cut point ) and agent 2 gets the right (left) piece. Since is -proportional and , . Also, for the rest of the proof let us assume that (we can make a similar construction as below if ).
Next, consider the profile , where is defined as follows.
[TABLE]
where , , and .
Since is -strategyproof, it has to allocate agent 1 a value of at least , for otherwise agent 1 can deviate to and as a result gain more than . Now, since and , it can seen that an RL-type allocation is not possible. Hence outputs an LR-type allocation with a cut point at, say, , and since we know that agent 1 has to get a value of at least , we have that . This in turn implies that agent 2 gets at most .
Finally, consider , where is defined as follows.
[TABLE]
where .
Now, here, since is -proportional and , it can be seen that an RL-type allocation is not possible. Therefore, makes an LR-type allocation and since it is -strategyproof and the whole cake needs to be allocated (since the agents are hungry and so every part of the cake is desired by them), agent 2 gets at least . But then, this implies that agent 2 in Profile 2 can deviate to Profile 3 and as a result gain a value of from it. And since , this contradicts our assumption that is -strategyproof. ∎
As an aside, note that the case in Proposition 5 essentially says that if we insist on contiguous and proportional allocations, then one cannot provide any guarantee on strategyproofness (i.e., such mechanisms cannot be -strategyproof for any feasible ). Later on, in Theorem 8, we show how one can circumvent this and obtain a -strategyproof and proportional mechanism for two agents by giving each of them at most two contiguous pieces.
Having proved the two agent case, next we look at the case when there are three or more agents.
Proof of Theorem 4.
We start off by introducing the following observations and terminologies which we will use throughout this proof.
- •
We say that a contiguous piece of cake is to the left of another piece if .
- •
Since we are interested in allocations that are contiguous, there exists an underlying allocation order, say, , for the agents in . That is, we can obtain an order, say, , where and agent gets a piece of cake that is to left of the piece allocated to agent .
- •
In all the valuation profiles defined below, every part of the cake is desired by at least one agent. And so, since we assume that a mechanism allocates all the pieces of cake that are valued at greater than zero by at least one of the agents, therefore in all the cases below we will have one agent who gets the piece for some . We refer to piece that contains the right endpoint of the cake (which is 1) as the right-end. Therefore, when we say that an agent gets the right-end, this implies that agent is the final agent in the underlying allocation order and that she gets a piece of cake that has the right endpoint of the cake. Correspondingly, we say that an agent gets a left-end if she gets a piece for some (i.e., if she gets piece that has the left endpoint).
Equipped with the above, let us assume for the sake of contradiction that there exists a mechanism that is deterministic, strategyproof, and -proportional for agents (the case has already been proved in Proposition 5). Next, let us consider the profile , where is the uniform function on and
[TABLE]
For the profile under consideration, let make an allocation and let the underlying allocation order be . First thing to notice is that the allocation order here can take only the following forms: or , where is some permutation of . This is so because of the following reasons: first is that neither agent nor agent can be in between the agents in (i.e., the agents in have to be consecutive (in some order) in ) as this would result in one of those agents not getting an -proportional allocation (this is true because all these agents only value the interval and so if agent 1 or 2 are in between, then since their allocation needs to be of length at least , agents that appear to the right of them in will not receive an -proportional allocation); the second reason is that none of the agents in can get the right-end as this would result in a cake of length strictly less than to allocate to agent 1 and agent 2; finally, agent 1 or 2 cannot get the left-end since this would again result in one of the agents in not getting an -proportional allocation. Hence, the above arguments imply that either agent 1 or agent 2 receives the right-end in this profile. For the rest of the proof, we assume, without loss of generality, that agent 2 gets the right-end (we can make a similar construction if instead agent 1 is the one who gets it).
Next, let us consider the profile , where
[TABLE]
Since the mechanism is strategyproof, agent 1 has to get the allocation in this profile, because if otherwise, then she can deviate to profile 1. Additionally, we claim that agent 2 gets the right-end even in this profile. This is because of the following reasons: first, again, for the reasons stated previously, none of the agents in can get the right-end; second, agent 1 cannot get the right-end because this would entail that agent 1 gets a piece such that (since was not in the end in profile 1), which in turn will imply that agent 1 in profile 1 can deviate to profile 2. Hence, agent 1 receives , where (as ), and agent 2 receives an allocation .
Finally, consider the profile , where , and
[TABLE]
Now, in the profile under consideration, again, it is easy to see that none of the agents in can receive the right-end, for this would result in agent 2 (with ) getting a zero allocation. Also, agent 1 cannot get the right-end because we know that if agent 1 were to receive the right-end, then she would need to receive at least which in turn would again result in agent 2 getting a zero allocation. Therefore, agent 2 has to receive the right-end here and this in turn implies that he has to receive a piece , where . However, this would result in agent 2 deviating from profile 2 to profile 3, thus contradicting the strategyproofness of . ∎
Given Theorem 4, the first natural question that arises is if we can extend it to the case when the mechanism can make arbitrary allocations (i.e., when the mechanism can output non-contiguous allocations). Unfortunately, we do not have an answer to this question. Instead, below, we show a connection between direct-revelation mechanisms and mechanisms in the Robertson-Webb model for the case when agents have piecewise constant valuations. We believe that it will be useful in either of the cases—i.e., if the answer to the above question is either in the positive or if we want to prove that such a mechanism does not exist. In the case that such a mechanism exists, the connection basically shows that when given an upper bound on the maximum number of breakpoints in any agent’s valuation function, one can construct a mechanism in the Robertson-Webb model that approximately achieves both of the properties. And in the case that one wants to prove that such a mechanism does not exist, one can use this connection to prove a non-existence (of mechanisms that are -strategyproof and -proportional for some ) in the Robertson-Webb model and then map it back to show that there is no (finite) direct-revelation mechanism that is strategyproof and proportional.
Proposition 6**.**
Let denote the property of strategyproofness, proportionality, and envy-freeness, respectively, and let . Given , an upper bound on the maximum number of breakpoints in any agent’s valuation function, and any , if there exists a (finite) deterministic direct-revelation mechanism for agents with piecewise constant valuations that satisfies , , then, for any , there exists a mechanism in the Robertson-Webb model for agents with piecewise constant valuations that asks at most queries on each input and is -, .
Proof.
As can be seen from the statement of the proposition, the main objective here is to draw a connection between direct-revelation mechanisms and mechanisms in the Robertson-Webb model. Since in the latter model we only have query access to the valuation functions of the agents, the first step is to basically “learn” their functions to a sufficiently good approximation using only eval and cut queries. Subsequently, once we have that, we can essentially feed these functions to the direct-revelation mechanism in order to create a mechanism in the Robertson-Webb model that achieves an approximate version of all the properties (among strategyproofness, proportionality, and envy-freeness) satisfied by the direct-revelation mechanism.
For the first step, given that an agent has a piecewise constant valuation function and is an upper bound on the maximum number of breakpoints in their valuation function, the key observation is that when given an we can -approximate their valuation function with another piecewise constant function such that for any piece of cake , . We show that this can be done with cut queries in the following claim.
Claim 1**.**
Given an , we can use cut queries to -approximate any piecewise constant function that has at most breakpoints by another piecewise constant function such that and for any piece of cake ,
[TABLE]
Proof.
Algorithm 1 describes how to convert to by using cut queries. First thing to notice is that since . So now, the only thing that’s left to prove is to show that for any piece of cake , .
To prove this, consider the case when is a collection of finitely many disjoint intervals (i.e., it is any arbitrary piece of cake). If we denote the breakpoints of by (since there are only a maximum of breakpoints), where , and if we let , then we know that . Additionally, also note that if does not contain any breakpoint of the original function , then since we know that is constant over this interval (as there are no breakpoints) and so . This, along with the fact that has at most breakpoints, implies that there are at most ’s for which . Now, if we assume without loss of generality that these are , then using the fact that and we have that for every ,
[TABLE]
Therefore, since
[TABLE]
we can now use equation 2 to see that,
[TABLE]
thus proving our claim that is an -approximation of .
Now that we know that any utility function of an agent can be -approximated using cut queries, we can build a mechanism, , in the Robertson-Webb model by just feeding these approximated valuation functions into the direct revelation mechanism . More formally, if are the original valuation functions of the agents and are the corresponding -approximated valuation functions, and denotes the allocation made by to agent , then is such that,
[TABLE]
It is clear that makes at most queries on each input and so the only part that remains to be proved is to show that is - for every property satisfied by . To prove this let us consider each of the properties separately.
i) When satisfies (strategyproofness). Let us assume without loss of generality that agent is the one trying to manipulate. Since the underlying direct-revelation mechanism is strategyproof, the only way for agent with a valuation function to manipulate is to pretend as if its function is some and answer the queries accordingly. This in turn will result in being the -approximated function instead of if it reported truthfully. However, since is strategyproof, we know that . This in turn implies that,
[TABLE]
And hence we have that , or in other words that is -strategyproof.
ii) When satisfies (proportionality). To prove that is -proportional note that , since is proportional. This implies that, using equation 1, we have,
[TABLE]
iii) When satisfies (envy-freeness). is -envy-free since , using equation 1 and the fact that is envy-free, we have,
[TABLE]
This in turn proves our proposition. ∎
Although, as mentioned above, it remains open as to whether a strategyproof and proportional mechanism exists, another goal one could still consider is on finding better proportional mechanisms (in terms of -strategyproofness). Below, we begin the pursuit of this goal and as our final question in this paper ask if there are positive results at least regarding mechanisms that are proportional and -strategyproof for some . We answer it with a “Yes” and in particular we first prove—by showing a bound on the maximum gain an agent can get by misreporting—that the well-known Even-Paz algorithm [Even and Paz, 1984] satisfies the above criterion for the case when there are at least four agents. And following this, we present a minor modification to the same that has better incentive compatible properties than the original Even-Paz algorithm for the cases when there are two or three agents. For the sake of completeness, the Even-Paz algorithm is presented in Appendix A.
Proposition 7**.**
For agents, the Even-Paz algorithm is deterministic, proportional, and -strategyproof, where
[TABLE]
Proof.
It is well known that the Even-Paz algorithm is deterministic and proportional. So below we only derive the bounds on . Also, for the sake of simplicity, we keep the proof largely informal.
For the and cases, it is easy to construct examples where the gain from lying is as much as —i.e., it is and , respectively. So let us consider the case when there are agents. Notice that in every instance of the Even-Paz algorithm (see Appendix A), the procedure EP is run multiple times and during each run the procedure asks an agent for a cutpoint such that , where is the cake to be proportionally allocated among the agents in . Throughout, we refer to each such run of the procedure EP as a “step” of the Even-Paz algorithm; therefore, the first step refers to the first run of the procedure EP where an agent is asked for a cutpoint such that .
So now, let us consider the first step of the algorithm. Without loss of generality, we can assume that for , if , then (since the agents can always be relabeled to satisfy this). Additionally, let us call the piece as the ‘left piece’, the piece as the ‘right piece’, the piece as the ‘middle piece’, and also denote by the maximum gain an agent can get by misreporting when there are agents.
Next, notice that in the Even-Paz algorithm every agent either recurses on the left piece or on the piece (which is the middle right piece). So let us consider the following two cases separately: i) an agent who if reporting truthfully in the first step would recurse on the left piece (i.e., whose true report is such that ) and ii) an agent who if reporting truthfully in the first step would recurse on the piece (i.e., whose true report is such that ). We will denote the gain for an agent in case i) and ii) to be and , respectively. Also note that since every agent belongs to either case i) or case ii), the maximum any agent can gain by lying is .
Case i): an agent such that . First, if is the true report of in the first step, then, when playing strategically, the maximum can gain by reporting a is at most . This is so because she is guaranteed to get when playing truthfully (since the mechanism is proportional) and she gets at most when misreporting (since the other players have not changed their reports). Therefore, given the fact that upper bound we want to prove is greater than , we need to only consider the case when misreports a .
So now, let us consider the case when misreports a . Note that even in this case, in order to maximize the gain, needs to report in such a way that it expands the cake she’s recursing on (i.e., report a such that ). This is so because, if does not expand the left piece (which is the piece it is recurses on if reporting truthfully), then the maximum gain can gain by misreporting in the algorithm is —the first term because that’s the maximum cake has access to from the second level onwards and the second term because is guaranteed to get at least a fraction of if he reports truthfully. And since , this implies that the maximum gain .
Therefore, we need to only consider the case when misreports and as a result expands the piece she recurses on (i.e., she reports a such that ). Now, in this case, it can be seen that if she has to gain more than in the case when there is no expansion, then she has to get the middle piece (or at least some part of it; for the rest of the proof although we talk about the middle piece as a whole, all the arguments will be true even if is only getting a part of it). However, note that the algorithm always produces a contiguous allocation (i.e., all the agents are allocated a single continuous interval of the cake), and so the only way an agent can get the middle piece is if the piece she recurses on at every level contains this middle piece.
Given this, let us consider the penultimate level where there are two agents ( and some other agent, say, ). Here will get the middle piece only if her report is to the right of the other agent. Now, if the value of this piece (i.e., the one that is to the right of ’s report in the penultimate level) is greater than according to ’s true valuation, then it would have meant that the only part of the cake received extra as a result of lying is the middle piece. This is so because, every other agent is playing the same way irrespective of whether is lying or otherwise. Therefore, when is lying and she expands the piece at the first level, the key observation to make is that none of the reports of the other players “decrease”—i.e., in every level, whenever the agents are asked for their reports during the course of the algorithm, the reports that they specify are no less than what they would have specified in the case where was playing truthfully (this is so because, when the cake is expanded, the value for it for every agent increases or remains the same and so when the agents are asked for their reports, their reports can only be greater than the case when the cake wasn’t expanded). This in turn implies that agent when playing truthfully would have got everything except the middle piece (which was introduced as a result of lying) because if not then she would have ended up receiving less than which is impossible. Hence, following this line of reasoning, only the middle piece is extra and we know that the value of the middle piece is at most . So now, the case that remains is when the value of this piece according to ’s true valuation is less than or equal to . And in this case we know that the gain from lying is at most since she’s guaranteed to get when playing truthfully.
Therefore, in all the cases above, an agent such that , cannot gain more than . And hence .
Case ii): an agent such that . This case is much easier to argue. Note that if agent reports a , then the gain is at most and since the bound we want to prove is bigger we can ignore this. So now, if we ignore the case above, then it is easy to see that has no real control over the piece he’s recursing on in the first step—unlike how it was in case i). Therefore, the worst case is when he has a value 1 for the piece he’s recursing on. Since there are only players recursing along with her in this piece, we can treat this as a new instance with players. And so the maximum gain for in this case is at most —because if it is anything more then it would contradict the fact that is the maximum an agent can gain in a -player instance.
Therefore, putting together cases i) and ii) we have, . Now, we know that , and so we get and . For , it is easy to see that works. Hence, Even-Paz algorithm is deterministic, proportional and -strategyproof, where
[TABLE]
∎
Next, we show that the bounds on can be improved for the cases when there are two or three agents. In particular, we show that Algorithm 2 is proportional and -strategyproof, where or depending on whether is even or odd, respectively. And so, for the cases when there are two or three agents, the gain is or , respectively, as opposed to or in the Even-Paz algorithm. The main difference between the original Even-Paz algorithm (see Appendix A) and the modified version presented here (Algorithm 2) is in how at each level the piece is handled. In the original Even-Paz algorithm (see procedure EP in Algorithm 3 in Appendix A), this piece is part of the piece that the agents in recurse on, while in the modifiedEP procedure above, at each level, this piece is proportionally split between the agents by again using the original Even-Paz algorithm.
Theorem 8**.**
Algorithm 2 is deterministic, proportional, and -strategyproof, where
[TABLE]
Proof.
It is easy to see that Algorithm 2 is deterministic and proportional. To prove that it is -strategyproof, we proceed like in the proof of Proposition 7 by considering the first step of the algorithm where each agent reports a point such that . Without loss of generality, we can assume that for , if , then (since the agents can always be relabeled to satisfy this). Also, it can be observed that all the agents () recursing on the piece (henceforth also referred to as the ‘left piece’) are symmetric—as in, after the first step all of them are treated in the same way. Similarly, all the agents () recursing on the piece (henceforth also referred to as the ‘right piece’) are also symmetric. Hence, for any agent , and for their true report in step 1, we need to only consider two cases—i) (this corresponds to the case when will recurse on the left piece when playing truthfully) and ii) (this corresponds to the case when will recurse on the right piece when playing truthfully)—and then argue that the maximum can gain by reporting untruthfully is or depending on whether is even or odd, respectively.
Case i): . First, if is the true report of , then, when playing strategically, if reports a , the maximum he can gain by doing so is at most . This is so because, he is guaranteed to get when playing truthfully (since the mechanism is proportional) and he gets at most when playing untruthfully as the other players have not changed their reports. Therefore, given the fact that upper bound we want to prove is greater than , we need to only consider the case when misreports a .
In this case, let be the maximum value he can get by lying. Since does not get any part of if he reports a , to get it has to be the case that . On other hand, if plays truthfully, then he gets T, where
[TABLE]
Therefore, the maximum gain as a result of reporting untruthfully is,
[TABLE]
Case ii): . Like in case i), if is the true report of , then, when playing strategically, if reports a , the maximum he can gain by doing so is at most , which is less than the upper bound we want to prove. Hence, we need to only consider the case when misreports a .
In this case, let be the maximum value he can get by lying. Since does not get any part of if he reports a , to get it has to be the case that . On other hand, if plays truthfully, then he gets T, where
[TABLE]
Therefore, the maximum gain as a result of reporting untruthfully is,
[TABLE]
From equation 3 and 4, we have that the mechanism is -strategyproof, where
[TABLE]
∎
Although the modifiedEP was designed to take care of the worst-case scenarios that arise in the original algorithm, it turns out that it works only for the cases when or . In the all the other cases, even though it still eliminates those worst-cases, it is interesting to note that it does this at the cost of introducing some other worst-case scenarios—ones which do not occur in the original algorithm—essentially because of the fact that it makes non-contiguous allocations (unlike the original Even-Paz which makes contiguous allocations).
5 Discussion
One of the main open questions raised by Chen et al. [2010, 2013] (and subsequently also by Aziz and Ye [2014] and Brânzei and Miltersen [2015]) was on the existence of deterministic mechanisms that are strategyproof and fair for piecewise constant valuations. Here we addressed a special case of this and we showed (in Theorem 4) that for any agents there is no deterministic mechanism that makes contiguous allocations and is strategyproof and even -proportional. Although the contiguous allocations constraint captures some interesting scenarios, we believe that answering the above question without this (rather strong) constraint is important. In particular, when given the fact that there exists randomized mechanisms that are a) truthful in expectation, proportional, and envy-free for piecewise linear valuations in the direct-revelation model [Chen et al., 2013] and b) truthful in expectation and -proportional for any and for general valuation functions in the Robertson-Webb model [Brânzei and Miltersen, 2015, Theorem 3], we believe that resolving this question can give us a clearer picture regarding the limits of determinism.
Moving away from the above result, in Section 4 we showed (in Theorem 8) that there exists a proportional mechanism that has better incentive-compatible properties than the Even-Paz algorithm for the cases when there are two or three agents. With regards to this result, one of the main questions that arise is the following and we suggest it as an open problem: for agents, what is the minimum achievable for which there exists a deterministic mechanism that is proportional and -strategyproof? It is unclear how we can provide a lower bound on mechanisms that are proportional and -strategyproof, or improve the proposed mechanism to get smaller values of . And also, at the same time—and this relates back to our results in Section 3—there is the question of whether we can make Algorithm 2 non-wasteful when agents have concisely representable valuation functions (as in, functions like piecewise uniform, piecewise constant etc.). At first glance it seems like it should be possible to easily do this at least when there are only two agents and one possible scheme that seems benign is: once the allocation is done as per the above mechanism, ask the agents to exchange their zero pieces (the pieces they value at zero)—thus resulting in an outcome that is possibly a Pareto-improvement over the existing one. Unfortunately it only seems benign, but actually isn’t as it turns out that it can result in breaking the guarantee on strategyproofness. We illustrate this through the following example.
Example 1**.**
The main issue with making the mechanism non-wasteful by doing as suggested above is that if the agents know that they will receive the zero pieces in the end, then they no longer have the incentives to behave like the way they did in the original mechanism. For instance, consider the case of two agents, where
[TABLE]
Now, according to our original mechanism if the reports of the agents were , then agent 1 would get + some part of , and agent 2 gets + some part of . And so the total utility for agent 2 is at most . But now, once we add the reallocation stage to make the mechanism non-wasteful, agent 2 knows that during reallocation she is assured to get and so she can misrepresent her utility function by reporting . This in turn will result in agent 1 getting + some part of , and agent 2 getting some part of . However, in the reallocation stage agent 2 will also be given , thus getting a utility of —which makes it a -SP mechanism.
Using a similar (but slightly more involved) example it can be shown that another seemingly promising scheme to make it non-wasteful where we was ask the players to exchange the zero pieces before the start of the mechanism and then run the mechanism on the rest of the cake does not work as well. So given the apparent difficulty and our lower bound (Theorem 1) in Section 3, another problem that remains open is whether we can guarantee non-wastefulness along with proportionality and -strategyproofness, where .
Acknowledgments
We thank Simina Brânzei for useful discussions.
Appendix A Even-Paz algorithm
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1Alijani et al. [2017] Reza Alijani, Majid Farhadi, Mohammad Ghodsi, Masoud Seddighin, and Ahmad S Tajik. Envy-free mechanisms with minimum number of cuts. In Proceedings of the 31st AAAI Conference on Artificial Intelligence (AAAI) , pages 312–318, 2017.
- 2Aziz and Mackenzie [2016] Haris Aziz and Simon Mackenzie. A discrete and bounded envy-free cake cutting protocol for any number of agents. In Proceedings of the 57th Annual IEEE Symposium on Foundations of Computer Science (FOCS) , pages 416–427, 2016.
- 3Aziz and Ye [2014] Haris Aziz and Chun Ye. Cake cutting algorithms for piecewise constant and piecewise uniform valuations. In Proceedings of the 10th International Conference on Web and Internet Economics (WINE) , pages 1–14. Springer, 2014.
- 4Bei et al. [2012] Xiaohui Bei, Ning Chen, Xia Hua, Biaoshuai Tao, and Endong Yang. Optimal proportional cake cutting with connected pieces. In Proceedings of the 26th AAAI Conference on Artificial Intelligence (AAAI) , pages 1263–1269, 2012.
- 5Birrell and Pass [2011] Eleanor Birrell and Rafael Pass. Approximately strategy-proof voting. In Proceedings of the 22nd International Joint Conference on Artificial Intelligence (IJCAI) , pages 67–72, 2011.
- 6Brams and Taylor [1996] Steven J Brams and Alan D Taylor. Fair Division: From cake-cutting to dispute resolution . Cambridge University Press, 1996.
- 7Brânzei and Miltersen [2015] Simina Brânzei and Peter Bro Miltersen. A dictatorship theorem for cake cutting. In Proceedings of the 24th International Joint Conference on Artificial Intelligence (IJCAI) , pages 482–488, 2015.
- 8Chen et al. [2010] Yiling Chen, John K Lai, David Parkes, and Ariel D Procaccia. Truth, justice, and cake cutting. In Proceedings of the 24th AAAI Conference on Artificial Intelligence (AAAI) , pages 626–631, 2010.
