Proportional division

For the scheduling algorithm, see Proportionally fair.

A proportional division is a kind of fair division in which a resource is divided among n partners, giving each partner at least 1/n of the resource by their own subjective valuation. For example, consider a land asset that has to be divided among 3 heirs: Alice and Bob who think that it's worth 3 million dollars, and George who thinks that it's worth $4.5M. In a proportional division, Alice receives a land-plot that she believes to be worth at least $1M, Bob receives a land-plot that he believes to be worth at least $1M (even though Alice may think it is worth less), and George receives a land-plot that he believes to be worth at least $1.5M.

proportionality was the first fairness criterion studied in the literature; hence it is sometimes called "simple fair division".

Existence

A proportional division does not always exist. For example, if the resource contains several indivisible items and the number of people is larger than the number of items, then some people will get no item at all and their value will be zero.

A proportional division is guaranteed to exist if the following conditions hold:

• The valuations of the players are non-atomic, i.e., there are no indivisible elements with positive value.
• The valuations of the players are additive, i.e., when a piece is divided, the sum of a piece is equal to the sum of its parts.

Hence, proportional division is usually studied in the context of fair cake-cutting.

A more lenient fairness criterion is partial proportionality, in which each partner receives a certain fraction f(n) of the total value, where f(n) ≤ 1/n. Partially proportional divisions exist (under certain conditions) even for indivisible items.

Procedures

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. If the valuations are non-atomic and additive, then both the divider and the chooser can act in a way that guarantees that they get a value of at least 1/2: the divider can cut the cake to two pieces that he thinks are equal, and the chooser can pick the piece that he thinks is more valuable.

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

Simple procedures

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, $n\times (n-1)/2=O(n^{2})$ 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.

• A knife is passed over the cake, parallel to itself, from one end to the other.
• A partner says 'stop' when they think $1/n$ 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.

Successive Pairs 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.

In contrast to Last Diminisher, this algorithm generates disconnected pieces ("crumbs"). Straightforward use of the successive pairs algorithm would generate $n!$ pieces, in fact only about $n^{3}/3$ are needed as each partner only really needs to do $n-1$ cuts when the $n$^th partner comes along.

Recursive halving

Using a divide-and-conquer strategy, it is possible to achieve a proportional division in time O(n log n). 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).

Randomized version

It is possible to use randomization in order to reduce the number of marks. The following randomized version of the recursive halving procedure achieves a proportional division using only O(n) mark queries on average. The idea is that, in each iteration, instead of asking all partners to make a half-value mark, only some partners are asked to make such marks, while the other partners only choose which half they prefer. The partners are sent either to the west or to the east according to their preferences, until the number of partners in each side is n/2. Then a cut is made, and each group of n/2 partners divides its half recursively.

In the worst case we still need n-1 marks per iteration so the worst-case number of marks required is O(n log n). However, on average only O(log n) marks are required per iteration; by solving a recurrence formula it is possible to show that the average number of marks required is O(n).

Note that the total number of queries is still O(n log n), since each partner has to select a half.

Selection procedures

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:

1. Each partner privately partitions the cake to n intervals that he considers to be of equal value; these are called candidate pieces.
2. 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.
3. 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..

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

Randomized versions

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 of the total value, where f<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:

1. Each partner privately partitions the cake to an pieces of equal subjective value. These n⋅an pieces are called candidate pieces.
2. Each partner picks 2d 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.
3. 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.
4. 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.
5. 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 high probability, 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/2an. 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:

Start by creating the implication graph: a graph whose nodes are the semifinal pieces, and there is an edge from piece I of partner i to piece J of partner j if piece I intersects the other piece of partner j (hence, if we select piece I and want to avoid intersection, we ought to select piece J too).

Select an arbitrary partner i that has not received a piece yet, and select an arbitrary piece I of that partner as a final piece. Then, traverse the links in the implication graph and select as final pieces all pieces that are reachable from I. There are two good scenarios: either we allocate a single final piece to each partner and we are done, or we reach a piece with no outgoing links (which implies that it does not intersect other pieces). In the latter case we just pick another piece of one of the remaining partners and continue. The bad scenario is that our traversal leads us to two different pieces of the same partner, or equivalently to the other piece of partner i from whom we started. Such a path, leading from one piece of partner i to another piece of the same partner, is called a pair path. If the implication graph contains no pair paths, then the selection algorithm just described returns a collection of n non-overlapping final pieces and we are done. Now it remains to calculate the probability that the implication graph contains a pair path.

First, consider the special case in which all partners have the same value function (and hence the same collection of candidate pieces). In this case the probability of a pair path is easy to calculate: since the probability of each edge is 1/an, and all edges are independent, the probability of a specific pair path of length k is 1/(an)^k, and the probability of any pair path is at most:

$\Sigma _{k}{\frac {(2dn)!}{(2dn-k)!(an)^{k}}}=O({\frac {1}{a^{2}}})$

By selecting d=1 and a sufficiently large, it is possible to make this probability as small as we want. This is true even if we omit the semi-final selection phase (#3) and just take all quarter-final pieces as semi-final.

Note that this case is analogous to the balls into bins model. It proves that, if d bins are picked randomly for each ball, then it is possible to select one bin for each ball such that the bins are all distinct (- the maximum load is 1).

In the general cake model, where the value functions are different, the probabilities of the edges in the implication graph are dependent. but thanks to the semi-final selection phase, we can prove that the probability that the implication graph contains a pair path of length at least 3 is at most ${\frac {32d^{5}}{a^{2}\cdot (a-4d^{2})}}$.

It remains to handle pair paths of length 2. Unfortunately the probability of having such pair paths in the implication graph is not negligible. However, with high probability it is possible to partition the partners to two groups, such that in each group there is no pair path of length 2. Hence, we can run the final-piece-selection algorithm twice: once for each group. Intersection can occur only between final pieces of different groups; hence the overlap in each point of the cake is at most 2. The probability that such a 2-partition is not possible is at most ${\frac {16d^{3}}{a^{3}}}+{\frac {8d^{2}}{a^{2}}}$.

By summing the above two expressions and setting d=2, we get that the probability of failure is still $O({\frac {1}{a^{2}}})$. Recall that a is the proportionality ratio - the more value we want to guarantee each partner, the more likely it is that the division will fail and we will have to start over at step #1.

The same algorithm works also when the cuts are approximate, i.e., the partners do not know to mark pieces with exactly the same value; they might mark a piece with a value of p percent above or below the required value, where the exact error is picked at random.

It is possible to further reduce the probability of failure using the following scheme:

• Make two independent runs of the original protocol.
• In each run, remove every partner that appears in the beginning of a pair path, and allocate final pieces only to the remaining partners as in the original protocol.
• If for every partner there is at least one run in which it is not removed, then we are done since every partner now holds at least one final piece.

The probability of removing a specific partner in each run is $O({\frac {1}{n}})$. The probability of removing a specific partner in both runs is $O({\frac {1}{n^{2}}})$. Hence the probability of failure is $O({\frac {n}{n^{2}}})=O({\frac {1}{n}})$, which goes to 0 when n increases, even when the partial proportionality ratio a is kept constant.

Hardness results

The hardness results are stated in terms of the "standard Robertson-Webb model", i.e., they relate to procedures employing two types of actions: "Evaluate" and "Cut".

Every deterministic proportional division procedure for n≥3 partners must use at least n actions, even if all valuations are identical.

Moreover, every deterministic or randomized proportional division procedure assigning each person a contiguous piece must use Ω(n log n) actions.

Moreover, every deterministic proportional division procedure must use Ω(n log n) actions, 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.

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.

The following table summarizes the known results:

Proportionality (full/partial)	Pieces (contiguous/disjoint)	Protocol type (deterministic/randomized)	Queries (exact/approximate)	#queries
full	contiguous	det.	exact	O(n log n) Ω(n log n)
full	contiguous	det.	approximate	Ω(n log n)
full	contiguous	rand.	exact	O(n log n) Ω(n log n)
full	contiguous	rand.	approximate	Ω(n log n)
full	disconnected	det.	exact	O(n log n) Ω(n log n)
full	disconnected	det.	approximate	Ω(n log n)
full	disconnected	rand.	exact	O(n log n)
full	disconnected	rand.	approximate	Ω(n log n)
partial	contiguous	det.	exact	O(n log n) Ω(n log n)
partial	contiguous	det.	approximate	Ω(n log n)
partial	contiguous	rand.	exact	O(n log n)
partial	contiguous	rand.	approximate	Ω(n log n)
partial	disconnected	det.	exact	O(n log n) Ω(n log n)
partial	disconnected	det.	approximate	Ω(n log n)
partial	disconnected	rand.	exact	O(n)
partial	disconnected	rand.	weakly approx. (error independent of value)	O(n)
partial	disconnected	rand.	approximate	Ω(n log n)

Variants

Weighted proportional division

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 shareholders such that one of them holds 20% and the other holds 80%. This leads to the criterion of weighted proportionality: there are several weights w_i that sum up to 1, and every partner i receives at least a fraction w_i of the resource by their own valuation.

When the value functions are additive and non-atomic, a weighted proportional division is guaranteed to exist for every set of weights.

When the entitlements are rational numbers, a weighted proportional division can be found by treating each player as a number of proxy players, each entitled to the same amount. For example, if Alice is entitled to 2/5 of the cake and George is entitled to 3/5, then we can define 5 proxy players: Alice1, Alice2, George1, George2 and George3, and use any proportional division algorithm to give each proxy player a value of 1/5.

Note that this simple scheme does not preserve the geometric properties of the original algorithm. I.e., if the original division algorithm guarantees that each partner receives a contiguous piece, this is no longer guaranteed when using proxy players.

Exact division

An exact division is a division in which each partner receives exactly 1/n of the resource according to the valuations of all n partners. A weighted exact division is a division in which every partner i receives exactly a fraction w_i of the resource according to the valuations of all n partners.

When the value functions are additive and non-atomic, a weighted exact division is guaranteed to exist for every set of weights. This is a consequence of the convexity of the space of partitions.

Super-proportional division

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.

When the valuations are additive and non-atomic, a super-proportional division always exists.

Proportional division of chores

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.

Comparison with Envy-freeness and other criteria

Implications

When there are only two players, a proportional division is always envy-free: If a player got 1/2 or more (on his subjective value unit) then the other piece is 1/2 or less, and the player does not envy that piece.

However, for three players and more, a proportional division might not be envy-free. For instance, the Successive Pairs Algorithm for three persons could yield to a situation where the first person thinks that the third person received more than he did (if the portion of the second player part that the third player chose looks bigger - to the first player- than the other portions of the second player part). So the first person might get a piece with value 1/3, but still prefer the third person'ss piece which has value 2/3.

If the value functions of the players are sigma additive, then an envy-free division is always proportional, since a piece with a value of not less than the other pieces, must have a value of at least 1/n. However, when the value functions are not additive, an envy-free division might be not proportional. For example, it is possible that the cake is divided in such a way that makes both pieces useless for one of the players. Then, this player will not envy the other player because there is nothing to envy, but his value will be much less than 1/2. The following table summarizes the implications between envy-freeness (EF) and proportionality (PR):

Agents	Valuations	EF implies PR?	PR implies EF?
2	additive	yes	yes
2	general	no	yes
3+	additive	yes	no
3+	general	no	no

Stability to voluntary exchanges

One advantage of the proportionality criterion over envy-freeness and similar criteria is that it is stable with regards to voluntary exchanges.

As an example, assume that a certain land is divided among 3 partners: Alice, Bob and George, in a division that is both proportional and envy-free. Several months later, Alice and George decide to merge their land-plots and re-divide them in a way that is more profitable for them. From Bob's point of view, the division is still proportional, since he still holds a subjective value of at least 1/3 of the total, regardless of what Alice and George do with their plots. On the other hand, the new division might not be envy free. For example, it is possible that initially both Alice and George received a land-plot which Bob subjectively values as 1/3, but now after the re-division George got all the value (in Bob's eyes) so now Bob envies George.

Hence, using envy-freeness as the fairness criterion implies that we must constrain the right of people to voluntary exchanges after the division. Using proportionality as the fairness criterion has no such negative implications.

Individual rationality

An additional advantage of proportionality is that it is compatible with individual rationality in the following sense. Suppose n partners own a resource in common. In many practical scenarios (though not always), the partners have the option to sell the resource in the market and split the revenues such that each partner receives exactly 1/n. Hence, a rational partner will agree to participate in a division procedure, only if the procedure guarantees the he receives at least 1/n of his total value.

Additionally, there should be at least a possibility (if not a guarantee) that the partner receives more than 1/n; this explains the importance of the existence theorems of #Super-proportional division.

See also

• Allocative efficiency

References

• Jack Robertson and William Webb (1998). Cake-Cutting Algorithms: Be Fair If You Can, AK Peters Ltd, . ISBN 1-56881-076-8.
• Steven J. Brams and Alan D. Taylor (1996). Fair Division - From cake-cutting to dispute resolution Cambridge University Press. ISBN 0-521-55390-3