Restricted Max-Min Allocation: Approximation and Integrality Gap

TL;DR

This paper advances the approximation algorithms for the restricted max-min allocation problem, reducing the ratio to nearly 4 and tightening the integrality gap bounds, thus bringing us closer to optimal solutions.

Contribution

It introduces a $(4+ ext{delta})$-approximation algorithm and improves the integrality gap upper bound for the configuration LP.

Findings

Approximation ratio improved to $(4+ ext{delta})$

Integrality gap upper bound refined to approximately 3.808

Algorithm runs in polynomial time with respect to input size

Abstract

Asadpour, Feige, and Saberi proved that the integrality gap of the configuration LP for the restricted max-min allocation problem is at most $4$. However, their proof does not give a polynomial-time approximation algorithm. A lot of efforts have been devoted to designing an efficient algorithm whose approximation ratio can match this upper bound for the integrality gap. In ICALP 2018, we present a $(6 + \delta)$-approximation algorithm where $\delta$ can be any positive constant, and there is still a gap of roughly $2$. In this paper, we narrow the gap significantly by proposing a $(4+\delta)$-approximation algorithm where $\delta$ can be any positive constant. The approximation ratio is with respect to the optimal value of the configuration LP, and the running time is $\mathit{poly}(m,n)\cdot n^{\mathit{poly}(\frac{1}{\delta})}$ where $n$ is the number of players and $m$ is the number of resources. We also improve the upper bound for the integrality gap of the configuration LP to $3 + \frac{21}{26} \approx 3.808$.

Tables

Table 1. Table 1 : Some facts about ℐ ℐ \cal I and the layers in the stack.

o X[1cb]X[5lp]   Fact   1		For every $i\in [1,\ell ]$, edges in ${𝒜}_i$ are mutually compatible.
	For every $i,j\in [1,\ell ]$ with $i\ne j$, $R\left({𝒜}_i\right)\cap R\left({𝒜}_j\right)=\varnothing$.
Fact 2	Edges in $ℐ$ are mutually compatible, and they are also compatible with edges in $ℰ$. For every $i\in [1,\ell ]$, $R\left({𝒜}_i\right)\cap R\left(ℐ\right)=\varnothing$
Fact 3	$\{{ℬ}_2,\dots ,{ℬ}_{\ell }\}$ are disjoint subsets of $ℰ$. Note that ${ℬ}_1=\left\{(p_0,\varnothing )\right\}$ does not share any resource with ${ℬ}_i$ for $i\in [2,\ell ]$.

Table 2. Table 2 : Invariants maintained by the algorithm.

o X[1cb]X[5lp]   Invariant   1		$f_M(B_{⩽\ell -1},I)=\left|I\right|$.
Invariant 2	For every $i\in [1,\ell -1]$, $f_M(B_{⩽i},A_{i+1}\cup I)⩾d_{i+1}$.
Invariant 3	For every $i\in [1,\ell ]$, $\left|A_i\right|⩽z_i$.
Invariant 4	For every $i\in [1,\ell ]$, $d_i⩾z_i$.

Equations

$$\sum _{C\in {\mathcal{C}}_p(T)}{x}_{p,C}$$

$$\sum _{p\in P}\sum _{C\in {\mathcal{C}}_p(T):r\in C}{x}_{p,C}$$

$$x_{p,C}$$

$$\max$$

$$s.t.$$

$$y_p$$

$$z_r$$

$$y_p^{\ast }$$

$$\sum _{p\in P^{+}}{y}_p^{\ast }-\sum _{r\in R_f^{+}}{z}_r^{\ast }⩾\left(1-(1+\gamma )\lambda \right)\left(|B_{⩽\ell }|-|A_{\ell +1}|-|I|\right).$$

$$\sum _{r\in R_t^{+}}{z}_r^{\ast }=\sum _{r\in R_t^{+}}{v}_r<\left(3+\frac{\beta }{\gamma }\right)\lambda |B_{⩽\ell }|+2\lambda |I|+\left(2+\gamma +\frac{4+2\gamma }{\beta }\right)\lambda |A_{\ell +1}|.$$

$$\sum _{p\in P^{+}}{y}_p^{\ast }-\sum _{r\in R_f^{+}}{z}_r^{\ast }-\sum _{r\in R_t^{+}}{z}_r^{\ast }$$

$$>$$

$$\sum _{p\in P^{+}}{y}_p^{\ast }-\sum _{r\in R_f^{+}}{z}_r^{\ast }-\sum _{r\in R_t^{+}}{z}_r^{\ast }$$

$$>$$

$$\sum _{p\in P^{+}}{y}_p^{\ast }-\sum _{r\in R_f^{+}}{z}_r^{\ast }-\sum _{r\in R_t^{+}}{z}_r^{\ast }>\left(\left(1-3{\gamma }^3\right)-\left(4+10\gamma +4{\gamma }^2+3{\gamma }^3-{\gamma }^4\right)\lambda \right)|B_{⩽\ell }|.$$

$$\sum _{p\in P}{y}_p^{\ast }-\sum _{r\in R}{z}_r^{\ast }=\sum _{p\in P^{+}}{y}_p^{\ast }-\sum _{r\in R_f^{+}}{z}_r^{\ast }-\sum _{r\in R_t^{+}}{z}_r^{\ast }>0.$$

$$E_{\oplus }=(M\oplus \Pi )\oplus \left(M\oplus {\Pi }^{\ast }\right)=\Pi \oplus {\Pi }^{\ast }.$$

$$E_{\oplus }=M\oplus (M\oplus \Pi \oplus \pi )=\Pi \oplus \pi ={\Pi }^{+}\oplus \pi .$$

$$f_M(B_{⩽\ell },A_{\ell +1}\cup I\cup \{p\})=f_M(B_{⩽\ell },A_{\ell +1}\cup I)+1.$$

$$f_M(B_{⩽\ell },I\cup \{p\})=f_M(B_{⩽\ell },\cup I)+1.$$

$$d_{\ell +1}=f_M(B_{⩽\ell },A_{⩽\ell +1}\cup I)⩾|{\mathcal{A}}_{\ell +1}|=z_{\ell +1}.$$

$$f_M(B_{⩽t-1},I_{⩽t-1})=|I_{⩽t-1}|.$$

$$f_M(B_{⩽i},A_{i+1}\cup I)⩾d_{i+1}$$

$$f_M(B_{⩽t-1},A_t\cup I)=f_M(B_{⩽t-1},(A_t\setminus \{p\})\cup I)+1.$$

$$f_M(B_{⩽t-1},I\cup \{p\})=f_M(B_{⩽t-1},I)+1,$$

$$f_M(B_{⩽\ell },A_{\ell +1}\cup I\cup \{p\})>f_M(B_{⩽\ell },A_{\ell +1}\cup I).$$

$$y_p^{\ast }$$

$$\sum _{r\in C}{z}_r^{\ast }⩾z_{r_f}^{\ast }⩾1-\frac{21}{26}\lambda .$$

$$\sum _{r\in C\cap R(\Sigma )}{v}_r⩾\sum _{r\in C}{v}_r-\sum _{r\in C\setminus R(\Sigma )}{v}_r>1-\lambda =\frac{73}{26}\lambda .$$

$$\sum _{r\in C\cap R(\Sigma )}{z}_r^{\ast }⩾3\lambda \stackrel{(\because \lambda =26/99)}{=}1-\frac{21}{26}\lambda .$$

$$\sum _{r\in C\cap R(\Sigma )}{z}_r^{\ast }⩾z_{r_1}^{\ast }+z_{r_2}^{\ast }+z_{r_3}^{\ast }=3\lambda .$$

$$\sum _{r\in R^{\prime }}{v}_r=\sum _{r\in C\cap R(\Sigma )}{v}_r-v_{r_1}\stackrel{\text{eqref}eq:gap-0}{>}\frac{73}{26}\lambda -\lambda =\frac{47}{26}\lambda .$$

$$\sum _{r\in R^{\prime }}{z}_r^{\ast }⩾\frac{6}{5}\sum _{r\in R^{\prime }}{v}_r\stackrel{\text{eqref}eq:gap-1}{>}\frac{141}{65}\lambda .$$

$$\sum _{r\in C\cap R(\Sigma )}{z}_r^{\ast }=\sum _{r\in R^{\prime }}{z}_r^{\ast }+z_{r_1}^{\ast }>\frac{151}{65}\lambda +\lambda >3\lambda$$

Full text

Restricted Max-Min Allocation: Approximation and Integrality Gap

Siu-Wing Cheng

  

Yuchen Mao

1 Introduction

Background

In the max-min fair allocation problem, we are given a set $P$ of $n$ players, a set $R$ of $m$ indivisible resources, and a set of non-negative values $\{v_{pr}\}_{p\in P,r\in R}$. For each $r\in R$ and each $p\in P$, resource $r$ is worth a value of $v_{pr}$ to player $p$. An allocation is a partition of $R$ into disjoint subsets $\{D_{p}\}_{p\in P}$ so that each player $p$ is assigned the resources in $D_{p}$. The goal is to find an allocation that maximizes the welfare of the least lucky player, that is, we want to maximize $\min_{p\in P}\sum_{r\in D_{p}}v_{pr}$. Unfortunately, unless $\mathrm{P}=\mathrm{NP}$, no polynomial-time algorithm can achieve an approximation ratio smaller than 2 [6].

Bezáková and Dani [6] tried to solve the problem using the assignment LP – a technique for the classic scheduling problem of makespan minimization [16]. However, they showed that the integrality gap of the assignment LP is unbounded, so rounding the assignment LP gives no guarantee on the approximation ratio. Later, Bansal and Sviridenko [4] proposed a stronger LP relaxation, the configuration LP, for the max-min allocation problem. Asadpour and Saberi [3] developed a polynomial-time rounding scheme for the configuration LP that gives an approximation ratio of $O(\sqrt{n}\log^{3}n)$. Saha and Srinivasan [18] improved it to $O(\sqrt{n\log n})$. These approximation ratios almost match the lower bound of $\Omega(\sqrt{n})$ for the integrality gap of the configuration LP proved by Bansal and Svirodenko [4]. Bateni et al. [5] and Chakrabarty et al. [7] established a trade-off between the approximation ratio and the running time. For any $\delta>0$, they can achieve an approximation ratio of $O(n^{\delta})$ with $O(n^{1/\delta})$ running time.

In this paper, we study the restricted max-min allocation problem. In the restricted case, we have $v_{pr}\in\{v_{r},0\}$. That is, each resource $r$ has an intrinsic value $v_{r}$, and it is worth value $v_{r}$ to those players who desire it and value [math] to those who do not. Assuming $\mathrm{P}\neq\mathrm{NP}$, the restricted case has a lower bound of $2$ for the approximation ratio. The integrality gap of configuration LP for the restricted case also has a lower bound of $2$. Bansal and Sviridenko [4] proposed an O\bigl{(}\frac{\log\log n}{\log\log\log n}\bigr{)}-approximation algorithm by rounding the configuration LP. Feige [11] proved that the integrality gap of the configuration LP is bounded by a constant, albeit large and unspecified. His proof was later made constructive by Haeupler et al. [12], and hence a constant approximation can be found in polynomial time. Asadpour et al. [2] viewed the restricted max-min allocation problem as a bipartite hyper-graph matching problem. Let $T^{*}$ be the optimal value of the configuration LP. By adapting Haxell’s [13] alternating tree technique for bipartite hyper-graph matchings, they proposed a local search algorithm that returns an allocation where every player receives at least $T^{*}/4$ worth of resources, and hence proved that the integrality gap of the configuration LP is at most $4$. However, their algorithm is not known to run in polynomial time. A lot of efforts have been devoted to making their algorithm run in polynomial time. Polacek and Svensson [17] showed that the local search can be done in quasi-polynomial time by building the alternating tree in a more careful way. Annamalai, Kalaitzis and Svensson [1] carried out the local search in a more structured way. Together with two new greedy and lazy update strategies, they can find in polynomial time an allocation in which every player receives a value of at least $T^{*}/(6+2\sqrt{10}+\delta)$. Recently, we proposed a more flexible, aggressive greedy strategy that improves the approximation ratio to $6+\delta$ [9]. Davies et al. [10] claimed a $(6+\delta)$-approximation algorithm for the restricted max-min allocation problem by reducing it to the fractional matroid max-min allocation problem.

Our Contribution

We adapt the framework in [1] by introducing two new strategies: layer-level node-disjoint paths and limited blocking. The performance of our framework is determined by three parameters, and a trade-off between the running time and the quality of solution can be achieved by tuning these parameters. On one extreme, our framework acts exactly the same as the original local search in [2], which achieves a ratio of $4$ but not necessarily run in polynomial time. On the other extreme, it becomes something like the algorithm in [1], which achieves a polynomial running time but a much worse ratio. We show that, in order to achieve a polynomial running time, one doesn’t have to go from one extreme to the other — a marginal movement is sufficient. As a result, a ratio slightly worse than $4$ can be achieved in polynomial time.

Theorem 1.1**.**

For any constant $\delta>0$, there is a $(4+\delta)$-approximation algorithm for the restricted max-min allocation problem that runs in $\mathit{poly}(m,n)\cdot n^{\mathit{poly}(\frac{1}{\delta})}$ time.

Although the algorithm we present takes the optimal value of the configuration LP as its input, one can avoid solving the configuration LP by combining our algorithm with binary search to zoom into the optimal value of configuration LP. The binary search technique is similar to that in [1, 9].

We also show that the integrality gap of the configuration LP is at most $3+\frac{21}{26}\approx 3.808$ by giving a better analysis of the AFS algorithm. This improves the bound of $3+\frac{5}{6}\approx 3.833$ recently obtained in [8, 15].

Theorem 1.2**.**

The integrality gap of the configuration LP for the restricted max-min allocation problem is at most $3+\frac{21}{26}\approx 3.808$.

We focus on only the proof of Theorem 1.1 in the main text and defer the proof of Theorem 1.2 to Appendix C.

2 Preliminaries

2.1 The configuration LP

Suppose that we hope to find an allocation where every player receives at least $T$ worth of resources. A configuration for a player $p$ is a subset $D$ of the resources desired by $p$ such that $\sum_{r\in D}v_{r}\geqslant T$. Let ${\cal C}_{p}(T)$ denote the set of all configurations for $p$.

The configuration LP is given on the left of Figure 1. Given a target $T$, the configuration LP, denoted as $\mathit{CLP}(T)$, associates a variable $x_{p,C}$ with each player $p$ and each configuration $C$ in ${\cal C}_{p}(T)$. Its first constraint ensures that each player receives at least $1$ unit of configurations, and the second constraint guarantees that every resource $r$ is used in at most 1 unit of configurations. The optimal value of the configuration LP is the largest $T$ for which $\mathit{CLP}(T)$ is feasible. We denote this optimal value by $T^{*}$. Without loss of generality, we assume that $T^{*}=1$ for the rest of the paper. Although the configuration LP may have an exponential number of variables, it can be solved within any constant relative error in polynomial time [4]. Viewing the objective function of the configuration LP as a minimization of a constant, one can get the dual LP on the right of the Figure 1.

2.2 Fat and thin edges

Our goal is to find an allocation in which every player receives at least $\lambda$ worth of resources for some $\lambda\in(0,1)$. In particular, our approximation algorithm sets $\lambda=\frac{1}{4+\delta}$ where $\delta$ is a positive constant. For each resource $r\in R$, we call $r$ fat if $v_{r}\geqslant\lambda$, and thin otherwise. To find the target allocation, it suffices to assign each player $p$ either a fat resource desired by $p$ or a subset $D$ of the thin resources desired by $p$ with $\sum_{r\in D}v_{r}\geqslant\lambda$.

For every $p\in P$ and every fat resource $r$ desired by $p$, we call $\{p,r\}$ a fat edge. For every $p\in P$ and every subset $D$ of the thin resources desired by $p$, we call $(p,D)$ a thin edge if $\sum_{r\in D}v_{r}\geqslant\lambda$. Two edges are compatible if they share no common resource. We say that a fat edge $\{p,r\}$ covers $p$ and $r$. Similarly, a thin edge $(p,D)$ covers $p$ and the resources in $D$. A player or a resource is covered by a set of edges if it is covered by some edge in the set. For any $w\geqslant 0$, a thin edge $(p,D)$ is $w$-minimal if $\sum_{r\in D}v_{r}\geqslant w$ and $\sum_{r\in D^{\prime}}v_{r}<w$ for any $D^{\prime}\subsetneq D$. For a $w$-minimal thin edge $(p,D)$, it is not hard to see that $w\leqslant\sum_{r\in D}v_{r}<w+\lambda$.

Given the above definitions of fat and thin edges, finding the target allocation is equivalent to finding a set of mutually compatible edges that covers all the players.

2.3 A local search idea

The following local search idea is initially proposed by Asadpour et al. [2], and is also used in [1, 9].

Let $G$ be the bipartite graph formed by the players, the fat resources, and the fat edges. We maintain a set $M$ of fat edges and a set $\cal E$ of thin edges such that: (i) $M$ is a maximum matching of $G$, (ii) edges in $\cal E$ are $\lambda$-minimal and are mutually compatible, and (iii) each player is covered by at most one edge in $M\cup{\cal E}$. We call such $M$ and ${\cal E}$ a partial allocation. Initially, $M$ is an arbitrary maximum matching of $G$, and $\cal E$ is empty. The set $M\cup{\cal E}$ is updated and grown iteratively so that one more player is covered in each iteration. The final set $M\cup{\cal E}$ covers all the players and induces our target allocation.

Let $p_{0}$ be a player not yet covered by $M\cup{\cal E}$. We need to update $M\cup{\cal E}$ to cover $p_{0}$ without losing any player that are already covered. The simplest case is that we can find a player $q_{0}$ such that $q_{0}$ is covered by a thin edge $a$ compatible with $\cal E$ and there is an alternating path [14] with respect to $M$ from $p_{0}$ to $q_{0}$. Let $\pi$ be this alternating path. We first update $M$ by taking the symmetric difference $M\oplus\pi$, i.e., remove the edges in $\pi\cap M$ from the matching and add the edges in $\pi\setminus M$ to the matching. $M\oplus\pi$ is also a maximum matching of $G$. After the update, $p_{0}$ becomes matched while $q_{0}$ becomes unmatched. Then we add $a$ to ${\cal E}$ to cover $q_{0}$ again. Here we slight abuse the notion of alternating paths in the sense that wen allow an alternating path with no edge. The $\oplus$ can easily extend to alternating paths with no edge.

It is possible that no edge covering $q_{0}$ is compatible with $\cal E$. Let $a$ be an edge covering $q_{0}$. Suppose that $b$ is an edge in $\cal E$ that is not compatible with $a$. We say $b$ blocks $a$. Let $p_{1}$ be the player covered by $b$. In order to add $a$ to ${\cal E}$, we have to release $b$ from $\cal E$. But we cannot lose $p_{1}$, so before we release $b$, we need to find another edge to cover $p_{1}$. Now $p_{1}$ has a similar role as $p_{0}$.

2.4 Node-disjoint alternating paths

In order to achieve a polynomial running time, our algorithm updates $M$ using multiple node-disjoint alternating paths from unmatched players to players . In this section, we define a problem of finding a largest set of node-disjoint paths. We also extend the $\oplus$ operation to a set of node-disjoint paths.

For any maximum matching $M$ of $G$, we define $G_{M}$ to be the directed graph obtained from $G$ by orienting edges of $G$ from $r$ to $p$ if $\{p,r\}\in M$, and from $p$ to $r$ if $\{p,r\}\notin M$. Let $S$ be a subset of the players not matched by $M$. Let $T$ be a subset of the players. Finding the largest set of node-disjoint alternating paths from $S$ to $T$ is equivalent to finding the largest set of node-disjoint paths in $G_{M}$ from $S$ to $T$. Let $G_{M}(S,T)$ denote the problem of finding the largest set of node-disjoint paths from $S$ to $T$ in $G_{M}$. Let $f_{M}(S,T)$ denotes the maximum number of such paths. Note that when $S\cap T\neq\emptyset$, a path consisting of a single node is allowed. Such path is called a trivial path. Paths with at least one edge is non-trivial. Let $\Pi$ be a feasible solution for $G_{M}(S,T)$. The paths in $\Pi$ originate from a subset of $S$, which we call the sources and denote as $\mathit{src}_{\Pi}$, and terminate in a subset of $T$, which we call the sinks and denote as $\mathit{sink}_{\Pi}$. We extend the $\oplus$ operation to $\Pi$. Viewing $\Pi$ as a set of edges, $M\oplus\Pi$ stands for removing the edges in $\Pi\cap M$ from the matching and adding the edges in $\Pi\setminus M$ to the matching. One can see that $M\oplus\Pi$ is a maximum matching of $G$.

The problem $G_{M}(S,T)$ can be solved in polynomial time. Please see the appendix A for more about this problem.

3 An Approximation Algorithm

We discuss below a few techniques used by our algorithm. Some of them are used in [1, 9, 10]. The limited blocking strategy is brand new, and is crucial to achieving an approximation ratio of $4+\delta$. In the following discussion, one can interpret addable edges as thin edges that we hope to add to $\cal E$, and blocking edges as edges in $\cal E$ that are not compatible with addable edges. The precise definition will be given later.

Layers. As in [1, 9], we maintain a stack of layers, where each layer consists of addable edges and their blocking edges. The key to achieving a polynomial running time is to guarantee a geometric growth in the number of blocking edges from the bottom to the top of the stack.

Layer-level node-disjoint paths. We require that the players covered by the addable edges in a layer can be simultaneously reached via node-disjoint paths in $G_{M}$ from the players covered by the blocking edges in the lower layers [10]. It has the same effect as the globally node-disjoint path used in [1]: if lots of addable edges in a layer become unblocked, then a significant update can be made. The advantage of our strategy is that it offers more flexibility when building a new layer.

Lazy update. When having an unblocked addable edge, one may be tempted to update $M$ and ${\cal E}$ immediately. However, as in [1], in order to achieve a polynomial running time, we should wait until there are lots of unblocked addable edges, and then a significant update can be made in one step. We will define a constant $\mu$ to control the laziness.

Greedy and Limited Blocking. Recall that the key to achieving a polynomial running time is to guarantee a geometric growth in the number of blocking edges from the bottom to the top of the stack. In [2], every addable edge is $\lambda$-minimal, and each blocking edge blocks exactly one addable edge. Using this strategy, in worst case, one may get a layer that has one addable edge being blocked by many blocking edges. After some of these blocking edges are released from $\cal E$, we may be left with a layer that has a single addable edge being blocked by a single blocking edge, which breaks the geometric growth in the number of blocking edges. To resolve this issue, Annamalai et al. [1] allow a blocking edge to block as many addable edges as possible. However, it causes a new trouble: one may get a layer that has many addable edges being blocked by one blocking edge. Again, this breaks the geometric growth in the number of blocking edges. As a consequence, they have to introduce another strategy Greedy. They require every addable edge to be $\frac{1}{2}$-minimal. Such an addable edge contains much more resources than necessary. If such an addable edge is blocked, at least $\frac{1}{2}-\lambda$ worth of its resources must be occupied by blocking edges. Provided that a blocking edge is $\lambda$-minimal and covers at most $2\lambda$ worth of resources, the greedy strategy ensures that, in a layer, the number of blocking edges cannot be too small comparing with the number of addable edges. Analysis shows that although the greedy strategy makes the algorithm faster, it deteriorates the approximation ratio. Our strategy is a generalization of those used in [2] and [1]. We allow a blocking edge $b$ to block more than one addable edge, but once $b$ shares strictly more than $\beta\lambda$ worth of resources with the addable edges blocked by it, we stop $e$ from blocking more edges. We use greedy too. In our algorithm, addable edges in layers are $(1+\gamma)\lambda$-minimal for some constant $\gamma$.

If we set $\beta,\gamma,\mu$ to be [math], then our algorithm acts exactly the same as the local search in [2], which achieves a ratio of $4$ but may not run in polynomial time. If $\beta,\gamma$ are set to be some large constant, then our algorithm acts like the algorithm in [1] which achieves a polynomial running time but a much worse ratio. We show that carefully selected tiny $\beta$ and tiny $\gamma$ guarantee a polynomial running time but barely hurt the approximation ratio.

3.1 The algorithm

Let $M\cup{\cal E}$ be the current partial allocation. Let $p_{0}$ be a player that is not yet covered by $M\cup{\cal E}$. The algorithm alternates between two phases to update and extend $M\cup{\cal E}$ so that the partial allocation covers $p_{0}$ eventually without losing any covered player. In the building phase, it pushes new layers onto a stack, where each layer stores some addable edges and their blocking edges. In the collapse phase, it uses unblocked addable edges to release some blocking edges in some layer from $\cal E$.

Since we frequently talk about resources covered by thin edges and take sum of values over a set of resources, we define the following notations. Given a thin edge $e$, $R_{e}$ denotes the set of resources covered by $e$. Given a set $\cal S$ of thin edges, $R({\cal S})$ denotes the set of thin resources covered by $\cal S$. Given a set $D$ of resources, define $v[D]=\sum_{r\in D}v_{r}$.

3.1.1 Building phase

The algorithm maintains a stack of layers. The layer index starts with $1$ from the bottommost layer in the stack. The $i$-th layer $L_{i}$ is a tuple $({\cal A}_{i},{\cal B}_{i},d_{i},z_{i})$, where ${\cal A}_{i}$ is a set of addable edges that we want to add to $\cal E$, and ${\cal B}_{i}$ is a set of blocking edges that prevent us from doing so. The two numeric values $d_{i}$ and $z_{i}$ are maintained for the sake of analysis. The algorithm also maintains a set $\cal I$ of addable edges that are compatible with $\cal E$. We will define addable edges and blocking edges later. We use $\ell$ to denote the number of layers in the current stack. The state of the algorithm is specified by $(M,{\cal E},{\cal I},(L_{1},\ldots,L_{\ell}))$.

For each ${\cal A}_{i}$, we use $A_{i}$ to denote the set of players covered by ${\cal A}_{i}$. Similarly, $B_{i}$ and $I$ denote the set of players covered by ${\cal B}_{i}$ and $\cal I$, respectively. For $i\in[1,\ell]$, define ${\cal B}_{\leqslant i}=\bigcup_{j=1}^{i}{\cal B}_{j}$, $B_{\leqslant i}=\bigcup_{j=1}^{i}B_{j}$, and ${\cal A}_{\leqslant i}=\bigcup_{j=1}^{i}{\cal A}_{j}$.

For simplicity, we define the first layer $L_{1}$ to be $(\emptyset,\{(p_{0},\emptyset)\},0,0)$. That is, ${\cal A}_{1}=\emptyset$, ${\cal B}_{1}=\{(p_{0},\emptyset)\}$, and $d_{1}=z_{1}=0$.

The layers are built inductively. Initially, there is only the layer $L_{1}$ and ${\cal I}=\emptyset$. Let $\ell$ be the number of layers in the current stack. Consider the construction of the $(\ell+1)$-th layer.

Definition 3.1**.**

Let $\beta\geqslant 0$ be a constant to be specified later. A thin resource $r$ is inactive if (i) $r\in R({\cal A}_{\leqslant\ell}\cup{\cal B}_{\leqslant\ell})$, or (ii) $r\in R({\cal A}_{\ell+1}\cup{\cal I})$, or (iii) $r\in R_{b}$ for some $b\in{\cal B}_{\ell+1}$ and $v[R_{b}\cap R({\cal A}_{\ell+1})]>\beta\lambda$. If a thin resource is not inactive, then it is active.

We will define addable edges so that they use only active thin resources.

Definition 3.2**.**

A player $p$ is addable if $f_{M}(B_{\leqslant\ell},A_{\ell+1}\cup I\cup\{p\})=f_{M}(B_{\leqslant\ell},A_{\ell+1}\cup I)+1$.

The activeness of thin resources and the addability of the players depend on ${\cal A}_{\ell+1}$ and ${\cal I}$ ($A_{\ell+1}$ and $I$), so they may be affected as we add edges to ${\cal A}_{\ell+1}$ and ${\cal I}$.

Definition 3.3**.**

A thin edge $(p,D)$ is addable if $p$ is addable and $D$ is a set of active thin resources desired by $p$ with $v[D]\geqslant\lambda$. The blocking edges of an addable edge $(p,D)$ are \{\textrm{e\in{\cal E}$:$R_{e}\cap D\neq\emptyset }\}. An addable edge $(p,D)$ is unblocked if $v[D\setminus R(\cal E)]\geqslant\lambda$.

Recall that, for any $w>0$, a thin edge $(p,D)$ is $w$-minimal if $v[D]\geqslant w$ and $v[D^{\prime}]<w$ for any $D^{\prime}\subsetneq D$. Our algorithm considers two kinds of addable edges. The first kind is unblocked addable edges that are $\lambda$-minimal. It is easy to see that if an unblocked addable edge is $\lambda$-minimal, then it must be compatible with ${\cal E}$. We use $\cal I$ to keep such addable edges. The second kind is blocked addable edges that are $(1+\gamma)\lambda$-minimal, where $\gamma$ is a constant to be specified later. Such edges will be added to ${\cal A}_{\ell+1}$. Once a $(1+\gamma)\lambda$-minimal addable edge $(p,D)$ becomes unblocked, we can easily extract a $\lambda$-minimal unblocked addable edge $(p,D^{\prime})$ with $D^{\prime}\subseteq D$.

Consider condition (iii) in Definition 3.1. Let $b$ be a blocking edge in ${\cal B}_{\ell+1}$. When $R_{b}$ and $R({\cal A}_{\ell+1})$ share strictly more than $\beta\lambda$ worth of resources, all resources in $R_{b}$ become inactive. Any addable edge to be added to ${\cal A}_{\ell+1}$ in the future cannot use these inactive resources, and hence, will not be blocked by $b$. This is how we achieve “limited blocking” mentioned before.

We call Build below to construct the $(\ell+1)$-th layer. Note that after adding an addable edge to ${\cal A}_{\ell+1}$, we immediately add its blocking edges to ${\cal B}_{\ell+1}$ in order to keep the inactive/active status of thin resources up-to-date.

Build$(M,{\cal E},{\cal I},(L_{1},\cdots,L_{\ell}))$

Initialize ${\cal A}_{\ell+1}=\emptyset$ and ${\cal B}_{\ell+1}=\emptyset$. 2. 2.

While there is an unblocked addable edge that is $\lambda$-minimal, add it to $\cal I$. 3. 3.

While there is an addable edge $(p,D)$ that is $(1+\gamma)\lambda$-minimal

1. 3.1

add $(p,D)$ to ${\cal A}_{\ell+1}$. (Note that $(p,D)$ must be blocked; otherwise, we could extract from it a $\lambda$-minimal unblocked addable edge, which should be added to ${\cal I}$ in step 2.) 2. 3.2

add to ${\cal B}_{\ell+1}$ the edges in $\cal E$ that block $(p,D)$. 4. 4.

Set $d_{\ell+1}:=f_{M}(B_{\leqslant\ell},A_{\ell+1}\cup I)$, $z_{\ell+1}:=\left|A_{\ell+1}\right|$, and $L_{\ell+1}:=({\cal A}_{\ell+1},{\cal B}_{\ell+1},d_{\ell+1},z_{\ell+1})$. 5. 5.

Update $\ell:=\ell+1$

Table 3.1.1 lists a few facts about the layers.