Fair Multi-Cake Cutting

TL;DR

This paper introduces a polynomial-time algorithm for fair division of multiple disjoint cake intervals among agents, guaranteeing each a fair share and extending to geometric land division problems.

Contribution

It generalizes classic cake-cutting to multiple disjoint intervals and provides an optimal guaranteed value algorithm using envy-free matchings.

Findings

Guarantees each agent at least min(1/n, k/(m+n-1)) of total value.

Algorithm is polynomial-time and optimal in guaranteed value.

Applicable to land division and geometric partitioning problems.

Abstract

In the classic problem of fair cake-cutting, a single interval ("cake") has to be divided among n agents with different value measures, giving each agent a single sub-interval with a value of at least 1/n of the total. This paper studies a generalization in which the cake is made of m disjoint intervals, and each agent should get at most k sub-intervals. The paper presents a polynomial-time algorithm that guarantees to each agent at least min(1/n, k/(m+n-1)) of the total value, and shows that this is the largest fraction that can be guaranteed. The algorithm simultaneously guarantees to each agent at least 1/n of the value that the agent can get without partners to share with. The main technical tool is envy-free matching in a bipartite graph. Some of the results remain valid even with additional fairness constraints such as envy-freeness. Besides the natural application of the algorithm to simultaneous division of multiple land-estates, the paper shows an application to a geometric problem -- fair division of a two-dimensional land estate shaped as a rectilinear polygon, where each agent should receive a rectangular piece.

Equations

$$V_i(Z_i):={\int }_{x\in Z_i}{v}_i(x)dx.$$

$$\min \left(\frac{1}{n},\frac{k}{n+m-1}\right)$$

$$V_i(Z_i)\ge \min \left(\frac{1}{n},\frac{k}{n+m-1}\right)\cdot V_i(C).$$

$$V_i(Z_i)\ge k$$

$$\frac{V_i(Z_i)}{V_i(C)}=\frac{V_i^{\prime }(Z_i)}{n+m^{\prime }-1}=\frac{V_i^{\prime }(Z_i)}{n+m-1}\ge \frac{k}{n+m-1}.$$

$$\frac{V_i(Z_i)}{V_i(C)}=\frac{V_i^{\prime }(Z_i)}{n+m^{\prime }-1}=\frac{V_i^{\prime }(Z_i)}{nk}\ge \frac{k}{nk}\ge \frac{1}{n}.$$

$$V_i(Z_i)\ge k$$

$$(m+n-1)-k\ell =(m-(k-1)\ell )+(n-\ell )-1=m^{\prime }+n^{\prime }-1$$

$$\forall x\in X\setminus X_M:\forall y\in Y_M:(x,y)\notin E.$$

$$k-1$$

$$V_i(Z_i)\ge \frac{1}{n}\cdot V_i\left({\text{Best}}_i^k(C)\right).$$

$$V_i(Z_i)\ge k.$$

$$v_i^{\prime }(x)$$

$$V_i^{\prime }(Z_i)$$

$$U_i^k(Z):=V_i({\text{Best}}_i^k(Z)).$$

$$U_A^k(Z_A)\ge k;$$

$$U_B^k(Z_B)\ge k;$$

$$U_i^k(Z_i)\ge k;$$

$$\sum _{j=1}^d{m}_j\le d+m-1.$$

$$\sum _{j=1}^d{V}_i(Z_j)>(d-1)\cdot k+\max (k,m)\ge (d-1)\cdot 1+m=d+m-1$$

$$V_i(Z_j)\ge m_j.$$

Full text

Besides the natural application of the algorithm to simultaneous division of multiple land-estates, the paper shows an application to a geometric problem — fair division of a two-dimensional land estate shaped as a rectilinear polygon, where each agent should receive a rectangular piece.

Keywords: Fair Division, Cutting, Matching, Rectilinear Polygon.

1 Introduction

Consider $n$ people who inherit $m$ distant land-estates (henceforth “islands”) and want to divide the property fairly among them. Classic algorithms for proportional cake-cutting (Steinhaus, 1948; Even and Paz, 1984) can be used to divide each island into $n$ pieces such that the value of piece $i$, according to the personal value-measure of person $i$, is at least $1/n$ of the total island value. However, this scheme requires each person to manage properties on $m$ distant locations, which may be quite inconvenient. An alternative scheme is to consider the union of all $m$ islands as a single cake (henceforth “multicake”), and partition it into $n$ pieces using the above-mentioned algorithms. However, this too might give some agents a share that overlaps many distinct islands. For example, with $m=5$ islands and $n=3$ agents, a typical partition might look like this:

where Alice’s share contains 4 disconnected pieces and Carl’s share contains 2 disconnected pieces.111 Such a partition may occur if the three leftmost islands have a low value while the fourth island is very valuable.

This may require Alice to waste a lot of time flying between her different estates.

Can we find a more convenient division? For example, can we divide the multicake fairly such that each agent receives at most $3$ disconnected pieces? In general, what is the smallest number $k$ (as a function of $m$ and $n$) such that there always exists a fair division of the multicake in which each agent receives at most $k$ disconnected pieces?

This paper studies the following more general question. We are given an integer parameter $k\geq 1$, and it is required to give each agent a share made of at most $k$ disconnected pieces. What is the largest fraction $r(m,k,n)$ such that there always exists an allocation giving each agent at least a fraction $r(m,k,n)$ of his/her total property value?

An obvious upper bound is $r(m,k,n)\leq 1/n$. It is attainable when $k\geq m$, since then we can just divide each island separately using classic cake-cutting algorithms. The question is more challenging when $k<m$. The main result of this paper is:

Theorem 1**.**

For every $m\geq 1,k\geq 1,n\geq 1$:         $r(m,k,n)=\min\left({1\over n},{k\over m+n-1}\right).$

In words: it is always possible to guarantee to each agent at least a fraction $\min\left({1\over n},{k\over m+n-1}\right)$ of the total multicake value, and in some cases it is impossible to guarantee a higher fraction.

The upper bound $r(m,k,n)\leq\min\left({1\over n},{k\over m+n-1}\right)$ is proved by a simple example (Section 3). The matching lower bound is proved constructively by a polynomial-time algorithm, which is the main technical contribution of the paper (Section 4). The case $k=1$ is simple and can be handled using classic cake-cutting techniques (sub. 4.2). However, for $k\geq 2$ these techniques yield a sub-optimal result, and to match the upper bound we need a new technique using an envy-free matching in a bipartite graph (sub. 4.3).

Whenever $k\geq 1+{m-1\over n}$, Theorem 1 implies that $r(m,k,n)=1/n$. Therefore,

Corollary 1**.**

If $k\geq 1+{m-1\over n}$ (each agent is willing to accept at least $1+{m-1\over n}$ disconnected pieces), then a proportional multicake allocation exists and can be computed efficiently.

In particular, in the opening example, it is indeed possible to find a fair allocation in which each person receives at most $3$ disconnected pieces.

Theorem 1 provides an absolute value guarantee — a fraction of the total multicake value. One may also be interested in a relative value guarantee — a fraction of the value that an agent could attain without partners, which is the value of his/her $k$ most valuable islands. What is the largest fraction $r_{R}(m,k,n)$ such that there always exists an allocation giving each agent at least a fraction $r_{R}(m,k,n)$ of his/her $k$ best islands? The next result shows that this fraction is $1/n$.

Theorem 2**.**

For every $m\geq 1,k\geq 1,n\geq 1$:          $r_{R}(m,k,n)=1/n.$

The upper bound of $1/n$ is obvious.222 For example, consider $n$ agents with the same valuation, all of whom value a single island at $1$ and the other $m-1$ islands at [math].

The lower bound is proved using the same algorithm as Theorem 1. Moreover, the algorithm can even allow each agent to choose between the two guarantees. This may be useful, as for each agent, a different guarantee may be preferred. As an example, suppose there are $n=10$ agents and $m=11$ islands and $k=1$. Theorem 1 guarantees to each agent a fraction $1/20$ of the total value. Suppose Alice values all $11$ islands uniformly at $1/11$ of the total value, while George thinks that all the multicake value is concentrated at a single island. Theorem 2 guarantees Alice $1/110$ and George $1/10$ of the total value. Our algorithm can give the better guarantee to each agent, i.e., at least $1/20$ to Alice and at least $1/10$ to George (Section 5).

Besides proportionality, an additional fairness condition is envy-freeness. It requires that every agent values his/her share at least as much as the share of every other agent. In the classic setting where $m=k=1$, it is known that envy-freeness implies proportionality, and an envy-free (and proportional) allocation always exists (Woodall, 1980; Stromquist, 1980; Su, 1999). When $n=2$, an envy-free allocation can be computed efficiently by the classic cut-and-choose protocol; when $n\geq 3$, an envy-free allocation cannot be computed by a finite protocol (Stromquist, 2008). What is the largest fraction $r_{E}(m,k,n)$ such that there always exists an envy-free allocation giving each agent at least a fraction $r_{E}(m,k,n)$ of his/her total property value?

An obvious upper bound is $r_{E}(m,k,n)\leq r(m,k,n)$: adding a constraint on the allocations cannot help attain a higher value-guarantee. A lower bound is presented below.

Theorem 3**.**

For every $m\geq 1,k\geq 1$:

(a) When $n=2$:          $r_{E}(m,k,n)=\min\left({1\over n},{k\over m+n-1}\right).$

(b) For any $n\geq 3$:          $r_{E}(m,k,n)\geq\min\left({1\over n},{k\over m+nk-k}\right).$

Part (a) is proved constructively by a polynomial-time algorithm. It exactly matches the upper bound of Theorem 1: when there are two agents, adding an envy-freeness constraint does not decrease the value-guarantee.

Part (b) is proved existentially by a reduction to the classic setting (Section 6). The bound is tight for $k=1$ but not for $k\geq 2$. The exact value of $r_{E}(m,k,n)$ for $n\geq 3$ and $k\geq 2$ remains unknown.

Besides the natural application of the multicake division algorithm to simultaneous division of multiple land-estates, it can be applied to the problem of dividing a two-dimensional land estate shaped as a rectilinear polygon, when each agent requires a rectangular land-plot. If the land-estate has $T$ reflex vertices (vertices with internal angle $270^{\circ}$), then each agent can be allocated a rectangle worth at least $1/(n+T)$ of the total polygon value, and this is tight (Section 7).

Various ideas for future work are presented at ending subsections of sections 4, 5, 6, 7.

1.1 Related work

Fair division problems have inspired hundreds of research papers and several books (Brams and Taylor, 1996; Robertson and Webb, 1998; Moulin, 2004; Brams, 2007). See Procaccia (2015); Brânzei (2015); Lindner and Rothe (2016); Brams and Klamler (2017); Segal-Halevi (2017) for recent surveys.333 Some relatively up-to-date surveys can be found in the Wikipedia pages “Fair division”, “Fair cake-cutting”, “Proportional cake-cutting”, “Envy-free cake-cutting” and “Fair item allocation”.  Some works that are more closely related to the present paper are surveyed below.

Most works on cake-cutting either require to give each agent a single connected piece, or ignore connectivity altogether; few works consider the natural intermediate case, in which each agent should receive at most a fixed number $k$ of disconnected pieces. We are aware of two exceptions.

(a) Arunachaleswaran and Gopalakrishnan (2018) consider a connected cake, i.e, a single island. They quantify the gain, as a function of $k$, in the optimal social welfare, defined as the sum of values of all agents or the minimum value per agent. Based on their results, they conjecture that this gain grows linearly with $\min(n,k)$.

(b) Bei and Suksompong (2019) consider a cake modeled as a connected graph, where the agents prefer to receive a connected subset of edges. This is a generalization of the classic model of an interval cake. They prove that, for every connected graph, it is possible to give each agent a connected piece worth at least ${1\over 2n-1}$ of his/her total value. For a star with $m<2n-1$ edges, the fraction improves to $\frac{1}{n+\lceil m/2\rceil-1}$. When there are $n=2$ agents, and the agents may get disconnected pieces whose total count (for both agents together) is at most $k+1$, the fraction improves to ${1\over 2}\cdot(1-{1\over 3^{k}})$.

The present paper is more general in that it considers a cake that may itself be disconnected. It is less general in that each connected component must be an interval (i.e., a single edge). A potential future work avenue is to generalize both papers by letting the cake be an arbitrary (possibly disconnected) graph.

Some works aim to minimize the number of cuts required to attain various fairness and efficiency goals (Webb, 1997; Shishido and Zeng, 1999; Barbanel and Brams, 2004, 2014; Alijani et al., 2017; Seddighin et al., 2019; Segal-Halevi, 2019). These works usually assume that the cake itself is connected. Moreover, their goal is to minimize the global number of cuts, while the goal in the present paper is to ensure that every individual agent is not given too many disconnected crumbs. Nevertheless, our algorithm makes at most $n-1$ cuts, which in some cases is the smallest possible amount (see Remark 4.11).

Some works consider a different multi-cake division problem, in which each agent must get a part of every sub-cake (Cloutier et al., 2010; Lebert et al., 2013; Nyman et al., 2020). This is opposite to the present paper, in which each agent wants to overlap as few cakes (islands) as possible.

Some works consider an endowment made of several discrete objects, and try to minimize the number of items that have to be shared. Brams and Taylor (2000) present the Adjusted Winner procedure, which divides items fairly and efficiently among two agents such that at most one item is shared. Wilson (1998), in an unpublished manuscript, shows that this can be generalized to $n$ agents such that at most $n-1$ items are shared, and this is the smallest number that can be guaranteed. Segal-Halevi (2020) extends these bounded sharing results to other fairness criteria, while Sandomirskiy and Segal-Halevi (2020) present an algorithm for finding a fair and efficient division with minimal sharing. The present paper focuses on the convenience of each individual agent, rather than the global number of items (islands) that are shared.

2 Preliminaries

There is a set $C$ (“the multicake”) that contains $m\geq 1$ disjoint subsets (“the islands”). It is convenient to assume that $C$ is a subset of the real line and the islands are pairwise-disjoint intervals of unit length. Given such an island $B\subseteq C$ and a real number $d\in[0,1]$, we denote by $B[d]$ the sub-interval of length $d$ at the left-hand side of $B$.

There are $n\geq 1$ agents. The preferences of each agent $i$ are represented by a non-negative integrable function $v_{i}:C\to\mathbb{R}_{+}$ called a value-density. The agent’s value of each piece $Z_{i}\subseteq C$ is denoted by $V_{i}(Z_{i})$, which is defined as the integral of the agent’s value-density:

[TABLE]

The definition implies that each $V_{i}$ is a non-negative measure (an additive set function) on $C$, and that it is non-atomic — the value of zero-length subsets is zero.

An allocation $\mathbf{Z}=Z_{1},\ldots,Z_{n}$ is a vector of $n$ pairwise-disjoint subsets of $C$.

There is a fixed integer constant $k\geq 1$, which denotes the maximum number of disconnected pieces that an agent can use. An allocation $\mathbf{Z}$ is called $k$-feasible if for each $i\in[n]$, $Z_{i}$ is the union of at most $k$ intervals. In particular, $Z_{i}$ overlaps at most $k$ different islands.

Free disposal is assumed, i.e., some parts of $C$ may remain unallocated. This assumption is unavoidable even with $n=1$ agent. For example, if there are $m=2$ islands, then an agent who wants $k=1$ interval must leave one island unallocated.

For every subset $Z\subseteq C$, $\textrm{Best}^{k}_{i}(Z)$ denotes the $k$ intervals contained in $Z$ that are most valuable for agent $i$ (breaking ties arbitrarily). In particular, $\textrm{Best}^{k}_{i}(C)$ denotes the $k$ islands most valuable for $i$. If an allocation $\mathbf{Z}$ is $k$-feasible, then every subset $Z_{i}\subseteq C$ is made of at most $k$ intervals, so $\textrm{Best}^{k}_{i}(Z_{i})=Z_{i}$. In general $V_{i}(\textrm{Best}^{k}_{i}(Z_{i}))$ may be smaller than $V_{i}(Z_{i})$.

3 Upper Bound

Before presenting an algorithm for dividing a multicake, it is useful to have an upper bound on what such an algorithm can hope to achieve.

Lemma 3.1**.**

For every $m\geq 1,n\geq 1,k\geq 1$, there is a multicake instance with $m$ islands and $n$ agents in which, in every $k$-feasible allocation, at least one agent receives at most the following fraction of the total multicake value:

[TABLE]

Proof.

Consider a multicake with $m-1$ “small” islands and one “big” island. All $n$ agents have the same value-measure: they value every small island at $1$ and value the big island at $n$. So the total multicake value for every agent $i$ is $V_{i}(C)=n+m-1$.

Since the valuations are identical, it is obviously impossible to give every agent $i$ a value of more than $V_{i}(C)/n$. It remains to show that it is impossible to give every agent a value of more than $k$.    Consider the following two cases:

At least one agent gets all his/her $k$ pieces in some $k$ small islands. Since the value of every small island is 1, this agent receives a value of at most $k$. 2. 2.

All $n$ agents get at least one of their $k$ intervals in the big island. Since the value of the big island is $n$, at least one agent receives a value of at most $1$ from that island. This agent receives a value of at most $k-1$ from his/her other $k-1$ pieces, which are subsets of small islands. Therefore his/her total value is at most $k$.

In both cases, at least one agent receives a value of at most ${k\over n+m-1}V_{i}(C)$. ∎

4 Algorithm

Motivated by the upper bound of Lemma 3.1, this section aims to solve the following problem.

Below, §4.1 presents the main algorithm: it is a recursive algorithm that, in each iteration, finds a partial allocation of a subset of $C$ to a subset of the agents. The main challenge is to find the appropriate partial allocation in each step. As a warm-up, §4.2 and §4.3 show how to find a partial allocation in the cases $k=1$ and $k=2$ respectively. §4.4 presents the algorithm for finding a partial allocation for any $k$, thus completing the description of the multicake division algorithm. §4.5 presents an example, which the reader is invited to follow in parallel to the algorithm. §4.6 presents some open questions.

4.1 Main loop

We first reduce Problem 1 into a more convenient normalized form displayed below as Problem 2.

Lemma 4.1**.**

Any instance of problem 1 can be reduced to an instance of problem 2.

Proof.

Given an instance of problem 1, construct an instance of problem 2 with the same $n,k$ and with $m^{\prime}=\max(m,nk-n+1)$; if $m<nk-n+1$, then add dummy islands whose value for all agents is [math], such that the total number of islands becomes $nk-n+1$.

For each $i\in[n]$, construct a normalized value function $V_{i}^{\prime}(\cdot):=\dfrac{n+m^{\prime}-1}{V_{i}(C)}\cdot V_{i}(\cdot)$, so that $V_{i}^{\prime}(C)=n+m^{\prime}-1$. Solve Problem 2 with integers $m^{\prime},n,k$ and value-measures $V_{1}^{\prime},\ldots,V_{n}^{\prime}$; note that these inputs satisfy the input requirements of problem 2.

The solution is an allocation $\mathbf{Z}$ such that $V_{i}^{\prime}(Z_{i})\geq k$ for all $i\in[n]$. Consider two cases:

In the original instance $m\geq nk-n+1$. Then $m^{\prime}=m$, and for each agent $i\in[n]$ we have

[TABLE] 2. 2.

In the original instance $m<nk-n+1$. Then $m^{\prime}=nk-n+1$, and for each agent $i\in[n]$ we have

[TABLE]

In both cases, $\mathbf{Z}$ is a solution to problem 1. ∎

Thus, to solve problem 1 it is sufficient to solve problem 2. We will solve problem 2 by a recursive algorithm that is presented as Algorithm 1.

At each recursion round, the algorithm allocates some subsets of $C$ to agents in some subset $L$. The agents in $L$ have received their due share and are therefore removed from further consideration. The remaining agents continue to divide the remainder of $C$ among them. In each round, the algorithm has to solve Problem 3 below.

Lemma 4.2**.**

Given a correct algorithm for solving the Partial Allocation problem (3), the Multicake Division problem (2) is correctly solved by Algorithm 1.

Proof.

By induction on $n$. If $n=1$ then the algorithm terminates at step 1. The agent values $C$ at least $m+n-1=m$, so the average value per island is at least $1$. Therefore the $k$ most valuable islands are worth for this agent at least $k$.

Suppose now that $n>1$ and that the claim holds whenever there are less than $n$ agents. At step 2, at least one agent receives a piece. Any allocated piece overlaps at most $k$ islands — $k-1$ whole islands and possibly a piece of a $k$-th island. Hence the partial allocation is $k$-feasible. Each allocated piece is worth at least $k$ to its receiver.

Let $\ell:=|L|$ and $m^{\prime}:=m-\ell\cdot(k-1)$. After $\ell$ agents receive $k-1$ whole islands each, the remaining multicake contains at most $m^{\prime}$ islands. Step 3 guarantees that it contains exactly $m^{\prime}$ islands. The remaining multicake has to be divided among $n^{\prime}=n-\ell$ agents. Since $n^{\prime}\cdot k-n^{\prime}+1=(n-\ell)(k-1)+1=(nk-n+1)-\ell(k-1)\leq m-\ell(k-1)=m^{\prime}$, the integers $m^{\prime},n^{\prime},k$ still satisfy the input requirements of the algorithm.

For each of the remaining $n^{\prime}$ agents, the allocated pieces are worth together at most $k\cdot\ell$, so the remaining multicake is worth for them at least:

[TABLE]

so the input requirements of algorithm 1 are satisfied. Therefore, by the induction assumption, the recursive call solves problem 2 for the remaining agents. ∎

The following sections are devoted to solving the Partial Allocation problem. For presentation purposes, we first solve the problem for $k=1$ and $k=2$ and then present the solution for an arbitrary $k$, since each increase in $k$ requires a new technique.

4.2 One Piece Per Agent

The following algorithm solves the partial allocation problem for $k=1$.

Let $B:=\textrm{Best}^{k}_{1}(C)=$ the island most valuable to agent #1. 2. 2.

Ask each agent $j\in[n]$ to specify a real number $d_{j}\geq 0$ as follows:

• •

If $V_{j}(B)\geq 1$ then $d_{j}$ is a number satisfying $V_{j}(B[d_{j}])=1$;

• •

If $V_{j}(B)<1$ then $d_{j}=\infty$. 3. 3.

Choose an $i\in[n]$ such that $d_{i}$ is minimal (break ties arbitrarily). Return $L:=\{i\}$ and the piece $Z_{i}:=B[d_{i}]$.

Let us show that this algorithm indeed solves problem 3.

The input conditions for that problem imply that the average value per island is at least $(m+n-1)/m\geq 1$. Hence, the island chosen in step 1 satisfies $V_{1}(B)\geq 1$. Hence, in step 2, the first case holds for agent #1, so $d_{1}$ is finite. Hence, in step 3, the minimal $d_{i}$ is finite. The piece $Z_{i}$ contains $0=k-1$ whole islands, plus a leftmost sub-interval of a single island $B$. Its value for agent $i$ is exactly $1=k$. By the minimality of $d_{i}$, its value for the remaining agents is at most $1$ (for agents with $d_{j}=\infty$, its value is strictly less than $1$). Hence, the output conditions for problem 3 are satisfied.

Remark 4.3**.**

In case there is $m=1$ island, the above algorithm reduces to the recursive step in the Last Diminisher algorithm (Steinhaus, 1948).

The case $m\geq 1$ and $k=1$ was solved using a different algorithm at Example 4.2 in Segal-Halevi et al. (2017) and Lemma 11 in Segal-Halevi (2018). A naive way to extend this algorithm to any $k>1$ is to replace each agent with $k$ clones having the same value function, run the algorithm for $k=1$, and then assign to each agent the union of the $k$ intervals allocated to his/her clones. This yields a value-guarantee of $k/(nk+m-1)$, which is much smaller than $k/(n+m-1)$ when $k$ is large. To attain the high bar set by Theorem 1, we will need some new tools.

4.3 Two Pieces Per Agent

As a warm-up for the general case, this section develops a solution to the Partial Allocation Problem when $k=2$. At first glance, it seems that we could proceed as in the algorithm for $k=1$:

Let $B,B^{\prime}:=\textrm{Best}^{k}_{1}(C)=$ the two best islands of agent #1; note that $V_{1}(B\cup B^{\prime})\geq 2$. 2. 2.

Ask each agent $j\in[n]$ to specify a $d_{j}\geq 0$ such that $V_{j}(B\cup B^{\prime}[d_{j}])=2$; 3. 3.

Choose an $i$ such that $d_{i}$ is minimal, return $L=\{i\}$ and $Z_{i}:=B\cup B^{\prime}[d_{i}]$.

But there is a problem: if there is an agent $j$ for whom $V_{j}(B)>2$, then this agent won’t be able to find an appropriate $d_{i}$. Indeed, this agent will not agree that the whole island $B$ be given to any other agent, since its value for him is more than $k$. Therefore, the above scheme can be followed only if there exists some island that all $n$ agents value at less than $2$. We call such an island barren.

Definition 4.4**.**

A subset $A\subseteq C$ is called barren if $V_{j}(A)<k$ for all agents $j\in[n]$.

To handle this case we introduce Algorithm 2. It is termed a Mark Auction:444 A mark auction is essentially a discrete version of the moving-knife procedure (Dubins and Spanier, 1961), or a simultaneous version of the last-diminisher procedure (Steinhaus, 1948). In last-diminisher, agent #1 marks a piece of cake, each consecutive agent is allowed to mark a subset of the currently marked piece, and the last agent who marked a subset (i.e. the agent who marked the smallest piece) wins. In a mark auction all marks are simultaneous, and in addition, the marks are constrained to a pre-specified island. Constrained mark auctions are also useful for dividing a 2-dimensional cake (Segal-Halevi et al., 2017).

Each agent “bids” by marking a piece of the cake, and the agent who has marked the smallest piece wins. The algorithm of subsection 4.2 is a special case of Algorithm 2 with $k=1$ and $A=\emptyset$; the correctness proofs of both algorithms are similar too.

Lemma 4.5**.**

Whenever the input conditions of Algorithm 2 are satisfied, it solves the partial allocation problem 3 for any $k\geq 1$.

Proof.

We first show that $d_{j}$ in step 1(b) is well-defined for all $j\in[n]$. By the condition that $A$ is barren, $V_{j}(A)<k$. In step 1(b), $V_{j}(A)+V_{j}(B)\geq k$. Hence, there is a positive fraction of $B$ that, when it is added to $A$, the total value is exactly $k$.

The input condition on $B$ implies that case 1(b) holds for at least one agent $j$. Hence, for this $j$, the $d_{j}$ is finite. Hence, the minimum $d_{i}$ found in step 2 is finite too.

The piece $Z_{i}$ contains, by construction, $k-1$ whole islands ($A$), plus a leftmost sub-interval of length $d_{i}$ of a single island ($B$). Its value for agent $i$ is exactly $k$. By minimality of $d_{i}$, the value of $Z_{i}$ for the remaining agents is at most $k$ (for agents with $d_{j}=\infty$ its value is strictly less than $k$). Hence, the output conditions for problem 3 are satisfied. ∎

To use the Mark Auction with $k=2$, we need a barren island. What if there is no barren island? To handle this case we need a different tool. We use the concept of envy-free matching (Luria, 2013). Let $G=(X\cup Y,E)$ be a bipartite graph. Recall that a matching in $G$ is a subset $M\subseteq E$ such that each vertex in $X\cup Y$ is adjacent to at most one edge in $M$. We denote by $X_{M}$ ($Y_{M}$) the vertices of $X$ ($Y$) that are adjacent to an edge of $M$.

Definition 4.6**.**

Let $G=(X\cup Y,E)$ be a bipartite graph. A matching $M\subseteq E$ is called an envy-free matching (EFM)555 Envy-free matching is unrelated to envy-freeness for mixed goods, which is also abbreviated as EFM (Bei et al., 2019).

if no unmatched vertex in $X$ is adjacent to a matched vertex in $Y$. Formally:

[TABLE]

In an EFM, an unmatched $x$ does not “envy” any matched $x^{\prime}$, because it does not “like” any matched $y^{\prime}$ anyway.666 The above definition of envy-free matching involves an unweighted graph, where each “agent” (a vertex in $X$) either likes or dislikes each “object” (a vertex in $Y$). Some other papers, such as Gan et al. (2019), study an envy-free assignment in a weighted graph, in which each agent has a ranking on the objects.

Any $X$-perfect matching (i.e., a matching in which every vertex in $X$ is matched) is envy-free, and the empty matching is envy-free too. The following theorem provides a sufficient condition for the existence of a nonempty EFM (here $N_{G}(X)$ is the set of neighbors of $X$ in the graph $G$):

EFM theorem**.**

Let $G=(X\cup Y,E)$ be a bipartite graph. If $|N_{G}(X)|\geq|X|\geq 1$, then $G$ admits a nonempty envy-free matching, and such a matching can be found by a polynomial-time algorithm.

The existential part of the EFM theorem was proved by Luria (2013). Recently, Aigner-Horev and Segal-Halevi (2019) presented a polynomial-time algorithm for finding an EFM of maximum cardinality; in particular, it finds a nonempty EFM whenever it exists. To make this paper self-contained, a short proof of the EFM theorem is presented in Appendix A.777 Amanatidis et al. (2017) also presented a polynomial-time algorithm for finding a nonempty EFM when the conditions of the EFM theorem are satisfied. Their algorithm was stated not for general graphs but for a specific graph constructed in the context of fair allocation of indivisible goods.

We now present an algorithm for Partial Allocation with $k=2$. Consider two main cases.

Case #1: There exists a barren island $A_{0}$.

For each agent $j\in[n]$, let $B_{j}$ be the island most valuable to $j$ (breaking ties arbitrarily). Consider two sub-cases:

Case #1.1: $V_{j}(A_{0}\cup B_{j})\geq 2$ for at least one agent $j$. Then:

Do a Mark Auction with $A=A_{0}$ and $B=B_{j}$.

Case #1.2: For all agents $j$, $V_{j}(A_{0}\cup B_{j})<2$. Then:

Let $B_{1},B_{1}^{\prime}$ be the two islands most valuable for agent #1. 2. 2.

Do a Mark Auction with $A=B_{1}$ and $B=B_{1}^{\prime}$.

Case #2: There is no barren island.

Construct a bipartite graph $G=(X\cup Y,E)$ where $X$ is the set of agents, $Y$ the set of islands, and there is an edge between agent $i$ and island $B$ whenever $V_{i}(B)\geq 2$. 2. 2.

Find a nonempty envy-free matching in $G$. 3. 3.

Return $L=$ the matched agents and $(Z_{i})_{i\in L}$ = the matched pieces.

Claim 4.7**.**

The algorithm described above solves the partial allocation problem 3 when $k=2$.

Proof.

We consider each case in turn.

Case #1.1: Since $A_{0}$ is barren, and $V_{j}(A_{0}\cup B_{j})\geq k$ for at least one $j\in[n]$, the input requirements of the Mark Auction are satisfied, so by Lemma 4.5 it finds a partial allocation.

Case #1.2: For all agents $j\in[n]$, we have $V_{j}(A_{0}\cup B_{j})<2$, where $B_{j}$ is the most valuable island of $j$. Hence, every agent values every island at less than $2$ — all islands are barren. In particular, $B_{1}$ is barren. On the other hand, $V_{1}(B_{1}\cup B_{1}^{\prime})\geq 2$, since the average value per island is at least $1$. Again the input requirements of the Mark Auction are satisfied, so by Lemma 4.5 it finds a partial allocation.

Case #2: Every island is valued at least $2$ by at least one agent. Hence, in the bipartite graph $G$ constructed in step 1, each island in $Y$ has at least one neighbor in $X$. Therefore, $|N_{G}(X)|=m\geq n+1\geq|X|$. The EFM theorem implies that $G$ admits a nonempty envy-free matching. Each matched piece contains $1=k-1$ whole island, and its value for its matched agent is at least $2=k$. Because the matching is envy-free, each matched piece is not adjacent to each unmatched agent, so the value of each matched piece to an unmatched agent is less than $2$. Hence the output requirements of problem 3 are satisfied and a partial allocation is found. ∎

4.4 Many Pieces per Agent

This section presents a partial-allocation algorithm for any $k\geq 1$. The general scheme is similar to the case $k=2$: we find either an appropriate input to a mark auction, or an appropriate input to an envy-free matching. We call a pair satisfying the requirements of a mark auction, a threshold pair.

Definition 4.8**.**

A threshold pair is a pair $(A,B)$ such that:

• •

$A\subseteq C$ is a barren subset of $k-1$ islands;

• •

$B\subseteq C$ is a single island such that, for some agent $j\in[n]$, $V_{j}(A\cup B)\geq k$.

Given a threshold pair, the Mark Auction (algorithm 2) can be used to find a partial allocation. Below it is shown that, given a single barren subset of $k-1$ islands, a threshold pair can be found.

Lemma 4.9**.**

Given any barren subset of $k-1$ islands, Algorithm 3 finds a threshold pair.

Before proving Lemma 4.9 formally, let us describe informally how Algorithm 3 works.

We are given $A_{0}$ — a barren subset of $k-1$ islands. We first look for an island $B_{j}\subseteq C\setminus A_{0}$ such that $V_{j}(B_{j})\geq k-V_{j}(A_{0})$ for some agent $j\in[n]$. If such a $B_{j}$ exists, then $(A_{0},B_{j})$ is a threshold pair, since $V_{j}(A_{0}\cup B_{j})\geq k$, so we are done.

If such a $B_{j}$ does not exist, we know that every subset of $k$ islands that contains the $k-1$ islands of $A_{0}$ is barren. Every barren subset obviously remains barren when any island is removed from it. Specifically, if we remove an arbitrary island $A^{\prime}$ from $A_{0}$, then every subset of $k-1$ islands that contains the $k-2$ islands remaining in $A_{0}$ is barren: it is barren even with $A^{\prime}$, so it is certainly barren without $A^{\prime}$. Now, we look for a pair of islands $B_{j},B_{j}^{\prime}$ such that $V_{j}(B_{j}^{\prime}\cup B_{j})\geq k-V_{j}(A_{0})$ for some agent $j\in[n]$. If such a pair exists, then $(A_{0}\cup B_{j}^{\prime},~{}B_{j})$ is a threshold pair, since, by the previous paragraph, $A_{0}\cup B_{j}^{\prime}$ is a barren set of $k-1$ islands, and $V_{j}(A_{0}\cup B_{j}^{\prime}\cup B_{j})\geq k$.

If such a pair $B_{j},B_{j}^{\prime}$ does not exist, then we know that every subset of $k$ islands that contains the $k-2$ islands of $A_{0}$ is barren. We remove another island from $A_{0}$; now every subset of $k-1$ islands that contains the $k-3$ islands remaining in $A_{0}$ is barren. We look for a triplet $B_{j},B_{j}^{\prime},B_{j}^{\prime\prime}$ such that $V_{j}(B_{j}^{\prime\prime}\cup B_{j}^{\prime}\cup B_{j})\geq k-V_{j}(A_{0})$ for some agent $j$. If such a triplet exists, then $(A_{0}\cup B_{j}^{\prime\prime}\cup B_{j}^{\prime},~{}B_{j})$ is a threshold pair, since $A_{0}\cup B_{j}^{\prime\prime}\cup B_{j}^{\prime}$ is a barren set of $k-1$ islands.

If such a triplet does not exist, then we keep removing islands from $A_{0}$, one by one, and looking for some $k-|A_{0}|$ islands that, for some agent $j$, are worth at least $k-V_{j}(A_{0})$. This process must end at some point, since the average value per island is at least $1$, so when $A_{0}$ becomes empty, for every agent, the $k$ most valuable islands are worth at least $k$.

We now formally prove the correctness of Algorithm 3.

Proof of Lemma 4.9.

We first show that the algorithm maintains the following invariant:

[TABLE]

This holds at the first time step 1 is reached, since by the input condition, $A_{0}$ contains $k-1$ islands and it is barren. If the algorithm does not terminate at step 2, it means that every set of $k$ islands that contains $A_{0}$ is barren. At step 3, an arbitrary island (say, $A^{\prime}$) is removed from $A_{0}$. Now, every set of $k-1$ islands that contains the islands remaining in $A_{0}$ is barren: it is barren even with $A^{\prime}$, so it is certainly barren without $A^{\prime}$. Hence (@ ‣ 4.4) remains valid.

Next, we show that the algorithm must terminate. Indeed, at each iteration, $A_{0}$ shrinks by one island, so at the $k$-th iteration, $A_{0}$ is empty. Then, for every $j\in[n]$, $B_{j}$ is a set of $k$ islands most valuable to $j$. Since the average value per island is at least $(m+n-1)/m\geq 1$, $V_{j}(B_{j})\geq k$ for every $j\in[n]$, so the algorithm terminates at step 2.

Suppose the algorithm terminates at step 2 of iteration $t$, for some $t\in\{1,\ldots,k\}$. Then, $A_{0}$ contains $k-t$ islands and $B_{j}$ contains $t$ islands. Therefore, $A^{*}$ contains $(k-t)+(t)-1=k-1$ islands. $A^{*}$ contains $A_{0}$, so by the invariant (@ ‣ 4.4), $A^{*}$ is barren. By the termination condition, $V_{j}(A^{*}\cup B^{*})=V_{j}(A_{0}\cup B_{j})\geq k$. Hence, $(A^{*},B^{*})$ is a threshold pair as claimed. ∎

Algorithm 4 uses Algorithm 3 to solve the partial allocation problem for any $k\geq 1$.

Lemma 4.10**.**

Algorithm 4 solves the Partial Allocation problem 3.

Proof.

By the input conditions, the number of islands is $m\geq nk-n+1>n\cdot(k-1)$. Hence there are indeed at least $n$ pairwise-disjoint subsets of $k-1$ islands, as required by the first step.

In Case #1, Lemma 4.9 implies that Algorithm 3 indeed finds a threshold pair, and Lemma 4.5 implies that Algorithm 2 indeed finds a partial allocation.

In Case #2, since each of the $n$ subsets is not barren, each vertex of $Y$ is adjacent to at least one vertex of $X$. Hence $|N_{G}(X)|=|Y|=|X|=n\geq 1$. By the EFM theorem, a nonempty envy-free matching exists. By the envy-freeness of the matching, the resulting $L$ and $(Z_{i})_{i\in L}$ are indeed a partial allocation. ∎

Now we can finally prove the main theorem.

Proof of Theorem 1.

Lemma 3.1 proves the upper bound $r(m,k,n)\leq\min\left({1\over n},{k\over m+n-1}\right)$.

Lemma 4.10 implies that Algorithm 4 solves the Partial Allocation Problem. By plugging this algorithm into Algorithm 1, Lemma 4.2 now implies that Algorithm 1 solves the Normalized Multicake Division Problem. By Lemma 4.1 it solves the Multicake Division Problem. Hence $r(m,k,n)\geq\min\left({1\over n},{k\over m+n-1}\right)$. ∎

Remark 4.11**.**

Algorithm 4 makes at most one cut on a single island: in case #1 it makes one cut during the mark auction, and in case #2 it makes no cuts at all. Therefore, Algorithm 1 makes at most $n-1$ cuts on the multicake. In some cases $n-1$ cuts may be necessary, e.g. when $m=1$.

4.5 Example

The operation of the multicake division algorithm is illustrated below.

In this example, $k=3$ and there are $n=4$ agents. Initially there are $m=7$ islands. Since $m<nk-n+1$, two dummy islands are added as in Lemma 4.1, and the total number of islands becomes $9$. The agents’ valuations are normalized such that the value of the entire multicake is $9+4-1=12$. The normalized values are shown below, where $C_{j}$ denotes the $j$-th island (in an arbitrary order).

\csvreader

[tabular=——c——c—c—c—c—c—c—c—c—c——c——, table head=Agent $C_{1}$ $C_{2}$ $C_{3}$ $C_{4}$ $C_{5}$ $C_{6}$ $C_{7}$ $C_{8}$ $C_{9}$ Sum

, late after line=

, late after last line=

, /csv/separator=semicolon, head to column names]example11.csv \agent \ca \cb \cc \cd \ce \cf \cg \ch \ci \total

Algorithm 4 is used to find a partial allocation. The $n$ subsets of $2$ islands are arbitrarily chosen as: $C_{1}\cup C_{2}$, $C_{3}\cup C_{4}$, $C_{5}\cup C_{6}$, $C_{7}\cup C_{8}$. Each of these is worth at least $3$ to some agent — no pair is barren. Therefore we look for an envy-free matching. The bipartite graph is:

1$$2$$3$$4$$C_{1}\cup C_{2}$$C_{3}\cup C_{4}$$C_{5}\cup C_{6}$$C_{7}\cup C_{8}

It contains a nonempty envy-free matching, for example matching agent $4$ to $C_{7}\cup C_{8}$ and agent $3$ to $C_{5}\cup C_{6}$. Agents $3$ and $4$ now receive two whole islands worth for them at least $3$ and are removed from further consideration. The remaining valuations are:

\csvreader

[tabular=——c——c—c—c—c—c——c——, table head=Agent $C_{1}$ $C_{2}$ $C_{3}$ $C_{4}$ $C_{9}$ Sum

, late after line=

, late after last line=

, /csv/separator=semicolon, head to column names]example12.csv \agent \ca \cb \cc \cd \ci \total

Again Algorithm 4 is used to find a partial allocation. The $n$ subsets of $2$ islands are arbitrarily chosen as: $C_{1}\cup C_{2}$ and $C_{3}\cup C_{4}$. The second pair is barren — it is worth less than $3$ to both agents. Therefore, Algorithm 3 is used to find a threshold pair. Initially $A_{0}=C_{3}\cup C_{4}$. $B_{1}$ is set to $C_{1}$ — the most valuable island for agent 1. Similarly, $B_{2}=C_{2}$. Since $V_{1}(A_{0}\cup B_{1})\geq k$, the algorithm returns $A^{*}:=C_{3}\cup C_{4}$ and $B^{*}:=C_{1}$. Now a Mark Auction (algorithm 2) is used: each agent $j\in\{1,2\}$ is asked to mark some $d_{j}\geq 0$ such that $V_{j}(C_{3}\cup C_{4}\cup C_{1}[d_{j}])=k$. For the sake of example, suppose that agent 1 marks $d_{1}=0.2$ and agent 2 marks $d_{2}=0.5$. Then agent 1 wins and receives two whole islands ($C_{3}$ and $C_{4}$), plus an interval of length $0.2$ at the left of $C_{1}$. The remaining values are (where $C_{1}^{\prime}$ is the remaining part at the right of $C_{1}$):

\csvreader

[tabular=——c——c—c—c——c——, table head=Agent $C_{1}^{\prime}$ $C_{2}$ $C_{9}$ Sum

, late after line=

, late after last line=

, /csv/separator=semicolon, head to column names]example13.csv \agent \ca \cb \ci \total

By the termination condition of Algorithm 1, agent 2 receives the three remaining islands.

4.6 Open questions

For a fixed $k$, our Multicake Division Algorithm attains the highest possible value-guarantee. This raises the question of what happens if different agents have different values of $k$, corresponding to different preferences about the number of pieces. Suppose some agents insist on getting a small number of pieces even if it entails a smaller value-guarantee, while others insist on getting a large value even if it requires many pieces. Is it possible to give a personalized guarantee to each agent?

Open question 1**.**

Given positive integers $k_{i}$ for all $i\in[n]$, is it possible to allocate to each agent $i$ a piece made of at most $k_{i}$ intervals, with a value of at least $\min\left({1\over n},{k_{i}\over m+n-1}\right)\cdot V_{i}(C)$?

Instead of the the hard constraint of having at most $k$ pieces per agent, one can consider a softer model where the number of pieces decreases the value by some known amount. For example, suppose that managing pieces on $k$ different islands incurs an expense of $E(k)$. Then the net utility of agent $i$ from an allotment $Z_{i}$ overlapping $k_{i}$ islands is $V_{i}(Z_{i})-E(k_{i})$.

Open question 2**.**

What value-guarantees are attainable in that model?

5 Relative Value Guarantee

This section aims to prove Theorem 2 by giving each agent at least $1/n$ of the value of his/her best $k$ islands. See Problem 4 below. As in the previous section, it is convenient to work with the normalized format specified by Problem 5 below.

Lemma 5.1**.**

Any instance of problem 4 can be reduced to an instance of problem 5.

Proof.

Given an instance of problem 4, construct an instance of problem 5 with the same $n,k$ and with $m^{\prime}=\max(m,nk-n+1)$; if $m<nk-n+1$, then add dummy islands whose value for all agents is [math], such that the total number of islands becomes $nk-n+1$. Construct value-measures $V_{1}^{\prime},\ldots,V_{n}^{\prime}$ as the integrals of the following value-density functions:

[TABLE]

For all $i\in[n]$, $V_{i}^{\prime}(C)=\dfrac{k\cdot n}{V_{i}\left(\textrm{Best}^{k}_{i}(C)\right)}\cdot V_{i}\left(\textrm{Best}^{k}_{i}(C)\right)=k\cdot n$. Moreover, only the (at most) $k$ best islands have a positive value by $V_{i}^{\prime}$. Hence, these valuations satisfy the input requirements of problem 5.

The solution is a $k$-feasible allocation $\mathbf{Z}$ such that $V_{i}^{\prime}(Z_{i})\geq k$ for all $i\in[n]$. By normalization, ${V_{i}(Z_{i})}\geq k\cdot\dfrac{V_{i}\left(\textrm{Best}^{k}_{i}(C)\right)}{k\cdot n}={1\over n}\cdot V_{i}\left(\textrm{Best}^{k}_{i}(C)\right)$, so the same allocation $\mathbf{Z}$ solves problem 4. ∎

Problem 5 can be solved by the same algorithm used in the previous section (Algorithm 1) — only the normalization should be different. To prove this claim we follow the proof steps of Section 4.

Lemma 5.2**.**

Given a correct algorithm for solving the Partial Allocation problem (3), when Algorithm 1 is executed with valuations satisfying the input conditions of Problem 5, it correctly solves Problem 5.

Proof.

By induction on $n$. If $n=1$ then the algorithm terminates at step 1. The agent values positively at most $k$ islands, and values them at least $k\cdot 1=k$. Therefore the $k$ most valuable islands are worth for this agent at least $k$.

Suppose now that $n>1$ and that the claim holds whenever there are less than $n$ agents. At step 2, at least one agent receives a piece, and the partial allocation is $k$-feasible. Each allocated piece is worth at least $k$ to its receiver.

Let $\ell=|L|$ and $n^{\prime}:=n-\ell$. For the remaining $n^{\prime}$ agents, the allocated pieces are worth together at most $k\cdot\ell$, so the remaining multicake is worth at least $k\cdot n^{\prime}$. Since the partial allocation does not create new islands with a positive value, at most $k$ islands have a positive value for each remaining agent. Hence, the input requirements of problem 5 are satisfied. By the induction assumption, the recursive call solves problem 5 for the remaining agents. ∎

Algorithm 2 — the Mark Auction — does not depend in any way on the normalization, so it still finds a partial allocation whenever its input conditions are satisfied (Lemma 4.5).

Algorithm 3 still finds a threshold pair; the proof is almost identical to Lemma 4.9. The only part of the proof that depends on the normalization is the claim that the algorithm must terminate when $A_{0}$ is empty (the before-last paragraph of the proof). To prove that the algorithm terminates, we have to prove that, for every agent, the value of the $k$ best islands is at least $k$. With the normalization of Problem 2, this follows from the fact that the total multicake value is at least $m$, so the average value per island is at least $1$. With the normalization of Problem 5, the total multicake value is $nk$ which may be smaller than $m$, so the average value per island may be less than $1$. However, the condition that only the $k$ best islands have a positive value guarantees that the value of these islands is at least $nk$, which is at least $k$.

Similarly, Algorithm 4 still finds a partial allocation when the input conditions are replaced with those of Problem 5; the proof is identical to Lemma 4.10.

Combining all the above arguments proves Theorem 2.

Remark 5.3**.**

All the proofs regarding the value guarantees use only the individual value functions. Therefore, when using Algorithm 1, it is possible to let different agents use different normalizations simultaneously and attain their more favorable guarantee. In particular, an agent for whom the absolute guarantee of Theorem 1 is higher may use the normalization of Problem 2, while an agent for whom the absolute guarantee of Theorem 2 is higher may use the normalization of Problem 5. An example is given below.

5.1 Example

In this example, $k=2$ and there are $n=4$ agents and $m=7$ islands. Initially, the agents’ valuations are normalized such that the value of the entire multicake is $7+4-1=10$. The normalized values are shown below.

\csvreader

[tabular=——c——c—c—c—c—c—c—c——c——, table head=Agent $C_{1}$ $C_{2}$ $C_{3}$ $C_{4}$ $C_{5}$ $C_{6}$ $C_{7}$ Sum

, late after line=

, late after last line=

, /csv/separator=semicolon, head to column names]example21.csv \agent \ca \cb \cc \cd \ce \cf \cg \total

Theorem 1 guarantees to each agent a value of at least $2$. However, for agent 1, Theorem 2 guarantees a higher value — at least $9.6/4=2.4$. To implement this higher guarantee, the valuations of agent 1 are re-normalized as in Problem 5 (see Section 5):

\csvreader

[tabular=——c——c—c—c—c—c—c—c——c——, table head=Agent $C_{1}$ $C_{2}$ $C_{3}$ $C_{4}$ $C_{5}$ $C_{6}$ $C_{7}$ Sum

, late after line=

, late after last line=

, /csv/separator=semicolon, head to column names]example22.csv \agent \ca \cb \cc \cd \ce \cf \cg \total

Now, all agents are given a value of at least $2$ as follows.

Algorithm 4 is used to find a partial allocation. The $n$ subsets of $1$ island are arbitrarily chosen as: $C_{1}$, $C_{2}$, $C_{3}$, $C_{4}$. The island $C_{4}$ is barren — it is worth less than $2$ to all agents. Therefore, Algorithm 3 is used to find a threshold pair, starting at $A_{0}:=C_{4}$. $B_{1}$ is set to $C_{1}$ — the most valuable island for agent 1. Since $V_{1}(A_{0}\cup B_{1})\geq k$, the algorithm returns $A^{*}:=C_{4}$ and $B^{*}:=C_{1}$. Now a Mark Auction is used: each agent $j$ is asked to mark some $d_{j}\geq 0$ such that $V_{j}(C_{4}\cup C_{1}[d_{j}])=2$. Since for agents $3$ and $4$ the value of $C_{4}\cup C_{1}$ is less than $2$, they report $d_{3}=d_{4}=\infty$. For the sake of example, suppose that the other marks are $d_{1}=0.4$ and $d_{2}=0.2$. Then agent 2 wins and receives $C_{4}$ plus an interval of length $0.2$ at the left of $C_{1}$. The remaining values are (where $C_{1}^{\prime}$ is the remainder at right of $C_{1}$):

\csvreader

[tabular=——c——c—c—c—c—c—c——c——, table head=Agent $C_{1}^{\prime}$ $C_{2}$ $C_{3}$ $C_{5}$ $C_{6}$ $C_{7}$ Sum

, late after line=

, late after last line=

, /csv/separator=semicolon, head to column names]example23.csv \agent \ca \cb \cc \ce \cf \cg \total

Algorithm 4 is used again, and let’s assume that the $3$ subsets of $1$ island are $C_{1}^{\prime}$ and $C_{2}$ and $C_{3}$. None of these islands is barren, so we find an envy-free matching in the following graph:

1$$3$$4$$C_{1}^{\prime}$$C_{2}$$C_{3}

The graph admits a nonempty envy-free matching, for example, matching agent 1 with $C_{1}^{\prime}$ and agent $3$ with $C_{3}$. Each of these two agents receives one island. The remaining agent $4$ receives his two most valuable remaining islands, namely $C_{6}$ and $C_{7}$.

5.2 Open question

In the study of fair allocation of indivisible items, a prominent fairness criterion is the maximin share (Budish, 2011). Given an arbitrary set $C$ and $n\geq 1$ agents, the maximin share (MMS) of agent $i\in[n]$ is the largest value that $i$ can get by constructing a feasible partition of $C$ into $n$ subsets and getting the least valuable part in that partition. When $C$ is a multicake, “feasible” means that each part contains at most $k$ intervals. So the MMS of agent $i$, denoted $\textrm{MMS}^{k,n}_{i}(C)$, is the largest value that $i$ can get by constructing a partition of (a subset of) $C$ into $n$ parts each of which contains at most $k$ intervals, and getting the least valuable part. An allocation is MMS-fair if the value allocated to each agent $i$ is at least $\textrm{MMS}^{k,n}_{i}(C)$.

In the classing setting, in which $k=m=1$, the MMS of all agents equals $1/n$ of the total cake value, so MMS-fairness is equivalent to proportionality. MMS-fairness becomes interesting when proportionality cannot be guaranteed, such as for a multicake with $m>k$.

Since each agent can “clone” itself $n$ times, Theorem 1 implies that for all $i\in[n]$, $\textrm{MMS}^{k,n}_{i}(C)\geq\min\left({1\over n},{k\over m+n-1}\right)\cdot V_{i}(C)$. Similarly, Theorem 2 implies that $\textrm{MMS}^{k,n}_{i}(C)\geq{1\over n}\cdot V_{i}(\textrm{Best}^{k}_{i}(C))$. But the MMS may be strictly larger than both these expressions. As an example, suppose there are $n=10$ agents and $m=10$ islands and $k=1$. Suppose Alice values all islands uniformly at $1/10$ of the total value. Then her MMS is $1/10$, but Theorem 1 guarantees her only $1/19$ of the total value, while Theorem 2 guarantees her only $1/100$. This raises the question of whether an MMS-fair allocation always exists.

It is easy to show that Algorithm 1 always finds an MMS-fair allocation when $k=1$, but may fail to find an MMS-fair allocation when $k\geq 2$ (see Appendix B).

Open question 3**.**

Does there always exist an MMS-fair allocation of a multicake with $m\geq 2$ islands among $n\geq 2$ agents with $k\geq 2$ intervals per agent?

6 Envy-free Allocation

The goal in this section is to find a $k$-feasible allocation which not only guarantees to each agent a value above some threshold, but is also envy-free: each agent should value his/her piece at least as much as the piece of every other agent. Formally, we want that for every two agents $i,j\in[n]$: $V_{i}(Z_{i})\geq V_{i}(Z_{j})$.

Define the utility that an agent $i\in[n]$ gains from a piece $Z\subseteq C$ as

[TABLE]

Observe that any general allocation can be converted to a $k$-feasible allocation by letting each agent $i$ pick the $k$ most valuable connected pieces contained in $Z_{i}$; in this case, the agent enjoys a utility of $U^{k}_{i}(Z_{i})$. Therefore, to find a $k$-feasible envy-free allocation, it is sufficient to find a general allocation in which for every two agents $i,j\in[n]$: $U^{k}_{i}(Z_{i})\geq U^{k}_{i}(Z_{j})$.

The proofs in this section use the following technical lemma.

Lemma 6.1**.**

Suppose a piece $Z_{i}$ is a union of $m_{i}$ intervals, and $V_{i}(Z_{i})\geq\max(k,m_{i})$. Then $U^{k}_{i}(Z_{i})\geq k$. In words: agent $i$ can take from $Z_{i}$ at most $k$ intervals with a total value of at least $k$.

Proof.

If $m_{i}\leq k$, then $\textrm{Best}^{k}_{i}(Z_{i})=Z_{i}$ and its value is at least $k$ by assumption.

If $m_{i}>k$, then the value of the entire $Z_{i}$ is at least $m_{i}$, so the average value per interval is at least $1$. By the pigeonhole principle, the $k$ most valuable intervals in $Z_{i}$ are worth together at least $k$. ∎

6.1 Two Agents

To prove Theorem 3(a), we present problem 6, which is an envy-free variant of problem 2 for $n=2$ agents. The normalization is justified by arguments similar to Lemma 4.1.

Proof of Theorem 3(a).

An algorithm for solving problem 6 is presented below.

One of the agents, say Alice, evaluates all $m$ islands, orders them in increasing order of their value, and arranges them on the interval $(0,m)$ in the following way. The first (least-valuable) island is mapped to the leftmost sub-interval $(0,1)$. The second island is mapped to the rightmost sub-interval $(m-1,m)$. The third is mapped to $(1,2)$, the fourth is mapped to $(m-2,m-1)$, and so on. So, the less valuable islands are mapped to the left and right ends of $(0,m)$ alternately, while the more valuable islands are mapped to the center of $(0,m)$.

Alice cuts the interval $(0,m)$ into two pieces that are equivalent in her eyes, i.e., the best $k$ intervals in the leftmost half have the same value for her as the best $k$ intervals in the rightmost half. Formally, Alice picks some $x_{A}\in(0,m)$ such that $U^{k}_{A}(0,x_{A})=U^{k}_{A}(x_{A},m)$. There exists such $x_{A}$ by the intermediate value theorem, since $U^{k}_{A}(0,x)$ is a continuous function of $x$ that increases from [math] towards $U^{k}_{A}(C)$, and $U^{k}_{A}(x,m)$ is a continuous function of $x$ that decreases from $U^{k}_{A}(C)$ towards [math]. An illustration is shown below, where $m=7$ and $k=3$:

The number above each island denotes its value for Alice. The dotted line denotes Alice’s cut $x_{A}$. It divides the multicake into two parts with $U^{k}_{A}(0,x_{A})=U^{k}_{A}(x_{A},7)=3.5$.

The other agent, say Ben, chooses the half that he prefers (the half with the larger $U^{k}_{B}(\cdot)$) and takes his best $k$ intervals from it, and Alice takes her best $k$ intervals from the remaining half. This obviously yields an envy-free allocation. It remains to prove the value guarantee.

We first prove an auxiliary claim: we prove that Alice can always make her cut in $[k-1,m-k+1]$, i.e., she never has to cut inside one of the $k-1$ leftmost islands or inside one of the $k-1$ rightmost islands. *Proof of auxiliary claim.*888 Based on ideas in https://math.stackexchange.com/q/3045731/29780 by lulu and Gregory Nisbet.

  Consider first the leftmost islands — those mapped to $(0,k-1)$. For each such island, the next (more valuable) island in Alice’s ordering is mapped to $(m-k+1,m)$. Therefore, $V_{A}(0,k-1)\leq V_{A}(m-k+1,m)$. Since both these intervals overlap less than $k$ islands, $U^{k}_{A}(0,k-1)\leq U^{k}_{A}(m-k+1,m)$ too. The assumption $m\geq 2k-1$ implies $k-1<k\leq m-k+1$, so $U^{k}_{A}(0,k-1)\leq U^{k}_{A}(k-1,m)$. Hence Alice has a halving-point to the right of $k-1$ and can cut at $x_{A}\geq k-1$. A similar consideration applies to the rightmost islands — those mapped to $(m-k+1,m)$. For each such island, the next island in Alice’s ordering is mapped to $(1,k)$. Therefore, $V_{A}(m-k+1,m)\leq V_{A}(1,k)\leq V_{A}(0,k)$. Since both these intervals overlap at most $k$ islands, $U^{k}_{A}(m-k+1,m)\leq U^{k}_{A}(0,k)$ too. The assumption $m\geq 2k-1$ implies that $m-k+1\geq k$, so $U^{k}_{A}(m-k+1,m)\leq U^{k}_{A}(0,m-k+1)$. Hence Alice has a halving-point to the left of $m-k+1$ and can cut at $x_{A}\leq m-k+1$. This completes the proof of the auxiliary claim.

The auxiliary claim implies that we can require Alice to make her cut in $[k-1,m-k+1]$, so that each half contains at least $k-1$ whole islands. Denote the two halves by $Z_{L}:=(0,x_{A})$ and $Z_{R}:=(x_{A},m)$ and their island counts by $m_{L}$ and $m_{R}$ with $m_{L}\geq k-1$ and $m_{R}\geq k-1$. We now prove that, for each agent $i$, there is at least one $j\in\{L,R\}$ for which $U^{k}_{i}(Z_{j})\geq k$. Since the division is envy-free, this will imply that each agent’s final utility is at least $k$.

To prove the last claim we consider two cases.

Case 1: Alice’s cut is in $(k-1,m-k+1)$. Then each half contains at least $k$ sub-intervals, so $k\leq m_{j}$ for all $j\in\{L,R\}$. Since Alice has made a single cut, $m_{L}+m_{R}\leq m+1$. Recall that the valuations are normalized such that the total multicake value for each agent is at least $m+1$, so for each agent $i$, $m_{L}+m_{R}\leq V_{i}(Z_{L})+V_{i}(Z_{R})$. Hence there exists some index $j\in\{L,R\}$ such that $m_{j}\leq V_{i}(Z_{j})$. Now $k\leq m_{j}$ implies $V_{i}(Z_{j})\geq\max(k,m_{j})$, and by Lemma 6.1, $U^{k}_{i}(Z_{j})\geq k$.

Case 2: The edge case in which Alice’s cut is at $x_{A}=k-1$ (the other edge case $x_{A}=m-k+1$ is analogous). Then $m_{L}=k-1$ and $m_{R}=m-k+1\geq k$. Since Alice’s cut is at an integer point, $m_{L}+m_{R}=m$, so $(m_{L}+1)+m_{R}=m+1\leq V_{i}(Z_{L})+V_{i}(Z_{R})$. Now for each agent $i$, either $(m_{L}+1)\leq V_{i}(Z_{L})$, or $m_{R}\leq V_{i}(Z_{R})$. In the former case, since $Z_{L}$ contains less than $k$ islands, $U^{k}_{i}(Z_{L})=V_{i}(Z_{L})\geq m_{L}+1=k$. In the latter case, since $m_{R}\geq k$, $V_{i}(Z_{R})\geq\max(m_{R},k)$, so by Lemma 6.1, $U^{k}_{i}(Z_{R})\geq k$. ∎

6.2 Many agents

To prove Theorem 3(b), we present problem 7, which is an envy-free variant of problem 2 differing only in the normalization. Note that the lower bound of the theorem, namely $\min\left({1\over n},{k\over nk+m-k}\right)$, equals ${k\over nk+\max(k,m)-k}$ by elementary arithmetics.

Proof of Theorem 3(b).

An algorithm for solving problem 7 is presented below.

Arrange the islands in an arbitrary order into the $m$ intervals $(0,1),\ldots,(m-1,m)$.

Consider any partition of the interval $(0,m)$ into $n$ intervals $Z_{1},\ldots,Z_{n}$. In each such partition, if an agent is asked to choose a preferred piece, he selects the piece $Z_{j}$ with the highest utility, i.e., $\arg\max_{j\in[n]}U^{k}_{i}(Z_{j})$. This selection satisfies two properties: (1) An agent always weakly prefers a nonempty piece over an empty piece; (2) The set of partitions in which an agent prefers the piece with index $j$ is a closed subset of the space of all partitions. This is because $U^{k}_{i}([x,y])$ is a continuous function of $x$ and $y$. In their classic papers, Stromquist (1980) and Su (1999) proved that, whenever the preferences of $n$ agents satisfy these two properties, there exists a connected partition of $(0,m)$, in which each agent prefers a different piece, i.e., the partition is envy-free. Let $(Z_{1},\ldots,Z_{n})$ be such a partition.

It remains to prove that, in this envy-free partition, $U^{k}_{i}(Z_{i})\geq k$ for all $i$. In words: each agent $i$ can find in his/her share $Z_{i}$ at most $k$ connected pieces with a total value of at least $k$. Since the allocation is envy-free, it is sufficient to prove that, for all $i\in[n]$, there exists some $j\in[n]$ with $U^{k}_{i}(Z_{j})\geq k$.

The proof focuses on a specific agent $i$. We first discard all the parts $Z_{j}$ for which $V_{i}(Z_{j})<k$. Suppose $n-d$ such parts are discarded (for some $d\in\{0,\dots,n\}$). Recall that the total multicake value is normalized to $nk+\max(k,m)-k$; therefore the total value of the remaining $d$ parts is strictly larger than $(d-1)k+\max(k,m)$. This expression is at least 0, so the remaining value is strictly larger than 0, so at least one part remains, so in fact $d\geq 1$.

Suppose w.l.o.g. that the remaining parts are $Z_{1},\ldots,Z_{d}$, and each part $Z_{j}$ contains $m_{j}$ sub-intervals. The total number of sub-intervals in $Z_{1},\ldots,Z_{n}$ is at most $m+n-1$ (since there were $m$ islands in the input instance, and the algorithm made $n-1$ cuts). After removing $n-d$ parts, each of which contains at least one interval, the total number of sub-intervals is at most $d+m-1$:

[TABLE]

On the other hand, the total value of the remaining parts is:

[TABLE]

Comparing (1) and (2) implies that $\sum_{j=1}^{d}V_{i}(Z_{j})\geq\sum_{j=1}^{d}m_{j}$, so for at least one $j\in\{1,\dots,d\}$:

[TABLE]

Moreover, since we started by discarding the parts whose value is less than $k$, in fact: $V_{i}(Z_{j})\geq\max(k,m_{j})$. Hence, by Lemma 6.1, $U^{k}_{i}(Z_{j})\geq k$. Agent $i$ does not envy agent $j$, so $U^{k}_{i}(Z_{i})\geq k$ too. ∎

6.3 Open questions

When either $n=2$ or $k=1$ (or both), the results presented in this section are tight, and they imply that $r_{E}(m,n,k)=r(m,n,k)$. However, for $n\geq 3$ and $k\geq 2$ the results are not tight. Intuitively, the algorithm of §6.2 does not use all the freedom allowed by the problem: it begins by ordering the islands arbitrarily on a line, and then gives each agent a contiguous subset of that line. The following example shows that this approach cannot guarantee a larger value.

Suppose all agents have the same value-measure: they value the $m-1$ leftmost islands $(0,1),\ldots,(m-2,m-1)$ at $1$, and the rightmost island $(m-1,m)$ at $nk-k+1$, so the total multicake value is $nk+m-k$. Now there are three cases:

At least one agent gets all his/her $k$ pieces in $k$ of the islands $1,\ldots,m-1$. This agent receives a value of at most $k$. 2. 2.

All $n$ agents get a piece of island $m$, and the leftmost agent (who gets the leftmost interval of $(0,m)$) gets a value of at most $1$ from island $m$. This leftmost agent can get at most $k-1$ other islands and remains with a total value of at most $k$. 3. 3.

All $n$ agents get a piece of island $m$, and the leftmost agent gets a value of more than $1$ from island $m$. Then, the remaining value in island $m$ is less than $nk-k=(n-1)k$. Therefore, at least one of the $n-1$ remaining agents gets a value of less than $k$.

To overcome this impossibility, it may be required to re-order the islands based on their value as in §6.1. It is not clear how to do this while keeping the envy-freeness guarantee. In theory, there could be a separation between the attainable value with and without envy.

Open question 4**.**

With $n\geq 3$ agents and $k\geq 2$ pieces per agent, what value can be guaranteed to all agents in an envy-free allocation? Is it smaller than the value-guarantee in an allocation that may have envy?

The proof of Theorem 3(b) is existential — it uses results on the existence of a connected envy-free allocation of an interval. It is known that, even in the classic setting where $m=1$ and $k=1$, such allocations cannot be found by a finite protocol when $n\geq 3$. (Stromquist, 2008). However, approximate envy-free allocations can be computed efficiently. Recently, Arunachaleswaran et al. (2019) presented a multiplicative approximation algorithm and Goldberg et al. (2020) presented some additive approximation algorithms. However, it is not immediately clear that these algorithms can be applied in our setting, since they assume that the agents’ valuations are additive, while the functions $U^{k}_{i}(\cdot)$ are not additive.999 The $U^{k}_{i}(\cdot)$ are not even subadditive. For example, suppose $k=1$ and $Z_{1}=[0,0.1]\cup[0.2,0.3]$ and $Z_{2}=[0.1,0.2]$. Then $U^{k}_{i}(Z_{1}\cup Z_{2})=V_{i}(Z_{1}\cup Z_{2})=V_{i}(Z_{1})+V_{i}(Z_{2})$, which may be larger than $U^{k}_{i}(Z_{1})+U^{k}_{i}(Z_{2})$.

Open question 5**.**

Can approximate envy-free multicake allocations can be found by an efficient algorithm?

Finally, let us mention an open problem that is interesting even in the classic setting of a single interval ($m=1$). The impossibility result of Stromquist (2008) is proved only for $k=1$. Allowing $k=2$ intervals per agent, the famous Selfridge-Conway protocol finds an envy-free cake-allocation in bounded time, but only for $n=3$ agents. In contrast, the recent protocols by Aziz and Mackenzie (2016) and Amanatidis et al. (2018) find an envy-free cake-allocation for $n=4$ agents, but may allocate each agent much more than two pieces.

Open question 6**.**

Does there exist a finite protocol that finds an envy-free allocation of a single interval among $n\geq 4$ agents giving at most $k=2$ intervals to each agent?

7 Dividing a Rectilinear Polygon

This section shows an application of the multicake division algorithm for fairly dividing a two-dimensional land-estate. A natural requirement in land division settings is to give each agent a rectangular piece (Segal-Halevi et al., 2020). We assume that the cake $C$ is a rectilinear polygon — a polygon whose angles are $90^{\circ}$ or $270^{\circ}$. Rectilinearity is a common assumption in practical partition problems (Keil, 2000). The complexity of a rectilinear polygon is characterized by the number of its reflex vertices — vertices with a $270^{\circ}$ angle. We denote this number by $T$. A rectangle — the simplest rectilinear polygon — has $T=0$. The polygon in Figure 1 has $T=4$ reflex vertices.

Theorem 7.1**.**

It is possible to divide a rectilinear polygon with $T$ reflex vertices among $n$ agents giving each agent a rectangle with value at least $1/(n+T)$ of the total polygon value.

Proof.

Keil (2000); Eppstein (2010) present efficient algorithms for partitioning a rectilinear polygon into a minimal number of rectangles. A rectilinear polygon with $T$ reflex vertices can be partitioned in time $O(\text{poly}(T))$ into at most $T+1$ rectangles (this number is tight when the polygon vertices are in general position). Using such algorithms, partition the polygon $C$ into at most $T+1$ rectangular “islands” and then apply the theorems for multicake division with $m=T+1$. By setting $k=1$ in Theorem 1, each agent $i$ gets a single rectangle worth at least $V_{i}(C)/(n+T)$. ∎

If each agent is willing to receive up to $k$ rectangles, then the value-guarantee (as a fraction of the total multicake value) increases accordingly to $\min~{}(1/n,~{}k/(n+T))$.

Theorem 7.1 is tight in the following sense:

Proposition 7.2**.**

for every integer $T\geq 0$, there exists a rectilinear polygon with $T$ reflex vertices, in which it is impossible to guarantee every agent a rectangle with a value of more than $1/(n+T)$ the total polygon value.

Proof.

Consider a staircase-shaped polygon with $T+1$ stairs as in Figure 1/Right. All agents have the same value-measure, which is concentrated in the diamond-shapes: the top diamond is worth $n$ and each of the other diamonds is worth 1. So for all agents, the total polygon value is $n+T$. Any rectangle in $C$ can touch at most a single diamond. There are two cases:

• •

At least one agent touches one of the $T$ bottom diamonds. Then, the value of that agent is at most 1.

• •

All $n$ agents touch the top diamond. Then, their total value is $n$ and at least one of them must receive a value of at most 1.

So, either some or all of the agents receive a value of at most $V_{i}(C)/(n+T)$. ∎

7.1 Open question

While Theorem 7.1 is tight for a worst-case polygon, it is not necessarily tight for specific polygons. For example, consider the following polygon:

It has $T=2$ reflex vertices, can be partitioned into $T+1=3$ disjoint rectangles, and cannot be partitioned into less disjoint rectangles. Hence, for a single agent, Theorem 7.1 guarantees $1/(1+2)=1/3$ of the total value. However, since the polygon can be covered by $2$ overlapping rectangles, at least one of them is worth at least $1/2$ of the total value, so the actual value-guarantee for a single agent is $1/2$. In general, for $n=1$ agent, Theorem 7.1 guarantees $V_{i}(C)$ divided by the partition-number of $C$ (the number of pairwise-disjoint rectangles whose union equals $C$), while it is possible to guarantee $V_{i}(C)$ divided by the cover-number of $C$ (the number of possibly-overlapping rectangles whose union equals $C$).

Open question 7**.**

Is it possible to divide a rectilinear polygon among $n\geq 2$ agents, with a value-guarantee that depends on its rectangle cover number rather than on $T$?

Acknowledgments

I am grateful to Elad Aigner-Horev, Chris Culter101010in http://math.stackexchange.com/q/461675, Zur Luria, Yuval Filmus, Gregory Nisbet and lulu for their helpful ideas, and three anonymous reviewers of Discrete Applied Mathematics for their many constructive comments. The research was partly funded by the Doctoral Fellowships of Excellence Program at Bar-Ilan University, the Mordecai and Monique Katz Graduate Fellowship Program, and the Israel Science Foundation grant 1083/13.

APPENDIX

Appendix A Finding an envy-free matching in a bipartite graph

This appendix presents a simplified proof of a corollary that is proved by Aigner-Horev and Segal-Halevi (2019).

For the algorithm below, recall that, given a matching $M$ in a graph $G$, an $M$-alternating path is a path in $G$ whose first edge is not in $M$, second edge is in $M$, third edge is not in $M$, and so on.

Theorem A.1**.**

Algorithm 5:

(a) Runs in polynomial time;

(b) Returns an envy-free matching;

(c) Returns a nonempty matching whenever its input conditions are satisfied.

Proof.

(a) In step 1, a maximum-cardinality matching can be find in polynomial time, e.g. by the Hopcroft-Karp algorithm. Step 2 is obviously linear. In step 3, the sets of reachable vertices can be found in polynomial time using breadth-first search starting at $X_{0}$.

(b) All vertices of $X_{L}$ are matched by $M$, since by definition the unmatched vertices are in $X_{0}$ which is contained in $X_{S}$. Hence the vertices of $X_{L}$ are not envious. Suppose by contradiction that a vertex $x_{0}\in X_{S}$ is envious. By definition of envy-free matching, this $x_{0}$ is adjacent to some vertex $y\in Y$, which is matched by $M$ to some other vertex $x_{1}\in X_{L}$. But this means that $x_{l}$ is reachable from $X_{0}$ by an $M$-alternating path (through $x_{0}$ and $y$), so $x_{1}\in X_{S}$. This contradicts the definition of $X_{L}$.

(c) If $X_{0}$ is empty, then $X_{S}$ is empty so $X_{L}=X$. By the input assumption, $|X|\geq 1$.

Suppose $X_{0}$ is not empty. By construction of $X_{S}$ and $Y_{S}$, every vertex in $Y_{S}$ is matched by $M$ to some vertex in $X_{S}$ (if a vertex $y\in Y_{S}$ were not matched by $M$, then we could trace an $M$-augmenting path from $y$ to $x_{0}$, contradicting the maximality of $M$). However, the vertices of $X_{0}$ are by definition not matched by $M$. Therefore, $|X_{S}|>|Y_{S}|$. Now, by construction of $X_{S}$ and $Y_{S}$, all neighbors of $X_{S}$ are in $Y_{S}$: $N_{G}(X_{S})\subseteq Y_{S}$. Therefore, $|N_{G}(X_{S})|<|X_{S}|$. By the input conditions, $|N_{G}(X)|\geq|X|$. Therefore $X_{S}\neq X$, so $X_{L}$ is not empty. ∎

Appendix B Maximin-share fairness

Given a multicake $C$ and integers $k\geq 1$ and $n\geq 1$, the maximin share (MMS) of agent $i$, denoted $\textrm{MMS}^{k,n}_{i}(C)$, is the largest value that $i$ can get by constructing a $k$-feasible $n$-partition of (a subset of) $C$, and getting the least valuable part in that partition. An allocation is MMS-fair if the value allocated to each agent $i$ is at least $\textrm{MMS}^{k,n}_{i}(C)$.

As in the previous algorithms, we present a normalized problem.

The normalization implies that, for each agent $i\in[n]$, there exist $n$ pieces $Y_{i,1},\ldots,Y_{i,n}$, each of which contains at most $k$ intervals, such that, for all $j\in[n]$, $V_{i}(Y_{i,j})\geq k$.

Theorem 4**.**

When $k=1$, for any $n\geq 1$ and $m\geq 1$, Algorithm 1 solves Problem 8.

Proof.

By induction on $n$. If $n=1$ then the algorithm terminates at step 1. The MMS allocation of the single remaining agent is made of a single contiguous interval with a value of at least $1$, so the most valuable island is worth for this agent at least $1$.

Suppose now that $n>1$ and that the claim holds whenever there are less than $n$ agents. At step 2 the algorithm finds a partial allocation. When $k=1$, such partial allocation can always be found by a mark auction (Algorithm 2), with $A=\emptyset$ as a barren subset of $k-1$ islands, and $B=\textrm{Best}^{k}_{1}(C)=$ the island most valuable to agent #1. The normalization guarantees that island $B$ is worth at least $1$ for agent #1. The mark auction does not depend in any way on the normalization, so it still (by Lemma 4.5) returns a partial allocation. In this allocation, a single agent, say agent $n$, receives a single interval $Z_{n}$, which is at the leftmost end of the island $B$. This $Z_{n}$ is worth exactly $1$ for agent $n$, so the output condition is satisfied for $n$.

Let $C^{\prime}:=C\setminus Z_{n}$ be the remaining multicake. We have to show that, for the remaining $n-1$ agents, the input requirements of Problem 8 are still satisfied, i.e., for every agent $i\in[n-1]$, $\textrm{MMS}^{k,{n-1}}_{i}(C^{\prime})\geq 1$.

By the input conditions, before the piece $Z_{n}$ was allocated, there existed $n$ intervals $Y_{i,1},\ldots,Y_{i,n}$ in $C$, such that, for all $j\in[n]$, $V_{i}(Y_{i,j})\geq 1$. Now, $Z_{n}$ is the leftmost part of the island $B$, and $V_{i}(Z_{n})\leq 1$, so $Z_{n}$ overlaps at most one of these $n$ intervals, say $Y_{i,n}$. This means that, for all $j\in[n-1]$, the intervals $Y_{i,n-1}$ do not overlap $Z_{n}$, and thus they are all subsets of $C^{\prime}$. Therefore, the $n-1$ intervals $Y_{i,1},\ldots,Y_{i,n-1}$ show that $\textrm{MMS}^{k,{n-1}}_{i}(C^{\prime})\geq 1$. By the induction assumption, the recursive call solves problem 8 for the remaining agents. ∎

Unfortunately, when $k=2$, Algorithm 1 may fail to find an MMS-fair allocation. As an example, consider a multicake with $m=4$ islands, denoted $C_{1},C_{2},C_{3},C_{4}$, and $n=2$ agents who value the islands at $1.5,1.5,0.5,0.5$ respectively. The MMS of both agents is $2$, by the partition $(C_{1}\cup C_{3},C_{2}\cup C_{4})$. All islands are barren, so Algorithm 1 starts by running a mark auction, with e.g. $A=C_{1}$ and $B=C_{2}$. Both agents cut $C_{2}$ at the same point; one of them receives $C_{1}$ and the leftmost part of $C_{2}$, which is worth $0.5$. The remaining cake now contains the remainder of $C_{2}$, which is worth $1$, and two more islands with values $0.5,0.5$. Now the remaining agent cannot get two intervals with a value of $2$.

In this particular case, an MMS allocation obviously exists, but in general, when $n\geq 2$ and $k\geq 2$, the existence of an MMS-fair multicake allocation remains open.