A Comparative Study of Classic Cake-Cutting Algorithms

Transcription

1 A Comparative Study of Classic Cake-Cutting Algorithms Marysia Winkels Bachelor thesis Credits: 18 EC Bachelor Opleiding Kunstmatige Intelligentie University of Amsterdam Faculty of Science Science Park XH Amsterdam Supervisor Ulle Endriss Institute for Language and Logic Faculty of Science University of Amsterdam Science Park XH Amsterdam June 27th,

2 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, Steinhaus, Banach-Knaster, Even-Paz and Selfridge-Conway procedures are compared 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 procedure 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 between any arbitrary number of agents. 2

3 Contents 1 Introduction 4 2 The Model Notation Valuation function Background Theory Types of Procedures Classical procedures Fairness Complexity Software tool Goal Requirements User Implementation Results Cut and Choose Steinhaus Banach-Knaster Even-Paz Selfridge-Conway Conclusion 25 3

4 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 dissimilar 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 household, the division of marital property in divorce settlements, and the distribution 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, divisible 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 participating 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 broadcast 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 referred 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 anecdotal 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 compared to previously suggested procedures, and the aim of this thesis is to provide 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 procedures. 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. 4

5 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 as = {1,...,n}. Furthermore, let division or allocation = (A 1,..., A n ) be the mapping of disjoint intervals to the agent i. The union of the disjoint intervals of represents the entire to be divided cake. Additionally, let subinterval X [0, 1] represent a piece of cake. The intervals X 1,... X m represent the m created pieces of the cake, and one agent may receive multiple slices. In such a case, A i consists of multiple disjoint intervals X. A contiguous allocation is one in which A i is a single interval for all i. A complete allocation is a division where every piece of the cake has been allocated 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. 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 be = ({X 2 },{X 3 },{X 1 }), which denotes that agent 1 has received piece X 2, agent 2 has received piece X 3 and agent 3 has received piece X 1. 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 be = ({X 2, X 4 },{X 3 },{X 1 }), where agent 1 received both piece X 2 and piece X 4 (A 1 = {X 2, X 4 }). 2.2 Valuation function Each agent i has its own valuation or utility function V i (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 is required to satisfy the following properties: Normalisation: V i ([0, 1]) = 1 and V i ( ) = 0. Non-negativity: V i (I ) 0 for all I [0, 1] Additivity: V i (X X ) = V i (X )+V i (X ) for all X, X [0, 1] on the condition that X and X are disjoint intervals. Divisibility: V i (x, z ) = λv i (x, y ) where λ 0 and λ 1 if z [x, y ] 5

6 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 assigns to any piece of the cake is always positive, which confirms that the cake is indeed a desirable good. A stronger assumption would be V i (I ) > 0, implying 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 addivity property ensures the valuation of the disjoint intervals by any agent is the sum of the individual valuation of those intervals. The divisibility property 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 intersection 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 are specified by an integrable value density function. In this case, v indicates an n-tuple of value density functions where normalization is ensured by 1 v 0 i (x )d x = 1 and the valuation given by agent i to a piece of cake X is equal to V i (X ) = v X i (x )d x = m v j =1 I i (x )d x. Both additivity and j divisibility are properties that follow immediately from the basic properties of integration. 6

7 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 significantly. Whereas all procedures describe a method which results in an allocation 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 approximately 700 B.C., which describes the Greek gods Prometheus and Zeus handling 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 formulation 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 publication 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 informal, rather than mathematical in nature, and as new procedures were introduced, 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 finite 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 produces 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 resemble a protocol as described by Even and Paz rather than to resemble an algorithm. After Even and Paz provided the initial description of what constituted a protocol, an exact specification was given by Robertson and Webb. [8] These ideas were subsequently formalized by Sgall and Woeginger, referred to their formal- 7

8 ization of Robertson and Webb s ideas as the Robertson-Webb model throughout 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: V i ([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 V i ([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 qualify as algorithms because they are continuous in nature. There are multiple moving-knife procedures, which generally involve one or more knives hovering 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 allocation. 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 classic cake cutting procedures in chronological order and, if applicable, provide a formalization of the procedure using the Robertson-Webb model. These procedures are considered classic cake cutting procedures as they were revolutionary in terms of complexity or fairness for the cases in which they were applicable (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 description of the procedures will assume the agents all act rationally, meaning that they are maximum risk averse Cut and Choose The cut and choose procedure knows no real origin, though mention of a solution 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 applicable for the division of cake when it concerns two agents (n = 2), and requires 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 example through a the flip of a coin. Regardless of the outcome of the coin flip, 8

9 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 = 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 α 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, assuming she is a rational agent, she would value equally. One of the two remaining players (player 2) is then represented with the task to pass if she believes at least two of the pieces to be worth 1 3 or 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 described by cut(1, 0, 1 3 = x and cut(1, x, 1 3 ) = y, dividing the cake in pieces X 1 = [0, x ], X 2 = [x, y ], X 3 = [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 X 3. 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 Banach Knaster The Banach Knaster procedure, also referred to as the last-diminisher procedure, works for any number of players. In this procedure, a player is asked to cut the cake at a point such that she considers the interval [0, x ] to be worth 1 n 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 9

10 them as being worth equal to or less then 1 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 worth 1 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 remaining 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, 1 n ) query, and a succession of n 1 evaluation queries, with somewhere between 0 and n 1 cut queries. The next round will require a similar 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 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 referred 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 procedures 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 discretised by repeatedly asking the agents to indicate where they would, hypothetically, shout cut if the knife were to make it to that point. Assumed is that an agent will call cut at his or her perceived 1 n point 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 alternative 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 th 2 mark and the ( n 2 + 1)th mark. 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 10

11 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 the n th 2 and ( n 2 +1)th mark, the cake would be cut between the ( n 2 1) th and ( n 2 +1) th mark. 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 number of agents, one can already see that the amount of cut queries issued during this procedure will always be equal to n logn Selfridge Conway Another algorithms for the three player case was first proposed by John Selfridge of Northern Illinois University in 1960 and later by John Horton Conway of Cambridge University in Although neither Selfridge nor Conway published 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 trimmings 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 issues two cut queries (cut(1, 0, 1 3 = xand cut(1, x, 1 3 ) = y), followed by two evaluation 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 least 1 n to the piece or combination of pieces of cake allocated to that agent Formally, for a procedure to be proportional, all i,v i (A i ) 1 n. 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,v i (A i ) V i (A j ) holds for all i. 11

12 A procedure that qualifies as envy-free will, per definition also procude a proportional allocation. Proportionality 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 than 1 n. 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, followed by the envy-free protocol for any arbitrary n introduced by Brams & Taylor in 1995.[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 experience 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 Proportional Protocol for n = 3 Steinhaus The Steinhaus procedure is proportional, but not envy-free. The cutter will be allocated a cake she values at 1 3. In the case that agent 2 passes, she considers at least two pieces to be 1 3. 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 1 3, 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 envyfree allocation Proportional Procedures for any n Banach-Knaster The Banach Knaster procedure is proportional, but not envyfree. 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 allocated to an agent in a later round. Dubins-Spanier Dubins-Spanier moving knife procedure produces a proportional allocation, as the first n 2 agents will receive an interval they believe to be worth exactly 1 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 V i (left) = 0.56 and the right as V i (right) = Agent i is grouped into the left group and eventually 12

13 receives she deems worth to be 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 In that case, V i (A i ) < V i (A j ) Envy-Free Protocol for n = 3 Selfridge-Conway Assuming that all agents act rationally, the allocation produced by the Selfridge-Conway procedure will always be envy-free. The division 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 therefore 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 assigns a value of 1 3. 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 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 players), 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 trimmings 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 aforementioned 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 13

14 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 logn cut queries (n queries for each round, for logn 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 14

15 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 possibility 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 procedures 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. Additionally, 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 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 protocol that uses (n 2 ) cuts.[2] By reduction from sorting, it was established that Ω(n logn) is the lower bound for cake cutting protocols that provide a guaranteed 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 cutting finalized, as the complexity of Even-Paz proportional divide-and-conquer procedure is (n logn), accodring to Procaccia.[7] However, as well as presenting the user with the minimum and maximum cut and evaluation queries required, it might be interesting to investigate how different (proportional and envy-free) procedures perform in terms of queries on average 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 interest 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 15

16 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 V i (A i ) to V i (A j ). The degree can be expressed in a boolean indicating whether or not agent i prefers agent j s allocated piece(s), or a value returned by computing V i (A j ) V i (A i ). 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 procedures that do not guarantee envy-freeness do in fact produce an envy-free allocation. Or, alternatively, explore whether specific agents (may it be in designated 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 navigate between the verious provided options. Additionally, it should have an implementation 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 Steinhaus procedure, Banach-Knaster s last-diminisher procedure, Even-Paz divideand-conquer procedure and the Selfridge-Conway procedure. The Dubins-Spanier procedure is excluded because it is a moving knife procedure and its discretisation 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 algorithms), 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 input, 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 procedures 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 16

17 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 explore (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 explanation 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 procedure 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 procedure 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 participating agent assigns the respective pieces (see figure 5). All allocations of A 1,..., A n are 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 1: Homescreen Figure 2: Procedure 17

18 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 iterations of the Even-Paz algorithm with n=7 Figure 8: Minimal, maximal and average amount of cut and evaluation queries made for the Steinhaus procedure over 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 argue 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, 18

19 and calculate whether an allocation is proportional and/or envy-free could be easier or more efficient using NumPy, an extension package for scientific computing 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 entirety. The program consists of an executable JAR file containing several.java and.class files, as well as the.jar files to support the JFreeChart library. The JFreeChart library was used to construct the various graphs and bar charts 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 variables division, cuts and EM 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 variable cuts 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 variable division 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 variable EM is a list that contains a list for each agent. These lists within the EM 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 generally is capitalized. The public variables are used to serve as input for the to-be build bar charts. The variables division and EM are also used to construct variables that resemble the notation of allocation (see figure 10) and contain the sum of the values of the combination of pieces respectively (see figure 12). These variables can be used to determine whether an allocation is proportional and/or envy-free, and if applicable the degrees of envy. division = X 1 X 2 X 3 X Figure 9: Data representation example 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 representation example of the outputted allocation with n=2 and cake pieces = 4. X 1 X 2 X 3 X 4 1 [ ] EM = 2 [ ] [X 1, X 4 ] [X 2, X 3 ] 1 [ ] endem = 2 [ ] Figure 11: Data representation example of public variable EM with n=2 and cake pieces = 4. Figure 12: Alternative data representation of the assigned values with n=2 and cake pieces =

20 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 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 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 algorithm 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 valuations 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 V i (A i ) = 0.5 and V j (A j 0.5 for = {i, j } holds for the cut and choose algorithm as well as this particular implementation thereof. By crossreferencing 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 The minimal amount of evaluation queries required is two and the maximum is five, with an average of 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 most 2 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 ( 1 3 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. Analysis of the paths taken showed that the cut and choose procedure must be performed in 25% of the cases, and the likelihood of agent one receiving the middle piece is 1 3 as both agent two and agent three s valuations were randomly 20

21 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 than 1 3 to one of the pieces (and lower than 1 3 to the other). As their value they assign to their own allocation is exactly 1 3, 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 a 1 3 chance 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. Therefore, the probability of an allocation produced using the Steinhaus procedure is ( ) + ( ) + (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 least 1 3, the degree of envy between two agents is always < Banach-Knaster The Banach-Knaster procedure produces a proportional, contiguous allocation for any arbitrary number of agents. For the minimal, maximal and average amount of cut and evaluation queries issued over iterations, see table 1 and figure 13. In none of the 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) Complexity The number of evaluation queries issued can be captured with the following n 2 formula: (n 1) (n (n 2)) + 1 or 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. However, 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 executions of the procedure 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. r =1 21

22 n = 3 n = 5 n = 7 n = 9 n = 11 n = 13 n = 15 n = 20 n = 30 Min. cuts Max.cuts Avg. cuts Min. eval Max. eval Avg. eval Table 1: Complexity in terms of cut and evaluation queries in iterations of the Banach-Knaster procedure Figure 13: Minimum, maximum and average amount of cut queries for n agents for the Banach-Knaster procedure, based on iterations. Figure 14: Number of required evaluation queries for n agents for the Banach-Knaster procedure, based on iterations Fairness The percentage of allocations produced by repeating the Banach-Knaster procedure times was 100.0% for n = 2 and 0.0% for n > 2. Additional analysis 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 envious. 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 n - rounds played n always be <. 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 Percentage envy-free Nr. of envious agents Maximal envy Avg. envy (positive envy/instances) Table 2: Envy experience in agents for Banach-Knaster procedure ( iterations per agent) 22

23 n % envy-free Maximal envy Average envy n % envy-free Maximal envy Average envy Table 3: Percentage of envy-free allocations for Even-Paz procedure based on 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 number 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 logn). While the algorithm is not guaranteed to produce an envy-free allocation, the percentage of allocations out of 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 allocations that are envy-free mostly seems to depend on the number of participating 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 % envy-free Table 4: Percentage of envy-free allocations for Even-Paz procedure where n is a power of 2, based on iterations Figure 15: Percentage of envy-free allocations of allocations for Even-Paz (n = 3 20) Figure 16: Percentage of envy-free allocations of allocations for Even-Paz where n is a power of 2 23