Jump to content

Robertson–Webb query model

Add links
From Wikipedia, the free encyclopedia
This is an old revision of this page, as edited by Erel Segal (talk | contribs) at 18:45, 17 February 2021 (→Results). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

In computer science, the Robertson–Webb (RW) query model is a model of computation used by algorithms for the problem of fair cake-cutting. In this problem, there is a resource called a "cake", and several agents with different value measures on the cake. The goal is to divide the cake among the agents such that each agent will consider his/her piece as "fair" by his/her personal value measure. Since the agents' valuations can be very complex, they cannot - in general - be given as inputs to a fair division algorithm. The RW model specifies two kinds of queries that a fair division algorithm may ask the agents: Eval and Cut. Informally, an Eval query asks an agent to specify his/her value to a given piece of the cake, and a Cut query (also called a Mark query) asks an agent to specify a piece of cake with a given value.

Despite the simplicity of the model, many classic cake-cutting algorithms can be described only by these two queries. On the other hand, there are fair cake-cutting problems that provably cannot be solved in the RW model using finitely many queries.

The Eval and Cut queries were first described in the book of Jack M. Robertson and William A. Webb.[1] The name "Robertson–Webb model" was coined and fofmalized by Woeginger and Sgall.[2]

Definitions

The standard RW model assumes that the cake is an interval, usually the interval [0,1]. There are n agents, and each agent i has a value measure vi on the cake. The algorithm does not know vi, but can access it using two kinds of queries:

  • An eval query: given two real numbers x and y, Evali(x,y) asks agent i to report the value of the interval [x,y], i.e., vi ([x,y]).
  • A cut query: given two real numbers x and r, Cuti(x,r) asks agent i to report some value y such that vi ([x,y]) = r.

Example

The classic Divide and choose algorithm, for cutting a cake between two children, can be done using four queries.

  • Ask Alice an Eval(0,1) query; let V1 be the answer (this is Alice's value of the entire cake).
  • Ask Alice a Cut(0, V1 / 2) query; let x1 be the answer (this is Alice's cut which yields to pieces equal in her eyes).
  • Ask George an Eval(0, x1) and an Eval(x1, 1) queries.
  • If the former value is larger, give (0,x1) to George and (x1,1) to Alice; else, give (0,x1) to Alice and (x1,1) to George.

Results

Besides divide-and-choose, many cake-cutting algorithms can be performed using RW queries whose number is polynomial in n (the number of agents). For example: Last diminisher can be done by O(n2) RW queries and Even–Paz protocol can be done by O(n log n) RW queries. In parallel, there are many hardness results, proving that certain fair division problems require many RW queries to complete. Some such hardness results are shown below.

Proportional cake-cutting requires Ω(n log n) RW queries when either

  • the pieces must be connected,[2] or
  • the protocol is deterministic[3], or
  • the precision of cutting the cake is finite.[3]
  • The only protocol which uses O(n) RW queries is a randomized protocol, which can return disconnected pieces, and the allocation might be only fractionally-proportional.

Envy-free cake-cutting requires

  • Ω(n2) RW queries when the pieces may be disconnected,[4]
  • Infintiely many queries when the pieces must be connected and there are at least 3 agents.[5] In other words, there is no algorithm that always finds an envy-free allocation among 3 or more agents using finitely-many RW queries.
  • For any ε > 0, an ε-envy-free connected cake-cutting requires at least Ω(log ε-1) queries. For 3 agents, an O(log ε-1) protocol exists. For 4 or more agents, the best known protocol requires O(n ε-1), which shows an exponential gap in the query complexity.[6]

Equitable cake-cutting cannot be done using finitely-many RW queries even for 2 agents. Moreover, for any ε > 0:

  • A connected ε-equitable cake-cutting requires at least Ω(log ε-1) queries.[6] For 2 agents, an O(log ε-1) protocol exists.[7] For 3 or more agents, the best known protocol requires O(n (log n + log ε-1)) queries.[8]
  • Even without connectivity, ε-equitable cake-cutting requires at least Ω(log ε-1 / log log ε-1 ) queries.[9]

Exact cake-cutting (also known as perfect cake-cutting) cannot be done using finitely-many RW queries even for 2 agents. Moreover, for any ε > 0:

  • An ε-perfect cake-cutting with the minimum possible number of cuts requires at least Ω(log ε-1) queries. For 2 agents, an O(log ε-1) protocol exists.[6] For 3 or more agents, the best known protocol requires O(n3 ε-1) queries.[10]

Maximin share cake-cutting, when the pieces must be separated by a positive distance, cannot be done using finitely-many RW queries. Moreover, even for a single agent, there is no algorithm that computes the agent's maximin-share using finitely-many RW queries. However:[11]

  • For any ε > 0, it is possible to compute a value between the MMS and the MMS-ε using O(n log ε-1) RW queries.
  • When the cake is circular (i.e., in fair pie-cutting), it is possible to compute a value between the MMS and the MMS-ε using O(n ε-1) RW queries. It is open whether O(n log ε-1) RW queries suffice.

Average-proportional cake-cutting (i.e., an allocation between n families, such that for each family, the average value is at least 1/n of the total) cannot be computed using finitely-many RW queries.[12]

Variants

Left-cut and right-cut

When the value measure of an agent is not strictly positive (i.e., there are parts that the agent values at 0), a cut query can, in principle, return infinitely many values. For example, if an agent values [0,0.9] at 1 and [0.9,1] at 0, then the query Cut(0,1) can return any value between 0.9 and 1. Some algorithms require a more specific value:

  • The left-cut query, LeftCut(x,r), returns the leftmost (smallest) y such that vi ([x,y]) = r;
  • The right-cut query, RightCut(x,r), returns the rightmost (largest) y such that vi ([x,y]) = r;

Note that, if only one of these two variants is given (in addition to the Eval query), the other variant cannot be computed in finite time.[8]

Two-dimensional cakes

The RW query model has been generalized to two-dimensional cakes[13] and multi-dimensional cakes.[14]

Alternative models

References

  1. ^ Robertson, Jack; Webb, William (1998). Cake-Cutting Algorithms: Be Fair If You Can. Natick, Massachusetts: A. K. Peters. ISBN 978-1-56881-076-8. LCCN 97041258. OL 2730675W.
  2. ^ a b Gerhard J. Woeginger and Jiri Sgall (2007). "On the complexity of cake cutting". Discrete Optimization. 4 (2): 213–220. doi:10.1016/j.disopt.2006.07.003.
  3. ^ a b Edmonds, Jeff (2006). Cake cutting really is not a piece of cake. pp. 271–278. CiteSeerX 10.1.1.412.7166. doi:10.1145/1109557.1109588. ISBN 978-0898716054. {{cite book}}: |journal= ignored (help), Edmonds, Jeff (2011). "Cake cutting really is not a piece of cake". ACM Transactions on Algorithms. 7 (4): 1–12. CiteSeerX 10.1.1.146.1536. doi:10.1145/2000807.2000819. S2CID 2440968.
  4. ^ Procaccia, Ariel (2009). "Thou Shalt Covet Thy Neighbor's Cake". IJCAI'09 Proceedings of the 21st International Joint Conference on Artificial Intelligence: 239–244.
  5. ^ Stromquist, Walter (2008). "Envy-free cake divisions cannot be found by finite protocols" (PDF). Electronic Journal of Combinatorics.
  6. ^ a b c Brânzei, Simina; Nisan, Noam (2018-07-13). "The Query Complexity of Cake Cutting". arXiv:1705.02946 [cs].
  7. ^ Cechlárová, Katarína; Pillárová, Eva (2012). "A near equitable 2-person cake cutting algorithm". Optimization. 61 (11): 1321. doi:10.1080/02331934.2011.563306.
  8. ^ a b "On the computability of equitable divisions". Discrete Optimization. 9 (4): 249–257. 2012-11-01. doi:10.1016/j.disopt.2012.08.001. ISSN 1572-5286.
  9. ^ Procaccia, Ariel D.; Wang, Junxing (2017-06-20). "A Lower Bound for Equitable Cake Cutting". Proceedings of the 2017 ACM Conference on Economics and Computation. EC '17. Cambridge, Massachusetts, USA: Association for Computing Machinery: 479–495. doi:10.1145/3033274.3085107. ISBN 978-1-4503-4527-9.
  10. ^ Brânzei, Simina; Miltersen, Peter Bro (2015-07-25). "A dictatorship theorem for cake cutting". Proceedings of the 24th International Conference on Artificial Intelligence. IJCAI'15. Buenos Aires, Argentina: AAAI Press: 482–488. ISBN 978-1-57735-738-4.
  11. ^ Elkind, Edith; Segal-Halevi, Erel; Suksompong, Warut (2020-12-11). "Mind the Gap: Cake Cutting With Separation". arXiv:2012.06682 [cs].
  12. ^ Segal-Halevi, Erel; Nitzan, Shmuel (2019-12-01). "Fair cake-cutting among families". Social Choice and Welfare. 53 (4): 709–740. doi:10.1007/s00355-019-01210-9. ISSN 1432-217X.
  13. ^ Segal-Halevi, Erel; Nitzan, Shmuel; Hassidim, Avinatan; Aumann, Yonatan (2017). "Fair and square: Cake-cutting in two dimensions". Journal of Mathematical Economics. 70: 1–28. arXiv:1409.4511. doi:10.1016/j.jmateco.2017.01.007. S2CID 1278209.
  14. ^ Cseh, Ágnes; Fleiner, Tamás (2018), "The Complexity of Cake Cutting with Unequal Shares", Algorithmic Game Theory, Springer International Publishing, pp. 19–30, arXiv:1709.03152, doi:10.1007/978-3-319-99660-8_3, ISBN 9783319996592
Retrieved from "https://en.wikipedia.org/w/index.php?title=Robertson–Webb_query_model&oldid=1007357981"