A Quasi-Polynomial Approximation for the Restricted Assignment Problem

TL;DR

This paper improves the approximation ratio for the Restricted Assignment Problem using a quasi-polynomial algorithm, reducing the integrality gap and simplifying the proof of the LP relaxation.

Contribution

It provides the first quasi-polynomial time algorithm with an approximation ratio better than 2 for the problem, improving previous bounds and simplifying analysis.

Findings

Integrality gap improved from 1.9142 to 1.8334

First quasi-polynomial approximation algorithm for the problem

Simplified proof of the LP relaxation bound

Abstract

The Restricted Assignment Problem is a prominent special case of Scheduling on Parallel Unrelated Machines. For the strongest known linear programming relaxation, the configuration LP, we improve the non-constructive bound on its integrality gap from 1.9142 to 1.8334 and significantly simplify the proof. Then we give a constructive variant, yielding a 1.8334-approximation in quasi-polynomial time. This is the first quasi-polynomial algorithm for this problem improving on the long-standing approximation rate of 2.

Equations

$$\mathcal{C}(i,\tau )=\{S\subseteq \mathcal{J}:p(S)\le \tau \text{ and for all j∈S},i\in \Gamma (j)\}.$$

$$\sum _{C\in \mathcal{C}(i,\tau )}{x}_{i,C}$$

$$\sum _{i\in \mathcal{M}}\sum _{C\in \mathcal{C}(i,\tau ):j\in C}{x}_{i,C}$$

$$x_{i,C}$$

$$\min \sum _{i\in \mathcal{M}}{y}_i$$

$$\sum _{j\in C}{z}_j$$

$$y_i,z_j$$

$$(b^{\prime },|\tilde{\mathcal{J}}(L_{\le 0}^{\prime },\sigma )|,\dots ,|\tilde{\mathcal{J}}(L_{\le {\ell }^{\prime }}^{\prime },\sigma )|,-1)$$

$$(b,|\tilde{\mathcal{J}}(L_{\le 0},\sigma )|,\dots ,|\tilde{\mathcal{J}}(L_{\le \ell },\sigma )|,-1),$$

$$y_i=(1+ϵ{)}^{1-k}.$$

$$z_j=(1+ϵ{)}^{-k}\cdot p_j/\tau ,$$

$$\begin{gathered} \sum _{j\in \mathcal{J}}{z}_j=\sum _{i\in \mathcal{M}}z({\sigma }^{-1}(i))=\sum _{k=0}^{\ell }\sum _{i\in L_k}(1+ϵ{)}^{-k}\frac{p({\sigma }^{-1}(i))}{\tau } \\ >(2+ϵ)|L_0|+\sum _{k=1}^{\ell }(1+ϵ{)}^{-k}(1+ϵ)|L_k|\ge 1+\sum _{k=0}^{\ell }(1+ϵ{)}^{1-k}|L_k| \\ =|\mathcal{M}|\cdot (1+ϵ{)}^{-{\log }_{1+ϵ}(|\mathcal{M}|)}+\sum _{k=0}^{\ell }(1+ϵ{)}^{1-k}|L_k|\ge \sum _{i\in \mathcal{M}}{y}_i. \end{gathered}$$

$$z(C)\le (1+ϵ{)}^{1-k}\frac{p(C)}{\tau }\le (1+ϵ{)}^{1-k}=y_i.$$

$$z(C)\le (1+ϵ{)}^{-\ell }\frac{p(C)}{\tau }\le (1+ϵ{)}^{-{\log }_{1+ϵ}(|\mathcal{M}|)}=y_i.$$

$$p(S_{i_k}(L_{\le k-1},\sigma ))+p(\{j\in {\sigma }^{-1}(i_k):1/2<p_j\le W\})+p_{j_k}>11/6\cdot \tau .$$

$$z_j=\{\begin{array}{ll}\min \left\{\frac{p_j}{\tau },\frac{5}{6}\right\}& \text{if j∈J~ and}\\ z_j=0& \text{otherwise}.\end{array}$$

$$p(S_i(P_{\le k-1},\sigma ))+p(\{j\in {\sigma }^{-1}(i):1/2<p_j\le W\})+p_{j_k}>11/6\cdot \tau .$$

$$z(C)\le z(C\setminus \{j_B\})+z_{j_B}\le z({\sigma }^{-1}(i)\setminus \{j_B^{\prime }\})+z_{j_B^{\prime }}=z({\sigma }^{-1}(i))=y_i.$$

$$p(S_i(P_{\le k-1},\sigma ))+p(\{j\in {\sigma }^{-1}(i):1/2<p_j\le W_0\})+p_{j_B}>11/6\cdot \tau .$$

$$z(C)\le z(C\setminus \{j_B\})+z_{j_B}\le z({\sigma }^{-1}(i)\setminus \{j_B^{\prime }\})+5/6=z({\sigma }^{-1}(i))=y_i.$$

$$y_i$$

$$\ge z(S_i(P_{\le k-1},\sigma ))+z(\{j\in {\sigma }^{-1}(i):1/2<p_j\le W_0\})$$

$$=p(S_i(P_{\le k-1},\sigma ))/\tau +p(\{j\in {\sigma }^{-1}(i):1/2<p_j\le W_0\})/\tau$$

$$>11/6-p_{j_B}/\tau \ge 5/6+(\tau -p_{j_B})/\tau \ge z(C).$$

$$z({\sigma }^{-1}(i))\ge 5/6\cdot p({\sigma }^{-1}(i))/\tau >55/36>1=y_i.$$

$$p(S_i(L_{\le k-1},\sigma ))+p(\{j\in {\sigma }^{-1}(i):p_j>1/2\})+p_{j_B}\le 11/6\cdot \tau .$$

$$p({\sigma }^{-1}(i))+p_{j_B}>11/6\cdot \tau .$$

$$z({\sigma }^{-1}(i))\ge \min \left\{\frac{5}{6},\frac{p({\sigma }^{-1}(i))}{\tau }\right\}\ge \min \left\{\frac{5}{6},\frac{11/6-p_{j_B}}{\tau }\right\}\ge \frac{5}{6}=y_i-\frac{1}{6}.$$

$$\begin{gathered} z({\sigma }^{-1}(i))\ge \min \left\{\frac{p({\sigma }^{-1}(i))}{\tau },\frac{p({\sigma }^{-1}(i))-\tau }{\tau }+\frac{5}{6},\frac{10}{6}\right\} \\ \ge \min \left\{\frac{11}{6}-\frac{p_{j_S}}{\tau }-1+\frac{5}{6},\frac{10}{6}\right\}\ge \frac{7}{6}=y_i+\frac{1}{6}. \end{gathered}$$

$$\sum _{j\in \mathcal{J}}{z}_j=\sum _{i\in \mathcal{M}}z({\sigma }^{-1}(i))>\sum _{i\in \mathcal{M}}{y}_i.\text{qed}$$

$$\Phi (P_{\le k},\sigma )=(p_{j_k},j_k,i_k,|\mathcal{J}\times \mathcal{M}|-|R(P_{\le k},\sigma )|,|\tilde{\mathcal{J}}(P_{\le k},\sigma )|)$$

$$(b^{\prime },|\tilde{\mathcal{J}}(P_{\le 0}^{\prime },{\sigma }^{\prime })|,\Phi (P_{\le 0}^{\prime },{\sigma }^{\prime }),\dots ,\Phi (P_{\le {\ell }^{\prime }}^{\prime },{\sigma }^{\prime }),-1)$$

$$(b,|\tilde{\mathcal{J}}(P_{\le 0},\sigma )|,\Phi (P_{\le 0},\sigma ),\dots ,\Phi (P_{\le \ell },\sigma ),-1).$$

$$\underset{=p(S_{i_k}^{\prime }(L_{\le k-1}^{\prime },{\sigma }^{\prime }))}{\underbrace{p(S_{i_k}(L_{\le k-1},\sigma ))}}+p(\{j\in {\sigma }^{-1}(i):1/2<p_j\le W\})+p_{j_k}>11/6\cdot \tau ,$$

Full text

1 Introduction

We consider a special case of the problem Scheduling on Unrelated Parallel Machines, where the goal is to compute an allocation $\sigma:\mathcal{J}\rightarrow\mathcal{M}$ of the jobs $\mathcal{J}$ to the machines $\mathcal{M}$. On machine $i$ the job $j$ has a processing time (size) $p_{ij}$. We want to minimize the makespan, which is the maximum load $\max_{i\in\mathcal{M}}\sum_{j\in\sigma^{-1}(i)}p_{ij}$. The classical 2-approximation by Lenstra et al. [9] is still the algorithm of choice for this problem. They also show that no approximation ratio better than $3/2$ can be found in polynomial time unless $\mathrm{P}=\mathrm{NP}$. Closing this gap appears in several lists of important open questions: Schuurman and Woeginger [11] include it in their influential survey on open questions scheduling and Shmoys and Williamson in their book on approximation algorithms [13].

While the general problem remains unclear, there has been progress on a special case called Restricted Assignment. Here each job $j$ has a processing time $p_{j}$, which is independent from the machines, and a set of feasible machines $\Gamma(j)$. This means $j$ can only be assigned to one of the machines in $\Gamma(j)$. Note that this is equivalent to the previous problem when $p_{ij}\in\{p_{j},\infty\}$. The lower bound of $3/2$ holds also in the restricted case and even if given quasi-polynomial running time no better approximation ratio can be obtained, unless $\mathrm{DTIME}(2^{\mathrm{polylog}(n)})=\mathrm{NP}$, which would contradict popular conjectures such as the Exponential Time Hypothesis.

In a seminal work, Svensson [12] proved that the configuration LP, a natural linear programming relaxation, has an integrality gap of at most $33/17$. By approximating the optimum of the configuration LP this yields an $(33/17+\epsilon)$-estimation algorithm. However, this proof is non-constructive and no polynomial algorithm is known that can produce a solution of this quality.

For instances with only two processing times additional progress has been made. Chakrabarty et al. gave a polynomial $(2-\delta)$-approximation for a very small $\delta$ [5]. Annamalai improved this with a $(17/9+\epsilon)$-approximation for every $\epsilon>0$ [1]. For this special case it was also shown that the integrality gap is at most $5/3$ [6].

In [12] and [6] the critical idea is to design a local search algorithm, which is then shown to produce good solutions. However, the algorithm has a potentially high running time; hence it could only be used to prove the existence of a good solution. For the closely related Santa Claus problem, in which the minimum is maximized instead of the maximum being minimized, similar algorithms were developed [3]. There, a quasi-polynomial variant by Polácek et al. [10] and a polynomial variant by Annamalai et al. [2] were later discovered.

In this article, we start by giving a simple quasi-polynomial time $(2+\epsilon)$-approximation in order to introduce some ideas. We then present a simpler variant of Svensson’s non-constructive algorithm, which in addition achieves a better approximation ratio; thereby we improve the bound on the integrality gap of the configuration LP. Finally, we combine both approaches in a very sophisticated $(11/6+\epsilon)$-approximation algorithm that terminates in quasi-polynomial time. This leads to the first better-than-2 approximation algorithm for Restricted Assignment, which does not need exponential running time. The algorithm is purely combinatorial and uses the configuration-LP only in the analysis. The last algorithm implies the results of the previous two. Nevertheless, they are significantly less complex and already demonstrate many of the key techniques used in the last algorithm.

Comparison to related algorithms

In Svensson’s algorithm [12] and ours, jobs are moved until the desired allocation is found. The presentations of the algorithms differ significantly, but on a high level Svensson’s algorithm is closely related to the second (exponential time) algorithm we give. Considering simplified instances with only jobs of two sizes, both algorithms and their analysis are essentially the same. Our exponential time algorithm is a cleaner adaption to general instances, which is much less technical and has an better approximation ratio.

The approach for obtaining a quasi-polynomial running time resembles that of [10], where it was done for the restricted Santa Claus problem. In the Restricted Assignment problem, however, this turns out to be significantly more challenging. The basic idea in both algorithms is to reduce the search depth to a logarithmic value. A fundamental structure in both cases are chains of big jobs or resources. Big jobs have a size greater than $1/2$ times the optimal makespan. Informally, a chain of big jobs is a sequence $j_{1},i_{1},j_{2},i_{2},j_{3},i_{3}\dotsc$, where $j_{1}$ is a big job allowed to be placed on $i_{1}$; $j_{2}$ is a big job currently assigned to $i_{1}$, which is also allowed on $i_{2}$; $j_{3}$ is a big job currently assigned to $i_{2}$, but also allowed on $i_{3}$; etc. A similar situation can arise in the restricted Santa Claus problem, except that big resources (the counter-part to jobs) have a size at least the desired solution value. It turns out that these chains play a critical role and in the Santa Claus problem they have a very simple structure. This is because on a player (the counter-part to a machine) which has one big resource we do not place any other resources. In the Restricted Assignment case it is necessary to place also other jobs on machines that have big jobs. This means that the simple operation of moving every job of a chain to the next machine works well in the Santa Claus case, but in the Restricted Assignment case this can result in bad machines (machines that have too much load), if we are not careful. Perhaps this is also a reason why at this time there is no polynomial time better-than-$2$ approximation algorithm known for Restricted Assignment and the only progress in this direction is in the case where we have only one big job size. Note that in this case, chains are again simple.

Notation

For a set of jobs $A\subseteq\mathcal{J}$, we write $p(A)$ in place of $\sum_{j\in A}p_{j}$. For other variables indexed by jobs, we may do the same. An allocation is a function $\sigma:\mathcal{J}\rightarrow\mathcal{M}$, where $\sigma(j)\in\Gamma(j)$ for all $j\in\mathcal{J}$. We write $\sigma^{-1}(i)$ for the set of all jobs $j$ which have $\sigma(j)=i$.

Configuration LP

The configuration LP has an exponential size, but can be solved approximately in polynomial time with a rate of $(1+\epsilon)$ for every $\epsilon>0$ [4]. For every machine $i$ and every $\tau\geq 0$ let

[TABLE]

These are the configurations for machine $i$ and makespan $\tau$. They are a set of jobs that have volume at most $\tau$ and can run on machine $i$. The optimum $\mathrm{OPT}^{*}$ of the configuration LP is the lowest $\tau$ such that the following linear program is feasible.

This linear program assigns at least one configuration to every machine and makes sure that every job is assigned at least once. We will also construct the dual after adding the objective $\max\ (0,\dotsc,0)\cdot x$ to the configuration LP:

Recall, the value $\tau$ is a constant in the LP and, if the configuration LP is infeasible with $\tau$, this means $\mathrm{OPT}^{*}>\tau$. Furthermore, we can derive the following condition from duality.

Lemma 1**.**

Let $y\in\mathbb{R}_{\geq 0}^{\mathcal{M}}$ and $z\in\mathbb{R}_{\geq 0}^{\mathcal{J}}$ such that $\sum_{i\in\mathcal{M}}y_{i}<\sum_{j\in\mathcal{J}}z_{j}$ and for every $i\in\mathcal{M}$ and $C\in\mathcal{C}(i,\tau)$ it holds that $\sum_{j\in C}z_{j}\leq y_{i}$, then $\mathrm{OPT}^{*}>\tau$.

It is easy to see that if such a solution $y,z$ exists, then every component can be scaled by a constant to obtain a feasible solution lower than any given value. Hence, the dual must be unbounded and therefore the primal must be infeasible.

2 Simple algorithm

In this section we present a quasi-polynomial time $(2+\epsilon)$-approximation algorithm. It should be noted that there do exist clean and simple polynomial time $2$-approximation algorithms for this problem and even for the general problem of scheduling on unrelated machines. The purpose of this section is merely to introduce some concepts and how they can be used to get a quasi-polynomial running time. We use a dual approximation framework where we perform a binary search over variable $\tau\in[p_{\max},\ n\cdot p_{\max}]$, where $p_{\max}=\max_{j\in\mathcal{J}}p_{j}$. In each iteration we either prove that $\mathrm{OPT}^{*}>\tau$ or find an allocation with makespan at most $(1+\epsilon)\tau$. We stop the binary search once upper and lower bound differ by less than a factor of $(1+\epsilon)$. This gives a $(1+\epsilon)^{2}$-approximation in $\log_{1+\epsilon}(n)=O(1/\epsilon\cdot\log(n))$ iterations of the binary search. By scaling down $\epsilon$ we can get a $(1+\epsilon)$-approximation in the same asymptotic time. The algorithmic idea for the inner method is basically a breadth-first search:

Let $\sigma:\mathcal{J}\rightarrow\mathcal{M}$ be an arbitrary allocation. We use layers $L_{0},\dotsc,L_{\ell}$, which are disjoint sets of machines. We write $L_{\leq k}$ for the union over all machines in $L_{0},\dotsc,L_{k}$. Further, let $\tilde{\mathcal{J}}(L_{\leq k},\sigma)$ denote the set of jobs $j$ with $\sigma(j)\in L_{\leq k}$. We call a machine $i$ good, if $p(\sigma^{-1}(i))\leq 2+\epsilon$, and bad, otherwise. The algorithm (see Alg. 3) initializes $L_{0}$ as the bad machines. Then the subsequent layers $L_{k+1}$ are created as the union over all $\Gamma(j)\setminus L_{\leq k}$ where $j\in\tilde{\mathcal{J}}(L_{\leq k},\sigma)$. If there is a machine with a load at most $(1+\epsilon)\tau$ in some layer, we move a job from a lower layer to this layer and then start from the beginning.

Running time

We consider two consecutive iterations right before some job is moved and the layers are deleted. Let $\sigma$ and $\sigma^{\prime}$ be the allocations at the earlier and at the later iteration. Likewise, let $L_{\leq\ell}$ and $L^{\prime}_{\leq\ell^{\prime}}$ be the layers. We show that the vector

[TABLE]

is lexicographically smaller than

[TABLE]

where $b^{\prime}$ and $b$ are the number of bad machines for $\sigma^{\prime}$ and $\sigma$. Since the number of layers is at most $\log_{1+\epsilon}(|\mathcal{M}|)=O(1/\epsilon\cdot\log(|\mathcal{M}|))$ and each component is bounded by $|\mathcal{J}|$, the overall running time is $|\mathcal{J}|^{O(1/\epsilon\cdot\log(|\mathcal{M}|))}$. For the lexicographic decrease, notice that the algorithm moves a job $j$ to a machine $i$ only when $p(\sigma^{-1}(i))\leq(1+\epsilon)\tau$. Hence, after adding $j$, the load on $i$ is $p(\sigma^{-1}(i))+p_{j}\leq(1+\epsilon)\tau+\tau\leq(2+\epsilon)\tau$. Thus, the algorithm never turns a good machine into a bad machine and $b^{\prime}\leq b$. If $b^{\prime}<b$ we are done. Otherwise, $b^{\prime}=b$ and since no jobs were moved to or from $L_{\leq\ell-1}$, $L^{\prime}_{\leq k}=L_{\leq k}$ and $\tilde{\mathcal{J}}(L^{\prime}_{\leq k},\sigma^{\prime})=\tilde{\mathcal{J}}(L_{\leq k},\sigma)$ for all $k\leq\min\{\ell-1,\ell^{\prime}\}$. If $\ell^{\prime}\leq\ell-1$, then the $\ell^{\prime}+1$-th component will be $-1$ and therefore smaller than $|\tilde{\mathcal{J}}(L_{\leq\ell^{\prime}+1},\sigma)|$. Otherwise, the $\ell$-th component will be smaller because we moved one job away from $L_{\leq\ell}$.

Correctness

We have to verify that if the algorithm returns ”err”, then $\mathrm{OPT}^{*}>\tau$. We will do so using Lemma 1. Assume that $\ell\geq\log_{1+\epsilon}(|\mathcal{M}|)$ and let $\sigma$ and $L_{\leq\ell}$ be the current allocation and layer structure. For every $i\in L_{k}$ define

[TABLE]

Furthermore, define $y_{i}=(1+\epsilon)^{-\log_{1+\epsilon}(|\mathcal{M}|)}$, if $i\notin L_{\leq\ell}$. For jobs $j\in\mathcal{J}$ set

[TABLE]

where $k$ is minimal with $j\in\tilde{\mathcal{J}}(L_{\leq k},\sigma)$ and $z_{j}=0$ if there is no such $k$. We need to show that $\sum_{j\in\mathcal{J}}z_{j}>\sum_{i\in\mathcal{M}}y_{i}$ and for all $i\in\mathcal{M}$ and $C\in\mathcal{C}(i,\tau)$ it holds that $z(C)\leq y_{i}$. For the former, we argue

[TABLE]

For the latter condition, first consider a machine $i\in L_{k}$ and $C\in\mathcal{C}(i,\tau)$. There can be no job $j\in C$ with $j\in\tilde{\mathcal{J}}(L_{\leq k-2},\sigma)$, since otherwise $i$ would be in an earlier layer. Therefore, $z_{j}\leq(1+\epsilon)^{-(k-1)}p_{j}$ for all $j\in C$. Thus,

[TABLE]

Now let $i\in\mathcal{M}\setminus L_{\leq\ell}$ and let $C\in\mathcal{C}(i,\tau)$. No job in $C$ can be in $\tilde{\mathcal{J}}(L_{\leq\ell-1},\sigma)$. This means, $z_{j}\leq(1+\epsilon)^{-\ell}p_{j}$ for all $j\in C$ and

[TABLE]

Using the lemma this implies that $\mathrm{OPT}^{*}>\tau$.

3 Non-constructive integrality gap bound

In this section, we give an approximation algorithm with ratio $11/6$. The algorithm is similar to the previous one, but it adds only single moves, instead of a whole layers of reachable machines. This leads to an exponential running time bound. Hence, the algorithm in this section only gives a non-constructive bound on the integrality gap of the configuration LP.

3.1 Algorithm

Given an allocation $\sigma:\mathcal{J}\rightarrow\mathcal{M}$, we call a machine $i$ bad, if $p(\sigma^{-1}(i))>11/6\cdot\tau$. A machine is good, if it is not bad. We define big jobs to be those $j\in\mathcal{J}$ that have $p_{j}>1/2\cdot\tau$ and small jobs all others.

As the previous one, this algorithm starts with an arbitrary allocation and moves jobs until all machines are good, or it can prove that the configuration LP is infeasible w.r.t. $\tau$. During this process, a machine that is already good will never be made bad.

The central data structure of the algorithm is an ordered list of pending moves $P=(P_{1},P_{2},\dotsc,P_{\ell})$. Here, every component $P_{k}=(j,i)$, $j\in\mathcal{J}$ and $i\in\Gamma(j)$, stands for a move the algorithm wants to perform. It will not perform the move, if this would create a bad machine, i.e., $p(\sigma^{-1}(i))+p_{j}>11/6\cdot\tau$. If it does not create a bad machine, we say that the move $(j,i)$ is valid. For every $0\leq k\leq\ell$ define $L_{\leq k}:=(L_{1},\dotsc,L_{k})$, the first $k$ elements of $L$ (with $L_{\leq 0}$ being the empty list).

Depending on the current allocation $\sigma$ and list of pending moves $P_{\leq\ell}$, we define a binary relation $R(P_{\leq\ell},\sigma)\subseteq\mathcal{J}\times\mathcal{M}$. For a pair $(j,i)\in R(P_{\leq\ell},\sigma)$ we say machine $i$ repels $j$ w.r.t. $P_{\leq\ell}$. This does not mention $\sigma$ and therefore slightly abuses notation, but during the lifetime of $P_{\leq\ell}$ the allocation $\sigma$ does not change and is always clear from the context.

The definition of repelled jobs is given later. The algorithm will only add a new move $(j,i)$ to the current list $P$, if $j$ is repelled by its current machine and not repelled by the target $i$ w.r.t. $P$ (see Alg. 4).

In the algorithm we use a lexicographic order $(p_{j},j,i)$ of the moves $(j,i)$. Here, we assume that there is an arbitrary order on jobs and machines, which is consistent throughout the iterations.

Repelled jobs

We define the repelled jobs of each machine inductively w.r.t. $P_{\leq k}$, $k=0,1,\dotsc,\ell$.

(initialization)

If $k=0$, let every bad machine $i$ repel every job $j$ w.r.t. $P_{\leq k}$.

(monotonicity)

If $i$ repels $j$ w.r.t. $L_{\leq k}$, then let $i$ repel $j$ also w.r.t. $P_{\leq k+1}$.

The remaining rules regard $k>0$ and we let $(j_{k},i_{k}):=P_{k}$, i.e., the last move added. In order to make space for $j_{k}$, the machine $i_{k}$ should repel jobs.

(small-all)

If $j_{k}$ is small, let $i_{k}$ repel all jobs.

In the case that $j_{k}$ is big, we need to be more careful. It helps to imagine that the algorithm is a lazy one: It repels jobs only if it is really necessary.

For $i\in\mathcal{M}$ let $S_{i}(P_{\leq k-1},\sigma)$ be those small jobs $j$ which have $\sigma(j)=i$ and which are repelled by all other potential machines, i.e., $\Gamma(j)\setminus\{i\}$, w.r.t. $P_{\leq k-1}$. The intuition behind $S_{i}(P_{\leq k-1},\sigma)$ is that we do not expect that $i$ can get rid of any of these jobs.

Next, define a threshold $W_{0}$ as the minimum $W\geq 0$ such that the small jobs in $S_{i_{k}}(P_{\leq k-1},\sigma)$ and all big jobs below this threshold are already too large to move $j_{k}$, i.e.,

[TABLE]

Furthermore, define $W_{0}=\infty$ if no such $W$ exists. In order to make $(j_{k},i_{k})$ valid, it is necessary (although not always sufficient) to remove one of the big jobs with size at most $W_{0}$. Hence, we define,

(big-all)

if $j_{k}$ is big and $W_{0}=\infty$, then let $i_{k}$ repel all jobs w.r.t $P_{\leq k}$ and

(big-big)

if $j_{k}$ is big and $W_{0}<\infty$, then let $i_{k}$ repel $S_{i_{k}}(L_{\leq k-1},\sigma)$ and all jobs $j$ with $1/2<p_{j}\leq W_{0}$.

Note that repelling $S_{i_{k}}(P_{\leq k-1},\sigma)$ seems unnecessary, since those jobs do not have any machine to go to. However, this definition simplifies the analysis. It is also notable that the special case where $W_{0}=0$ is equivalent to $p(S_{i_{k}}(L),\sigma)+p_{j_{k}}>11/6\cdot\tau$ and here the algorithm gives up making $(j_{k},i_{k})$ valid. Finally, we want to highlight the following counter-intuitive (but intentional) aspect of the algorithm. It might happen that some job of size greater than $W_{0}$ is moved to $i_{k}$, but has to be moved again later in order to make $(j_{k},i_{k})$ valid.

3.2 Analysis

Lemma 2**.**

If the configuration LP is feasible for $\tau$ and there is a bad machine, the algorithm always finds a move to execute.

Proof.

Suppose toward contradiction, there is a bad machine, no move in $P_{\leq\ell}$ is valid and no move can be added to $P_{\leq\ell}$. We will construct values $(z_{j})_{j\in\mathcal{J}}$, $(y_{i})_{i\in\mathcal{M}}$ with the properties as in Lemma 1 and thereby show that the configuration LP is infeasible. During this proof, $\sigma$ and $P_{\leq\ell}$ are constant and refer to the state at which the algorithm is stuck. We omit $P_{\leq\ell}$ when we say $i$ repels $j$.

Let $\tilde{\mathcal{J}}_{i}$ denote all jobs $j\in\sigma^{-1}(i)$ that are repelled by $i$. We write $\tilde{\mathcal{J}}=\bigcup_{i\in\mathcal{M}}\tilde{\mathcal{J}}_{i}$. For every $j\in\mathcal{J}$ let

[TABLE]

Let $y_{i}:=1$ if $i\in\mathcal{M}$ repels all jobs and $y_{i}=z(\sigma^{-1}(i))$ otherwise.

Let $i\in\mathcal{M}$ and $C\in\mathcal{C}(i,\tau)$. We need to show that $z(C)\leq y_{i}$. If $y_{i}=1$ this follows immediately, because $z(C)\leq p(C)/\tau\leq 1$. We assume w.l.o.g. that $i$ does not repel all jobs and thus $y_{i}=z(\sigma^{-1}(i))$. In particular, $i$ does not repel small jobs that are on other machines. This means that $z_{j}=0$ for every small job $j\in C\setminus\sigma^{-1}(j)$. Otherwise, $(j,i)$ could be added to $P_{\leq\ell}$. If there are no big jobs in $C$, we therefore get $z(C)\leq z(\sigma^{-1}(i))=y_{i}$. Clearly, there can be at most one big job $j_{B}\in C$, since such a job has $p_{j_{B}}>1/2\cdot\tau$ and $C$ cannot have a load greater than $\tau$. If $z_{j_{B}}=0$ or $\sigma(j_{B})=i$ the argument above still holds.

We recap: The only interesting case is when $y_{i}=z(\sigma^{-1}(i))$, there is exactly one big job $j_{B}\in C\setminus\sigma^{-1}(i)$, and $z_{j_{B}}=\min\{p_{j_{B}}/\tau,5/6\}$.

Case 1: $i$ repels $j_{B}$.

Since $i$ is not the target of a small job move and it is good (otherwise it would repel all jobs), there must be a big job move that causes $i$ to repel $j_{B}$. In other words, there is a move $(j_{k},i)=P_{k}$ such that $j_{B}\leq W_{0}$, where $W_{0}$ is as in the definition of repelled jobs for $P_{\leq k}$. Recall that $W_{0}<\infty$ is the minimal $W$ with

[TABLE]

Since $W_{0}\geq p_{j_{B}}$ and it is minimal, there must be a big job $j_{B}^{\prime}\in\sigma^{-1}(i)$ with $p_{j_{B}^{\prime}}=W_{0}\geq p_{j_{B}}$ and $j_{B}^{\prime}$ is also repelled by $i$ (because $p_{j^{\prime}_{B}}\leq W_{0}$). We get

[TABLE]

Case 2: $i$ does not repel $j_{B}$.

Since $(j_{B},i)$ cannot be added to $P$, it must already be in $P$. Let $P_{k}=(j_{B},i)$ and $W_{0}$ as in the definition of repelled edges w.r.t. $P_{\leq k}$. Then

[TABLE]

If $W_{0}\geq 5/6$, then there is some $j^{\prime}_{B}\in\sigma^{-1}(i)$ with $p_{j^{\prime}_{B}}=W_{0}\geq 5/6$. Similar to the previous case, it follows that

[TABLE]

If $W_{0}\leq 5/6$, then all of the considered jobs have $z_{j}=p_{j}/\tau$, i.e.,

[TABLE]

The last inequality holds, because the $z_{j_{B}}$ is at most $5/6$ and the volume of the small jobs in $C$ (in particular, their value) is at most $(\tau-p_{j_{B}})/\tau$.

It remains to show that $\sum_{j\in\mathcal{J}}z_{j}>\sum_{i\in\mathcal{M}}y_{i}$. We prove that, with amortization, good machines satisfy $z(\sigma^{-1}(i))\geq y_{i}$ and on bad machines strict inequality holds. Let $i$ be a bad machine. Then $i$ repels all jobs (in particular, those in $\sigma^{-1}(i)$). Hence,

[TABLE]

For good machines that do not repel all jobs, equality holds by definition. We will partition those good machines that do repel all jobs into those $i\in\mathcal{M}$ which have $(j_{S},i)\in P_{\leq\ell}$ for a small job $j_{S}$ and those that do not.

Lemma 3**.**

At least half of the machines $i$ that repel all jobs are target of a small job, i.e., $(j_{S},i)\in P_{\leq\ell}$ for some small job $j_{S}$.

We argue that whenever a move $(j_{B},i)=P_{k}$ of a big job $j_{B}$ is added, it is not valid, and $W_{0}=\infty$ in the definition of repelled jobs w.r.t. $P_{\leq k}$, then there is some small job move $(j_{S},i^{\prime})$ that can be added to $P$. Since the algorithm prefers small job moves over big ones, the next move after $P_{k}$ will necessarily be a small job move. Since no two small job moves can be added for the same target, the lemma follows. If $W_{0}=\infty$, this means that

[TABLE]

Since the move $(j_{B},i)$ is not valid, however, we also have that

[TABLE]

This implies that there must be a small job $j_{S}\in\sigma^{-1}(i)\setminus S_{i}(L_{\leq k-1}\sigma)$. In particular, there exists some $i^{\prime}\in\Gamma(j_{S})\setminus\{i\}$ by which $j_{S}$ is not repelled. It is also not repelled by $i^{\prime}$ w.r.t. $P_{\leq k}$, since $P_{k}$ only adds repelled jobs for $i$. Therefore, $(j_{S},i^{\prime})$ is a candidate for the next move to be added after $P_{\leq k}$. This concludes the proof for the lemma.

Let $i$ be a machine that repels all jobs, but is not target of a small job. Then there is a big job $j_{B}$ with $(j_{B},i)\in P_{\leq\ell}$ and this move is not valid. Either there is a job $j\in\sigma^{-1}(i)$ with $z_{j}=5/6$ or $z_{j}=p_{j}/\tau$ for all $j\in\sigma^{-1}(i)$. Thus,

[TABLE]

Next, let $i$ be a machine such that there exists a small job $j_{S}$ with $(j_{S},i)\in P_{\leq\ell}$. This move is also not valid. In the following, we distinguish between the cases where $\sigma^{-1}(i)$ has no job $j$ with $z_{j}=5/6$, one such job, or at least two. Note that all jobs have $p_{j}\leq\tau$.

[TABLE]

Because of Lemma 3, we can amortize and get

[TABLE]

Lemma 4**.**

The algorithm terminates.

Proof.

Consider two consecutive iterations of the main loop right before a move is executed and the list of moves $P$ is deleted. Let $\sigma$, $P_{\leq\ell}$ be the allocation and list of pending moves in the former iteration and $\sigma^{\prime}$, $P^{\prime}_{\leq\ell^{\prime}}$ in the latter. Let $b$ and $b^{\prime}$ be the number of bad machines in $\sigma$ and $\sigma^{\prime}$. Recall, $R(P_{\leq k},\sigma)\subseteq\mathcal{J}\times\mathcal{M}$ is the set of all $i,j$ where $j$ is repelled by $i$ w.r.t. $P_{\leq k}$. Further, let $\tilde{\mathcal{J}}(P_{\leq k},\sigma)$ denote all jobs $j$ that are repelled by $\sigma(j)$ w.r.t. $P_{\leq k}$. For each prefix of $P$ (and of $P^{\prime}$) we define a potential function

[TABLE]

We claim that the vector

[TABLE]

is lexicographically smaller than

[TABLE]

Note that the length of the vector is bounded by $5\cdot|\mathcal{M}|\cdot|\mathcal{J}|+3$, since no move appears twice in the list and every component can have at most $|\mathcal{J}|\cdot|\mathcal{M}|+1$ different values. Thus, the number of possible vectors is finite and hence the algorithm terminates.

Recall that the algorithm never turns a good machine bad, which means $b^{\prime}\leq b$. If $b^{\prime}<b$, we are done. Likewise, if $b=b^{\prime}$ and some job is moved from a bad machine to a good machine, then $|\tilde{\mathcal{J}}(P^{\prime}_{\leq 0},\sigma^{\prime})|<|\tilde{\mathcal{J}}(P_{\leq 0},\sigma)|$ and again the first vector is lexicographically smaller. We can therefore focus on the case $b^{\prime}=b$, $\tilde{\mathcal{J}}(P^{\prime}_{\leq 0},\sigma^{\prime})=\tilde{\mathcal{J}}(P_{\leq 0},\sigma)$, and $\sigma(j)=\sigma^{\prime}(j)$ for all $j\in\tilde{\mathcal{J}}(P_{\leq 0},\sigma)$. The rest of the argument is by induction. Let $k\leq\min\{\ell-1,\ell^{\prime}\}$ and assume that

$P^{\prime}_{\leq k-1}=P_{\leq k-1}$, 2. 2.

$R(P^{\prime}_{\leq k-1},\sigma^{\prime})=R(P_{\leq k-1},\sigma)$. 3. 3.

$\tilde{\mathcal{J}}(P^{\prime}_{\leq k-1},\sigma^{\prime})=\tilde{\mathcal{J}}(P_{\leq k-1},\sigma)$; $\sigma^{\prime}(j)=\sigma(j)$ for all $j\in\tilde{\mathcal{J}}(P_{\leq k-1},\sigma)$,

We will show that $\Phi(L^{\prime}_{\leq k})\leq\Phi(L_{\leq k})$ (lexicographically) and if equality holds, then (1), (2), and (3) also hold for $k$. This implies the lexicographical decrease: If $\ell^{\prime}<\ell$ it follows easily. This is because the prefix of the first vector ending in $\Phi(P^{\prime}_{\leq\ell^{\prime}})$ is lexicographically not bigger than the prefix of the second vector ending in $\Phi(P_{\leq\ell^{\prime}})$. Furthermore, the next component is $-1$ in the first vector, but something non-negative in the other. Now consider the case $\ell^{\prime}\geq\ell$. Let $(j_{\ell},i_{\ell})=P_{\ell}$ be the move that was executed. Then $\sigma^{\prime}(j_{\ell})=i_{\ell}\neq\sigma(j_{\ell})$. Furthermore, $j_{\ell}$ is repelled by $\sigma(j_{\ell})$ w.r.t. $L_{\leq\ell-1}$. Hence, (2) cannot hold with $k-1=\ell-1$ and thus we cannot have $\Phi(L^{\prime}_{\leq k})=\Phi(L_{\leq k})$ for all $k$.

The approach for the induction is to show that if $\Phi(L^{\prime}_{\leq k},\sigma^{\prime})$ is not smaller than $\Phi(L_{\leq k},\sigma)$, $(j_{k},i_{k})=P_{k}$ also has to be selected as $P^{\prime}_{k}$. In that case, no job can have been moved to $i_{k}$, if it is repelled by $i_{k}$ w.r.t. $L_{\leq k}$. From the way they are chosen, this implies the jobs which $i_{k}$ repels as a consequence of $P_{k}$ are also repelled in the rules for $P^{\prime}_{k}$. If they do not increase, the number of jobs $j$ with $\sigma(j)$ that are repelled by $i_{k}$ cannot increase. Let us now formalize this argument.

Notice that $(j_{\ell},i_{\ell})=P_{\ell}$ is the move that was executed, i.e., $\sigma^{\prime}(j_{\ell})=i_{\ell}$ and by construction of $P_{\leq\ell}$, $j_{\ell}$ is not repelled by $i_{\ell}$ w.r.t. $P_{\leq\ell-1}$ (in particular, not w.r.t. $P_{\leq k}$ $(*)$). Let $(j_{k},i_{k})=P_{k}$. By (1) we have that $(j_{k},i_{k})\notin P_{\leq k-1}=P^{\prime}_{\leq k-1}$. Since $j_{k}$ is repelled by $\sigma(j_{k})$ w.r.t. $L_{\leq k}$, by (2) we have that $\sigma^{\prime}(j_{k})=\sigma(j_{k})$. By (3) it is not repelled by $i_{k}$ w.r.t. $L^{\prime}_{\leq k-1}$. Therefore, $(j_{k},i_{k})$ is was a candidate for $P^{\prime}_{k}$. Either this or a move $(j,i)$, where $(p_{j},j,i)$ is lexicographically smaller than $(p_{j_{k}},j_{k},i_{k})$ is chosen. In the latter case we have $\Phi(L^{\prime}_{\leq k})<\Phi(L_{\leq k})$. Hence, assume that $P^{\prime}_{k}=(j_{k},i_{k})$. This means (1) holds for $k$. Note that since (2) and (3) hold for $k-1$, we only have to check the consequences of $P^{\prime}_{k}$ and $P_{k}$. In other words, we have to check whether the rules for move $P^{\prime}_{k}$ imply the same repelled jobs as $P_{k}$ and whether some job repelled due to this rule has been moved.

If $j_{k}$ is small, then $i_{k}$ repels all jobs w.r.t. $L^{\prime}_{\leq k}$ and $L_{\leq k}$ and therefore (3) also holds for $k$. Job $j_{\ell}$ cannot have been moved to $i_{k}$ (see $(*)$). If it was moved away from $i_{k}$, then $\tilde{\mathcal{J}}(P^{\prime}_{\leq k},\sigma^{\prime})\subsetneq\tilde{\mathcal{J}}(P_{\leq k-1},\sigma)$. Otherwise, equality holds and no job was moved in this set, i.e., (2) holds for $k$.

Now assume $j_{k}$ is big. First, we argue that $S^{\prime}_{i_{k}}(L^{\prime}_{\leq k-1},\sigma^{\prime})=S_{i_{k}}(L_{\leq k-1},\sigma)$. Recall, $S_{i_{k}}(L_{\leq k-1},\sigma)$ are the small jobs $j$ with $\sigma(j)=i_{k}$ and $j$ is repelled by all machines in $\Gamma(j)\setminus\{i_{k}\}$ w.r.t. $L_{\leq k}$. Let $j\in S^{\prime}_{i_{k}}(L^{\prime}_{\leq k-1},\sigma^{\prime})$. Assume toward contradiction that $\sigma(j)\neq i_{k}=\sigma^{\prime}(j)$. Then $j=j_{\ell}$ and $i_{k}=i_{\ell}$. However, $\sigma(j_{\ell})$ does not repel $j_{\ell}$ w.r.t. $P_{\leq k-1}$. Otherwise $(j_{\ell},i_{\ell})$ would have been chosen instead of $(j_{k},i_{k})$ as $P_{k}$. By (3) $\sigma(j_{\ell})$ also does not repel $j_{\ell}$ w.r.t. $P^{\prime}_{\leq k-1}$. Hence, $j\notin S^{\prime}_{i_{k}}(L^{\prime}_{\leq k-1},\sigma^{\prime})$, a contradiction. Consequently, $\sigma(j)=i_{k}$. By (3) it follows that $j\in S_{i_{k}}(L_{\leq k-1},\sigma)$. Let $j\in S_{i_{k}}(L_{\leq k-1},\sigma)$. Since it is repelled by all potential machines w.r.t. $P_{\leq k-1}$, there cannot be a move for $j$ in a later layer. In particular $j_{\ell}$ cannot be $j$. This means $\sigma^{\prime}(j)=\sigma(j)=i_{k}$ and by (3) $j\in S_{i_{k}}(L_{\leq k-1})$. We conclude that $S_{i_{k}}(L_{\leq k-1})=S^{\prime}_{i_{k}}(L^{\prime}_{\leq k-1})$. Let $W_{0}$ be the minimal the minimal $W\geq 0$ with

[TABLE]

or $\infty$ if no such $W$ exists. Since all jobs $j$ with $1/2<p_{j}\leq W_{0}$ are repelled by $i_{k}$ w.r.t. $P_{\leq k}$, it follows by $(*)$ that

[TABLE]

It follows that $W^{\prime}_{0}$, the minimal $W\geq 0$ with

[TABLE]

is at least as big as $W_{0}$. In particular, if $W_{0}=\infty$, then $i_{k}$ repels all jobs w.r.t. $P_{\leq k}$ and w.r.t. $P^{\prime}_{\leq k}$. Otherwise, by definition $i_{k}$ repels all jobs in $S_{i}(L_{\leq k-1},\sigma)$ and all jobs $j$ with $1/2<p_{j}\leq W_{0}$ w.r.t. $L_{\leq k}$. By $W^{\prime}_{0}\geq W_{0}$ these jobs are also repelled by $i_{k}$ w.r.t. $L^{\prime}_{\leq k}$. Hence $R(P^{\prime}_{\leq k},\sigma^{\prime})\supseteq R(P_{\leq k},\sigma)$. If equality holds then because of $(*)$, $\tilde{\mathcal{J}}(P^{\prime}_{\leq k},\sigma^{\prime})\supseteq\tilde{\mathcal{J}}(P_{\leq k},\sigma)$. If equality also holds here, then none of these jobs are moved and (1), (2), and (3) hold. If equality does not hold at some point, $\Phi(L^{\prime}_{\leq k-1},\sigma^{\prime})<\Phi(L_{\leq k-1},\sigma)$. ∎

Theorem 5**.**

The integrality gap of the configuration LP for Restricted Assignment is at most $11/6$.

4 Quasi-polynomial time algorithm

The previous running time bound is clearly exponential. In this section, we will improve the running time to $n^{O(1/\epsilon\cdot\log(n))}$ for an approximation rate of $11/6+2\epsilon$, where $n=|\mathcal{M}|+|\mathcal{J}|$ and $\epsilon>0$ can be chosen arbitrarily. Note that by scaling $\epsilon$, the coefficient of $2$ can be removed.

4.1 Algorithm

Our approach for turning the running time quasi-polynomial is to combine the two algorithms presented in the previous sections. Instead of adding only one candidate move at a time like in the exponential time algorithm, we add them all. The set of these moves is called a layer. After a layer is added, re-evaluate the repelled jobs and again construct a layer of all sensible moves.

This simple approach described has some major issues that we have to handle carefully using more sophisticated techniques as described in the following. First, however, we make some technical preparations. We will call a machine $i$ bad, if $p(\sigma^{-1}(i))>(11/6+2\epsilon)\tau$ and good, otherwise. As before, we call jobs $j$ small, if $p_{j}\leq 1/2\cdot\tau$ and big otherwise. Further, we distinguish big jobs into medium, which have $p_{j}\leq 5/6\cdot\tau$, and huge, which have $p_{j}>5/6\cdot\tau$. Unlike in the previous algorithms we establish the invariant that at all times the current allocation assigns at most one huge job to each machine. An initial allocation that satisfies this can easily be found via bipartite matching with the huge jobs on one side and the machines on the other. It is maintained by the following definition of a valid huge job move.

Definition 6** (Valid huge move).**

Let $j\in\mathcal{J},i\in\Gamma(j)\setminus\{\sigma(j)\}$ with $p_{j}>5/6\cdot\tau$. $(j,i)$ is a valid move, if $p(\sigma^{-1}(i))+p_{j}\leq(11/6+2\epsilon)\tau$ and there is no huge job in $\sigma^{-1}(i)$.

For the remaining jobs we define the moves as follows.

Definition 7** (Valid non-huge move).**

Let $j\in\mathcal{J},i\in\Gamma(j)\setminus\{\sigma(j)\}$ with $p_{j}\leq 5/6\cdot\tau$. $(j,i)$ is a valid move, if

$p(\sigma^{-1}(i))+p_{j}\leq(11/6+2\epsilon)\tau$* and $\sigma^{-1}(i)$ contains no huge job, or* 2. 2.

$p(\{j^{\prime}\in\sigma^{-1}(i):p_{j}\leq 5/6\cdot\tau\})+p_{j}\leq(5/6+2\epsilon)\tau$* and $\sigma^{-1}(i)$ contains one huge job.*

Each valid move $(j,i)$ satisfies $p(\sigma^{-1}(i))+p_{j}\leq(11/6+2\epsilon)\tau$, i.e., each good machine stays good. (2) needs further elaboration. One could falsely assume that this establishes an invariant which says the non-huge load is at most $(5/6+2\epsilon)\cdot\tau$ on a machine with a huge job. This would be a marvelous invariant, if it could be guaranteed. However, a valid huge move can break this property. Therefore, (2) only gives something weaker. It’s purpose is that when a machine has a huge job and a low non-huge load, then it will stay this way for as long as the huge job remains on the machine. This is to keep edges in the leap graph intact, a technique that will be elaborated later.

Layers

We will operate in layers $L_{1},\dotsc,L_{\ell}$ like in the first algorithm. These, however, will not only contain machines, but also fine grained moves like in the second algorithm. Again, we define a binary relation $R(L_{\leq k},\sigma)\subseteq\mathcal{J}\times\mathcal{M}$, which states that $i$ repels $j$ w.r.t. $L_{\leq k}$, if $(j,i)\in R(L_{\leq k},\sigma)$. In the previous algorithms, the local search is mostly stateless, i.e., it searches for an improvement of $\sigma$ without remembering anything from the past. Here we make a small exception. We maintain an order $\pi$ on $\mathcal{J}\times\mathcal{M}$. When the algorithm adds certain critical moves, they are moved to the front of $\pi$. This will hint at the algorithm to do the same in the next iteration. It helps to argue about the running time, since the layers created this way are more consistent throughout the iterations. Finally, layers come in different forms. They can be leap layers, critical layers, small layers, or non-critical layers. This will become more clear in the actual description of the algorithm.

Leaps

A straight-forward example shows that if we are using only simple moves like in the previous two algorithms, the number of layers needs to grow linearly. This would be a problem for obtaining a quasi-polynomial running time.

In the example (see Fig. 1) the leftmost machine has two jobs $j_{1},j^{\prime}_{1}$ of size $\tau$ assigned to it, which make the machine bad. The jobs each have a chain of machines connected to it: $j_{1}$ can go to a machine $i_{1}\in\Gamma(j_{1})$. On $i_{1}$ there is another job $j_{2}$ of size $\tau$ which can go to a machine $i_{2}\in\Gamma(j_{2})$, etc. At some point this chain ends with an empty machine. The same construction is made for $j^{\prime}_{1}$. In order to make the bad machine good, either the top chain of jobs or the bottom chain has to be traversed. Hence, it seems like the number of layers would be roughly half the jobs or machines. It turns out that this problem only occurs with huge jobs and we will carefully circumvent it.

The leap technique is intended for moving such a chain of huge jobs at once. For an easy description we construct a directed bipartite graph $G(\sigma)=(V,E(\sigma))$ where $V=B\cup\mathcal{M}$, i.e., the vertices are big jobs $B$ and the machines. There is an edge $(j_{B},i)\in E(\sigma)$ if $i\in\Gamma(j_{B})\setminus\{\sigma(j_{B})\}$ and

[TABLE]

i.e., if there is no huge job in $\sigma^{-1}(i)$ the move $(j_{B},i)$ is valid. Furthermore, we let $(i,j_{H})\in E(\sigma)$, if $j_{H}$ is huge and $i=\sigma(j_{H})$.

Suppose that there is some path $j_{1},i_{1},j_{2},i_{2},\dotsc,j_{k},i_{k}$ in $G$, where no huge job is assigned to $i_{k}$. Then we can move $j_{1}$ to $i_{1}$, $j_{2}$ from $i_{1}$ to $i_{2}$, $j_{3}$ from $i_{2}$ to $i_{3}$, etc. We will call this a leap.

The general theme for using this graph is the following. A big job $j_{B}$ is repelled by $\sigma(j_{B})$. Then all machines that are reachable by some path from $j_{B}$ should repel their huge jobs as well. When one of them is removed, we can instantly free $i$ from $j_{B}$. This way we are not going to put all moves of the path sequentially into the layers and avoid making it unnecessarily long.

Definition 8** (Valid leap).**

Let $j_{1},i_{1},\dotsc,j_{r},i_{r}$ be a path in the leap graph. It is called valid leap, if $(j_{r},i_{r})$ is a valid move.

By definition of the leap graph and the fact that every machine has at most one huge job, for a valid leap the following moves are all valid if executed in reverse order, i.e., $(j_{r},i_{r}),(j_{r-1},i_{r-1}),\dots,(j_{1},i_{1})$.

Finally, we define a graph $G(L_{\leq k},\sigma)$ which has all edges from $G(\sigma)$ of the form $(i,j_{H})$, but only the edges $(j_{B},i)$ where $i$ does not repel $j_{B}$ w.r.t. $L_{\leq k}$. The definition of repelled edges will be given later.

Description of the algorithm

We are now ready to state the algorithm (see Alg. 5). It starts with an allocation $\sigma$ with the property that each machine has at most one huge job assigned to it. The allocation of huge jobs can be found using bipartite matching and the remaining jobs are assigned arbitrarily. We initialize $\pi$ as an arbitrary permutation of $\mathcal{J}\times\mathcal{M}$. Until all machines are good the algorithm searches for valid moves or leaps that improve $\sigma$. For this purpose we build layers. The layers are alternating between leap layers, critical layers, small layers, and non-critical layers: Layer $L_{4k+1}$ is always a leap layer; $L_{4k+2}$ is a critical layer; $L_{4k+3}$ is a small layer; $L_{4k+3}$ is a non-critical layer. A leap-layer $L_{\ell+1}$ consists of the machines that are reachable in the leap graph $G(L_{\leq\ell},\sigma)$ by a job that is repelled by its current machine w.r.t. $L_{\leq\ell}$. For the critical layer $L_{\ell+2}$ and non-critical layer $L_{\ell+4}$, we select all $(j_{B},i)$ where $j_{B}$ is a big job repelled by $\sigma(j_{B})$, but not by $i$ w.r.t. $L_{\leq\ell+1}$. A subset of these is taken in $L_{\ell+2}$. We will define below precisely how they are chosen, but they depend on $\pi$ giving priority to the moves in the front. After they are selected, the critical moves are pushed to the front of $\pi$. All moves $(j_{S},i)$, where $j_{S}$ is repelled by $\sigma(j_{S})$, but not by $i$ w.r.t. $L_{\leq\ell+2}$ are put in $L_{\ell+3}$. Finally, the previously considered big job moves $(j_{B},i)$ which were not taken in $L_{\ell+2}$ and where $i$ still does not repel $j_{B}$ (now w.r.t. $L_{\leq\ell+3}$) are taken in the non-critical layer $L_{\ell+4}$. If at any point a valid leap or move is found, it is executed and the structure of layers is reset. Note that the meaning of the continue statement in the pseudo-code is to jump to the next iteration of the while loop.

Repelled jobs

We define the repelled jobs of each machine inductively w.r.t. $L_{\leq k}$, $k=0,1,\dotsc,\ell$.

(initialization)

Let the bad machine repel every job w.r.t. $L_{\leq 0}$.

(monotonicity)

If $i$ repels $j$ w.r.t. $L_{\leq k}$, then let $i$ repel $j$ also w.r.t. $L_{\leq k+1}$.

The remaining rules regard $k>0$ and we define repelled jobs for a layer $L_{k}$. A layer $L_{k}$ may be a leap layer, a critical layer, a small layer, or a non-critical layer. In the first case, $L_{k}$ contains a set of machines reachable in the leap graph. We define:

(leap)

If $L_{k}$ is a leap layer, let every machine $i$ in $L_{k}$ repel all big jobs that are adjacent to $i$ in the leap graph $G(\sigma)$—that is, all huge jobs in $\sigma^{-1}(i)$ and all big jobs $j_{B}$ with $i\in\Gamma(j_{B})$ and

[TABLE]

(critical)

If $L_{k}$ is a critical layer, for every move $(j,i)$ in $L_{k}$ let $i$ repel all jobs.

(small)

If $L_{k}$ is a small layer, for every move $(j,i)$ in $L_{k}$ let $i$ repel all jobs.

Now assume that $L_{k}$ is a non-critical-layer and consider a move $(j,i)$ in $L_{k}$. In the non-critical case the algorithm is lazy: It repels jobs only if it is really necessary. We first identify a set of small jobs that is unlikely to be moved. For $i\in\mathcal{M}$ define $S_{i}(L_{\leq k-1},\sigma)$ to be the small jobs $j\in\sigma^{-1}(i)$ which are repelled by all machines in $\Gamma(j)\setminus\{i\}$.

Next, define a threshold $W_{0}$ as the minimum $W\geq 0$ such that the small jobs in $S_{i}(L_{\leq k-1},\sigma)$ and all big jobs below this threshold are already too large to add $j$, i.e.,

[TABLE]

It will follow from the selection of critical moves that such a $W_{0}$ always exists and, moreover, $W_{0}\leq 5/6$. When none of the jobs in $S_{i}(L_{\leq k-1},\sigma)$ can be removed, it is necessary (although not always sufficient) to remove one of the big jobs with size at most $W_{0}$ in order to make $(j,i)$ valid. Hence, we define,

(non-critical)

if $L_{k}$ is a non-critical layer then for every move $(j,i)$ let $i$ repel all jobs $j$ with $1/2<p_{j}\leq W_{0}$ (where $W_{0}$ is defined as above) and all jobs in $S_{i}(L_{\leq k-1},\sigma)$.

It is notable that the corner case where $W_{0}=0$ is equivalent to

[TABLE]

and here the algorithm gives up making $(j,i)$ valid. In particular, no additional big jobs will be repelled.

Finally, we want to highlight the following counter-intuitive (but intentional) aspect of the algorithm. It might happen that some job of size greater than $W_{0}$ is moved to $i$, only to be removed again in a later iteration, when $W_{0}$ has increased.

Critical move selection

Suppose we are given some layers $L_{\leq\ell+1}$ and big job moves $(j,i)\in L^{B}_{\mathrm{new}}$ where $j$ is repelled by $\sigma(j)$ w.r.t. $L_{\leq\ell+1}$, but not by $i$. Which of these moves should be critical? Recall that for critical moves $(j,i)$ the target machine $i$ always repels all jobs. As in the exponential time algorithm, we later need to amortize these moves with small job moves. Hence, we should select critical moves in a way that they produce many small job moves.

In the following let $\overline{\mathcal{M}}$ denote the set of machines that repel all jobs w.r.t. $L_{\leq\ell+1}$. As a prime example of a situation we want to avoid, consider the following: There are a lot of critical moves $(j,i)$ where $p_{j}=1$, but on $i$ there is a load of small jobs with volume slightly above $(11/6+2\epsilon)\tau-p_{j}=(5/6+2\epsilon)\tau\ll\tau$ . Moreover, these small jobs $j_{S}$ cannot go anywhere (meaning later layers will not have moves for them), because all their potential machines are in $\overline{\mathcal{M}}$, i.e., $\Gamma(j_{S})\setminus\{i\}\subseteq\overline{\mathcal{M}}$. Hence, there will not be any machines to amortize this low load. We should consider small jobs like this as blocked volume and when there is too much blocked volume on $i$, a move $(j,i)$ should not be critical. However, it is not enough to consider small jobs that have nowhere to go. It might also be that a lot of small jobs have only very few machines to go to. In the example above, imagine that all the small jobs share only one machine $i^{\prime}\notin\overline{\mathcal{M}}$ to which they could go (see Fig. 2). Then the average load is still very low. This is also something we want to avoid. So how do we avoid these situations? We will make sure that for non-valid critical moves $(j,i)$ where $j$ is big, $i$ has one or more private machine $i^{\prime}\in\overline{\mathcal{M}}$, which are reachable by some of its small jobs. We select the critical edges sequentially (see Alg. 6). For the already added critical moves $(j,i)$, we consider all machines reachable by a small job on $i$ can go to as blocked as well, i.e., we add them to $\overline{\mathcal{M}}$. We add $(j,i)$ to the critical moves only when the blocked small jobs (as described above) and the medium jobs on $i$ have a volume that allows $j$ to be added to $i$, if there were no other jobs.

4.2 Analysis

Lemma 9**.**

If the configuration LP is feasible for $\tau$ and there remains a bad machine, then within the first $\ell\leq 4\lceil\log_{1+\epsilon}(4|\mathcal{M}|)\rceil$ layers there will be a valid leap or move.

Proof.

Suppose toward contradiction, there are bad machines, no move in $L_{\leq\ell}$ is valid, and $\ell=4\lceil\log_{1+\epsilon}(4|\mathcal{M}|)\rceil$. We will construct values $(z_{j})_{j\in\mathcal{J}}$, $(y_{i})_{i\in\mathcal{M}}$ with the properties as in Lemma 1 and thereby show that the configuration LP is infeasible. Throughout the proof the allocation $\sigma$ refers to the allocation in the iteration where no move or leap is found.

First, we define values $z^{(k)}_{j},y^{(k)}_{i}$ for all prefixes of the layers ending in a leap layer, i.e., for each $L_{\leq 4k+1}$ with $0\leq k<\ell/4$. Furthermore, for technical reasons we define the values $z^{(-1)}_{j},y^{(-1)}_{i}$ as well as $y^{(\ell/4)}_{i}$. Then $z_{j}$, $y_{i}$ will be set as a positive linear combination of these values.

Let $\tilde{\mathcal{J}}(L_{\leq 4k+1})$ denote all jobs $j$ that are repelled by $\sigma(j)$ w.r.t. $L_{\leq 4k+1}$. For every $0\leq k<\ell/4$ and $j\in\mathcal{J}$ let

[TABLE]

Moreover, let $y^{(k)}_{i}:=1+\epsilon$, if $i$ repels all jobs w.r.t. $L_{\leq 4k+1}$ and $y^{(k)}_{i}:=z^{(k)}(\sigma^{-1}(i))$, otherwise. Finally, define the corner cases $y^{(-1)}_{i}=0$, $z^{(-1)}_{j}=0$, and $y^{(\ell/4)}_{i}:=1+\epsilon$ for all $i,j$.

Notice that $z^{(-1)}_{j}\leq z^{(0)}_{j}\leq\cdots\leq z^{(\ell/4)}_{j}$ for all $j$ (and the same holds for all $y^{(k)}_{i}$). We set

[TABLE]

The coefficients decrease exponentially with the layer number. As we will see, this makes to the last values negligibly small (as in the first algorithm). Finally, set $z_{j}=z^{(\leq\ell/4-1)}_{j}$ and $y_{i}=y^{(\leq\ell/4)}_{i}$.

Claim 10**.**

Let $-1\leq k<\ell/4$, $i\in\mathcal{M}$ and $C\in\mathcal{C}(i,\tau)$. Then

[TABLE]

In particular, this implies $z(C)=z^{(\leq\ell/4-1)}\leq y^{(\leq\ell/4)}_{i}=y_{i}$ for all $i,C$.

Claim 11**.**

[TABLE]

Together the claims imply $\tau<\mathrm{OPT}^{*}$, a contradiction. ∎

Before we prove the claims, we will state the following auxiliary lemmata.

Lemma 12**.**

In an iteration where no valid move or leap is found consider the set $L^{B}_{\mathrm{new}}$ selected in the algorithm after a leap layer $L_{\ell+1}$ is created and let $(j_{B},i)\in L^{B}_{\mathrm{new}}$. Then

[TABLE]

Proof.

Suppose toward contradiction that this does not hold. Then $(j_{B},i)$ is in the leap graph $G(\sigma)$. It is also in $G(L_{\leq\ell},\sigma)$, since $i$ does not repel $j_{B}$ w.r.t. $L_{\leq\ell+1}$. Otherwise, $(j_{B},i)$ would not be in $L^{B}_{\mathrm{new}}$. Obviously $i$ is reachable by $j_{B}$ in $G(L_{\leq\ell},\sigma)$. We argue that $i$ is reachable by some big job repelled by its current machine w.r.t. $L_{\leq\ell}$. This implies that $i$ repels $j_{B}$ w.r.t. $L_{\leq\ell+1}$ by definition of repelled edges for a leap layer. This is a contradiction, since $(j_{B},i)$ could not be in $L^{B}_{\mathrm{new}}$ then. We know that $\sigma(j_{B})$ repels $j_{B}$ w.r.t. $L_{\leq\ell+1}$. If it repels $j_{B}$ already w.r.t. $L_{\leq\ell}$, this follows trivially. Otherwise, $j_{B}$ is repelled by $i$ because of the (leap) rule in the definition of repelled edges for $L_{\ell+1}$. This can only be when $i\in L_{\ell+1}$, which means it is reachable by some big job repelled by its machine w.r.t. $L_{\leq\ell}$. ∎

Lemma 13**.**

In an iteration where no valid move or leap is found consider the set $L^{B}_{\mathrm{new}}$ selected in the algorithm after a leap layer $L_{\ell+1}$ is created and let $(j_{B},i)\in L^{B}_{\mathrm{new}}$. Then

[TABLE]

This lemma implies that the threshold $W_{0}$ chosen in the definition of repelled edges always exists and $W_{0}\leq 5/6$.

Proof.

When $(j_{B},i)$ is a critical moves in $L_{\ell+2}$ or when $(j_{S},i)\in L_{\ell+3}$ for some small job $j_{S}$, this is follows easily from the previous lemma, since $S_{i}(L_{\leq\ell+3},\sigma)$ contains all small jobs in $\sigma^{-1}(i)$. Each other move $(j_{B},i)$ would have been selected as a critical move, if this inequality did not hold: Consider the set $\overline{\mathcal{M}}$ in the selection of critical moves at the time $(j_{B},i)$ is considered. The algorithm adds $(j_{B},i)$ to the critical moves, if $i\notin\overline{\mathcal{M}}$ and

[TABLE]

where $S^{\prime}_{i}(\overline{\mathcal{M}},\sigma)$ is the set of small jobs $j_{S}\in\sigma^{-1}(i)$ with $\Gamma(j_{S})\setminus\{i\}\subseteq\overline{\mathcal{M}}$. Recall that all machines in $\overline{\mathcal{M}}$ either repel all jobs w.r.t. $L_{\leq\ell+1}$ or they are reachable by a small job on a machine that is target of a critical move. The latter kind must repel all jobs w.r.t. $L_{\leq\ell+3}$, because it is target of a small job move in $L_{\ell+3}$. Thus, $S^{\prime}_{i}(\overline{\mathcal{M}},\sigma)\subseteq S_{i}(L_{\leq\ell+3},\sigma)$ and (1) is satisfied. Furthermore, $i\notin\overline{\mathcal{M}}$, since $i$ does not repel all jobs w.r.t. $L_{\leq\ell+1}$ and we assumed that there is no small job $j_{S}$ with $(j_{S},i)\in L_{\ell+3}$. Thus, $(j_{B},i)$ would have been selected as a critical move. ∎

Proof of Claim 10.

We argue inductively. The basis of the induction is trivial, since $z^{(\leq-1)}(C)=0\leq y^{(\leq 0)}_{i}$. Suppose that $k\geq 0$ and for all $k^{\prime}<k$,

[TABLE]

If $y^{(k+1)}_{i}\geq 1+\epsilon$ then immediately

[TABLE]

We can therefore assume w.l.o.g. that $y^{(k+1)}_{i}=z^{(k+1)}(\sigma^{-1}(i))$. Thus, $k<\ell/4$ and $i$ does not repel all jobs w.r.t. $L_{\leq 4(k+1)+1}$. Since by definition of repelled jobs, a machine that repels any small job from another machine always repels all jobs, we know that $i$ does not repel small jobs that are on other machines w.r.t. $L_{\leq 4(k+1)+1}$. Hence, for all small jobs $j_{S}\in C\setminus\sigma^{-1}(i)$ it holds that $z^{(k)}_{j_{S}}=0$: If this was not true, $\sigma(j_{S})$ would repel $j_{S}$ w.r.t. $L_{4k+1}$, in which case $(j_{S},i)$ would have been added to $L_{4k+3}$ and $i$ would repel all jobs, which is not true.

Consider the cases of big jobs in $C$. If there is none, then obviously every jobs in $C\setminus\sigma^{-1}(i)$ is small. Let $k^{\prime}\leq k$. Then for all $j\in C\setminus\sigma^{-1}(i)$ it holds that $z^{(k^{\prime})}_{j}\leq z^{(k)}_{j}=0$. Consequently, $z^{(k^{\prime})}(C)\leq z^{(k^{\prime})}(\sigma^{-1}(i))=y^{(k^{\prime})}_{i}$. Hence,

[TABLE]

Clearly, there can be at most one big job $j_{B}\in C$, since such a job has $p_{j_{B}}>1/2\cdot\tau$ and $C$ cannot have a volume greater than $\tau$. If $z^{(k)}_{j_{B}}=0$ or $j_{B}\in\sigma^{-1}(i)$, the argument above still works.

We recap: The crucial case is when $y^{(k+1)}_{i}=z^{(k+1)}(\sigma^{-1}(i))$, there is exactly one big job $j_{B}\in C\setminus\sigma^{-1}(i)$, and $z^{(k)}_{j_{B}}=\min\{p_{j_{B}}/\tau,5/6\}$. Let $k^{\prime}\leq k$ be minimal with $z^{(k^{\prime})}_{j_{B}}=\min\{p_{j_{B}}/\tau,5/6\}$. In particular, $z^{(-1)}_{j_{B}}=z^{(0)}_{j_{B}}=\cdots=z^{(k^{\prime}-1)}_{j_{B}}=0$.

Case 1: $i$ repels $j_{B}$ w.r.t. $L_{\leq 4k^{\prime}+1}$.

This can either be because of a leap layer or a move layer in $L_{\leq 4k^{\prime}+1}$. In the former case, there has to be a huge job in $j_{H}\in\sigma^{-1}(i)$ which $i$ repels w.r.t. $L_{\leq 4k^{\prime}+1}$. Otherwise, there would be a valid path. Thus, for all $k^{\prime\prime}\geq k^{\prime}$ it holds that $z^{(k^{\prime\prime})}_{j_{H}}=5/6\geq z^{(k^{\prime\prime})}_{j_{B}}$ and

[TABLE]

Furthermore, for all $k^{\prime\prime}<k^{\prime}$,

[TABLE]

Hence, $z^{(\leq k)}(C)\leq y^{(\leq k)}_{i}\leq y^{(\leq k+1)}_{i}$.

Now consider the case in which there is some move $(j_{k^{\prime}},i)$ which causes $i$ to repel $j_{B}$ is w.r.t. $L_{\leq 4k^{\prime}+1}$. The move $(j_{k^{\prime}},i)$ must be in a non-critical layer $L_{4k^{\prime\prime}+4}$, where $k^{\prime\prime}<k^{\prime}$, since $i$ does not repel all jobs w.r.t. $L_{\leq 4k^{\prime}+1}$. Let $W_{0}$ as in the definition of repelled jobs in consequence of $(j_{k^{\prime}},i)$ and let

[TABLE]

The edges repelled by $i$ because of $(j_{k^{\prime}},i)$ are exactly $S_{i}(L_{\leq 4k^{\prime\prime}+3},\sigma)$ and all those $j$ with $1/2<p_{j}\leq W_{0}$. Hence, $p_{j_{B}}\leq W_{0}$. Recall that $W_{0}$ is chosen minimal with $p(R)+p_{j_{k^{\prime}}}>(11/6+2\epsilon)\tau$. There must be a job $j^{\prime}_{B}\in\sigma^{-1}(i)$ with $p_{j^{\prime}_{B}}=W_{0}$, since otherwise $W_{0}$ would not be minimal. Thus, for all $k^{\prime\prime\prime}$ it holds that $z^{(k^{\prime\prime\prime})}_{j^{\prime}_{B}}\geq z^{(k^{\prime\prime\prime})}_{j_{B}}$ and

[TABLE]

It follows conveniently that $z^{(\leq k)}(C)\leq y^{(\leq k)}_{i}\leq y^{(\leq k+1)}_{i}$.

Case 2: $i$ does not repel $j_{B}$ w.r.t. $L_{\leq 4k^{\prime}+1}$

Since $z^{(k^{\prime})}_{j_{B}}>0$, $j_{B}$ is repelled by $\sigma(j_{B})$ w.r.t. $L_{\leq 4k^{\prime}+1}$. Machine $i$ does not repel all jobs w.r.t. $L_{\leq 4k^{\prime}+1}$, which implies there is no move with target $i$ in $L_{4k^{\prime}+2}$ or $L_{4k^{\prime}+3}$. Hence, $(j_{B},i)$ must be a move in layer $L_{4k^{\prime}+4}$. Let

[TABLE]

where $W_{0}$ is as in the definition of repelled jobs in consequence of $(j_{B},i)$. Then

[TABLE]

Furthermore, all jobs in $R$ are repelled by $i$ w.r.t. $L_{\leq 4k^{\prime}+4}$ and therefore in $\tilde{\mathcal{J}}(L_{\leq 4(k^{\prime}+1)+1})$. Since for all $j^{\prime}\in R$ it holds that $p_{j^{\prime}}\leq W_{0}\leq 5/6$ (see Lemma 13), it follows that $z^{(k^{\prime\prime}+1)}_{j^{\prime}}=p_{j^{\prime}}/\tau$ for all $k^{\prime\prime}\geq k^{\prime}$. Thus,

[TABLE]

Here we use that $i$ is a good machine and therefore $p(R)\leq p(\sigma^{-1}(i))\leq(11/6+2\epsilon)\tau<2\tau$. We conclude,

[TABLE]

Proof of Claim 11.

Let $i$ be a bad machine. Then $i$ repels all jobs (in particular those in $\sigma^{-1}(i)$) w.r.t. $L_{\leq 0}$. Hence, for every $0\leq k<\ell/4$ and $j\in\sigma^{-1}(i)$, $z^{(k)}_{j}=\min\{5/6,p_{j}/\tau\}\geq 5/6\cdot p_{j}/\tau$ Thus,

[TABLE]

This implies

[TABLE]

In the last inequation, we use the last two elements of the sum $\sum_{k=0}^{\ell/4-1}(1+\epsilon)^{-k}$ to compensate for $(1+\epsilon)^{-(\ell/4-1)}$. The inequation shows that $y_{i}$ is much smaller than $z(\sigma^{-1}(i))$. If for all good machines $i$ and layers $k$ we had $y^{(k)}_{i}=z^{(k)}(\sigma^{-1}(i))$ (which is the case when $i$ does not repel all jobs w.r.t. $L_{\leq k}$), the proof would be easy: $\sum_{j\in\mathcal{J}}z^{(\leq\ell/4-1)}_{j}=\sum_{i\in\mathcal{M}}z^{(\leq\ell/4-1)}(\sigma^{-1}(i))$ would be larger than $1/2+\sum_{i\in\mathcal{M}}y^{(\leq\ell/4-1)}_{i}$. The former is exactly $\sum_{j\in\mathcal{J}}z_{j}$ and the latter is

[TABLE]

Here we use that the decrease in the coefficient makes $y^{(\ell/4)}_{i}$ neglectable, which we will explain in detail as we go through the actual proof.

Of course, there can be machines that repel all jobs and are set to $y^{(k)}_{i}=1+\epsilon$. We have to make sure that they do not have a negative effect. Let $B_{k}$ be the machines $i$ with $(j_{B},i)$ in the $k$-th critical layer for some $j_{B}$, i.e., in $L_{4k+1}$. Let $A_{k}$ be the machines $i$ with $(j_{S},i)$ in the $k$-th small layer for some $j_{S}$, i.e., in $L_{4k+3}$.

Let $k<\ell/4$ and $i\in B_{k}$. $i$ repels all jobs w.r.t. $L_{\leq 4(k+1)+1}$. Thus, $\sigma^{-1}(i)\subseteq\tilde{\mathcal{J}}(L_{\leq 4(k+1)+1})$. Let $(j_{B},i)$ as above. This move is not valid. Either there is a job $j\in\sigma^{-1}(i)$ with $z^{(k+1)}_{j}=5/6$ or $z^{(k+1)}_{j}=p_{j}/\tau$ for all $j\in\sigma^{-1}(i)$. Thus,

[TABLE]

Next, let $i\in A_{k}$. Then there is a move $(j_{S},i)\in L_{\leq 4k+1}$ with $j_{S}$ small. Of course, this move is not valid either. In the following, we distinguish between the cases where $\sigma^{-1}(i)$ has no huge job or one huge job.

[TABLE]

The bounds above show that machines in $A_{k}$ have $z^{(k+1)}(\sigma^{-1}(i))$ above $y^{(k+1)}_{i}$ and machines in $B_{k}$ below. In order to amortize the machines, we have to proof a bounded ratio between them: We argue that for every $k<\ell/4$, $|A_{k}|\geq|B_{k}|$. Notice that $B_{k}\dot{\cup}A_{k}$ are exactly the machines that are added to $\overline{\mathcal{M}}$ in the selection of critical moves for $L_{4k+2}$. Hence, it suffices to show that at most half of them are target of critical big job moves. Consider a critical move $(j_{B},i)$ for a big job $j_{B}$ that is added in the critical move selection. By Lemma 12

[TABLE]

Because the move $(j_{B},i)$ is selected as a critical move, it holds that

[TABLE]

where $S^{\prime}_{i}(\overline{\mathcal{M}},\sigma)$ are the small jobs $j_{S}\in\sigma^{-1}(i)$ with $\Gamma(j_{S})\setminus\{i\}\subseteq\overline{\mathcal{M}}$ with $\overline{\mathcal{M}}$ as at the time before $(j_{B},i)$ is selected. Consequently, there is a small job $j_{S}\in\sigma^{-1}(i)\setminus S^{\prime}_{i}(\overline{\mathcal{M}},\sigma)$. It follows that there exists a machine $i^{\prime}\in\Gamma(j_{S})\setminus(\overline{\mathcal{M}}\cup\{i\})$. The algorithm adds $i$ and $i^{\prime}$ to $\overline{\mathcal{M}}$. In other words, whenever the algorithm adds a machine $i$ to $B_{k}$, it adds at least one machine $i^{\prime}$ to $A_{k}$. It follows that

[TABLE]

In the last inequality we use that by choice of $\ell$, $(1+\epsilon)^{\ell/4}\leq 4|\mathcal{M}|$, which implies

[TABLE]

Lemma 14**.**

The algorithm terminates in time $n^{O(1/\epsilon\log(n))}$, where $n=|\mathcal{J}|+|\mathcal{M}|$.

Proof.

We are looking at the states of two consecutive iterations right before a move or leap is performed. Let $\sigma$ be the schedule in the former iteration and $\sigma^{\prime}$ in the latter. Likewise, define layers $L_{\leq\ell}$ and $L^{\prime}_{\leq\ell^{\prime}}$ right before they collapse. Let $\tilde{\mathcal{J}}(L_{\leq k},\sigma)$ be the jobs $j$ repelled by $\sigma(j)$ w.r.t. $L_{\leq k}$. Recall, $R(L_{\leq k},\sigma)$ is the set of all $(j,i)\in\mathcal{J}\times\mathcal{M}$ where $i$ repels $j$ w.r.t. $L_{\leq k}$.

We define a potential function $\Phi$ for each of the layers. Set

[TABLE]

Claim 15**.**

The vector

[TABLE]

is lexicographically bigger than

[TABLE]

Since the number of layers is at most $O(1/\epsilon\log(n))$ and components can have only $O(n^{3})$ different values, the number of vectors is is bounded by $n^{O(1/\epsilon\log(n))}$. Since for every move or leap it decreases lexicographically, the lemma follows easily from the claim. ∎

Proof of Claim 15.

If the number of good machines increases, the claim follows immediately. If it does not, but a job is moved from a bad machine to a good one, then $\tilde{\mathcal{J}}^{\prime}(L^{\prime}_{\leq 0},\sigma^{\prime})\subsetneq\tilde{\mathcal{J}}(L_{\leq 0},\sigma)$, i.e., the claim follows again. Hence, assume neither case is true. Let $1\leq k\leq\min\{\ell-1,\ell^{\prime}\}$ and:

$L_{\leq k-1}=L^{\prime}_{\leq k-1}$; 2. 2.

$\tilde{\mathcal{J}}(L_{\leq k-1})=\tilde{\mathcal{J}}^{\prime}(L^{\prime}_{\leq k-1})$ and $\sigma(j)=\sigma^{\prime}(j)$ for all $j\in\tilde{\mathcal{J}}(L_{\leq k-1})$; 3. 3.

$R(L^{\prime}_{\leq k-1},\sigma^{\prime})=R(L_{\leq k},\sigma)$.

We will prove: $\Phi(L^{\prime}_{\leq k})\geq\Phi(L_{\leq k})$ and if equality holds, (1), (2) and (3) also hold for $k$. This implies the claim by induction: If $\ell^{\prime}<\ell$, then the prefix of the first vector ending in $\Phi(L^{\prime}_{\leq\ell^{\prime}},\sigma)$ is lexicographically not smaller than the prefix of the second one ending in $\Phi(L_{\leq\ell^{\prime}},\sigma)$. Furthermore, the next component in the first vector is $\infty$, whereas it is something finite in the second. If $\ell^{\prime}\geq\ell$, then we notice that (2) cannot hold for $k-1=\ell-1$. This is because some leap or move in $L_{\ell}$ was executed and therefore a job $j$ that is repelled by $\sigma(j)$ w.r.t. $L_{\leq\ell-1}$ was moved.

Case 1: $L_{k}$ is a leap layer.

We argue that every machine $i$ reachable in the leap graph $G(L_{\leq k-1},\sigma)$ by a job big job $j_{0}$ repelled by $\sigma(j_{0})$ w.r.t. $L_{\leq k-1}$ is also reachable by $j_{0}$ in the leap graph $G(L^{\prime}_{\leq k-1},\sigma^{\prime})$. Because of (2), this means that the set of reachable machines in $\sigma$ by any such job, which is exactly $L_{k}$, is a subset of $L^{\prime}_{k}$. It suffices to show that every edge reachable by $j_{0}$ in $G(L_{\leq k-1},\sigma)$ is also in the leap graph $G(L^{\prime}_{\leq k-1},\sigma^{\prime})$. Because of (3) it suffices to show that it is in $G(\sigma^{\prime})$. An edge in the leap graph can be one of two kinds. It can be from a machine to a huge job, i.e., $(i,j_{H})$, which exists because $\sigma(j_{H})=i$. We argue that $j_{H}$ was not not moved, which means $\sigma^{\prime}(j_{H})=\sigma(j_{H})=i$ and therefore the edge is also in $G(\sigma^{\prime})$. Suppose toward contradiction that a move $(j_{H},i^{\prime})$ was executed. Then there is no huge job in $\sigma^{-1}(i^{\prime})$ and $p(\sigma^{-1}(i^{\prime}))+p_{j_{H}}\leq(11/6+2\epsilon)\cdot\tau$. Therefore $i^{\prime}$ would also be reachable by $j_{0}$ in $G(\sigma)$. Hence, the algorithm would execute a leap in $L_{k}$, which it did not, since $\ell>k$. Similarly, if $j_{H}$ was moved as part of a leap, then all machines in this leap would be reachable already in $L_{k}$ and there would have been a valid leap already.

Now consider an edge of the form $(j_{B},i)$. If $i$ had no huge job in $\sigma^{-1}(i)$, then again, there would have been a valid leap in $L_{k}$, which cannot be. The edge $(j_{B},i)$ exists in the leap graph of $\sigma$ because $i\in\Gamma(j_{B})\setminus\{\sigma(j_{B})\}$ and

[TABLE]

It could only be removed, if $j_{B}$ was moved to $i$—this cannot be the case for the same reason as above—or some job $j^{\prime}$ with $p_{j^{\prime}}\leq 5/6$ is moved to $i$. By definition of a valid non-huge move, however, this means that

[TABLE]

Therefore, $(j_{B},i)$ is also in $G(\sigma^{\prime})$. We conclude, all reachable machines in $L_{k}$ are also in $L^{\prime}_{k}$, i.e., $L^{\prime}_{k}\supseteq L_{k}$. By the arguments above, every job adjacent to a machine in $L_{k}$ in $G(L_{\leq k-1},\sigma)$ is also adjacent to this machine in $L^{\prime}_{k}$ in $G(L^{\prime}_{\leq k-1},\sigma^{\prime})$. Thus, $R(L^{\prime}_{\leq k},\sigma^{\prime})\supseteq R(L_{\leq k},\sigma)$. If equality does not hold, then $\Phi(L^{\prime}_{\leq k},\sigma^{\prime})>\Phi(L_{\leq k},\sigma)$. Otherwise, (3) holds for $k$. (1) must also hold for $k$, because $L^{\prime}_{k}\supsetneq L_{k}$ was true, then the additional machine would repel at least one additional job (its huge job). Finally, (2) holds, because no huge job on a reachable machine was moved as elaborated above.

Case 2: $L_{k}$ is a critical layer.

We show that every critical move in $L_{k}$ is also in $L^{\prime}_{k}$. By induction hypothesis, we know that the moves $(j,i)$, $i\in\Gamma(j)$, where $j$ is a big job repelled by $\sigma(j)=\sigma^{\prime}(j)$, but not by $i$, w.r.t. $L_{\leq k-1}$ and w.r.t. $L^{\prime}_{\leq k-1}$ are the same. Therefore, the sets $L^{B}_{\mathrm{new}}$ from which the critical moves are selected are the same in both cases. Recall that critical moves are added greedily in the order of $\pi^{\prime}$ ($\pi$). In $\pi^{\prime}$ the moves $L^{B}_{\mathrm{new}}$ are ordered in a way that first the moves from $L_{k}$ appear (in the order of $\pi$) and then all others. This is because in the main algorithm when $L_{k}$ was created, all $(j,i)\in L_{k}$ were moved to the front of $\pi$. We just have to understand that none of $L^{B}_{\mathrm{new}}\setminus L_{k}$ were moved to the front at a later time. This is because there is no way that a move, which is not selected as critical, can be selected in a later layer.

Let $(j_{1},i_{1}),\dotsc,(j_{r-1},i_{r-1})$ be the first $r-1$ critical moves selected in $L_{k}$. Furthermore, let $\overline{\mathcal{M}}_{r-1}$ and $\overline{\mathcal{M}}_{r-1}^{\prime}$ be as in the algorithm before the $r$-th critical move was added. Note that before the first critical move was added, by (3) it holds that $\overline{\mathcal{M}}^{\prime}_{0}=\overline{\mathcal{M}}_{0}$, since these are the machines that repel all jobs w.r.t. $L_{\leq k-1}$. We assume for induction that $\overline{\mathcal{M}}^{\prime}_{r-1}\subseteq\overline{\mathcal{M}}_{r-1}$ and that $(j_{1},i_{1}),\dotsc,(j_{r-1},i_{r-1})$ were also added to $L^{\prime}_{k}$. Because no move or leap in $L_{\leq k-1}$ was executed and $i_{r}$ repels all jobs w.r.t. $L_{\leq k}$, we know that $\sigma^{\prime-1}(i_{r})\subseteq\sigma^{-1}(i_{r})$. In particular, every medium job in $\sigma^{\prime-1}(i_{r})$ was already in $\sigma^{-1}(i_{r})$. Moreover, every small job $j_{S}\in\sigma^{\prime-1}(i_{r})$ with $\Gamma(j_{S})\setminus\{i_{r}\}\subseteq\overline{\mathcal{M}}^{\prime}_{r-1}\subseteq\overline{\mathcal{M}}_{r-1}$ was also in $\sigma^{-1}(i_{r})$ . Hence, the condition for adding $(j_{r},i_{r})$ to $L^{\prime}_{k}$ holds, since it did for $L_{k}$. Finally, $\overline{\mathcal{M}}^{\prime}_{r}$ is the union of $\overline{\mathcal{M}}^{\prime}_{r-1}$, $\{i\}$, and $\Gamma(j_{S})$ for every small $j_{S}\in\sigma^{\prime-1}(i_{r})$. This is a subset of $\overline{\mathcal{M}}_{r-1}$, $\{i\}$, and $\Gamma(j_{S})$ for every small $j_{S}\in\sigma^{-1}(i_{r})\subseteq\sigma^{\prime-1}(i_{r})$, which is $\overline{\mathcal{M}}_{r}$.

If $L^{\prime}_{k}\supsetneq L_{k}$, nothing has to be shown, since $\Phi(L^{\prime}_{\leq k})>\Phi(L_{\leq k})$. Otherwise, $L^{\prime}_{k}=L_{k}$ and therefore (3) follows for $k$ directly. If some job was moved away from a machine of a critical move, then again $\Phi(L^{\prime}_{\leq k})>\Phi(L_{\leq k})$. Otherwise, (2) follows for $k$.

Case 3: $L_{k}$ is a small layer.

As in the previous case, we have that $L_{k}=L^{\prime}_{k}$, i.e., (1) holds also for $k$. (3) also holds for $k$, since in the rules of a small layer, every target of a move repels every job. This is the same in $L^{\prime}_{\leq k}$ and $L_{\leq k}$. If some job was moved away from a target machine of a move in $L_{k}$, then $\tilde{\mathcal{J}}(L^{\prime}_{\leq k})\subsetneq\tilde{\mathcal{J}}(L_{\leq k})$ and therefore $\Phi(L^{\prime}_{\leq k})>\Phi(L_{\leq k})$. Otherwise, (2) follows for $k$ as well.

Case 4: $L_{k}$ is a non-critical-layer.

By the arguments in Case 2 we know that the previous critical moves and the moves they are chosen from are the same and therefore also for the non-critical moves $L^{\prime}_{k}=L_{k}$. Let $(j,i)\in L_{k}$. We argue that

[TABLE]

Let $j_{S}\in S_{i}(L_{\leq k-1},\sigma)$. Then there cannot be a move $(j_{S},i^{\prime})$ in some higher layer than $L_{k-1}$. This is because $j_{S}$ is repelled by all $i^{\prime}\in\Gamma(j_{S})\setminus\{\sigma(j_{S})\}$ w.r.t. $L_{k-1}$. Hence, $\sigma^{\prime}(j_{S})=\sigma(j_{S})=i$. With (3) it follows that $j_{S}\in S_{i}(L^{\prime}_{\leq k-1},\sigma^{\prime})$. Now let $j_{S}\in S_{i}(L^{\prime}_{\leq k-1},\sigma^{\prime})$. If $\sigma(j_{S})=\sigma^{\prime}(j_{S})=i$, then as above with (3) it follows that $j_{S}\in S_{i}(L_{\leq k-1},\sigma)$. Now assume toward contradiction $\sigma(j_{S})\neq i$. By (2), $j_{S}$ is not repelled by $\sigma(j_{S})$ w.r.t. $L_{\leq k-1}$; By (3) this means that $j_{S}$ is also not repelled by $\sigma(j_{S})\neq i$ w.r.t. $L^{\prime}_{\leq k-1}$. Hence, $j_{S}\notin S_{i}(L^{\prime}_{\leq k-1},\sigma^{\prime})$, a contradiction. Let $W_{0}$ be the minimal $W\geq 0$ such that

[TABLE]

Since $i$ repels all jobs $j^{\prime}$ with $1/2<p_{j^{\prime}}\leq W$ w.r.t. $L_{\leq k}$, we get

[TABLE]

This implies that $W^{\prime}_{0}$, the minimal $W\geq 0$ with

[TABLE]

is at least as big as $W_{0}$, i.e., $W^{\prime}_{0}\geq W_{0}$. This means all jobs repelled by $i$ w.r.t. $L_{\leq k}$ are also repelled w.r.t. $L^{\prime}_{\leq k}$, which implies $R(L^{\prime}_{\leq k},\sigma^{\prime})\supseteq R(L_{\leq k},\sigma)$. If equality does not hold, then $\Phi(L^{\prime}_{\leq k},\sigma^{\prime})>\Phi(L_{\leq k},\sigma)$. Otherwise (3) is fulfilled for $k$. If one of the jobs repelled by $i$ is moved, then $\tilde{\mathcal{J}}(L^{\prime}_{\leq k-1})\subsetneq\tilde{\mathcal{J}}(L_{\leq k-1})$. Otherwise, equality holds and (2) follows for $k$.

∎

Theorem 16**.**

We can find a $(11/6+\epsilon)$-approximate solution for Restricted Assignment in time $n^{O(1/\epsilon\log(n))}$ for every $\epsilon>0$, where $n=|\mathcal{J}|+|\mathcal{M}|$.