1,636
Views
2
CrossRef citations to date
0
Altmetric
Original Articles

Cutting a Cake Fairly for Groups Revisited

&
Pages 203-213 | Received 11 Oct 2021, Accepted 03 Jan 2022, Published online: 13 Jan 2023

Abstract

Cake cutting is a classic fair division problem, with the cake serving as a metaphor for a heterogeneous divisible resource. Recently, it was shown that for any number of players with arbitrary preferences over a cake, it is possible to partition the players into groups of any desired size and divide the cake among the groups so that each group receives a single contiguous piece and every player is envy-free. For two groups, we characterize the group sizes for which such an assignment can be computed by a finite algorithm, showing that the task is possible exactly when one of the groups is a singleton. We also establish an analogous existence result for chore division, and show that the result does not hold for a mixed cake.

1 Introduction

After a strong annual performance, the owner of a company decides to reward her 20 employees by renting them a holiday cottage for the last two weeks of the year. Due to capacity constraints, she needs to split the employees into two groups of ten, divide the two-week period into two contiguous intervals, and assign one interval to each group. The employees have different preferences on the time they would like to spend at the cottage. Can the owner make sure that the resulting assignment is envy-free, that is, no employee believes that the time slot given to the other group is better than the one given to his or her own group?

In a recent Monthly note, Segal-Halevi and Suksompong [Citation10] showed that for any preferences that the employees may have, there always exists an assignment fulfilling the owner’s wishes. In fact, the result holds even if there are n employees and the owner would like them to vacation at the cottage in groups of size k1,k2,,km in this order, for any n, m, and any kj ’s that sum to n. This result generalizes an influential theorem by Stromquist [Citation12], Su [Citation14], and Woodall [Citation15] (the first two also in this Monthly), which concerns the case where k1==km=1, i.e., the employees go to the cottage one at a time. Yet, two important questions remain:

  • How can the owner compute a desired assignment? Is it even possible to do so?

  • What if instead of dividing a good like holiday accommodation, we were to divide a chore such as housework, which yields a disutility to everyone involved? Or a mixture of goods and chores?

In this article, we provide comprehensive answers to both of these questions.

2 Model

We switch to the language of cake cutting—the classical framework for studying how to divide a resource fairly [Citation3, Citation8]. In cake cutting, we have a set of n players along with a cake in the form of an interval [0,1]. A partition of the cake is specified by nonnegative real numbers x1,,xm such that j=1mxj=1, where xj denotes the length of the jth piece. For each partition (x1,,xm), a player prefers one or more pieces.Footnote1 The result by Segal-Halevi and Suksompong [Citation10] is based on reducing the problem to the case of singleton groups and applying the theorem of Stromquist [Citation12] and Su [Citation14]. Both of these results work under the following two mild assumptions:

  1. Hungry players. Players never prefer an empty piece.

  2. Closed preference sets. Any piece that is preferred for a convergent sequence of partitions is also preferred at the limiting partition.

An envy-free assignment is a partition of the cake into m contiguous pieces, together with a division of the players into m groups with group j containing kj players, such that each player in group j prefers the jth piece from the left in the partition.

3 Protocols

We focus first on the case of two groups. For this case, a protocol for computing an envy-free assignment is given in [Citation10]: each player i marks a point xi[0,1] such that the player prefers both [0,xi] and [xi,1]. The protocol then cuts the cake at a point y between the k1th and the (k1+1) st marks from the left, and assigns the players with the k1 leftmost marks to [0,y] and the remaining players to [y,1]. However, this protocol relies crucially on an additional assumption that the players’ preferences are monotone, meaning that if a player prefers a piece [0,y], he or she must also prefer the piece [0,z] for any z > y, and analogously for [y,1]. While monotonicity is a reasonable assumption in certain situations, it is relatively strong in comparison to the two assumptions needed for the existence result. Indeed, in our introductory example, some employees may not want to spend too long at the cottage, and forgoing part of the allotted time can be frowned upon by the owner or the other group. What, then, can we do when the preferences are possibly non-monotone?

For brevity, let us say that a player prefers the left piece (resp., right piece) at point x[0,1] if the player prefers the interval [0,x] (resp., [x,1]). The hungry players assumption implies that every player prefers only the right piece at 0 and prefers only the left piece at 1. A first idea that comes to mind is to ask the players for their entire preferences so that we can determine an appropriate cut point x, which we know must exist. However, this may lead to an infinite protocol. Specifically, given any infinite sequence of numbers 0<a1<a2<<1, it is possible that a player prefers the right piece at any point in [0,a1], the left piece at any point in [a1,a2], the right piece at any point in [a2,a3], and so on—such a preference is consistent with the hungry players and closed preference sets assumptions, but cannot be described in finite time. A protocol that attempts to learn this preference in its entirety will never terminate.

To see what can be done with finite protocols, let us recall the simplest cake-cutting protocol: cut-and-choose. This protocol begins by asking one of the players a query, which can be phrased as “mark a point x such that you are indifferent between the cake to the left of x and the cake to the right of x.” We slightly modify this query to handle the case in which there are several such “indifference points:”

First-indifference-point. Given a player i, return the smallest point y[0,1] such that i prefers both pieces at y.

Lemma 1.

For every hungry player i with closed preference sets, i’s first indifference point exists, it equals the smallest point at which i prefers the left piece, and it is strictly between 0 and 1.

Proof.

Let y be the smallest point such that i prefers the left piece at y. Observe that (i) y exists because i prefers the left piece at 1, (ii) y > 0 because i prefers only the right piece at 0, and (iii) y is well-defined due to the closed preference sets assumption. Then, since i prefers the right piece at any point z < y, the closedness assumption tells us that i also prefers the right piece at y. Hence y is the first indifference point. The hungry players assumption implies that this point y is strictly between 0 and 1. □

When the preferences are monotone, the set of indifference points is a (possibly degenerate) closed interval, and the answer to a First-indifference-point query is the leftmost point of that interval. However, when the preferences are not monotone, the set of indifference points can be any closed subset of (0, 1). Indeed, given such a subset C, suppose that its rightmost point is r < 1, which is well-defined since C is closed. A hungry player may prefer the left piece at any point in C[r,1] and the right piece at any point in [0,r]. The set of indifference points is then precisely C.

We show that the First-indifference-point query is sufficient for handling the special case in which the first group is a singleton. For any positive integer t, denote by [t] the set {1,2,,t}.

Theorem 2.

Let n be any positive integer and m = 2. For n hungry players with closed preference sets, there is a finite protocol using the First-indifference-point query that computes an envy-free assignment with the first group containing one player and the second group containing n – 1 players.

Proof.

Our protocol makes a First-indifference-point query for every player—assume that the answers are x1,,xn.

Let i[n] be such that xi=min{x1,,xn}. The protocol cuts the cake at point xi, and assigns player i to the left piece and the remaining players to the right piece. Player i prefers the left piece by definition of xi. For any other player i, Lemma 1 implies that xi is the smallest point at which i prefers the left piece, so i prefers the right piece at any point zixi, and therefore also prefers the right piece at xixi. □

At this point, one might be tempted to think that the simple protocol in Theorem 2 can be generalized to two groups with any player distribution. However, and perhaps surprisingly, we show that no finite protocol can compute an envy-free assignment when both groups consist of at least two players. This impossibility holds even if we allow the protocol to make more general types of queries:Footnote2

  • Next-indifference-point. Given a player and a point x[0,1], return the smallest point yx such that the player prefers both pieces at y (or state that no such y exists). Note that this is a generalization of the First-indifference-point query, which corresponds to the special case where x = 0.

  • Previous-indifference-point. Given a player and a point x[0,1], return the largest point yx such that the player prefers both pieces at y (or state that no such y exists).

  • Evaluate. Given a player and a point x[0,1], return whether the player prefers the left piece, the right piece, or both pieces at x.

While it may seem restrictive to consider only indifference points, we remark here that the three types of queries are together quite powerful. For example, suppose we are given a point x, and we want to determine the smallest point yx such that the player prefers the left piece at y. We can first make an Evaluate query at x. If the left piece is preferred, the answer is x. Else, we make a Next-indifference-point query at x. By an argument similar to that in Lemma 1, the answer y to this query is also our desired answer. Analogously, we can determine the smallest point yx such that the player prefers the right piece at y, or the largest point yx such that the player prefers the left (or right) piece at y.

Theorem 3.

Let n be any positive integer, m = 2, and k1, k2 be positive integers such that k1+k2=n and min{k1,k2}2. There does not exist a finite protocol using the Next-indifference-point, Previous-indifference-point, and Evaluate queries that, for any n hungry players with closed preference sets, computes an envy-free assignment with group j containing kj players.

Proof.

Assume for the sake of contradiction that such a protocol exists. We will show how an adversary can answer the protocol’s queries in such a way that after any finite number of queries, for any assignment that the protocol may output, there exist players’ preferences consistent with the answers for which the assignment is not envy-free. This is sufficient to obtain the desired contradiction.

During the run of the protocol, the adversary maintains a set of “known intervals”—the protocol knows the preferences of all players at every point in these intervals. All of these intervals are closed. Initially, only the degenerate intervals [0,0] and [1,1] are known. Whenever the protocol makes a query, the adversary modifies the known intervals in such a way that (a) the query can be answered using the information encoded in the known intervals, (b) the known intervals do not cover the entire cake, and (c) if the cake is cut anywhere inside a known interval, then at least n – 1 players want the same piece. We now explain exactly how the adversary modifies the known intervals.

Suppose that the protocol asks player i a query at point x. If x belongs to a known interval, the adversary extends the interval on both sides (unless the interval contains 0 or 1, in which case the protocol extends it on one side) so that the gap to the next known interval is reduced by half. For example, if at the beginning a query is made at point 0, the adversary extends the known interval [0,0] to [0,0.5]. On the other hand, if x is outside any known interval, the adversary adds a new known interval containing x such that the gap to the adjacent known interval on each side is reduced by half. For example, if at the beginning a query is made at point 0.4, the adversary adds a new known interval [0.2,0.7].

Now, the adversary determines the players’ preferences in the newly added (or extended) known intervals as follows. All players ii prefer only the right piece at any point added to a known interval. For player i, for each maximal new portion [a,b] of a known interval, the adversary chooses a<a<b<b, and lets player i prefer only the right piece everywhere in [a,a)(b,b], only the left piece everywhere in (a,b), and both pieces at a and b. For example, if at the beginning the protocol asks player i a query at point 0.4, then all players except i prefer only the right piece at any point in [0.2,0.7], while player i prefers only the right piece at, e.g., any y[0.2,0.4)(0.5,0.7], only the left piece at any y(0.4,0.5), and both pieces at 0.4 and 0.5.

The only exception to the rules in the previous paragraph is if the query is made at a point in the rightmost known interval—in this case, the roles of “right” and “left” are reversed. So, if at the beginning a query is made at point 1 for player i, then all other players prefer only the left piece at any y[0.5,1], while player i prefers only the left piece at, e.g., any y[0.5,0.7)(0.8,1], only the right piece at any y(0.7,0.8), and both pieces at 0.7 and 0.8.

Observe that, after the modifications, player i has indifference points both to the left and to the right of x (or on one side if x = 0 or x = 1), and the preference of i at x is known, so the adversary has sufficient information to answer any query based on the newly specified preferences.

Since the protocol is finite, it must eventually return a partition of the cake with some cut point y. If y is not in a known interval, then the adversary voluntarily answers a query for some player i at point y, using the same rules as above, so now y is in a known interval.

The adversary’s answers guarantee that, at any point in a known interval, including y, at least n – 1 players prefer only the left piece, or at least n – 1 players prefer only the right piece. Since min{k1,k2}2, it follows that the assignment returned by the protocol cannot be envy-free.

Finally, to demonstrate that there are complete preferences that are consistent with its answers, the adversary completes the preferences of all players in all unknown intervals by letting all players prefer only the right piece at every point in each interval. The only exception is the unknown interval adjacent to the rightmost known interval—for this unknown interval, the adversary chooses a point z in it and lets all players prefer only the right piece at points to the left of z, only the left piece at points to the right of z, and both pieces at z. It is easy to verify that the resulting preferences satisfy both the hungry players assumption and the closed preference sets assumption. □

Theorems 2 and 3, combined with the observation that an analog of Theorem 2 yields a finite protocol using the Previous-indifference-point query for the case k2=1, provide a complete characterization of the group sizes for which a finite protocol exists in the setting with two groups.

What happens when we desire a division into three or more groups? It turns out that even for three or more singleton groups (that is, m3 and kj = 1 for all j[m]), no finite protocol exists. This follows from an impossibility result by Stromquist [Citation13] for the additive model. In this model, each player i has a utility function ui , which is a nonnegative nonatomic measure on the cake, such that ui([0,1])>0. In each cake partition, player i prefers piece [x,y] if and only if ui([x,y]) is maximum among the pieces in the partition. The assumption that the functions ui are nonnegative implies the hungry players assumption; the assumption that they are nonatomic implies the closed preference sets assumption. Hence, the additive model is a special case of the model that we study.

In the additive model, a protocol is allowed to make two types of queries (which together form the Robertson–Webb model [Citation8]): an Evaluate query, returning a player’s utility for a given piece of cake, and a Cut query, returning a piece of cake for which a player has a certain utility starting from a given point. Like our proof, Stromquist’s proof uses an adversary argument where the adversary answers the protocol’s queries in such a way that the protocol cannot produce an envy-free assignment with certainty after any finite number of queries. Under our general preferences without cardinal utilities, it is unclear which queries should be allowed when there are three or more groups; moreover, in light of the impossibility result in the more specific model, it appears unlikely that a finite algorithm would exist for any reasonable set of permitted queries. We will therefore go no further in this direction.Footnote3

The following table compares our results in this section with previous results. Positive results are valid even for non-additive preferences, while negative results are valid even for additive preferences.

4 Chore Division

Suppose now that, instead of a holiday cottage, there is a sensitive public building that must be secured during the night. We therefore wish to partition the night into m shifts. In each shift j[m], the building should be secured by kj guards.

When kj = 1 for all j[m], the problem is an instance of the well-known chore division problem, wherein an undesirable task is to be divided among players who prefer to receive as little of the task as possible according to their own preferences. The difference between chore division and cake cutting is expressed by replacing the hungry players assumption with the lazy players assumption:

1.* Lazy players. Players never prefer a nonempty piece if an empty piece is available.

Lemma 4.

A lazy player with closed preference sets prefers all (and only) the empty pieces whenever there is at least one empty piece.

Proof.

If exactly one piece is empty, then a lazy player by definition prefers only this piece. Consider now a partition x in which pieces j1,,jt are empty for some t > 1. This partition x is the limit of t sequences of partitions such that in each sequence l[t], only piece jl is empty while the sizes of the pieces jl for ll converge to 0. A lazy player prefers piece jl in all partitions of sequence l; therefore, a lazy player with closed preference sets prefers piece jl in the limit partition x too. This is true for every empty piece jl. □

For individuals (i.e., singleton groups), the existence of an envy-free chore division was established in this Monthly by Su [Citation14]. We show next that the general group result of Segal-Halevi and Suksompong [Citation10], too, extends to chore division. The proof uses a reduction from group chore division to group cake cutting, which may be useful in other contexts beyond group division.Footnote4

Theorem 5.

Let nm be any positive integers, and let k1,k2,,km be positive integers such that j=1mkj=n. For any n lazy players with closed preference sets, there is an m-partition of the chore and an envy-free assignment of the parts to m groups, with group j containing kj players.

Before proving the theorem, we introduce some formal notation. We represent each m-partition of the cake or chore by a vector xΔm1, where Δm1 is the standard simplex in Rm (i.e., for all j[m],xj0 and j=1mxj=1). The value of xj indicates the length of piece j (where the piece indices start from the left).

The preferences of a player are represented by a demand function h:Δm12[m] that assigns to each partition a nonempty subset of preferred pieces. Given j[m] and a demand function h, we define Ph,j:={xΔm1 | jh(x)} to be the set of partitions in which piece j is preferred according to h. If h satisfies the closed preference sets assumption, then Ph,j is a closed subset of Δm1 for every j.

The proof idea is to convert any chore-allocation instance to a cake-allocation instance. Instead of giving each point of the chore [0,1] to a single group, we give exemptions from the chore to m – 1 groups. We show that, if the players’ preferences in the chore instance satisfy the lazy players and closed preference sets assumptions, then their preferences in the exemptions instance satisfy the hungry players and closed preference sets assumptions, and therefore the existence result for cake cutting is applicable. The details are given below.

Proof of Theorem 5.

For each m-partition xΔm1, define a vector xRm byx:=1m(m1)·x,where 1m is a vector of m ones, i.e., x̂j:=1(m1)·xj for all j[m]. Note that j=1mx̂j=m(m1)=1, and xΔm1 if and only if xj1m1 for all j[m]. Let δm1:={xΔm1 | j[m]:xj1m1}. Intuitively, for any point xδm1, the vector (m1)·x represents an allocation of exemptions, and x represents the corresponding allocation of chores.

We are given n lazy players, where each lazy player i[n] has a demand function li:Δm12[m]. From these players, we construct n hungry players, with demand functions hi:Δm12[m] defined as follows:hi(x):={li(x)if xδm1;{j | xj1m1}otherwise.

Note that hi(x) is nonempty in both cases. In the first case, (m1)·x corresponds to a valid allocation of exemptions; in the second case, (m1)·x corresponds to an “over-allocation” of exemptions, that is, an allocation in which some exemptions (those with xj>1m1) span more than the entire cake.

In order to apply the cake-cutting theorem from [Citation10], we now show that hi satisfies the hungry players and closed preference sets assumptions.

Hungry players. Consider an m-partition x where xj = 0 for some j[m]. We have to show that jhi(x). If xδm1, then by definition hi(x) contains only pieces of length at least 1m1, so jhi(x). Suppose now that xδm1. Since j=1mxj=1, the definition of δm1 implies that xj=1m1 for all jj. Hence, x̂j=1, and x̂j=0 for all jj. Since li represents a lazy player, who never prefers a positive piece if an empty piece is available, jli(x)=hi(x).

Closed preference sets. Fix some i[n] and j[m]. The definition of hi implies that Phi,j=Qhi,jRhi,j, whereQhi,j:={xδm1 | jli(x)};Rhi,j:={xδm1 | xj1m1}.

The set Qhi,j is closed since it is a linear transformation of Pli,j, which is closed by the closed preference sets assumption on the original lazy-players instance. Specifically, recall that Pli,j={xΔm1 | jli(x)}. If we take the reflection of Pli,j over the origin, translate it by 1m, and dilate it by 1m1, we get another closed set:{1m1·(1mx) | xPli,j}={yRm  |  1m(m1)·yPli,j}={yRm  |  ŷPli,j}={yRm  |  ŷΔm1 , jli(ŷ)}={yRm  |  yδm1 , jli(ŷ)}(since ŷΔm1 iff yδm1)=Qhi,j.

Hence, Qhi,j is closed.

The set Rhi,j by itself is not closed, but its boundary is contained in Qhi,j. Specifically, by Lemma 4, for any xδm1 (i.e., xΔm1), li(x) contains all j for which x̂j=0, so it contains all j for which xj=1m1. Therefore,Qhi,j{xδm1 | xj=1m1}={xδm1 | xj1m1}Qhi,jRhi,j=Qhi,j{xΔm1 | xj1m1}so Phi,j is the union of two closed sets and is consequently closed itself.

We are now ready to complete our proof. By theorem 2 in [Citation10], there exists a partition yΔm1, along with a division of the hungry players (represented by the demand functions hi ) into groups with group j containing kj players, such that the partition is envy-free for the hungry players. If yδm1, then all hungry players prefer only pieces with length at least 1m1, and there are at most m – 1 such pieces, so at least one group is assigned a non-preferred piece, a contradiction with envy-freeness. Hence, yδm1. By construction, the partition y along with the same division of the lazy players into groups is envy-free for the lazy players. □

5 Mixed Cake

Cake cutting assumes that all players are hungry and never prefer an empty piece, whereas chore division assumes that all of them are lazy and never prefer a nonempty piece over an empty one. What if neither of these assumptions are universally true—perhaps some employees would rather stay home than spending certain periods at the cottage, and some guards enjoy making sure that the public building is secured? The division of a so-called “mixed cake” among individual players has been studied by several authors in the last few years [Citation1, Citation2, Citation4, Citation9].

The mixed cake model makes neither the hungry players nor the lazy players assumptions, while keeping the closed preference sets assumption. Without additional assumptions, an envy-free allocation might not exist even for two singleton groups—for example, when both players always prefer only the right piece regardless of the cut point. While this preference satisfies the closed preference sets assumption, it implies that the players prefer the whole cake to an empty cake (when the cut point is 0) and also prefer an empty cake to the whole cake (when the cut point is 1)! To avoid this unrealistic situation, we add the requirement that that if two partitions (x1,,xm) and (x1,,xm) give rise to the same split of the cake, then each player’s preference should be consistent across the partitions. For instance, if in the partition (0,0.2,0.8) a player prefers only the piece of length 0.8, then the player should prefer only the piece of length 0.8 in the partitions (0.2,0,0.8) and (0.2,0.8,0) too. However, even with this requirement, the existence of an envy-free assignment still cannot be guaranteed. Indeed, consider five players whose preferences are represented by additive cardinal utility functions shown in . The utilities are uniformly distributed within each labeled piece. Given any partition of the mixed cake into two pieces, each player prefers the piece that yields a higher utility to the player (or both pieces in case of a tie). It is clear that the closed preference sets assumption is satisfied for all players, and an unrealistic situation as above no longer occurs. On the other hand, one can check that in any 2-partition, each piece is preferred by no more than three players, meaning that an envy-free assignment for two groups of sizes four and one does not exist.

Fig. 1 An example showing that Theorem 5 does not extend to a mixed cake.

Fig. 1 An example showing that Theorem 5 does not extend to a mixed cake.

This counterexample implies that in order to recover the guaranteed existence of an envy-free assignment, it may be necessary to allocate more than one contiguous piece of the mixed cake to each group. The preferences in our model thus far are defined only for partitions into m contiguous pieces, where m is the number of groups. We therefore extend them to partitions into m collections of pieces, where each collection consists of a finite number of contiguous pieces. As before, for any such partition, each player prefers one or more collections, and the corresponding preference sets are closed. For several division problems, it is desirable to allocate a small number of pieces to each group. Unfortunately, the example in can be generalized to show that a number of cuts that is linear in the number of players may be inevitable even in the case of two groups.

Theorem 6.

Let n4 be any integer, m = 2, and k1, k2 be positive integers with k1+k2=n and min{k1,k2}=1. There exist n players with preferences represented by additive cardinal utility functions such that any envy-free assignment of the mixed cake with group j containing kj players requires at least n – 3 cuts.

Proof.

Assume without loss of generality that k1=n1 and k2=1. Consider n players whose preferences are represented by additive cardinal utility functions. For odd i[n], player i has utility 1 for the interval [i1n,in], and utility 0 for other intervals; the utilities are uniformly distributed within each interval. Similarly, for even i[n], player i has utility –1 for the interval [i1n,in], and utility 0 for other intervals. The case n = 5 is illustrated in .

Consider an envy-free allocation, and let C be the piece (union of intervals) preferred by n – 1 players. Call a pair of players with adjacent indices i and i + 1 conforming if both of them prefer C. Note that, of the n – 1 adjacent pairs of players, at least n – 3 pairs are conforming. For each conforming pair {i,i+1}, if i has utility 1 for the interval [i1n,in], there must be a cut in the interval (i1n,i+1n) such that the piece to the left of the cut belongs to C, while the piece to the right does not. Analogously, if player i has utility –1 for the interval [i1n,in], there must be a cut in the interval (i1n,i+1n) such that the piece to the left of the cut does not belong to C, while the piece to the right does. Since no two cuts corresponding to different conforming pairs can coincide, the number of cuts is at least n – 3. □

On the positive side, by using a classical result on “consensus halving,” one can see that the n – 3 cuts required by Theorem 6 is almost as bad as it gets, even for an arbitrary distribution of the players into the two groups. Formally, for any positive integers k1, k2 such that k1+k2=n, for n players with preferences represented by continuous cardinal utility functions (not necessarily additive or monotone), there exists an envy-free assignment of the mixed cake with group j containing kj players that uses at most n cuts. Indeed, a result of Simmons and Su [Citation11] states that for n players with such utility functions, there exists a partition of the mixed cake into two parts using at most n cuts such that every player has equal utility for both parts. This partition allows us to divide the players into two groups arbitrarily so that group j contains kj players.Footnote5

As our final remark, we note that the vast majority of the cake-cutting literature assumes that players’ preferences are captured by additive utility functions—indeed, additivity is portrayed as an inherent part of the model in surveys on the subject [Citation6, Citation7]. However, in many applications of cake cutting the preferences are neither additive nor monotone, and as our work demonstrates, allowing general preferences raises several new questions with intriguing answers. Investigating other questions in the more general preference model is therefore an appealing direction for future work.

Acknowledgments

This work was partially supported by the Israel Science Foundation under grant number 712/20, by the Singapore Ministry of Education under grant number MOE-T2EP20221-0001, and by an NUS Start-up Grant. The authors wish to thank the editor and the anonymous reviewers for several constructive comments.

Additional information

Funding

This work was partially supported by the Israel Science Foundation under grant number 712/20, by the Singapore Ministry of Education under grant number MOE-T2EP20221-0001, and by an NUS Start-up Grant.

Notes on contributors

Erel Segal-Halevi

EREL SEGAL-HALEVI received bachelor’s and master’s degrees from the Technion, and a Ph.D. in computer science from Bar-Ilan University. He is now a faculty member in Ariel University. He strives to make the world fairer by developing new fair division algorithms and teaching existing algorithms to his students.

Warut Suksompong

WARUT SUKSOMPONG received his Ph.D. in computer science from Stanford University and his bachelor’s and master’s degrees from the Massachusetts Institute of Technology. After a postdoctoral stint at the University of Oxford, he is now an assistant professor at the National University of Singapore. He has published papers in mathematics, computer science, economics, and operations research venues, and has written surveys on fair division and on tournaments in computational social choice.

Notes

1 Formally, each player’s preference is represented by a function from the standard simplex Δm1 to a nonempty subset of {1,2,,m}. Note that this model allows a player to prefer, for example, the piece of length 0.8 in the partition (0,0.2,0.8) and the piece of length 0.2 in the partition (0.2,0,0.8), even though the partitions are physically identical. We could add a requirement that each player always prefers the same physical piece(s) in such equivalent partitions; this would not affect our results except in Section 5.

2 Our queries are intended to mirror those in the “Robertson–Webb model”—see the discussion at the end of this section.

3 As we noted above, Stromquist’s impossibility result holds even when all players have preferences based on additive utility functions. The same is true for our Theorem 3: the preferences used in the proof can be represented by additive utility functions (however, unlike Stromquist’s result, our result requires non-monotone preferences). To see this, for each player i, plot a continuous function between (0, 0) and (1, 1), crossing 1/2 at every indifference point of i, so that the function is below 1/2 in any interval in which i prefers the right piece, and above 1/2 in any interval in which i prefers the left piece. Since every player has a finite number of indifference points in our construction, such a function Ui:[0,1][0,1] represents an additive utility function, which assigns to each interval [x,y] the utility Ui(y)Ui(x).

4 Segal-Halevi and Suksompong [10] reduced group cake cutting to individual cake cutting. Why can we not use the same method for reducing group chore division to individual chore division? The reason is that while their reduction preserves “hungriness,” it does not preserve “laziness.”

More specifically, given a player in a group cake-cutting instance, the reduction constructs a player in an individual cake-cutting instance. To determine the preferences of the individual-instance player on an n-partition x, the reduction constructs an m-partition x by uniting sequences of adjacent pieces: the union of pieces 1,k1 in x is the first piece in x; the union of pieces k1+1,k2 in x is the second piece in x; and so on.

Now, if some piece in x is nonempty, then the corresponding piece in x is nonempty too; therefore, hungriness of the group-instance player implies hungriness of the individual-instance player. However, if some piece in x is empty, then there is no reason to assume that the corresponding piece (or any other piece) in x will be empty too; so laziness of the group-instance player does not imply laziness of the individual-instance player.

5 In fact, n – 1 cuts suffice, since we can compute a consensus halving for n – 1 players and let the nth player pick a preferred piece for his or her group.

References

  • Avvakumov, S., Karasev, R. (2021). Envy-free division using mapping degree. Mathematika. 67(1): 36–53. DOI: 10.1112/mtk.12059.
  • Bogomolnaia, A., Moulin, H., Sandomirskiy, F., Yanovskaya, E. (2017). Competitive division of a mixed manna. Econometrica. 85(6): 1847–1871.
  • Brams, S. J., Taylor, A. D. (1996). Fair Division: From Cake-Cutting to Dispute Resolution. Cambridge, UK: Cambridge Univ. Press.
  • Meunier, F., Zerbib, S. (2019). Envy-free cake division without assuming the players prefer nonempty pieces. Israel J. Math. 234(2): 907–925.
  • Nyman, K., Su, F. E., and Zerbib, S. (2020). Fair division with multiple pieces. Discrete Appl. Math. 283: 115–122. DOI: 10.1016/j.dam.2019.12.018.
  • Procaccia, A. D. (2013). Cake cutting: Not just child’s play. Commun. ACM. 56(7): 78–87. DOI: 10.1145/2483852.2483870.
  • Procaccia, A. D. (2016). Cake cutting algorithms. In: Brandt, F., Conitzer, V., Endriss, U., Lang, J., Procaccia, A. D., eds. Handbook of Computational Social Choice. Cambridge, UK: Cambridge University Press, pp. 311–329.
  • Robertson, J., Webb, W. (1998). Cake-Cutting Algorithms: Be Fair if You Can. Boca Raton, FL: Peters/CRC Press.
  • Segal-Halevi, E. (2018). Fairly dividing a cake after some parts were burnt in the oven. In: André, E., Koenig, S., Dastani, M., Sukthankar, G., eds. Proceedings of the 17th International Conference on Autonomous Agents and MultiAgent Systems. Richland, SC: International Foundation for Autonomous Agents and Multiagent Systems, pp. 1276–1284.
  • Segal-Halevi, E., Suksompong W. (2021). How to cut a cake fairly: a generalization to groups. Amer. Math. Monthly. 128(1): 79–83.
  • Simmons, F. W., Su, F. E. (2003). Consensus-halving via theorems of Borsuk-Ulam and Tucker. Math. Soc. Sci. 45(1): 15–25.
  • Stromquist, W. (1980). How to cut a cake fairly. Amer. Math. Monthly. 87(8): 640–644. Addendum at Amer. Math. Monthly. 88(8): 613–614.
  • Stromquist, W. (2008). Envy-free cake divisions cannot be found by finite protocols. Electron. J. Comb. 15: #R11.
  • Su, F. E. (1999). Rental harmony: Sperner’s lemma in fair division. Amer. Math. Monthly. 106(10): 936–942.
  • Woodall, D. R. (1980). Dividing a cake fairly. J. Math. Anal. Appl. 78(1): 233–247.