A Comparative Study of Classic
Cake-Cutting Algorithms
Marysia Winkels
10163727
Bachelor thesis
Credits: 18 EC
Bachelor Opleiding Kunstmatige Intelligentie
University of Amsterdam
Faculty of Science
Science Park 904
1098 XH Amsterdam
Supervisor
Ulle Endriss
Institute for Language and Logic
Faculty of Science
University of Amsterdam
Science Park 904
1098 XH Amsterdam
Abstract
Cake-cutting is the area of fair division that is concerned with the division of a single heterogeneous, divisble good in such a way that it satisfies some pre-defined fairness criterion. Since the 1940s, several procedures have been proposed. This thesis aims to give an insight as to how the classical procedures perform in comparison to one another in terms of fairness and complexity. To achieve this goal, a software tool has been developed that allows the user to explore the different algorithms individually. The cut and choose, Stein-haus, Banach-Knaster, Even-Paz and Selfridge-Conway procedures are com-pared based on the information retrieved from the software tool. The result of this comparison is that the Even-Paz procedure is the most suitable choice in case a good must be divided between two agents, the Selfridge-Conway proce-dure is the most suitable choice in terms of fairness and the Even-Paz in terms of complexity when it concerns the division of a good between three agents, and the Even-Paz procedure is best choice when a good must be divided be-tween any arbitrary number of agents.
Contents
1 Introduction 4 2 The Model 5 2.1 Notation . . . 5 2.2 Valuation function . . . 5 3 Background Theory 7 3.1 Types of Procedures . . . 7 3.2 Classical procedures . . . 8 3.3 Fairness . . . 11 3.4 Complexity . . . 13 4 Software tool 15 4.1 Goal . . . 15 4.2 Requirements . . . 16 4.3 User . . . 17 4.4 Implementation . . . 18 5 Results 20 5.1 Cut and Choose . . . 205.2 Steinhaus . . . 20
5.3 Banach-Knaster . . . 21
5.4 Even-Paz . . . 23
5.5 Selfridge-Conway . . . 24
1
Introduction
The concept of fair division refers to the problem of distributing resources or duties amongst a set of agents in such a way that the allocation satisfies some pre-defined fairness criterion. Individual agents may have identical or dissim-ilar ordinal or cardinal preferences over the set of goods, and the types of goods involved may vary. These factors, as well as the criterion for fairness, determine the nature of the division problem. Several examples of division problems may be found in real world situations, such as the allocation of chores in a house-hold, the division of marital property in divorce settlements, and the distribu-tion of radio frequencies regulated by governments to the various interested parties. These examples illustrate how the to be allocated goods may vary in nature; for example, whereas one could arguably assume that the possessions to be divided among a formerly married couple are all considered desirable, the chores are most likely not.
A distinct area of fair division concerns the division of a heterogeneous, divis-ible resource. An example of such a resource is land, a single good that can be divided into as many segments as desired which allows that any participat-ing agent can receive one or multiple plots of any size. The preferences of the agents may vary, as one agent might prefer a certain type of soil over another and water over vegetation, or might base his or her preference on the amount of sunlight that the particular plot is exposed to per day. Similarly, time can be divided into smaller fragments which can each be assigned to an agent from a set of agents such as television program makers or scientists in need of time on a particular computational cloud. A television program maker might prefer an early time slot over a time slot in the late evening if he or she desires to broad-cast a children’s television show, and the preferences of the scientists who are to make use of the computational cloud are most likely dependent on the time zone in which they operate. This specific area of fair division is commonly re-ferred to as cake cutting, as a cake (with different icings or toppings) exhibits all features that define this domain.
Although the first mention of a procedure to divide the type of goods which cake cutting is concerned with can be traced back to ancient texts, such as
Theogeny, a poem composed approximately 700 B.C.[2], it was not until the
1940s that the problem was approached from a more scientific and less anec-dotal perspective. Following the initial publication on this subject by Steinhaus in 1948[10], the aim has been to describe a step-by-step procedure to obtain a fair division of a heterogeneous, divisible good according to some criterion, most notably proportionality or envy-freeness. Since 1948, multiple procedures have been proposed, each with their own advantages and disadvantages com-pared to previously suggested procedures, and the aim of this thesis is to pro-vide an insight into the workings different existing procedures and how their performance differs from one another.
In order to do this, a tool has been developed for both students learning about cake cutting as well as researchers trying to advance the field of study that enables the user to investigate and explore various classic cake cutting pro-cedures. This thesis will contain information about the existing procedures, including how they perform in terms of the relevant notions of fairness and complexity, as well as a description of the model with which these procedures have been formalized. Furthermore, the tool that was built will be described and the conclusions that can be drawn from the use of this tool will be shared.
2
The Model
The good discussed is a single, static, unshareable, divisible, heterogenous good. This indicates that there is only one available good that is to be divided, which cannot change properties during the process of allocation and cannot be shared among multiple agents. The good is divisible, meaning a segment of any size can be allocated to an agent and the good is heterogeneous, which signifies that any agent may have a different valuation of the same segment of the good. Additionally, the good is considered desirable, conveying that the agents amongst which the good is to be divided all prefer to be allocated as much of the good as possible. For the purpose of readability, this good will henceforth be referred to as cake, as a cake (with different icings or flavours) arguably embodies all these criteria.
2.1
Notation
As initially suggested by Woodall[12], let the cake be represented by the unit interval[0,1] and the set of agents or players amongst which the cake is to be divided through a series of parallel cuts be denoted asN = {1, . . . , n}. Fur-thermore, let division or allocationA = (A1, . . . , An) be the mapping of disjoint
intervals to the agent i . The union of the disjoint intervals ofA represents the entire to be divided cake. Additionally, let subinterval X⊆ [0, 1] represent a piece of cake. The intervals X1, . . . Xmrepresent the m created pieces of the
cake, and one agent may receive multiple slices. In such a case, Aiconsists of
multiple disjoint intervals X . A contiguous allocation is one in which Aiis a
single interval for all i∈ N .
A complete allocation is a division where every piece of the cake has been al-located to some agent. A partial allocation denotes a division in which one or several subintervals of[0,1] has or have been allocated to a subset of N . In this case, the union of allocated intervals does not equal the interval[0,1] (the complete cake) and one or several subintervals of[0,1] has or have remained unallocated.
An example of a contiguous, complete allocation of a cake cut where m= 3 would beA = ({X2}, {X3}, {X1}), which denotes that agent 1 has received piece
X2, agent 2 has received piece X3and agent 3 has received piece X1. In this
case, agent 3 received the interval[0, x ], agent 1 received the interval [x , y ] and agent 2 received the interval[y,1] for an unknown x and y . An example of an allocation that is not contiguous would beA = ({X2, X4}, {X3}, {X1}), where
agent 1 received both piece X2and piece X4(A1= {X2, X4}).
2.2
Valuation function
Each agent i∈ N has its own valuation or utility function Vi(X ), which maps a
given subinterval X⊆ [0, 1] to the value assigned by agent i to that interval X . The valuation function for each agent i∈ N is required to satisfy the following properties:
• Normalisation: Vi([0,1]) = 1 and Vi(;) = 0.
• Non-negativity: Vi(I ) ≥ 0 for all I ⊆ [0,1]
• Additivity: Vi(X ∪X0) = Vi(X )+Vi(X0) for all X , X0⊆ [0, 1] on the condition
that X and X0are disjoint intervals.
The normalisation property ensures the valuation of the entire cake by any agent is always equal to 1 and the valuation of no subinterval of the cake is equal to 0. The non-negativity property ensures that the value an agent as-signs to any piece of the cake is always positive, which confirms that the cake is indeed a desirable good. A stronger assumption would be Vi(I ) > 0,
imply-ing that an agent will always prefer a segment of the cake above no piece at all. However, one could imagine that an agent might have no preference for a crum of the cake of (in his or her opinion) neglible size above no crum at all. The ad-divity property ensures the valuation of the disjoint intervals by any agent is the sum of the individual valuation of those intervals. The divisibility prop-erty denotes that the value of a subinterval is less than the agent’s valuation of the interval of which the subinterval is a part of. The divisibility property also implies that the valuation function is non-atomic and the Intermediate-Value Theorem applies, which allows us to treat two intervals as disjoint if their inter-section is a singleton. In a more specific model for valuation functions often encountered in literature regarding cake cutting problems, valuation functions for each agent i∈ N are specified by an integrable value density function. In this case, v indicates an n-tuple of value density functions where normaliza-tion is ensured byR01vi(x )d x = 1 and the valuation given by agent i to a piece of
cake X is equal to Vi(X ) = R Xvi(x )d x = P m j=1 R
Ijvi(x )d x . Both additivity and
divisibility are properties that follow immediately from the basic properties of integration.
3
Background Theory
A cake cutting procedure is a method with which to divide a cake amongst a set of agents. Procedures for cake cutting problems may vary in nature signif-icantly. Whereas all procedures describe a method which results in an alloca-tion of cake, some methods may for example be captured within a computer program, while others may not.
The earliest mention of a cake-cutting procedure was discovered by Steven Brams and Alan Taylor to be in Hesoid’s Theogeny, a poem composed approx-imately 700 B.C., which describes the Greek gods Prometheus and Zeus han-dling a division problem regarding a portion of meat.[2, page 11] A perhaps more well-known early example can be found in the Bible (Genesis 13), where Abraham suggests the aforementioned algorithm to divide the land between Lot and himself.[2, page 7] However, despite these early mentions, there was no general method to achieve a fair divison of any heterogeneous divisible good among a set of three or more agents until the 1940s. Then, in a report of the international meeting by the Econometric Society held in Washington in 1947, Polish mathematician Hugo Steinhaus provides the original formula-tion of the cake division problem and noted that the cut and choose algorithm could be extended to an procedure for three agents.[10] In the same report, Steinhaus introduced a procedure devised by fellow Polish mathematicians Stefan Banach and Bronislaw Knaster for any number of agents. This publica-tion by Steinhaus is what instigated the interest in cake cutting from a scientific perspective.
3.1
Types of Procedures
All aforementioned descriptions of methods to fairly allocate cake were infor-mal, rather than mathematical in nature, and as new procedures were intro-duced, their descriptions remained narrative until Even and Paz[5] were the first to describe a protocol; an interactive procedure that could be programmed and executed by a computer as it is simply sufficient to issue instructions and queries to participants. It guides the players through the process of dividing the cake amongst them. A protocol ensures that all participants (given that all agents abide by the instructions) will receive an interval of the cake after a fi-nite number of steps. Similarly, unlike described by Even and Paz, one could create a program that does not issue queries to the agents, but instead takes the agents’ valuation functions or value density function as input and pro-duces and returns an allocation as output. This is commonly referred to as a cake cutting algorithm.[1] An algorithm differs from a protocol as a protocol has and needs no information about the valuations the participating agents assign to the various pieces, as it requires the agents to calculate and provide these themselves. However, as cake cutting procedures have generally been described to be applicable in a real world situation, in which interaction with the participating agents is feasible but the use of a computational centre is not, most informal descriptions can be and have been succesfully formalized to re-semble a protocol as described by Even and Paz rather than to rere-semble an algorithm.
After Even and Paz provided the initial description of what constituted a pro-tocol, an exact specification was given by Robertson and Webb.[8] These ideas were subsequently formalized by Sgall and Woeginger, referred to their
formal-ization of Robertson and Webb’s ideas as the Robertson-Webb model through-out their paper. [9] Within the Robertson-Webb model, the following three types of queries are allowed:
• Cut(i , x , α); returns y : Agent i is asked to either indicate or cut the cake at place y such that the value agent i assigns to interval[x , y ] is equal to
α. In other words: Vi([x , y ]) = α.
• Eval(i , x , y ); returns α: Agent i is asked to evaluate interval [x , y ]. The output of eval(i , x , y ) is therefore identical to Vi([x , y ]).
• Assign(i , x , y ); no return: Agent i is assigned the piece of cake denoted as interval[x , y ], where x < y .
.
Different from programmable protocols and algorithms (of which the former can be captured by the Robertson-Webb model) are moving-knife procedures, of which the first was introduced in 1961.[3] These are procedures in the sense that they provide a method to produce an allocation of cake, but do not qual-ify as algorithms because they are continuous in nature. There are multiple moving-knife procedures, which generally involve one or more knives hov-ering over the cake, most often from left to right. In each of the suggested moving-knife procedures, the agents are required to indicate when the knife or knives hovering over the cake (regardless of whether these knives are held by a referee or fellow players) should cease to move and instead cut the cake at the point above which the knife or knives hover. As the knife or knives move continuously above the cake, the individual agents are required to perform an infinite number of computations. Therefore, while these types of procedures could very well have a real world application, it would be impossible create an executable program which could carry out this procedure and return an al-location. Either an infinite number of queries would have to be issued to the agents or an infinite number of computations would have to be made using the provided valuation functions of the agents. The program would not be able to end and could therefore not return an allocation.
3.2
Classical procedures
This section shall contain a brief elaboration on the workings of several clas-sic cake cutting procedures in chronological order and, if applicable, provide a formalization of the procedure using the Robertson-Webb model. These pro-cedures are considered classic cake cutting propro-cedures as they were revolu-tionary in terms of complexity or fairness for the cases in which they were ap-plicable (n= 2,n = 3 or any n). While it is perfectly possible that an agent or player is not rational or follow a different strategy than described, the descrip-tion of the procedures will assume the agents all act radescrip-tionally, meaning that they are maximum risk averse.
3.2.1
Cut and Choose
The cut and choose procedure knows no real origin, though mention of a so-lution for a division problem resembling the cut and choose method can be traced back in ancient literature to as early as 700 B.C.[2] This procedure is ap-plicable for the division of cake when it concerns two agents (n= 2), and re-quires that one of these agents is designated as cutter and the other as chooser. As the chooser has an advantage over the cutter (see more on this in section 3.3), one could argue this division of roles should be made at random, for ex-ample through a the flip of a coin. Regardless of the outcome of the coin flip,
the procedure remains the same. To divide the cake, the cutter is asked to cut the cake at such a point that he or she values both slices of the cake equally. The chooser is thereupon asked to indicate which of the two sections of the cake she prefers and is assigned that slice. This requires two queries in the Robertson-Webb model (or four, if you are to include the assign query); cut(cutter,
0, 0.5) which returns x , as this would result in two pieces of cake valued 0.5 and
1.0− 0.5 = 0.5 by the cutter, and eval(chooser, 0, x) which returns α. Knowing
α, the value the chooser associates with interval [0, x ] lets us deduce the value
the chooser associates with interval[x ,1], namely 1 − α.
3.2.2
Steinhaus
The Steinhaus procedure was the first cake cutting procedure to be published[10], and is applicable for three players (n= 3). In this case, similar to the cut and choose procedure, an agent should be designated as cutter. The other two agents are not designated a role, although the order in which they act must be decided upon. Again, one could argue the cutter has a slight disadvantage with regards to the other two player, similar to the cutter in the cut and choose procedure.
First, the cutter (player 1) is asked to cut the cake in three pieces which, assum-ing she is a rational agent, she would value equally. One of the two remainassum-ing players (player 2) is then represented with the task to pass if she believes at least two of the pieces to be worth≥13or label two of the pieces as bad if she
believes them to be worth less than that. In the case that player 2 has passed, the second remaining player (player 3) is allowed to choose one of the slices created by player 1, followed by player 2 who is allowed to do the same. Lastly, player 1 is assigned the remaining piece.
If, however, player 2 chooses to label two pieces as bad rather than pass, player 3 is presented with the same task player 2 previously had. If player 3 passes in this case, player 2, 3 and 1 are to choose a piece created by player 1 in that order. In the case that player 3 chooses to label two pieces rather than pass as well, player 1 is required to choose one of pieces labelled as bad by both agents. If it happens that player 2 and player 3 did not label identical pieces, player 1 is to required to take the one piece that has been labelled as bad by both agents. To divide the remainder of the cake, the pieces not chosen by or assigned to player one are reassembled and player 2 and player 3 utilize the cut and choose procedure to produce a satisfying allocation.
From the viewpoint of the Robertson-Webb model, the first step can be de-scribed by cut(1, 0,13 = x and cut(1, x ,13)= y, dividing the cake in pieces X1=
[0, x ], X2 = [x , y ], X3 = [y,1]. During the second step, player 2 is issues the
queries eval(2, 0, x) and eval(2, x, y) from which we can deduce her valuation of
X3. In the case that player 2 passes, player 3 is presented with similar queries.
In the case that player 3 passes as well, the queries that formalize the cut and choose procedure are presented to these agents.
3.2.3
Banach–Knaster
The Banach–Knaster procedure, also referred to as the last-diminisher proce-dure, works for any number of players. In this proceproce-dure, a player is asked to cut the cake at a point such that she considers the interval[0, x ] to be worth1n of the value of the cake. This piece is then passed around to other players, who determine their own value of this piece. If they evaluate the piece presented to
them as being worth equal to or less then1
n, they pass it on to another player. If
they believe the piece to be bigger than that, they trim it down to a piece he or she considers to be worth1
n. When all players have cut, passed or trimmed, the
slice is assigned to the player who made the last cut. In the case that nobody trimmed, this is the original cutter. In any other case, it is the last player who trimmed the slice down to a smaller slice. As a contiguous division is generally preferred, one could add the restriction that players are only allowed to trim from the right side of the cake. This procedure is repeated from the point of the last trim, until all but two players have been assigned a slice. The remain-ing two players perform cut and choose to divide the remainder of the cake.[10] From a Robertson-Webb model perspective, the first round in this procedure requires a cut(1, 0,1n) query, and a succession of n− 1 evaluation queries, with somewhere between 0 and n−1 cut queries. The next round will require a sim-ilar cut query, with n− 2 evaluation queries and at most as many cut queries. This continues for n− 2 rounds, after which cut and choose will be played.
3.2.4
Dubins-Spanier
Dubins and Spanier were the first to suggest that a moving knife could be used to cut a cake, thereby introducing type of cake cutting procedures earlier re-ferred to as moving knife procedures. The procedure was proposed by Dubins and Spanier in 1961 and is very similar to that the procedure initially thought of by Banach and Knaster.[3] However, the difference between these two proce-dures is that whereas the latter issues queries to the participating players and can be described by the Robertson-Webb model, the Dubins-Spanier does not. Instead, it requires a referee to hold a knife above the cake and slowly move this knife from one edge of the cake (point 0.0) to the opposite edge. When an agent calls cut, the cake it cut at the exact location above which the knife hovers and the agent who called cut receives the piece to either the left or right of the cut, depending on the starting point of the knife. When only two agents have not been allocated a piece of cake, the remainder of the cake is divide between these agents with the cut and choose method.
While the Dubins-Spanier procedure is not a protocol or algorithm, it can dis-cretised by repeatedly asking the agents to indicate where they would, hypo-thetically, shout cut if the knife were to make it to that point. Assumed is that an agent will call cut at his or her perceived1npoint.
3.2.5
Even-Paz
In addition to providing an insight in what would constitute a protocol, Even and Paz have proposed a procedure, now known as the Even-Paz procedure or the Divide-and-Conquer procedure, specifically to present a more efficient al-ternative to previously proposed procedures. This procedure is applicable for any n .[5]
In the event that n is even, ask each player to mark a point at the cake such that if it were to be cut at that specific point, that player would value both slices equally. To not be confused with actual cuts, these points will from now on be referred to as marks. The cake is cut halfway between the n
2 th
mark and the(n2+ 1)thmark. If n= 2, the procedure would stop here and assign the two
pieces: the piece left of the cut to the player who made the leftmost cut and the piece right of the cut to the player who made the rightmost cut . However, if n
is equal to or bigger than 4, sort the players into two groups: those who made a mark left of the actual cut and those who made a mark right of the actual cut. Repeatedly ask the players within their groups to mark the cake and sort them into groups until each of the groups only contains two players. Then assign the pieces of cake as described previously.
If the amount of players amongst which the cake should be divided were to be odd, one would follow a similar procedure. However, instead of then2thand (n
2+1)thmark, the cake would be cut between theb(
n
2−1)cthandd(
n
2+1)ethmark.
If the number of agents in a group is three, cut the subpiece containing to the first case and then stop.
In this recursive procedure, all agents are repeatedly issued a cut query to mark the point where they would cut and no evaluation queries. For an even num-ber of agents, one can already see that the amount of cut queries issued during this procedure will always be equal to n log n .
3.2.6
Selfridge–Conway
Another algorithms for the three player case was first proposed by John Self-ridge of Northern Illinois University in 1960 and later by John Horton Conway of Cambridge University in 1993. Although neither Selfridge nor Conway pub-lished the result, the procedure was named after both of them.[2] [8] In this procedure, player 1 is once again the cutter who divides the cake into three pieces which she all considers equal. Player 2 now has the opportunity to pass, if she believes at least two pieces are tied for largest, in which case players 3, 2 and 1 choose one of the pieces in that order. If player 2 decides not to pass, she trims the largest slice down in such a way that she assigns the same value to the newly trimmed piece as she did to the (previously) secondmost valued piece, after which players 3, 2, 1 choose a piece in that order. Player 2 will, in this case, choose the trimmed piece if this was not chosen by player 3. Next, the trim-mings are to be divided. Whoever of 2 and 3 received the untrimmed piece is the agent designated to cut the trimming. The players subsequently choose in the following order: non-cutter (player 2 or 3), player 1, cutter (player 2 or 3). If player 2 does not pass, the allocation will not be contiguous.
From the perspective of the Robertson-Webb model, player 1 is once again is-sues two cut queries (cut(1, 0,13= xand cut(1, x, 13)= y), followed by two eval-uation queries issued to player two (eval(2, 0, x) and eval(2, x, y)). Based on the outcome of the evaluation queries, either pieces get assigned to agents or player 2 is issued a cut query and player 3 is to answer evaluation queries. In the last case, another two cut queries are issued, as well as three evaluation queries (two for the non-cutter, one for player 1).
3.3
Fairness
The criteria of fairness upon which the different procedures are traditionally evaluated are proportionality and envy-freeness. Proportionality is the notion that each agent of the set of agents assign a value of at least1
n to the piece or
combination of pieces of cake allocated to that agent Formally, for a procedure to be proportional, all i∈ N , Vi(Ai) ≥1n. A procedure is deemed envy-free if all
agents involved value the piece or the combination of pieces of cake received by that agent higher than or equal to the pieces allocated to the other agents. Therefore, a procedure is envy free if i , j∈ N , Vi(Ai) ≥ Vi(Aj) holds for all i ∈ N .
A procedure that qualifies as envy-free will, per definition also procude a pro-portional allocation. Propro-portionality is implied as the sum of valuations by an agent of all allocated pieces must be equal to one and this cannot be the case if the valuation an agent assigns to their own allocated piece(s) is less thann1. The first protocol to embody both proportionality and envy-freeness was the cut and choose procedure for n= 2. The first proportional protocol for n = 3 was introduced by Steinhaus in 1948, followed by a proportional protocol for arbitrary n by Banach and Knaster. Then, Selfridge and Conway independently discovered an envy-free protocol for n= 3 in 1960 and 1993 respectively, fol-lowed by the envy-free protocol for any arbitrary n introduced by Brams & Tay-lor in 1995.[1]
3.3.1
Envy-free Protocol for n
= 2
Cut and Choose The Cut and Choose procedure produces an envy-free and (therefore) proportional allocation. The agent who cuts the cake will experi-ence no envy, whichever piece the other agent chooses, as they assign the same value to both pieces. The choosing agent will not be envious as they have the ability to choose the preferred piece.
3.3.2
Proportional Protocol for n
= 3
Steinhaus The Steinhaus procedure is proportional, but not envy-free. The cutter will be allocated a cake she values at1
3. In the case that agent 2 passes,
she considers at least two pieces to be≥13. Agent 3 is allowed to choose first
and may choose the piece player 2 considers the best, therefore allowing for the possibility that agent 2 envies agent 3. However, as player 2 has passed, this indicates that she values at least one of the two remaining pieces as≥13,
resulting in a proportional allocation. The same applies when player 2 chooses to label, but player 3 chooses to pass. In case both agents choose to label, the cut and choose procedure on the remainder of the cake will produce an envy-free allocation.
3.3.3
Proportional Procedures for any n
Banach-Knaster The Banach–Knaster procedure is proportional, but not envy-free. Whereas the last diminisher will never envy any of the agents who were allocated a piece in a previous round, they assign a higher value to a piece al-located to an agent in a later round.
Dubins-Spanier Dubins-Spanier moving knife procedure produces a propor-tional allocation, as the first n− 2 agents will receive an interval they believe to be worth exactly1
n of their valuation of the cake in its entirety, and the two
remaining agents will receive a piece they value similarly or higher than that. Even-Paz The Even–Paz procedure produces an allocation that is proportional, but not necessarily envy–free. While an agent will continuously be grouped into a group with the, in their opinion, more valuable slice, that agent might eventually envy an agent who was originally in grouped in a different group. For example: agent i values the left side of the cake as Vi(left) = 0.56 and the
receives she deems worth to be 0.23. However, an agent j , who was originally grouped in the right group, receives a piece from slice of cake to the right of the first cut nears agent i ’s original valuation of that slice, for example 0.39. In that case, Vi(Ai) < Vi(Aj).
3.3.4
Envy-Free Protocol for n
= 3
Selfridge-Conway Assuming that all agents act rationally, the allocation pro-duced by the Selfridge-Conway procedure will always be envy-free. The divi-sion of the cake without the trimming is envy-free as player 3 chooses first, player 2 has no preference between her two highest rated pieces and is there-fore not influenced by what player 3 picks, and as either player 2 or player 3 receive the trimmed down piece, player 1 will be left with a piece that she as-signs a value of13. For the trimming, the player who took the trimmed piece is allowed to choose first and will therefore not be envious towards any of the other agents. Player one is allowed to choose second and will not be envious of the player who took the trimmed piece, because – according to player 1 – the value of the trimmed piece and the entire trimming combined is equal to the piece player 1 has already secured. The player who took the untrimmed piece has no preference for any of the slices of the trimming, as that player was the one to cut the trimming in the first place.
3.3.5
Envy-Free Protocol for Arbitrary n
Brams-Taylor In 1995, Brams & Taylor introduced an envy-free protocol for n agents with as a central feature that agents trim pieces of cake in order to
create pieces between which they are indifferent.[1] In the case that n > 3, the trimming and choosing process involves more pieces than there are players to arrive at partial allocations. An informal illustration with four agents: suppose player one cuts the cake into five equal pieces (one more than there are play-ers), and player two trims the - in her opinion - largest pieces down to create a three-way tie. A third player now trims down one piece, to create a two-way tie. The last remaining player may choose first (ensuring he or she receives she values highest), the third player may choose second (ensuring he or she receives at least one of the pieces tied for largest), followed by agent two (who is left with at least one piece of her three-way tie) and one (for who at least one untrimmed piece is left). The remainder of the cake, a combination of the trim-mings and the unallocated piece, is used continue the procedure. The partial allocation, so far, is envy-free.
3.4
Complexity
The complexity of a cake cutting algorithm is measured either through the amount of cuts required to complete the procedure, or the sum of both the cut and eval queries that have to be issued to the agents. In the aforemen-tioned algorithms (section 3.2), the complexity is dependent on the number of participating agents and the nature of the procedure, with exception of the Brams-Taylor algorithm.
Fixed n The cut and choose method requires one cut and one evaluation query. The Steinhaus procedure requires at best two cut and two evaluation queries, and at worst three cut (two for agent one, one from cut and choose) and five
evaluation queries (two for agent two, two for agent three, and one from cut and choose). The Selfridge-Conway procedure requires at best two cut and two evaluation queries and at most five cuts (two by player one, one trimming by player two, and two by the player who took the untrimmed piece) and four evaluation queries.
Any n In the case that a procedure is applicable for any number of agents, the complexity is dependent on n . In the case of the Banach-Knaster algorithm, one requires n+(n −1)+···+1 =n(n+1)2 (n minus the number of rounds that have been played, plus the evaluation from the cut and choose method) in each case and, in the worst case scenario, as many cuts. In the case that in each round, there is no last diminisher and the slice is assigned to the original cutter, the algorithm requires n cut queries. The Even-Paz algorithm, on the other hand, requires no evaluation queries and in each case exactly n log n cut queries (n queries for each round, for log n rounds).
Brams-Taylor Repeating the steps of the Brams-Taylor protocol results in an envy-free allocation after a finite number of steps. For n= 3, the number at cuts needed is at most 5. For n≥ 4, however, the number of steps necessary (cuts and evaluation queries) can be made arbitrarily large by a suitable choice of the agents’ valuation functions
4
Software tool
4.1
Goal
To recapitulate, the goal was to provide students learning about cake cutting, as well as researchers trying to advance the theory of cake cutting further, with a tool that enables them to explore the field of cake cutting. In order to explore the theory of cake cutting, the tool would need to provide the user with the pos-sibility to investigate the individual procedures in such a way that the user will be able to compare them and determine the advantages and disadvantages of the respective algorithms in comparison with one another. Multiple aspects can be of interest when comparing the various algorithms, such as whether the procedure is guaranteed to produce a contiguous slice rather than a union of subintervals, whether or not the procedure requires an active referee, and whether or not a procedure qualifies as an algorithm.
As a software tool has been chosen as the method with which various proce-dures will be compared, the question whether or not a procedure qualifies as an algorithm is not of interest. That is to say, those procedures that do not qualify as algorithms nor as protocols (such as moving-knife procedures, see section 3.1) will not be among the to be implemented procedures. Addition-ally, while a user using the to be implemented tool will be able to determine whether or not a procedure requires a referee, this is not of special interest. The algorithms will, instead, be compared solely in terms of complexity and fairness.
4.1.1
Complexity
The question of how to measure complexity dates as far back as the start of cake cutting as a field of research, with Banach and Knaster devising a proto-col that usesO (n2) cuts.[2] By reduction from sorting, it was established that
Ω(n logn) is the lower bound for cake cutting protocols that provide a
guar-anteed proportional allocation.[6] This complexity was expressed in terms of number of comparisons needed to administer the cuts. However, another way of expressing complexity is by describing the amount of performed cuts or evaluation queries. The lower bound expressed in terms of necessary queries is alsoΩ(n logn) for a deterministic protocol that guarantees proportionality.[4] [11] essentially rendering the research into complexity proportional cake cut-ting finalized, as the complexity of Even-Paz proportional divide-and-conquer procedure isO (n log n), accodring to Procaccia.[7] However, as well as present-ing the user with the minimum and maximum cut and evaluation queries re-quired, it might be interesting to investigate how different (proportional and envy-free) procedures perform in terms of queries on average.
4.1.2
Additional Measure of Fairness
The performance of the procedures mentioned in section 3.2 is known in terms of guaranteed proportionality and envy-freeness, which will certainly be of in-terest to the user of the software tool. However, additional measures of fairness exist, such as the degree of experienced envy, for the occasions that an allocation is not envy-free. The degree of envy can be measured between a pair of agents, of a single agent and of the set of agents. The user might want to compare the different algorithms on how many agents experience envy (as a procedure in which at most one agent might envy another might preferable over one in
which all agents may end up envying another), or to what degree an individual agent might experience envy on average and as a maximum.
The degree of envy between a pair of agents is the degree to which agent i envies agent j , detemined by comparing Vi(Ai) to Vi(Aj). The degree can be
expressed in a boolean indicating whether or not agent i prefers agent j ’s al-located piece(s), or a value returned by computing Vi(Aj)−Vi(Ai). To compute
the envy of a single agent, one can take the sum of the envies towards all other agents in the set of agents. To determine the envy of society, one can take the sum of the individual envies or take the largest value of the individual envies. Additionally, it might be interesting to investigate which percentage of pro-cedures that do not guarantee envy-freeness do in fact produce an envy-free allocation. Or, alternatively, explore whether specific agents (may it be in des-ignated agent number and therefore role or depending on their participation within the procedure) are more at risk of experiencing envy than others.
4.2
Requirements
The tool needs an implementation of each individual to-be-explored algorithm, as well as a clear, easy-to-use user interface with which the user can easily nav-igate between the verious provided options. Additionally, it should have an im-plementation with which to evaluate the complexity and fairness measures as described in section 4.1.
In summary, the requirements of the tool are:
1. A user interface enabling navigation between the available options. 2. An implementation of the various algorithms.
3. An implementation of a method to evaluate the output of the algorithms in terms of complexity and fairness.
4. An implementation of a method to repeatedly execute algorithms and appropriately handle the resulting data.
5. A graphical representation of various relevant concepts.
The algorithms referred the list of requirements are cut and choose, the
Stein-haus procedure, Banach-Knaster’s last-diminisher procedure, Even-Paz divide-and-conquer procedure and the Selfridge-Conway procedure. The Dubins-Spanier
procedure is excluded because it is a moving knife procedure and its discreti-sation would be too similar to the Banach-Knaster procedure to be interesting. However, the results from the Banach-Knaster procedure might be applicable to the (discretized version) of the Dubins-Spanier procedure. These specific algorithms were chosen as they are classical procedures (that qualify as algo-rithms), that were revolutionary in terms of either fairness or complexity at the time of their introduction and therefore the most interesting or relevant for a user to fully understand.
The implementation of the algorithms will mostly be able to run independently of user intput; the valuation functions of the agents will not be required as in-put, nor will the execution of the algorithm be dependent on user answers to querries issued by the program. A user can be asked to indicate how often a procedure must be executed. The implementations of the different proce-dures are therefore technically not algorithms nor protocols, though by lack of a more accurate term, the procedures (and the implementations thereof ) will be referred to as either algorithm, protocol or procedure interchangeably from
this point onwards. The program runs independently by generating necessary the values, such as cutting points or evaluations, randomly to enable executing the procedure an arbitrary amount of times.
4.3
User
To start, the user is asked to indicate which algorithm he or she wishes to ex-plore (see figure 1), after which the user can select various options depending on his or her preference (see figure 2). To provide the student of cake cutting with some context, the tool will be equiped with the option to educate yourself on the history of the algorithm and how it came to be, as well as with a brief ex-planation on which steps are to be taken by the algorithm when it is executed. Additionally, the user will be able look into an example of an executed proce-dure with randomly generated values step-by-step and will be presented with a graphical representations of the various relevant concepts. Lastly, a user can choose to execute a single procedure multiple times and view how the proce-dure performed in terms of fairness and complexity.
The graphical representations presented to the user include the following: • A two-dimensional, rectangular "cake" on which the cutting point(s) are
indicated (see figure 4). All intervals allocated to a specific agent are of the same colour.
• A horizontal bar chart which represents the valuations each participat-ing agent assigns the respective pieces (see figure 5). All allocations of
A1, . . . , Anare represented by a different colour and all evaluations by an
agent of these allocations are grouped together.
• A bar chart that illustrates which queries have been issued to which agents (see figure 6)
• A bar chart representing the number of allocations that are proportional and envy-free, as a result of executing a procedure an arbitrary number of times (see figure 7)
• A bar chart representing the minimal, maximal and average amount of cut and evaluation queries that are the result of executing the procedure an arbitrary amount of times (see figure 8).
Figure 3: Step-by-step walkthrough of
Selfridge-Conway procedure
Figure 4: Division for Cut and Choose
algorithm with n=2
Figure 5: All evalutations for each
agent of each agent’s allocation after
executing Even-Paz algorithm with
n=6
Figure 6: Total amount of cut and
evaluation queries issued to each
agent 1
− 6 after the execution of the
Banach-Knaster procedure
Figure 7: Number of proportional
and envy-free allocations produced
10.000 iterations of the Even-Paz
al-gorithm with n=7
Figure 8: Minimal, maximal and
av-erage amount of cut and evaluation
queries made for the Steinhaus
proce-dure over 10.000 iterations.
4.4
Implementation
The choice was made to implement software tool in Java. Each algorithm has been implemented in a seperate class that can be called for. One could ar-gue that Python, which also enables the creation of multiple classes, would be equally or perhaps better suited for the implementation of these procedures, as the matrix arithmetics necessary to compute evaluations, determine divisions,
and calculate whether an allocation is proportional and/or envy-free could be easier or more efficient using
NumPy
, an extension package for scientific com-puting with Python. However, as one of the requirements of the tool is that it must be able to present the user with a graphic user interface, and Swing (a standard Java GUI library) is still one of the most powerful cross-compatible GUI toolkits, the choice was made to implement the program in Java in its en-tirety. The program consists of an executable JAR file containing several.java
and.class
files, as well as the.jar
files to support theJFreeChart
library. The JFreeChart library was used to construct the various graphs and bar charts.4.4.1
Data Representation
The implementation of each algorithm is contained in a seperate class. A call to the constructor of the class executes the algorithm and sets the public vari-ables
division
,cuts
andEM
to represent the mapping of the intervals to the agents to which these have been assigned, the points at which the cake has been cut, and the agents’ valuations of all created intervals respectively. The variablecuts
contains (sorted) information on the points at which the cake has been cut, where the first value corresponds with 0.0 and the last with 1.0. The variabledivision
is a list of integers of which the index corresponds with a cake piece (interval[cuts(index), cuts(index+1)]
) and the value with the agent that received that particular piece of cake (see figure 9). The vari-ableEM
is a list that contains a list for each agent. These lists within theEM
list contain the values that an agent assigns to the slices of cake (see figure 11). It should be noted that although Java convention dictates that variable names are not capitalized, EM resembles a matrix, of which the variable name gener-ally is capitalized.The public variables are used to serve as input for the to-be build bar charts. The variables
division
andEM
are also used to construct variables that re-semble the notation of allocationA (see figure 10) and contain the sum of the values of the combination of pieces respectively (see figure 12). These vari-ables can be used to determine whether an allocation is proportional and/or envy-free, and if applicable the degrees of envy.division
=
X
1X
2X
3X
41
2
2
1
Figure 9: Data representation
exam-ple of public variable
division
with
n=2 and cake pieces = 4.
endDiv
=
1
2
[X
1, X
4] [X
2, X
3]
Figure 10: Alternative data
rep-resentation example of the
out-putted allocation with n=2 and
cake pieces
= 4.
EM
=
X
1X
2X
3X
41
[0.1 0.3 0.4 0.2]
2
[0.3 0.5 0.1 0.1]
Figure 11: Data representation
example of public variable
EM
with n=2 and cake pieces = 4.
endEM
=
[X
1, X
4] [X
2, X
3]
1
[0.3
0.7]
2
[0.4
0.6]
Figure 12: Alternative data
rep-resentation of the assigned values
with n=2 and cake pieces = 4..
5
Results
From the use of the software tool, a user can draw the conclusions described below. The observations and conclusions described in this section are based on performing each procedure 10.000 times for every given n .
5.1
Cut and Choose
The cut and choose algorithm produces a contiguous proportional, envy-free allocation for two agents issuing one cut query and one evaluation query in 100% of the cases (based on 100.000 iterations). Additionally, each agent has a 50% chance of being designated either possible position (cutter or chooser). At least one agent is guaranteed to give an equal valuation to both pieces. In nearly all cases, the other agent prefers one piece over another.
The software tool yielded little information about the cut and choose algo-rithm that could not be known from reading section 3. The observation that one agent will assign an equal valuation to both pieces and the other will most likely prefer once piece over another stems from the generation of random val-uations by the program. Whereas one agent is assigned a standard value (0.5), the valuations the other agent assigns to the pieces only have the restriction that the sum of the values must be one, and not that these valuations must be similar to the cutting agent’s valuations. As the generated values have sixteen significant figures, the chance that these values happen to be 0.5 is very slim. Thereforem Vi(Ai) = 0.5 and Vj(Aj ≥ 0.5 for N = {i , j } holds for the cut and
choose algorithm as well as this particular implementation thereof. By cross-referencing the evaluations of the agents with the respective roles these agents were designated, a user is likely to conclude that being designated the role of chooser is preferable over being designated the role of cutter.
5.2
Steinhaus
The Steinhaus procedure produces a proportional allocation for two agents, which is contiguous in approximately 91.67% of the cases. The minimal amount of cuts required is two and the maximum is three, with an average of 2.083. The minimal amount of evaluation queries required is two and the maximum is five, with an average of 3.09. The procedure produces an envy-free allocation in 50% of the cases. In the cases that the allocation is not envy-free, at most one agent experiences envy and the degree of envy is at most2
3 of the cake. Agent
one is most at risk of experiencing envy, experiencing envy in 25% of cases (50% of the cases with envy), agent three the least (8.33% of cases, 16.66% of cases with envy). Agent two experiences envy in approximately 16.66% of cases (13 of the cases with envy). Each agent will envy at most one agent. In 50% of the cases, agent 2 passed and the protocol was{3, 2, 1}. In 25% of the cases agent 3 passed and the protocol was{2, 3, 1}. In 25% of the cases, the cut and choose procedure had to be performed.
That the Steinhaus procedure proved to produce a contiguous allocation in 91.67% of the cases is similar to what one would expect, as allocations that are not contiguous only occur in the case that the cut and choose procedure must be perfomed and agent one happened to receive the middle cake piece. Anal-ysis of the paths taken showed that the cut and choose procedure must be per-formed in 25% of the cases, and the likelihood of agent one receiving the mid-dle piece is13 as both agent two and agent three’s valuations were randomly
generated. This means that the allocation is contiguous in 33.33%∗ 25.0% ≈ 8.3% of the cases. The 50% envy-free rate was also to be expected. Agent one is very probable to be envious of one of the other agents if the cut and choose method is performed. Unless the cutter happens to make the cut in such a way that agent one values both pieces equally, agent one will assign a value higher than13 to one of the pieces (and lower than 13 to the other). As their value they assign to their own allocation is exactly13, this means agent one will be envious of one of the other agents. Additionally, when the protocol is{3, 2, 1} (50% of the cases), there is a13chance that the piece chosen by was also agent 2’s preferred piece. When the protocol is{2, 3, 1} (25% of the cases), there is a
1
3 chance that the piece chosen by was also agent 3’s preferred piece.
There-fore, the probability of an allocation produced using the Steinhaus procedure is(13∗ 50) + (1
3∗ 25) + (1.0 ∗ 25) = 50.0% and agent one, two and three are most at
risk of being envious of another in that order, although at most only one agent will experience envy. As the procedure can produce envy-free allocations, the minimum degree of envy between two agents is zero. As each agent will receive a piece that he or she values to be worth at least1
3, the degree of envy between
two agents is always<23.
5.3
Banach-Knaster
The Banach-Knaster procedure produces a proportional, contiguous alloca-tion for any arbitrary number of agents. For the minimal, maximal and average amount of cut and evaluation queries issued over 10.000 iterations, see table 1 and figure 13. In none of the 10.000 iterations of the procedure where n> 2 did the Banach-Knaster algorithm produce an envy-free allocation. The amount of agents experiencing envy is n− 2 in all cases (see table 2).
5.3.1
Complexity
The number of evaluation queries issued can be captured with the following formula:(n − 1) + ... + (n − (n − 2)) + 1 or 1 +
n−2
P
r=1(n − r ). This corresponds with
the idea that there are n− numer of rounds played-1 evaluation queries issued per round, and an additional query during the cut and choose process. How-ever, the data in table 1 does not support the notion that the minimal amount of cuts required is n−1 (one for each round, plus one for cut and choose). The most probable explanation is that the minimal amount of cuts required for the Banach-Knaster procedure is in fact n− 1, but 10.000 executions of the pro-cedure per n was not enough to encounter an iteration in which the minimal amount of cuts occurred once n> 7. This explanation is supported by the fact that the deviation from the expected minimal amount of cuts is greater with each increase in n . The more participating agents there are, the more rounds are played and the more probable it is that one of these rounds requires more than one cut.
n
= 3 n = 5
n
= 7
n
= 9
n
= 11 n = 13 n = 15 n = 20 n = 30
Min. cuts
2
4
6
9
14
18
23
36
69
Max.cuts
4
13
21
30
36
44
54
78
121
Avg. cuts
2.81
7.18
12.24
17.75
23.7
30.03
36.57
53.94
92.39
Min. eval.
3
10
21
30
66
78
105
190
435
Max. eval.
3
10
21
30
66
78
105
190
435
Avg. eval.
3
10
21
30
66
78
105
190
435
Table 1: Complexity in terms of cut and evaluation queries in 10.000 iterations of
the Banach-Knaster procedure
Figure 13: Minimum, maximum and
average amount of cut queries for n
agents for the Banach-Knaster
proce-dure, based on 10.000 iterations.
Figure 14: Number of required
eval-uation queries for n agents for the
Banach-Knaster procedure, based on
10.000 iterations.
5.3.2
Fairness
The percentage of allocations produced by repeating the Banach-Knaster pro-cedure 10.000 times was 100.0% for n= 2 and 0.0% for n > 2. Additional anal-ysis shows that the agents between that have been allocated a piece of cake through the use of the cut and choose procedure are never at risk of being en-vious. However, practically all agents that received a cake interval by being the last diminisher in a round do experience envy. An agent will only envy agents that receive an interval of the cake that was divided after the agent in question exited the procedure as the last diminisher. The degree of envy for an agent will always be<n - rounds playedn . In the case of the Banach-Knaster algorithm, where the possible degree of envy increases the earlier an agent receives a piece of cake, a participating agent not act risk averse and wait until he or she is one of the remaining two players, in order to secure a piece that he or she desires most.
n
2
3
5
7
9
11
15
20
Percentage envy-free
100.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
Nr. of envious agents
0
1
3
5
7
9
13
18
Maximal envy
0.0
0.62
0.61
0.58
0.60
0.59
0.56
0.57
Avg. envy (positive envy/instances)
0.0
0.13
0.12
0.10
0.08
0.07
0.06
0.4
Table 2: Envy experience in agents for Banach-Knaster procedure (10.000 iterations
n
3
4
5
6
7
8
9
10
11
% envy-free
66.99
82.64
41.12
23.46
31.91
54.81
24.01
11.25
5.28
Maximal envy
0.31
0.17
0.51
0.54
0.58
0.22
0.60
0.57
0.67
Average envy
0.06
0.05
0.07
0.08
0.07
0.04
0.05
0.06
0.06
n
12
13
14
15
16
17
18
19
20
% envy-free
2.97
4.39
7.54
14.65
29.90
12.03
4.57
2.01
0.92
Maximal envy
0.60
0.57
0.59
0.60
0.19
0.51
0.52
0.59
0.59
Average envy
0.06
0.06
0.06
0.05
0.02
0.04
0.05
0.05
0.05
Table 3: Percentage of envy-free allocations for Even-Paz procedure based on 10.000
iterations
5.4
Even-Paz
Using the software tool, a user can come to the conclusion that the Even-Paz procedure produces a proportional, contiguous allocation for an arbitrary num-ber of agents. No evaluation queries are issued and the amount of cut queries issued can be described as a function of the number of participating agents (n log n ). While the algorithm is not guaranteed to produce an envy-free al-location, the percentage of allocations out of 10.000 in which no agent envies another vary based on the number of participating agents (see table3). A plot of the percentages in table 3 reveals that the percentage of produced envy-free procedures is noticably higher when n is a power of 2. The percentage of al-locations that are envy-free mostly seems to depend on the number of partic-ipating agents and the amount of groups of three that are formed. The spikes in figure 15 when n is a power of 2 can be explained by the fact that a situation in which three agents are to divide one piece of cake never arises as after each round, all groups are of equal (even) size.
n
2
4
8
16
32
64
128
256
% envy-free
100.0
82.85
54.6
28.72
9.36
1.18
0.04
0.0
Table 4: Percentage of envy-free allocations for Even-Paz procedure where n is a
power of 2, based on 10.000 iterations
Figure 15: Percentage of envy-free
allocations of 10.000 allocations for
Even-Paz (n
= 3 − 20)
Figure 16: Percentage of envy-free
allocations of 10.000 allocations for
Even-Paz where n is a power of 2
5.5
Selfridge-Conway
The Selfridge-Conway procedure produces a proportional, envy-free alloca-tion, which is never contiguous, as either four, five or six intervals are allo-cated three agents. The procedure issues four cut queries and seven evalua-tion queries in each case. In 2
3 of the cases, agent two is assigned the piece
6
Conclusion
In the case that there are two agents amongst whom a heterogeneous, divis-ible good is to be divided, the classic algorithms that can be used to arrive at an allocation are the Cut and Choose, the Banach-Knaster, and the Even-Paz algorithm. However, as the Banach-Knaster algorithm is identical to the Cut and Choose procedure when n= 2, this option is disregarded. The Cut and Choose algorithm is a suitable choice to allocate a heterogeneous, divisible good amongst two agents, as the allocation is guaranteed to be envy-free, as for the agentsN = {i , j }, Vi(Ai) = 0.5 and Vj(Aj) ≥ 0.5. The Even-Paz algorithm is
also guaranteed to produce an envy-free allocation if n= 2, where Vi(Ai) ≥ 0.5
and Vj(Aj) ≥ 0.5. As the Even-Paz algorithm allows for the possibility that both
agents value their allocation as being worth more than half the value of the good, this algorithm is preferable over the Cut and Choose algorithm in the case that n= 2 in terms of fairness. The complexity of the two algorithms in terms of Robertson-Webb queries is equal, as both procedures each issue one query to each agent.
In the case that a single heterogeneous, divisible good is to be divided among three agents, the classic algorithms that are applicable are the Steinhaus, Banach-Knaster, Even-Paz and Selfridge-Conway procedures. The allocation returned by the Steinhaus algorithm has a 91.67% chance of being contiguous and a 50% chance of being envy-free, where agent one is most at risk of being envious and agent three is the least at risk. The maximum envy an agent can experience is23. This procedure requires between four and eight Robertson-Webb queries. The allocation returned by the Banach-Knaster procedure is contiguous, but is not envy-free unless the point indicated by the cutting agent during the Cut and Choose phase of the procedure happens to coincide exactly with the2
n point
of the agent who received the first interval. In 10.000 iterations of the proce-dure, this never occurred. The envious agent will always be the agent that re-ceived the first interval and the maximum envy that agent can experience is23. This procedure issues between five and seven Robertson-Webb queries to the participating agents. The Even-Paz procedure produces a contiguous alloca-tion that is not necessarily envy-free, though always proporalloca-tional. The algo-rithm requires n log n cut queries and the percentage of envy-free allocations it does produce seems to be dependent on the number of participating agents in combination with the amount of groups of three that are formed during the execution of this procedure. The allocation returned by the Selfridge-Conway will never be contiguous, but always envy-free. If fairness is the most relevant point of consideration, the Selfridge-Conway is preferable over the Steinhaus, Banach-Knaster and Even-Paz procedure. If one wishes to avoid contiguous allocations, the Even-Paz algorithm is preferable over the Banach-Knaster pro-cedure as the Even-Paz propro-cedure outperforms the Banach-Knaster propro-cedure in terms of fairness and complexity. The Even-Paz algorithm is also preferable if one’s main point of consideration is the complexity of the to be used algo-rithm.
In the case that a cake or similar good is to be divided between an arbitrary
n amount of agents, the classical procedures that can be used to arrive at a
division of the cake are the Even-Paz procedure and the Banach-Knaster pro-cedure, either of which will result in a contiguous allocation. Neither of these procedures are guaranteed to produce an envy-free allocation, but the Even-Paz has a higher chance of producing a allocation in such a way that none of the participating n agents are envious of another. In the case that the
Even-Paz procedure does produce an allocation in which one or more agents are envious, the degree of envy is generally lower than the envy experience per (envious) agent as a result of the allocation produced by the Banach-Knaster procedure. Additionally, the nature of the Banach-Knaster procedure is such that it can be beneficial for agents to be dishonest, whereas it is not beneficial for agents when applying the Even-Paz procedure. Furthermore, the amount of queries issued to agents is lower for the Even-Paz procedure than it is for the Banach-Knaster procedure. Overall, the Even-Paz procedure is preferable over the Banach-Knaster procedure both in terms of complexity and fairness.
References
[1] Steven J. Brams and Alan D. Taylor. An envy-free cake division protocol.
American Mathematical Monthly, pages 9–18, 1995.
[2] Steven J. Brams and Alan D. Taylor. Fair Division: From Cake Cutting to
Dispute Resolution. Cambridge University Press, 1996.
[3] Lester E. Dubins and Edwin H. Spanier. How to cut a cake fairly. American
mathematical monthly, pages 1–17, 1961.
[4] Jeff Edmonds and Kirk Pruhs. Cake cutting really is not a piece of cake. In
Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm, pages 271–278. ACM, 2006.
[5] Shimon Even and Azaria Paz. A note on cake cutting. Discrete Applied
Mathematics, 7(3):285–296, 1984.
[6] Malik Magdon-Ismail, Costas Busch, and Mukkai S Krishnamoorthy. Cake-cutting is not a piece of cake. In STACS 2003, pages 596–607. Springer, 2003.
[7] Ariel D. Procaccia. Thou shalt covet thy neighbor’s cake. In IJCAI, pages 239–244, 2009.
[8] Jack Robertson and William Webb. Cake Cutting Algorithms: Be Fair If You
Can. Peters, 1998.
[9] Jiˇrí Sgall and Gerhard J. Woeginger. A lower bound for cake cutting. In
Algorithms-ESA 2003, pages 459–469. Springer, 2003.
[10] Hugo Steinhaus. The problem of fair division. Econometrica, 16(1), 1948. [11] Gerhard J Woeginger and Jiˇrí Sgall. On the complexity of cake cutting.
Discrete Optimization, 4(2):213–220, 2007.
[12] D. R. Woodall. Dividing a cake fairly. Journal of Mathematical Analysis
