1000/1000

Hot
Most Recent

Submitted Successfully!

To reward your contribution, here is a gift for you: A free trial for our video production service.

Thank you for your contribution! You can also upload a video entry or images related to this topic.

Do you have a full video?

Are you sure to Delete?

Cite

If you have any further questions, please contact Encyclopedia Editorial Office.

HandWiki. Proportional Cake-Cutting. Encyclopedia. Available online: https://encyclopedia.pub/entry/31456 (accessed on 03 August 2024).

HandWiki. Proportional Cake-Cutting. Encyclopedia. Available at: https://encyclopedia.pub/entry/31456. Accessed August 03, 2024.

HandWiki. "Proportional Cake-Cutting" *Encyclopedia*, https://encyclopedia.pub/entry/31456 (accessed August 03, 2024).

HandWiki. (2022, October 26). Proportional Cake-Cutting. In *Encyclopedia*. https://encyclopedia.pub/entry/31456

HandWiki. "Proportional Cake-Cutting." *Encyclopedia*. Web. 26 October, 2022.

Copy Citation

A proportional cake-cutting is a kind of fair cake-cutting. It is a division of a heterogeneous resource ("cake") that satisfies the proportionality criterion, namely, that every partner feels that his allocated share is worth at least 1/n of the total. Two assumptions are usually made when proportionality is discussed: The valuations of the partners are *non-atomic*, i.e., there are no indivisible elements with positive value. The valuations of the partners are *additive*, i.e., when a piece is divided, the value of the piece is equal to the sum of its parts.

proportionality
cake-cutting
cake

The cake is denoted by [math]\displaystyle{ C }[/math]. There are [math]\displaystyle{ n }[/math] people. Each person [math]\displaystyle{ i }[/math] has a value function [math]\displaystyle{ V_i }[/math]. A partition of the cake, [math]\displaystyle{ X_1\sqcup \cdots \sqcup X_n = C }[/math], is called *proportional* if:

[math]\displaystyle{ V_i(X_i) \ge V_i(C)/n }[/math] for every person [math]\displaystyle{ i \in \{1,\ldots,n\} }[/math].

For two people, divide and choose is the classic solution. One person divides the resource into what they believe are equal halves, and the other person chooses the "half" they prefer. The non-atomicity assumption guarantees that the cutter can indeed cut the cake to two equal pieces; the additivity assumption guarantees that both partners value their pieces as at least 1/2.

There are many ways to extend this procedure to more than 2 people. Each way has its own advantages and disadvantages.

**Last diminisher** is the earliest proportional division procedure developed for *n* people:

- One of the partners is asked to draw a piece which he values as at least 1/
*n*. - The other partners in turn have the option to claim that the current piece is actually worth more than 1/
*n*; in that case, they are asked to diminish it such that the remaining value is 1/*n*according to their own valuation. - The last partner to diminish the current piece, receives it.
- The remaining cake is then divided in the same way among the remaining
*n*− 1 people.

By induction, it is possible to prove that each partner following the rules is guaranteed to get a value of 1/*n*, regardless of what the other partners do. This is a discrete procedure that can be played in turns. In the worst case, [math]\displaystyle{ n\times(n-1)/2 = O(n^2) }[/math] actions are needed: one action per player per turn. However, most of these actions can be done on paper; only *n* − 1 cuts of the cake are actually needed. Hence, if the cake is contiguous then it is possible to guarantee that each piece is contiguous.

**Dubins–Spanier moving-knife procedure** is a continuous-time version of Last Diminisher.^{[1]}

- A knife is passed over the cake, parallel to itself, from one end to the other.
- A partner says 'stop' when they think [math]\displaystyle{ 1 / n }[/math] of the cake is to the left of the knife. Then the cake is cut and they get that piece.
- This is repeated with the remaining cake and partners. the last partner gets the remainder of the cake.

**Fink protocol** is an algorithm that continues the division to successively smaller "equal" portions.

- The first partner divides the resource into what they believe are equal halves.
- The second then chooses a half, leaving the remainder for the first partner
- Each of these two partners then divide their respective portions into thirds.
- The third partner picks two of the resulting portions: one from the first partner and one from the second partner.
- If there are four partners, each of the first three partners divides their portions into fourths, and the process continues.

The advantage of this protocol is that it can be executed online – as new partners enter the party, the existing division is adjusted to accommodate them, without needing to restart the entire division process. The disadvantage is that the each partner receives a large number of disconnected pieces rather than a single connected piece.

**Lone divider** is a procedure based on an equal partition made by a single agent. Its advantage is that it can be generalized to yield a symmetric fair cake-cutting.

See also: ^{[2]}

Using a divide-and-conquer strategy, it is possible to achieve a proportional division in time O(*n* log *n*).^{[3]} For simplicity the procedure is described here for an even number of partners, but it can be easily adapted to any number of partners:

- Each partner is asked to draw a line dividing the cake to two pieces that he believes to be of equal value. The cuts are required to be non-intersecting; a simple way to guarantee this is to allow only horizontal lines or only vertical lines.
- The algorithm sorts the
*n*lines in increasing order and cuts the cake in the median of the lines. E.g., if there are 4 partners that draw lines at*x*= 1,*x*= 3,*x*= 5 and*x*= 9, then the algorithm cuts the cake vertically at*x*= 4. - The algorithm assigns to each of the two halves
*n*/2 partners – the partners whose line is inside that half. E.g., the partners that drew lines at*x*= 1 and*x*= 3 are assigned to the western half and the other two partners are assigned to the eastern half. Each half is divided recursively among the*n*/2 partners assigned to it.

It is possible to prove by induction that every partner playing by the rules is guaranteed a piece with a value of at least 1/*n*, regardless of what the other partners do.

Thanks to the divide-and-conquer strategy, the number of iterations is only O(log *n*), in contrast to O(*n*) in the Last Diminisher procedure. In each iteration, each partner is required to make a single mark. Hence, the total number of marks required is O(*n* log *n*).

This algorithm has a randomized version which can be used to reduce the number of marks; see Even-Paz algorithm.

A different approach to cake-cutting is to let every partner draw a certain number of pieces depending on the number of partners, *p*(*n*), and give each partner one of his selected pieces, such that the pieces do not overlap.

As a simple example of a selection procedure, assume the cake is a 1-dimensional interval and that each partner wants to receive a single contiguous interval. Use the following protocol:

- Each partner privately partitions the cake to
*n*intervals that he considers to be of equal value; these are called*candidate pieces*. - The protocol orders the
*n*^2 candidates by increasing order of their eastern (from west to east) and select the interval with the most western eastern end. This interval is called a*final piece*. - The protocol gives the final piece to its owner and remove all candidates intersected by it. Step #2 is then repeated with the remaining intervals of the remaining
*n*− 1 partners.

The selection rule in step #2 guarantees that, at each iteration, at most one interval of every partner is removed. Hence, after each iteration the number of intervals per partners is still equal to the number of partners, and the process can proceed until every partner receives an interval.^{[4]}

This protocol requires each partner to answer *n* queries so the query complexity is O(*n*^{2}), similarly to Last Diminisher.

It is possible to use randomization in order to reduce the number of queries. The idea is that each partner reports, not the entire collection of *n* candidates but only a constant number *d* of candidates, picked at random. The query complexity is O(*n*), which is obviously the best possible. In many cases, it will still be possible to give each partner a single candidate such that the candidates do not overlap. However, there are scenarios in which such an allocation will be impossible.

We can still cut a cake using O(*n*) queries if we make several compromises:

- Instead of guaranteeing full proportionality, we guarantee
*partial proportionality*, i.e. each partner receives a certain constant fraction*f*(*n*) of the total value, where*f*(*n*)<1/*n*. - Instead of giving each partner a single contiguous piece, we give each partner a union of one or more disjoint pieces.

The general scheme is as follows:^{[5]}

- Each partner privately partitions the cake to
*an*pieces of equal subjective value. These*n⋅an*pieces are called*candidate pieces*. - Each partner picks 2
*d*candidate pieces uniformly at random, with replacement. The candidates are grouped into*d*pairs, which the partner reports to the algorithm. These*n⋅d*pairs are called*quarterfinal brackets*. - From each quarterfinal bracket, the algorithm selects a single piece – the piece that intersects the fewer number of other candidate pieces. These
*n⋅d*pieces are called*semifinal pieces*. - For each partner, the algorithm selects a single piece; they are called
*final pieces*. The final pieces are selected such that each point of the cake is covered by at most 2 final pieces (see below). If this succeeds, proceed to step #5. If this fails, start over at step #1. - Each part of the cake which belongs to only a single final piece, is given to the owner of that piece. Each part of the cake which belongs to two final pieces, is divided proportionally by any deterministic proportional division algorithm.

The algorithm guarantees that, with probability O(1*a*^{2}), each partner receives at least half of one of his candidate pieces, which implies (if the values are additive) a value of at least 1/2*an*. There are O(*n*) candidate pieces and O(*n*) additional divisions in step #5, each of which takes O(1) time. Hence the total run-time of the algorithm is O(*n*).

The main challenge in this scheme is selecting the final pieces in step #4. For details, see Edmonds–Pruhs protocol.

The hardness results are stated in terms of the Robertson–Webb query model, i.e., they relate to procedures asking the agents two types of queries: "Evaluate" and "Cut".

Every deterministic proportional division procedure for *n*≥3 partners must use at least *n* queries, even if all valuations are identical.^{[3]}

Moreover, every deterministic or randomized proportional division procedure assigning each person a contiguous piece must use Ω(*n* log *n*) actions.^{[6]}

Moreover, every deterministic proportional division procedure must use Ω(*n* log *n*) queries, even if the procedure is allowed to assign to each partner a piece that is a union of intervals, and even if the procedure is allowed to only guarantee *approximate fairness*. The proof is based on lower bounding the complexity to find, for a single player, a piece of cake that is both rich in value, and thin in width.^{[7]}

These hardness results imply that recursive halving is the fastest possible algorithm for achieving full proportionality with contiguous pieces, and it is the fastest possible deterministic algorithm for achieving even partial proportionality and even with disconnected pieces. The only case in which it can be improved is with randomized algorithms guaranteeing partial proportionality with disconnected pieces.

If the players are able to cut with only finite precision, then the Ω(n log n) lower bound also includes randomized protocols.^{[7]}

The following table summarizes the known results:^{[5]}

Proportionality(full/partial) |
Pieces(contiguous/disjoint) |
Protocol type(deterministic/randomized) |
Queries(exact/approximate) |
#queries |
---|---|---|---|---|

full | contiguous | det. | exact | O(n log n)^{[3]}Ω( n log n)^{[6]} |

full | contiguous | det. | approximate | Ω(n log n)^{[6]} |

full | contiguous | rand. | exact | O(n log n)^{[3]}Ω( n log n)^{[6]} |

full | contiguous | rand. | approximate | Ω(n log n)^{[6]} |

full | disconnected | det. | exact | O(n log n)^{[3]}Ω( n log n)^{[7]} |

full | disconnected | det. | approximate | Ω(n log n)^{[7]} |

full | disconnected | rand. | exact | O(n log n)^{[3]} |

full | disconnected | rand. | approximate | Ω(n log n)^{[7]} |

partial | contiguous | det. | exact | O(n log n)^{[3]}Ω( n log n)^{[7]} |

partial | contiguous | det. | approximate | Ω(n log n)^{[7]} |

partial | contiguous | rand. | exact | O(n log n)^{[3]} |

partial | contiguous | rand. | approximate | Ω(n log n)^{[7]} |

partial | disconnected | det. | exact | O(n log n)^{[3]}Ω( n log n)^{[7]} |

partial | disconnected | det. | approximate | Ω(n log n)^{[7]} |

partial | disconnected | rand. | exact | O(n)^{[5]} |

partial | disconnected | rand. | weakly approx. (error independent of value) |
O(n)^{[5]} |

partial | disconnected | rand. | approximate | Ω(n log n)^{[7]} |

The proportionality criterion can be generalized to situations in which the entitlements of the partners are not equal. For example, the resource may belong to two shareholders such that Alice holds 8/13 and George holds 5/13. This leads to the criterion of *weighted proportionality* (WPR): there are several weights *w _{i}* that sum up to 1, and every partner

A *super-proportional division* is a division in which each partner receives strictly more than 1/*n* of the resource by their own subjective valuation.

Of course such a division does not always exist: when all partners have exactly the same value functions, the best we can do is give each partner exactly 1/*n*. So a necessary condition for the existence of a super-proportional division is that not all partners have the same value measure.

The surprising fact is that, when the valuations are additive and non-atomic, this condition is also sufficient. I.e., when there are at least *two* partners whose value function is even slightly different, then there is a super-proportional division in which *all* partners receive more than 1/*n*. See super-proportional division for details.

In addition to the usual constraint that all pieces must be connected, in some cases there are additional constraints. In particular, when the *cake* to divide is a disputed territory lying among several countries, it may be required that the piece allocated to each country is adjacent to its current location. A proportional division with this property always exists and can be found by combining the Last Diminisher protocol with geometric tricks involving conformal mappings. See Hill–Beck land division problem.

When the "cake" to be divided is two-dimensional, such as a land-estate or an advertisement space in print or electronic media, it is often required that the pieces satisfy some geometric constraints, in addition to connectivity. For example, it may be required that each piece be a square, a fat rectangle, or generally a fat object. With such fatness constraints, a proportional division usually does not exist, but a partially-proportional division usually exists and can be found by efficient algorithms.^{[8]}

In addition to being proportional, it is often required that the division be economically efficient, i.e., maximize the social welfare (defined as the sum of the utilities of all agents).

For example, consider a cake which contains 500 gram chocolate and 500 gram vanilla, divided between two partners one of whom wants only the chocolate and the other wants only the vanilla. Many cake-cutting protocols will give each agent 250 gram chocolate and 250 gram vanilla. This division is proportional because each partner receives 0.5 of his total value so the normalized social welfare is 1. However, this partition is very inefficient because we could give all the chocolate to one partner and all the vanilla to the other partner, achieving a normalized social welfare of 2.

The *optimal proportional division* problem is the problem of finding a proportional allocation that maximizes the social welfare among all possible proportional allocations. This problem currently has a solution only for the very special case where the cake is a 1-dimensional interval and the utility density functions are linear (i.e. *u*(*x*) = *Ax* + *B*). In general the problem is NP-hard. When the utility functions are not normalized (i.e. we allow each partner to have a different value for the whole cake), the problem is even NP-hard to approximate within a factor of 1/√*n*.^{[9]}

Truthfulness is not a property of a division but rather a property of the protocol. All protocols for proportional division are *weakly truthful* in that each partner acting according to his true valuation is guaranteed to get at least 1/*n* (or 1/*an* in case of a partially proportional protocol) regardless of what the other partners do. Even if all other partners make a coalition with the only intent to harm him, he will still receive his guaranteed proportion.^{[10]}

However, most of the protocols are not *strongly truthful* in that some partners may have an incentive to lie in order to receive even more than the guaranteed share. This is true even for the simple divide and choose protocol: if the cutter knows the preferences of the chooser, he can cut a piece which the chooser values as slightly less than 1/2, but which the cutter himself values as much more than 1/2.

There are truthful mechanisms for achieving a perfect division; since a perfect division is proportional, these are also truthful mechanisms for proportional division.

These mechanisms can be extended to provide a super-proportional division when it exists:^{[11]}

- Ask each partner to report his entire value measure.
- Pick a random partition (see
^{[11]}for more details). - If the random partition happens to be super-proportional according to the reported value measures, then implement it. Otherwise, use a truthful mechanism for providing a perfect division.

When a super-proportional division exists, there is a positive chance that it will be picked in step 2. Hence the expected value of every truthful partner is strictly more than 1/*n*. To see that the mechanism is truthful, consider three cases: (a) If the picked partition is truly super-proportional, then the only possible result of lying is to mislead the mechanism to think that it is not; this will make the mechanism implement a perfect division, which will be worse for all partners including the liar. (b) If the picked partition is not super-proportional because it gives only the liar a value of 1/*n* or less, then the only effect of lying is to make the mechanism think that the partition *is* super-proportional and implement it, which only harms the liar himself. (c) If the picked partition is truly not super-proportional because it gives another partner a value of 1/*n* or less, then lying has no effect at all since the partition will not be implemented in any case.

When the resource to divide is undesirable (like in chore division), a proportional division is defined as a division giving each person *at most* 1/*n* of the resource (i.e. the sign of inequality is inversed).

Most algorithms for proportional division can be adapted to chore division in a straightforward way.

- Dubins, Lester Eli; Spanier, Edwin Henry (1961). "How to Cut a Cake Fairly". The American Mathematical Monthly 68 (1): 1–17. doi:10.2307/2311357. https://dx.doi.org/10.2307%2F2311357
- Tasnadi, Attila. "A new proportional procedure for the n-person cake-cutting problem". https://www.researchgate.net/publication/4804657. Retrieved 24 September 2015.
- Even, S.; Paz, A. (1984). "A note on cake cutting". Discrete Applied Mathematics 7 (3): 285. doi:10.1016/0166-218x(84)90005-2. https://dx.doi.org/10.1016%2F0166-218x%2884%2990005-2
- This selection procedure is similar to the Interval scheduling)
- Jeff Edmonds and Kirk Pruhs (2006). "Balanced Allocations of Cake". 623–634. doi:10.1109/focs.2006.17. ISBN 978-0-7695-2720-8. https://dx.doi.org/10.1109%2Ffocs.2006.17
- Gerhard J. Woeginger and Jiri Sgall (2007). "On the complexity of cake cutting". Discrete Optimization 4 (2): 213–220. doi:10.1016/j.disopt.2006.07.003. https://dx.doi.org/10.1016%2Fj.disopt.2006.07.003
- Edmonds, Jeff (2006). Cake cutting really is not a piece of cake. 271–278. doi:10.1145/1109557.1109588. ISBN 978-0898716054. , Edmonds, Jeff (2011). "Cake cutting really is not a piece of cake". ACM Transactions on Algorithms 7 (4): 1–12. doi:10.1145/2000807.2000819. https://dx.doi.org/10.1145%2F1109557.1109588
- Segal-Halevi, Erel; Nitzan, Shmuel; Hassidim, Avinatan; Aumann, Yonatan (2017). "Fair and square: Cake-cutting in two dimensions". Journal of Mathematical Economics 70: 1–28. doi:10.1016/j.jmateco.2017.01.007. https://dx.doi.org/10.1016%2Fj.jmateco.2017.01.007
- Bei, Xiaohui; Chen, Ning; Hua, Xia; Tao, Biaoshuai; Yang, Endong (2012). "Optimal Proportional Cake Cutting with Connected Pieces". AAAI Conference Proceedings. http://www.aaai.org/ocs/index.php/AAAI/AAAI12/paper/download/4980/5456. Retrieved 2 November 2014.
- Steinhaus, Hugo (1948). "The problem of fair division". Econometrica 16 (1): 101–4.
- Mossel, Elchanan; Tamuz, Omer (2010). Truthful Fair Division. Lecture Notes in Computer Science. 6386. pp. 288–299. doi:10.1007/978-3-642-16170-4_25. ISBN 978-3-642-16169-8. Bibcode: 2010LNCS.6386..288M. https://dx.doi.org/10.1007%2F978-3-642-16170-4_25

More

Information

Subjects:
Others

Contributor
MDPI registered users' name will be linked to their SciProfiles pages. To register with us, please refer to https://encyclopedia.pub/register
:

View Times:
436

Entry Collection:
HandWiki

Update Date:
31 Oct 2022