Symmetry exploitation for Online Machine Covering with Bounded Migration

Online models that allow recourse are highly effective in situations where classical models are too pessimistic. One such problem is the online machine covering problem on identical machines. In this setting jobs arrive one by one and must be assigned to machines with the objective of maximizing the minimum machine load. When a job arrives, we are allowed to reassign some jobs as long as their total size is (at most) proportional to the processing time of the arriving job. The proportionality constant is called the migration factor of the algorithm. Using a new rounding procedure specially tailored for online problems, we design a $(4/3+\varepsilon)$-competitive algorithm using migration factor $\tilde{O}(1/\varepsilon^3)$. At every arrival we run an adaptation of the Largest Processing Time first (LPT) algorithm. Since the new job can cause a complete change of the assignment of smaller jobs, a low migration factor is achieved by carefully exploiting the highly symmetric structure obtained by our rounding. We also study local search algorithms for the machine covering problem, and show that jump and swap optimality have an approximation ratio which lies in the interval $[1.691, 1.75]$ and can be adapted to the online context with a small constant as migration factor. Our lower bound is obtained by a nice construction based on Sylvester's sequence.


Introduction
We consider a fundamental load balancing problem where n jobs need to be assigned to m identical parallel machines. Each job j is fully characterized by its non-negative processing time p j . Given an assignment of jobs, the load of a machine is the sum of the processing times of jobs assigned to it. The machine covering problem asks for an assignment of jobs to machines maximizing the load of the least loaded machine.
This problem is well known to be strongly NP-hard and allows for a polynomial-time approximation scheme (PTAS) [21]. A well studied algorithm for this problem is the Largest Processing Time First rule (LPT), that sorts the jobs non-increasingly and assigns them iteratively to the least loaded machine. Deuermeyer et al. [6] show that LPT is a 4 3 -approximation and that this factor is asymptotically tight; later Csirik et al. [5] refine the analysis giving a tight bound for each m.
In the online setting jobs arrive one after another, and at the moment of an arrival we must decide on a machine to assign the arriving job. This natural problem does not admit a constant competitive ratio. Deterministically, the best possible competitive ratio is m [21], while randomization allows for aÕ( √ m)-competitive algorithm, which is the best possible up to logarithmic factors [1].
Dynamic model. The previous negative facts motivate the study of a relaxed online scenario with bounded migration. Unlike the classic online model, when a new job j arrives we are allowed to reassign other jobs. More precisely, given a constant β > 0, we can migrate jobs whose total size is upper bounded by βp j . The value β is called the migration factor and it accounts for the robustness of the algorithm. In one extreme, we can model the usual online framework by setting β = 0. In the other extreme, setting β = ∞ allows to compute the optimal offline solution in each iteration. Our main interest is to understand the exact trade-off between the migration factor β and the competitiveness of our algorithms. Besides being a natural problem with an interesting theoretical motivation, its original purpose was to find good algorithms for a problem in the context of Storage Area Networks (SAN) [18].
Local search and migration. The local search method has been extensively used to tackle different hard combinatorial problems. Local search algorithms and online algorithms where recourse is allowed are closely related. This comes from the fact that simple local search neighborhoods allow to get considerably improved solutions while having accurate control over the recourse actions needed, and in some cases even a bounded number of local moves leads to substantially improved solutions (see [10,13,15] for examples in network design problems).
Related Work. Sanders et al. [18] develop online algorithms for load balancing problems in the migration framework. For the makespan minimization objective, where the aim is to minimize the maximum load, they give a (1 + ε)-competitive algorithm with migration factor 2Õ (1/ε) . A mayor open problem in this area is to determine whether a migration factor of poly(1/ε) is achievable. The landscape for the machine covering problem is somewhat different. Sanders et al. [18] give a 2-competitive algorithm with migration factor 1, this is until now the best competitive ratio known for any algorithm with constant migration factor. On the negative side, Skutella and Verschae [20] show that it is not possible to maintain arbitrarily near optimal solutions using constant migration factor, giving a lower bound of 20/19 for the best competitive ratio achievable in that case. The lower bound is based on an instance where arriving jobs are very small, which do not allow to migrate any other job. This motivated the study of an amortized version, called reassignment cost model, and develop a (1 + ε)-competitive algorithm using constant reassignment factor. They also show that if all arriving jobs are larger that ε · OPT, then there is a (1 + ε)-competitive algorithm with constant migration factor. Similar migration models have been studied for other packing and covering problems. For example Epstein & Levin [7] design a (1 + ε)-competitive algorithm for online bin packing using 2Õ (1/ε 2 ) migration factor , which was improved later by Jansen & Klein [11] to poly(1/ε) migration factor, and then further refined by Berndt et al. [3]. Also, for makespan minimization with  preemption and other objectives, Epstein & Levin [8] design a best-possible online algorithm using migration factor 1 − 1 m . Regarding local search applied to load balancing problems, many neighborhoods have been studied such as jump, swap, push and lexicographical jump in the context of makespan minimization on related machines [19], makespan minimization on restricted related machines [16], and also multiexchange neighborhoods for makespan minimization on identical parallel machines [9]. To the best of our knowledge, this is the first time that local search algorithms are analyzed for the machine covering problem.
Our Contribution. Our main result is a (4/3 + ε)-competitive algorithm using poly(1/ε) migration factor. This is achieved by running a carefully crafted version of LPT at the arrival of each new job. We would like to stress that, even though LPT is a simple and very well studied algorithm in the offline context, solutions can change dramatically in the online context; see Figure 1 and Lemma 28 in Appendix A.
To overcome this barrier, we first adapt a less standard rounding procedure to the online framework. The rounding is such that jobs larger than Ω(εOPT) (where OPT is the offline optimum value) take onlyÕ(1/ε) many job sizes, and all values are multiples of a common number g ∈ Θ(ε 2 OPT). This implies that the number of possible loads for machines having only big jobs is constant. Unlike known techniques that yield similar results (see e.g. [12]), our rounding is well suited for online algorithms and helps simplifying the analysis as it does not depend on OPT (which varies through iterations).
The properties obtained by rounding are crucial to create symmetries: While assigning a job to a current least loaded machine, since there is a constant number of possible machine loads, there will usually be multiple least loaded machines to assign the job. All options lead to different solutions in terms of job assignments, but they all achieve the same objective value. Broadly speaking, the algorithm will construct one of these equivalent schedules, trying to maintain as many machines with assignments equivalent to the original solution as possible. The analysis of the algorithm will rely on monotonicity properties implied by LPT which, coupled with rounding, implies that for every job size the increase in the number of machines with different assignments (w.r.t the solution of the previous iteration) is constant, finally yielding a migration factor that only grows polynomially on 1/ε. In addition, we give a slightly improved lower bound of 17/16 for the best competitive ratio achievable using constant migration.
In the second part of the paper we analyze the local search neighborhoods jump and swap. We show that for the machine covering problem they give an approximation guarantee r lying in the interval [1.691, 1.75]. The family of instances leading to the lower bound is constructed using Sylvester's sequence and exploiting its properties. Moreover, using the rounding procedure for the online setting, the local search procedures can be adapted to the online setting. Compared to our online version of LPT, this yields a slightly worse competitive factor of (r + ε) but gets a improved migration factor of O(1/ε).
Consider a set of n jobs J and a set of m machines M. In our problem, a solution or schedule S : J → M corresponds to an assignment of jobs to machines. The set of jobs assigned to a machine i is then S −1 (i) ⊆ J. The load of machine i in S corresponds to ℓ i (S) = j∈S −1 (i) p j . The minimum load is denoted by ℓ min (S) = min i∈M ℓ i (S), and a machine i is said to be least loaded in S if ℓ i (S) = ℓ min (S).
For an algorithm A and set of jobs J we denote by S A (J , M) the schedule returned by A on instance (J , M). Similarly, S OPT (J , M) denotes the optimal schedule, being OPT(J , M) its minimum load. When it is clear from the context we will drop the dependency on J or M.

Algorithms with robust structure.
An important fact used in the design of the robust PTAS for makespan minimization from Sanders et al. [18] is that small jobs can be assigned greedily almost without affecting the approximation guarantee. This is however not the case for machine covering; see, e.g. [20] or Lemma 19. One way to avoid this inconvenience is to develop algorithms that are oblivious to the arrival of small jobs, that is, algorithms where the assignment of big jobs is not affected when a new small job arrives. Definition 1. Let h ∈ R + . An algorithm A has robust structure at level h if, for any instance (J , M) and j * / ∈ J such that p j * ≤ h, S A (J , M) and S A (J ∪{j * }, M) assign to the same machines all the jobs in J with processing time at least h.
This definition highlights also the usefulness of working with the LPT rule, since the addition of a new small job to the instance does not affect the assignment of larger jobs. Indeed, it is easy to see the following.
Remark. For any h ∈ R + , LPT has robust structure at level h.
The next definition will help show that algorithms with robust structure at level h, for small enough h, allow us to focus mainly on maintaining the structure of the big jobs.
Definition 2. Let A be an α-approximation algorithm for the machine covering problem, with α constant, k ∈ N constant, and ε > 0. Given a machine covering instance (J , M), a schedule S is a k-relaxed version of S A if: 1. jobs with processing time at least kεOPT are assigned exactly as in S A , and 2. for every machine i ∈ M such that S assigns at least one job of size less than kεOPT, ℓ i (S) ≤ ℓ min (S) + kεOPT.
Lemma 3. Let A be an α-approximation, α ≥ 1 constant, k ∈ N constant, 0 < ε < 1 2kα and (J , M) a machine covering instance. If A has robust structure at level kεOPT, then every k-relaxed version of S A is an (α + O(ε))-approximate solution.
Proof. Suppose by contradiction that there exists a k-relaxed version of S A , say S, which is not (α + 2kα 2 ε)-approximate. This implies that ℓ min (S) < 1 α+2kα 2 ε OPT ≤ 1 α − kε OPT. Let M s the set of machines where S assigns at least one job of size less than kεOPT. Notice that M s = ∅, because otherwise ℓ min (S A ) = ℓ min (S) < 1 α − kε OPT, which contradicts that S A is α-approximate. Since A has robust structure at level kεOPT, S and S A differ only on the machines from M s , and the total processing time of jobs assigned by S to M s is at most |M s |(ℓ min (S) + kεOPT). Thus, which contradicts that S A is α-approximate.
Assume that we have developed an algorithm A with robust structure to some convenient level h, such that the migration of jobs larger than h is upper bounded properly. Dealing with jobs smaller than h becomes simpler since, as we will see, a simple greedy algorithm helps to assign small jobs, creating a k-relaxed version of S A .

Rounding, LPT and symmetry exploitation
In this section we show first how to create symmetries via rounding the job sizes and how to exploit this to obtain bounded migration factors.
Rounding. Let us consider 0 < ε < 1 such that 1/ε ∈ Z. We introduce a new rounding technique that is specially designed for our online algorithm. For any job j, let e j ∈ Z be such that 2 e j ≤ p j < 2 e j +1 . We then round down p j to the previous number of the form 2 e j + kε2 e j for k ∈ N, that is, we definep j := 2 e j + p j −2 e j ε2 e j ε2 e j . Observe that p j ≥p j ≥ p j − ε2 e j ≥ (1 − ε)p j . Hence, an α-approximation algorithm for a rounded instance is immediately an (α/(1 − ε))-approximation for the original instance. From now on we work exclusively with the rounded processing times.
Consider an upper bound UB on OPT such that OPT ≤ UB ≤ 2OPT. This can be computed with any 2-approximation to the problem, in particular from LPT. Consider the index set We classify jobs as small ifp j < 2 ℓ , big ifp j ∈ [2 ℓ , 2 u+1 ), and huge otherwise. Notice that small jobs have size at most 2εUB and huge jobs have size at least UB. As we will see, our main difficulty will be given by big jobs; small and huge jobs are easy to handle. Notice that in every solution S constructed using LPT, without considering small jobs, huge jobs are assigned to a machine on their own and every machine without huge jobs has load at most 2UB (either it has a big job alone, of size at most 2UB, or it has load at most ℓ min (S) +p j ≤ 2ℓ min (S) ≤ 2UB, where j is the smallest job in the machine). Let the set of all (rounded) processing times that a big job may take. The next lemma highlights the main properties of our rounding procedure. Proof. From the definition ofP , we have that |P | = 1 ε (u − ℓ − 1) − 1. Since ℓ ≥ log (εUB) and u ≤ log(UB), then (u − ℓ − 1) ≤ log 1 ε . Altogether, |P | ∈ O((1/ε) log(1/ε)). Also, if j is a big or huge job, thenp j = 2 i + kε2 i for some i ≥ ℓ and k ∈ {0, . . . , 1 ε − 1}. We conclude by noticing that Unlike other standard techniques [12], the rounded sizes do not depend on OPT (or UB). This avoids possible migrations provoked by new rounded values, greatly simplifying our techniques.
Load Monotonicity. The algorithm described in the present section is an approximate online adaptation of LPT using poly(1/ε) migration factor. In order to analyze it we will first show some structural properties of the solutions constructed by LPT and how it behaves when the instance is perturbed by a new job. Unless stated otherwise, for the rest of this section machine loads are considered with respect to the rounded processing timesp j .
Definition 5. Given a schedule S, its load profile, denoted by load(S), is an R m ≥0 -vector (t 1 , . . . , t m ) containing the load of each machine sorted so that t 1 ≤ t 2 ≤ . . . ≤ t m . .
The following lemma shows that after the arrival of a job, the load profile of solutions constructed using LPT can only increase. We remark that this property only holds if the vector of loads is sorted, as it can be observed in Figure 1. This monotonicity will be crucial later for our analysis. To show the mentioned property, the following rather technical lemma will help. Lemma 6. Let x, y ∈ R n + , x = (x 1 , x 2 , . . . , x n ), y = (y 1 , y 2 , . . . , y n ) such that x 1 ≤ x 2 ≤ · · · ≤ x n , y 1 ≤ y 2 ≤ · · · ≤ y n and x ≤ y coordinate-wise, and α, β ∈ R such that α ≤ β. If we consider the new vectors defined by replacing x i by x i + α in x and y i by y i + β in y for some i ∈ {1, 2, . . . , n}, and then we sort the coordinates non-decreasingly of the new vectors, obtaining x ′ and y ′ , then x ′ ≤ y ′ coordinate-wise.
Proof. Letī be the coordinate such that x ′ i = x i + α andj such that y ′ j = y i + β. For each coordinate k < min{ī,j} or k > max{ī,j} we have that x ′ k = x k and y ′ k = y k , thus satisfying the desired inequality by hypothesis. In the remaining we have two cases: • Assume thatī <j, and let k ∈ {ī,ī + 1, . . . ,j − 1}. Then we have that where the first inequality holds due to the monotonicity of the vectors and the second one because of the hypothesis. Similarly, for k =j we have that where the first inequality follows from the hypothesis.
• Assume thatī ≥j and let k ∈ {j,j + 1, . . . ,ī}. Then, where, the first and third inequalities follows from the monotonicity of the vectors, and the second one from the fact that x i + α ≤ y i + β.
Lemma 7. Let (J , M) be a machine covering instance and j * / ∈ J a job. Then, it holds that load(S LPT (J , M)) ≤ load(S LPT (J ′ , M)), where the inequality is considered coordinate-wise and Proof. Let us first relabel the jobs in J so thatp 1 ≥p 2 ≥ . . . ≥p n . To simplify the argument we assume that both runs of LPT assign jobs in the order given by the labeling above 1, 2, . . . , n, where in the run for J ′ the new job j * is inserted to the list in any position consistent with LPT. This is without loss of generality since different tie breaking do not affect the load profiles of the solutions.
Consider the set of instances (J | k , M) for k = r, . . . , n, where J | k ⊆ J is the set of the k largest jobs in J , and r is the maximal index such thatp r ≤p j * . Similarly, let J ′ | k = J | k ∪{j * } for any k ∈ {r, . . . , n}. We will show by induction that the lemma is true for each pair (J | k , M) and (J ′ | k , M). The base case k = r follows easily from Lemma 6 since S LPT (J | k , M) and S LPT (J ′ | k \ {j * }, M) assign to the same machines all jobs {1, . . . , r}, and adding j * to the least loaded machine in S LPT (J ′ | k \ {j * }, M) (and a job of size 0 to the least loaded machine in S LPT (J | k , M)) is the same as addingp j * to the first coordinate of load(S LPT (J ′ | k \ {j * }, M)), and then the inequality holds.
Showing that the inequality is true for k + 1 is equivalent to show that when assigning job k + 1 to a least loaded machine in S LPT (J | k , M) and in S LPT (J ′ | k , M), the resulting load profiles satisfy the inequality, which is precisely the statement of Lemma 6 addingp k+1 to the first coordinate of load(S LPT (J | k , M)) and also to the first coordinate of load(S LPT (J ′ | k , M)).
This lemma together with our rounding procedure allow us to show that the difference (in terms of the Hamming distance) of the load profiles of two consecutive solutions consisting purely of big jobs, is bounded by a small constant.
we obtain that the number of coordinates in which the load profiles differ is at mostp j * ε2 ℓ . Finally, recalling that j * is big, thenp j * ≤ 2 u ≤ UB ≤ 2 ℓ /ε, and we can bound the number of different coordinates bỹ Description of Online LPT. Consider two instances (J , M) and (J ′ , M) such that J ′ = J ∪ {j * }, and let OPT and OPT ′ be their optimal values, respectively. We say that an assignment is an LPT-solution if there is some tie-breaking rule such that LPT yields such assignment. We will compute an upper bound UB on OPT ′ by computing an LPT-solution and duplicating the value of its minimum load. For this upper bound we compute its respective setP with (1) and (2). In the algorithm we will label elements inP = {q 1 , . . . , q |P | } such that Similarly, we define J 0 (resp. J ′ 0 ) to be the set of jobs in J (resp. J ′ ) of sizes larger than q 1 , that is, all huge jobs in J (resp. J ′ ). Also, let S h (resp. S ′ h ) be the solution S (resp. S ′ ) restricted to jobs of size q h or larger. Finally, S 0 and S ′ 0 are the respective solutions restricted to jobs in J 0 . In the description of the algorithm we use the concept of a list-scheduling algorithm, that refers to assigning jobs iteratively (in any order) to some machine of minimum load. In what follows, x + denotes the positive part of x ∈ R, i.e., x + = max{x, 0}.
To understand the algorithm, it is useful to have the following observation in mind.
Observation 9. Consider a solution S for jobs in J and let K be a set of jobs with J ∩ K = ∅ and all jobs in K have the same size p. Consider a solution S LS constructed by adding the jobs from K in S using list-scheduling, and let λ = ℓ min (S LS ). Notice that λ is independent of the tie-breaking rule used in list-scheduling. Consider any solution S ′ that is constructed starting from S and adding jobs in K in some arbitrary way. Then S ′ corresponds to a solution obtained by adding jobs from K with a list-scheduling procedure (for some tie-breaking rule) if and only if the number of jobs in K added to each machine i is: Our main procedure is called every time that we get a new job j * (where J ′ = J ∪ {j * }) and receives as input the current solution S for (J , M). If J = ∅ then S is trivially initialized as empty. Broadly speaking, it works in phases h ∈ {0, . . . , |P |}, where for each h it assigns jobs in J ′ h . First, we assign jobs exactly as in S h for machines in which the assignment of S h−1 and S ′ h−1 coincide. As we will see, this is consistent with LPT by the previous observation and Lemma 7. The remaining jobs in J ′ h are assigned using list-scheduling. Crucially, we will break ties in favor of machines where the assignment of S h−1 and S ′ h−1 differ. This is necessary to avoid creating new machines with different assignments. After assigning huge and big jobs, small jobs are added exactly as in S in machines where the assignment of big jobs in S and S ′ coincides. The rest of small jobs are added greedily. In the last part, the algorithm rebalances small jobs by moving them from machines of load higher than ℓ i (S ′ ) + 2 ℓ to the least loaded machines. The exact description is given in Algorithm 1.
During the analysis we will consider the run of the algorithm for solution S. For such run we will call UB 0 the corresponding upper bound andP 0 the set of big job sizes as defined by (1) and (2). Similarly we will denote by ℓ 0 and u 0 the smallest and largest values in I(UB 0 ), as defined in (1). First we prove the following auxiliary lemma.
Lemma 10. If S ′ is the output of the algorithm then S ′ |P | is an LPT-solution.
Proof. We show the proof inductively. Consider a run of the algorithm with input assignment S. If S is empty then it is clearly an LPT-solution. Otherwise, S is the output of a run of the algorithm. We can assume inductively that S |P 0 | is an LPT-solution (and thus also any restriction of S |P 0 | to for jobs in J ′ h still not assigned in S ′ , apply list-scheduling (with an arbitrary order of jobs). If there is more than one least loaded machine break ties in favor of machines in M = h−1 .
assign all small jobs w.r.t to UB in J ∩ S −1 (i) to i in S ′ . 10: end for 11: assign the remaining jobs using list-scheduling. 12: set M to be the set of machines containing a small job w.r.t UB.
consider a machine i ∈ M of maximum load. Reassign the smallest job in S ′−1 (i) to any least loaded machine. 15: update M to be the set of machines containing a small job w.r.t UB. 16: end while 17: return S ′ .
We use a second induction to show that, for every h ∈ {0, . . . , |P |}, S ′ h is an LPT-solution . To show the base case (h = 0), consider jobs in J ′ 0 , which are all larger than UB ≥ OPT ′ . Hence there are at most m of them, and the algorithm assigns them each to a different machine (this, again, follows inductively). Thus, the base case holds.
Consider h ≥ 1 and let us assume that S ′ h−1 is an LPT-solution. Let S LPT,h be an LPT-solution for jobs in J 0 ∪ . . . ∪ J h , and similarly S ′ LPT,h for jobs in J ′ 0 ∪ . . . ∪ J ′ h . First observe that the load profile vector load(S ′ LPT,h ) is independent of the tie-breaking rule. Consider the target value λ = ℓ min (S LPT,h ) and h are added using listscheduling. By Observation 9 the following characterizes this fact: for all machines i ∈ M , the number of jobs assigned in S ′ h to i is: and S h is an LPT-solution, then the number of jobs assigned in Step 4 is never ) + /q h is not an integer, and never more than This implies that after adding jobs in Step 5 we obtain an LPT-solution.
Now we can argue about the approximation guarantee of the obtained solution.
Proof. We will use the previous lemma to show that S ′ is a k-relaxed version of S LPT (J ′ , M) for some k ≤ 4, which is enough to conclude the lemma due to Lemma 3. Indeed, let k = 2 ℓ /(εOPT ′ ). Then, by the previous lemma all jobs larger than kεOPT ′ = 2 ℓ are assigned with LPT. Also, the while loop at Step 13 ensures that the output of the algorithm is a k-relaxed version of S LPT (J ′ , M). The lemma follows since k = 2 ℓ /(εOPT ′ ) ≤ 2εUB/(εOPT ′ ) ≤ 4.
Bounding the migration factor. To analyze the migration factor of the algorithm, we will show that |M = |P | | is upper bounded by a constant. This will be done inductively by first bounding |M = h \ M = h−1 | for each h and then using the fact that |P | ∈ O((1/ε) log(1/ε)). To understand the overall idea of the proof consider Figure 2. Let us consider huge jobs w.r.t UB (i.e. jobs in J ′ 0 ). Notice that all these jobs are larger than OPT ′ ≥ OPT, and hence in S ′ 0 each one is assigned alone to one machine. The same situation happens in solution S restricted to jobs in J 0 . Thus, none of these jobs are migrated. Hence, we can assume w.l.o.g. for the sake of the analysis of the migration that all jobs are big or small w.r.t UB (including j * ). Additionally, we can assume that j * is not small, since otherwise there is no migration. As Proof. We consider two cases. If λ ′ = λ, then the number of jobs in J h assigned to machine i is at least is fractional then the number of jobs must be many jobs. However, if this is the case the tie-breaking rule in Step 5 implies that J = h = ∅, which contradicts our hypothesis. Then the number of assigned jobs is exactly h−1 )) + q h + 1, and thus the claim holds.
If λ ′ > λ, then λ ′ > ℓ i (S ′ h−1 ) and the number of jobs in J h assigned to machine i is at least h−1 )) + q h + 1 and hence the claim holds.
Lemma 13. Let x, y ∈ R n + , x = (x 1 , x 2 , . . . , x n ), y = (y 1 , y 2 , . . . , y n ) such that x 1 ≤ x 2 ≤ · · · ≤ x n , y 1 ≤ y 2 ≤ · · · ≤ y n and x ≤ y coordinate-wise. Assume that x j = y i for some indices i, j. If x −i denotes the (n − 1)-dimensional vector obtained by removing the i-th entry of x, and y −j is the vector obtained by removing the j-th entry of y, then x −i ≤ y −j .
Proof. Notice first that if i = j then the result is a direct consequence of Lemma 6: by taking α = β = −x i and coordinate i, we get new vectorsx andỹ satisfyingx ≤ỹ andx 1 =ỹ 1 = 0, and hence we can conclude that x −i ≤ y −j because x −i (resp y −j ) corresponds to the last n − 1 coordinates ofx (resp.ỹ).
We now distinguish two cases: if i < j, we have that y j = x i ≤ x j ≤ y j , hence x k = y j for every k = i, i + 1, . . . , j. This implies that x −i = x −(i+1) = · · · = x −j , and then we can conclude that x −i ≤ y −j by applying the previous observation for x −j and y −j . On the other hand, if j < i, we define vector z equal to y but replacing coordinates j, j + 1, . . . , i by y j . It is not difficult to see that x ≤ z ≤ y coordinate-wise, and also z −j = z −(j+1) = · · · = z −i . If we apply the first observation for x and z using coordinate i we have that x −i ≤ z −i , and applying it to z and y using coordinate j we get that z −j ≤ y −j . Merging both inequalities and using the fact that z −i = z −j , we conclude that x −i ≤ y −j .

Lemma 14. It holds that |J
Let us consider sets Lemma 12 implies that the total number of jobs from J ′ h assigned by S ′ h to machines in Notice that the set T − ∪ T + contains all indices i ∈ M = h−1 such that ℓ σ(i) (S h−1 ) ≤ λ. Hence, the first sum in the last expression upper bounds the number of jobs in J h that solution S assigns to

Let us now consider
Thus, the last expression is at most Also, Lemma 8 can be applied and thus |T = | ≤p j * ε2 ℓ . The lemma finally follows since q h ≥ 2 ℓ by definition.

Notice that jobs in
. Putting all the discussed ideas together, we prove the following result.
Proof. We first argue that the algorithm runs in polynomial time. Indeed, it suffices to show that the algorithm enters the while loop in Step 13 a polynomial number of times. This follows easily as the quantity ℓ min (S ′ ) is non-decreasing, and hence a job can be reassigned to a least loaded machine at most once .
Let us now bound the migration factor. We do this in two steps. First consider solution S ′ before entering Step 13. We first bound the volume of jobs migrated between S and S ′ , and then bound the total volume of jobs reassigned in the while loop in Step 13.
For the first bound, by the previous lemma and since On the other hand, since we are assuming (w.l.o.g) that there is no huge job, the total load of each machine is at most 2UB as argued in Section 2.2. We conclude that the big jobs migrated have a total load of at most 2UB · |M = |P | | = UB · O((1/ε) log(1/ε)p j * ε2 ℓ ). Finally, notice that small jobs migrated (before entering Step 13) are the ones assigned to machines in M = |P | by S. Since S is the output of Online LPT, then the total load of these jobs is at most (ℓ min (S ′ ) . We conclude that the total load migrated is at most UB · O((1/ε) log(1/ε)p j * ε2 ℓ ). It remains to bound the volume migrated in the while loop of Step 13. For this we will show the following claim. Claim: Let S ′ be the solution constructed before entering Step 13. Then all reassigned jobs in the while loop, except possibly the one reassigned last, are assigned to a machine in M = |P | by S ′ . Assume the claim holds and let us consider the solution S ′ as output by the algorithm. Then the total volume of reassigned jobs is bounded by |M = |P | | max i∈M = |P | ℓ i (S ′ ). Since by construction the load of a machine that process a job smaller than 2 ℓ is at most ℓ min (S ′ ) + 2 ℓ ≤ 2UB, the total volume migrated will be at most UB · O((1/ε) log(1/ε)p j * ε2 ℓ ) as before. Hence, the migration factor is upper bounded by To show the claim, consider S ′ before entering Step 11 together with the corresponding set M of machines that process some small job. Since S is the output of Online LPT, then the difference between the maximum an minimum loads of machines in M∩M = |P | for solution S ′ is at most 2 ℓ . We call this property (P1). Also, notice that M ∩ M = |P | = ∅, and hence, the maximum load difference of two machines in this set is at most 2 ℓ , vacuously. We refer to this property as (P2). Notice that (P1) and (P2) hold iteratively throughout the later steps of the algorithm. Additionally, if some job is assigned to a machine M = |P | in Step 11, the algorithm does not enter the while loop and we are done. Otherwise, the minimum load is achieved at M = |P | . Hence, if there is a job migrated from a machine in M = |P | to M = |P | then the algorithm finishes. The claim follows.

A note on geometric v/s arithmetic rounding
One of the main reasons to use our rounding procedure to multiples of ε2 ℓ instead of the geometric rounding (i.e., down to the nearest power of (1+ε)) is because the same arguments used in this work cannot be applied to geometric rounded instances. It is crucial in the analysis that the number of possible loads is poly (1/ε), while for geometric rounded instances that is not true as the following lemmas show.
Lemma 17. Let ε ∈ Q + , ε < 1. Given a machine covering instance (J , M), letJ be the set of jobs obtained by rounding geometrically jobs with processing time p j ∈ [εOPT, OPT]. If C 1 , C 2 ⊆J are two different multi-sets of jobs with processing times at least εOPT such that j∈C i p j ∈ [εOPT, OPT], i = 1, 2, then j∈C 1 p j = j∈C 2 p j .
Proof. Assume w.l.o.g. OPT = 1. Hence the possible processing times are (1 + ε) i , with i such that ε ≤ (1 + ε) i ≤ 1 (a finite family of such possible values). Suppose by contradiction that there are two different non-empty multi-sets C 1 , C 2 with the same total load, and assume they are minimal, i.e. that there is no other pair of non-empty multi-sets with the same total load but with smaller total load. For k = 1, 2, let C k (j) be the number of jobs with processing time (1 + ε) j in set C k .
Since the pair C 1 , C 2 is minimal, we have that C 1 (j) = 0 or C 2 (j) = 0 for every j. C 1 and C 2 having the same total load means that where k = −⌊log 1+ε (ε)⌋. This last equality can be rephrased as the existence of a non-zero polynomial p(x) = b 0 + b 1 x + · · · + b k x k , with |b j | ∈ {C 1 (j), C 2 (j)} (i.e. with integer coefficients), that has (1 + ε) as one of its roots. Since ε = c d > 0 for some co-primes c and d, then 1 + ε = c+d d . Dividing p(x) by (dx − (c + d)) leads to a polynomial q(x) = a 0 + a 1 x + · · · + a k−1 x k−1 which, thanks to Gauss lemma, has integer coefficients too. Let b i be the first coefficient of p different from zero. Then implying, since the size of each job is at least ε, that the total load of the multi-sets is at least b i ε > 1, which is a contradiction.
Lemma 18. Given 0 < ε < 1, the number of different multi-sets of jobs with processing time at least εOPT with total load at most OPT for a geometrically rounded instance is 2 Ω( 1 ε ) . Proof. Let u = ⌊log 2 OPT⌋ and ℓ = ⌈log 2 (εOPT)⌉. We will give a lower bound on the number of different sets with total load 2 u when the jobs are rounded to powers of 2, which implies that for 0 < ε < 1 the same bound holds for processing times rounded to powers of (1 + ε). Let C i be the number of different multi-sets with total load 2 ℓ+i . This number is characterized by the recurrence This last term comes from the fact that a multi-set with total load 2 ℓ+i+1 can be constructed using only one job of size 2 ℓ+i+1 , or merging two multi-sets of size 2 ℓ+i (there are such pairs).
Since recurrence a 0 = 1, a i = Because of these two lemmas, if we use geometrically rounded instances we cannot make sure that, when a new jobs arrives to the system, the load profile changes only by poly (1/ε) coordinates since there are 2 Ω(1/ε) number of possible different loads.

An improved lower bound for the competitive ratio with constant migration factor
In opposition to the online makespan minimization with migration, where competitive ratio arbitrarily close to one can be achieved using constant migration factor [18], the online machine covering problem does not allow it. Until now, the best lower bound known for this ratio is 20 19 [20], which we now improve to 17 16 using similar ideas.
Lemma 19. For any ε > 0, there is no 17 16 − ε -competitive algorithm using constant migration factor for the online machine covering problem with migration.
Proof. Consider an instance consisting of 3 machines and 6 jobs of sizes p 1 = p 2 = p 3 = 2, p 4 = p 5 = 3 and p 6 = 80 17 . It is easy to see that the optimal solution is given by Figure 3 (a). Moreover, there is no other 17 16 − ε -approximate solution (up to symmetry). Suppose by contradiction that there exists a 17 16 − ε -competitive algorithm with constant migration factor C. While processing the above instance, the algorithm must construct the optimal solution depicted in Figure 3 (left). Consider now that jobs with processing time smaller than 1/C arrive to the system, with total processing time 22 17 . Since the migration factor is C, none of the six previous jobs can be migrated, thus the best minimum load we can obtain is 96 17 , while the optimal solution is 6 (see Figure 3 (right)). We conclude by noting that 6 96/17 = 17 16 .
Notice that the instance reaching the lower bound crucially depends on the arrival of jobs with arbitrarily small processing times. This kind of jobs are in fact the problematic ones, because under the assumption that at each iteration the incoming job is big enough (has processing time at least εOPT), there is a robust PTAS with constant migration factor [20].

Jump and swap optimality for machine covering.
Let F denote the set of feasible solutions of a general combinatorial maximization problem with weight function f : F → R. A neighborhood function is a mapping N : F → 2 F that specifies for each solution s ∈ F a set N (s) ⊆ F, called neighborhood of s. The solutions in N (s) are called neighbors of s, and a solutions ∈ F is called locally optimal with respect to N or N-optimal if f (s) ≥ f (s) for every s ∈ N (s). A local move is a replacement of a solution by one of its neighbors. Any algorithm that starts from a feasible solution and iteratively perform local moves that improve the current solution until no such local move is possible is called a local search algorithm.
It is a good strategy to look for local search algorithms with good approximation guarantees whose locally optimal solution can be found efficiently, because they can be effectively adapted to the online context with migration. The analysis of their migration factor is done using the following premise: the migrated load corresponds to the sum of the migrated jobs in each local move, and for simplified instances (rounded, for example) the number of local moves until a locally optimal solution is found is usually a constant. That will be the case for two natural neighborhoods used in the load balancing context: jump and swap.
Two solutions are jump-neighbors if they assign the jobs to the same machines (up to symmetry) except for at most one job. A solution S ′ is a swap-neighbors of S if they assign the jobs to the same machines (up to symmetry) except for at most two jobs and, if they differ in exactly two jobs j 1 , j 2 then they are in swapped machines, i.e., S(j 1 ) = S ′ (j 2 ) and S(j 2 ) = S(j 1 ). The weight of a solution is defined through a two-dimensional vector having the minimum load of the schedule as first coordinate and the number of non-least loaded machines as second ones. We compare the weight of two solutions lexicographically 1 .
In other words, a solution is jump-optimal (respectively swap-optimal) if the migration of a single job (resp. the migration of a job or the swapping of two jobs) does not increase the minimum load and, if it maintains the minimum load then it does not reduce the number of least loaded machines. The following lemma characterizes jump-optimal solutions for machine covering.
Lemma 20. Given (J , M) a machine covering instance, a schedule S is jump optimal if and only if for any machine i ∈ M and any job j ∈ S −1 (i), we have that ℓ i (S) − p j ≤ ℓ min (S).
Proof. If S is jump-optimal and there is a job not satisfying the inequality, then moving it to a least loaded machine either increases the minimum load of the schedule or reduces the number of least loaded machines, which is a contradiction.
On the other hand, if S is not jump-optimal then there is a job j whose migration improves the weight of the solution or, if not, a job whose migration to a least loaded machine decreases the number of least loaded machines. Consider first the case in which moving j from a machine i increases the minimum load. This means that the new load of machine i, ℓ i (S) − p j , is at least the new minimum load, which is strictly larger than ℓ min (S), proving the needed inequality. Consider now the case in which moving j from a machine i to machine i ′ maintains the minimum load while reducing the number of least loaded machines. Then i ′ must have been a non-unique least loaded machine in S. Furthermore, machine i cannot become a minimum loaded machine in the new schedule (otherwise the number of least loaded machines would not change). This means that ℓ i (S) − p j is strictly larger than ℓ min (S). Now we show a simple upper bound for the approximation ratio of jump-optimality for machine covering.
Lemma 21. Given an instance (J , M) for the machine covering problem, any jump-optimal solution S is 7 4 -approximate. Proof. For this proof we will not assume that the processing times are rounded. Observe first that every job j with p j > ℓ min (S) must be assigned in S to a machine i on its own. If not, there would be another job j ′ in machine i such that ℓ(i) − j ′ ≥ p j > ℓ min (S) which contradicts Lemma 20). Therefore, we can remove both the job j and one machine from the instance. By doing this, the restricted schedules S is still jump-optimal, and the optimal value of the new instance cannot decrease: by arbitrarily reassigning the jobs that were in the same machine as j in the optimal schedule to other machines we obtain a schedule for the new instance with the same or larger minimum load. As a consequence, we can assume by scaling the processing times that ℓ min (S) = 1, and that p j ≤ 1 for all j ∈ J .
Let M 1 be the set of machines i ∈ M such that S assigns exactly two jobs to i and ℓ i (S) > 1. Hence every machine i outside M 1 either has a load of 1, or it contains at least 3 jobs. In the latter case, we deduce there is a job j with p j ≤ ℓ i (S)/3. By using Lemma 20 we conclude that all machines not in M 1 have load at most 3/2. Consider now a modified instance (J , M) where all the jobs assigned to machines in M 1 are replaced by jobs of size 1. S is still jump-optimal in the modified instance, it has the same minimum load and the optimal value cannot decrease because we are only enlarging the processing times. For this modified instance we have two cases: Since all modifications cannot decrease the optimal value and do not change ℓ min (S), we conclude that S is a 7 4 -approximate solution for the machine covering problem. To get a lower bound in the approximation ratio r, we will use Sylvester's sequence t := (2, 3, 7, 43, 1807, . . . ), also defined by Salzer [17], and the related constant 69103, which appears many times in the design of natural approximation algorithms for packing problems [2,4,14]. First, we give some properties of the previous sequence which will be useful for the construction of the instances. It is not difficult to see that, in the optimal solution, each machine will have assigned one job of each kind, implying that The constructed solution S jump k assigns the jobs in the following way (see Figure 4 for an example): the t k − 1 jobs of size (t k − 2) −1 are assigned to a single machine, and for i = 1, . . . , k − 1, the jobs of size (t i − 1) −1 are assigned to (t k − 1)/t i machines, each one having t i jobs.
Lemma 22 implies that (t k − 1)/t i is an integer and thus this assignment is valid, yielding a minimum load of ℓ min (S k ) = 1 + (t k − 2) −1 . Also, S jump k is jump-optimal because migrating a job to the least loaded machine will leave the original machine with a load of 1, which would decrease the minimum load. Hence, the approximation ratio r must satisfy, for any k ≥ 2, that Taking k → ∞ and together with Lemma 21, we conclude the following result.
Theorem 23. For the machine covering problem, any jump-optimal schedule S is r-approximate, where r ∈ [h ∞ , 7 4 ] ≈ [1.691, 1.75]. Remark. The lower and upper bound also apply for the approximation ratio of swap-optimality: the schedules S jump k are swap-optimal, and any swap-optimal schedule is also jump-optimal by definition.

Algorithm 2 Push
take out k from i in S ′ .
Using the rounding procedure developed in Section 2.2, jump-optimality can be adapted to the online context using migration factor O 1 ε . In order to do this, we need an auxiliary algorithm called Push (Algorithm 2) to assign a job j to a given machine. The algorithm assigns the job to the machine and then iteratively push out from that machine all jobs breaking jump-optimality, storing them in a special set which is part of the output. This algorithm is the base of the push neighborhood analyzed by Schuurman and Vredeveld [19].
Our algorithm, which is described in detail in Algorithm 3, is called every time a new job j * arrives to the system, and will receive as input the current solution S for (J , M), initialized as empty if J = ∅. It will output a 4-relaxed version of a jump-optimal solution. The general idea of Algorithm 3 is to first round the instance, and then use the Push algorithm to assign the incoming job to a least loaded machine. This can push out some jobs that need to be reassigned. We assign them iteratively using Push until a jump-optimal solution is obtained. Notice that assigning and pushing jobs can be interpreted as cleverly moving from neighbor to neighbor in the jump neighborhood. As a last step, all small jobs that were pushed during the entire procedure are reassigned using list-scheduling.
Similarly to Algorithm 1, this procedure is called every time a new job j * arrives to the system, and will receive as input the current solution S for (J , M), initialized as empty if J = ∅. In the algorithm, S ′ B denotes schedule S ′ restricted to big jobs. For simplicity, we assume that every arriving job is either small or big. It is easy to extend the algorithm to handle huge jobs. 1: run LPT on input J ′ and let τ be the minimum load. Set UB ← 2τ . DefineP , ℓ, and u based on this upper bound UB using (1) and (2). 2: set S ′ ← S 3: ifp j * < 2 ℓ then. 4: assign j * to a least loaded machine in S ′ . 5: else 6: set Q B ← {j * }.
⊲ Set with unassigned big jobs.

8:
while Q B = ∅ do 9: for any j ∈ Q B , Q B ← Q B \ {j}. 10: in S ′ B , use Algorithm 2 to assign j to a least loaded machine m * , obtaining its output set Q. Update S ′ B to be the output solution of this procedure.

11:
reassign jobs in S ′ such that the assignment of (big) jobs in S ′ and S ′ B coincides.

16:
end while 17: assign the jobs in Q s to S ′ using list-scheduling. 18: end if 19: return S ′ .
Using similar techniques as in Lemma 11, we can argue about the approximation ratio of the algorithm.
Proof. In order to show that the competitive ratio is (r + ε), we just need to show that the schedule constructed by Algorithm 3 is a k-relaxed version of a jump-optimal solution for some convenient k. This follows from Theorem 23 and Lemma 3.
First, Algorithm 3 has, for any h ∈ R + , robust structure to level h because each time that Push is called, it moves a total load of jobs smaller than the processing time of the inserted job (otherwise, the machine would not be a least loaded machine), and if the job is small, then nothing is migrated. This also directly implies that the running time of the algorithm is polynomial because every job is migrated at most once, so each while loop is executed only a polynomial number of times.
Now, let us show that the constructed schedule is a 4-relaxed version of a jump-optimal schedule. Let k = 2 ℓ εOPT ′ , which implies that big jobs have processing time at least kεOPT ′ . Ifp j * < 2 ℓ , it is easy to see that the conditions are fulfilled. If job j * is big, we first notice that in each iteration of the while loop indexed by Q B , after applying Push and updating, the resulting schedule restricted to big jobs S ′ B is jump-optimal if the jobs in Q B are excluded. When this while loop is finished, since Q B = ∅, the partial schedule is jump-optimal restricted to big jobs, fulfilling the first condition of being k-relaxed. Also, the internal while loop makes sure that at each iteration the second condition of being k-relaxed is satisfied, so at the end of the while loop indexed by Q B , the partial schedule is a k-relaxed version of a jump-optimal solution. By assigning the remaining small jobs using list-scheduling, the final solution is a k-relaxed version of a jump-optimal solution, and we finish by noticing as in Lemma 11 that k ≤ 4.
To analyze the migration factor, we define the migration tree of the algorithm as a node-weighted tree G = (V, E), where V is the set of migrated jobs together with the incoming job j * / ∈ J . The weight of each node v ∈ V is the processing time of the corresponding jobp v . The tree is constructed by first adding job j * as root. For each node (job) v in the tree that is migrated, its children are defined as all the jobs migrated at the insertion of v. It is easy to see that this process does not create any loops as the processing time of a child is strictly smaller than the processing time of its parent. By definition the leaves of the tree are the jobs not inducing migration, and thus any small job in the tree is a leaf. In the context of local search, the number of nodes in the tree corresponds to the number of iterations of the specific local search procedure. The following lemma bounds the migration factor of Algorithm 3.
Proof. Let w i be the total processing time of nodes corresponding to big jobs in level i of the migration tree. Assume thatp j * = q κ = 2 g + hε2 g for some κ ∈ {1, . . . , |P |}, g ∈ {ℓ, . . . , u} and h ∈ {0, . . . , 1 ε − 1}. Every time a job j is inserted using Push, the total load of jobs in the output Q of the algorithm is strictly less thanp j , which means that w i is strictly decreasing, and also that at each level i of the tree there are at most w i 2 ℓ nodes corresponding to big jobs. Since the second condition of being a k-relaxed version (Definition 2) of a jump-optimal solution is maintained through the iterations, the small jobs that need to be migrated because of insertion of a big job j have total load at mostp j + 2 ℓ . This implies that the total load of small jobs at each level i ≥ 1 of the tree is at most w i−1 + w i−1 2 ℓ · 2 ℓ = 2w i−1 , and hence the total processing time of nodes corresponding to small jobs is at most twice the total processing time of nodes corresponding to big jobs.
From now on we assume that the migration tree contains only nodes corresponding to big jobs. We categorize each level i ≥ 1 of the migration tree according to the following two cases: if there is a node in level i − 1 having at least two children, we say that level i falls in case 1, and it falls in case 2 otherwise. We first show that there are at mostp j * 2 ℓ ≤ 1/ε levels of the tree falling in case 1. Because of the way the migration tree is constructed, it is not difficult to see that the total weight of the leaves in the tree is at mostp j * (this property is maintained inductively through the executions of Algorithm Push). Because of this, since each big job has processing time at least 2 ℓ , every migration tree has at mostp j * /2 ℓ leaves, which is also an upper bound for the number of nodes that have more than one children in the tree (each one of them induces at least one extra leaf), and hence for the number of levels falling in case 1.
There can be more than 1/ε levels falling in case 2 along the tree, but we will show that in that case w i quickly decreases based on the following claim.
Notice that the claim implies that for a level i falling in case 2, if w i−1 ∈ (q s+1 , q s ] for some s ∈ {1, . . . , |P |}, then w i ≤ w i−1 − ε 4 q s+1 . To compute the total processing time of the nodes in the migration tree, we will bound the total weight of the levels corresponding to each case separately. Since there are at most 1/ε levels falling in case 1, each one of them having total weight at most p j * , we can bound the total weight of those levels by 1 εp j * . Let us now relabel the levels of the tree where the second case occurs by just {1, 2, . . . , L 2 } (i.e. we ignore the levels falling in case 1). Thanks to the claim, for every i ∈ {1, 2, . . . , L 2 }, if w i−1 ∈ (q s+1 , q s ] for some s ∈ {1, . . . , |P |}, then i+2 j=i−1 w j ≤ 4q s and w i+3 ≤ q s+1 (because q s − εq s+1 ≤ q s+1 ), and we can restart the process for i + 3 with the correct value q s ′ ≤ q s+1 . If we use this argument starting with w 0 ∈ (q κ+1 , q κ ], we can conclude that L 2 i=0 w i ≤ 4 |P | i=κ q i , which, recalling thatp j * = 2 g + hε2 g , is at most These two bounds, together with the fact that the total load of small migrated jobs is at most twice this value, implies that the migration factor is at most O 1 ε . To prove the claim, notice first that Also, since k j=1 2 ⌈log(q i j )⌉ ≥ k j=1 q i j > q s+1 , we have that k j=1 2 ⌊log(q i j )⌋ > q s+1 2 . This concludes the proof of the claim.
Moreover, the following lemma shows that the previous analysis is essentially tight.
Lemma 26. There are instances for which Algorithm 3 uses a migration factor of at least Ω 1 ε . Proof. Consider an instance with OPT = 2 u+1 and εOPT = 2 ℓ for some integers ℓ, u, and assume for simplicity that UB = OPT. This way,Ĩ(UB) = {ℓ, . . . , u}. The instance, consisting of m ∈ O 1 ε log 1 ε machines, is constructed in the following way: Consider the possible processing times sorted non increasingly t 1 , . . . , t h . For each i such that t i < 2 u , the schedule has a machine with a job of size t i assigned, and it is completed with jobs until having load 2 u+1 : if t i = 2 k + jε2 k , this can be done adding a job of size 2 k + 1 ε − j ε2 k , a job of size 2 k and for each k ′ = k + 2, . . . , u, a job of size 2 k ′ (if i = u − 1, the machine will not have any of these last jobs). By doing so, the load of the machine is Now, if a job of size 2 u arrives to the system, it can be inserted using Push in the machine with the largest job of size less than 2 u (i.e., with processing time 2 u−1 + 1 ε − 1 ε2 u−1 ), taking out such job because it breaks jump-optimality. If Algorithm 3 takes the decision in the same way iteratively, then at least one job of each possible size t i < 2 u is migrated, being then the total migrated load at least and hence the migration factor needed for this instance is Ω 1 ε .
Putting Lemmas 24, 25 and 26 together, we can conclude the following result.

A Non-constant Migration for classic LPT
Lemma 28. For any k ≥ 2 there exists a set J of 4k + 1 jobs and an extra job j * / ∈ J such that, for every schedule S constructed using LPT on 2k + 1 machines, it is not possible to construct a schedule S ′ using LPT for J ∪ {j * } with migration factor less than m/2.
Proof. Fix a constant 0 < ε ≤ 1 6k . Consider a set J consisting of the following 4k + 1 jobs: k + 1 jobs of size 1; for each i ∈ {0, . . . , k − 1}, a job of size 1 2 + iε and a job of size 1 2 − (i + 1)ε, and finally k jobs of size 1 2 − kε ≥ 1 3 . Assume the jobs in J are sorted non-increasingly by size. There is a unique schedule constructed using LPT for this instance (up to symmetry) which assigns the jobs in the following way (see Figure 1a): The k + 1 jobs of size 1 to a machine on their own, and for each i = 1, . . . , k, it assigns to machine k + i a job of size 1 2 + (k − i − 1)ε, a job of size 1 2 − (k − i)ε and a job of size 1 2 − kε (since the total load of the first two jobs is 1 − ε, the last k jobs must be assigned to these k machines). Now consider an arriving job j * of size 1 2 + kε ≤ 2 3 . There is a unique schedule constructed using LPT for the new instance (up to symmetry) which assigns the jobs in the following way (see Figure 1b): it assigns to the first k + 1 machines a job of size 1 and a job of size 1 2 − kε, to machine k + 2 job p j * and a job of size 1 2 − (k − 1)ε, for each i = 2, . . . , k − 1 it assigns to machine k + i + 1 a job of size 1 2 + (k + 1 − i)ε and a job of size 1 2 − (k − i)ε, and finally to machine 2k + 1 a job of size 1 2 + ε and a job of size 1 2 (now the total load of machines k + 2, . . . , 2k + 1 is 1 + ε, then the last k + 1 jobs must be assigned to the first k + 1 jobs).
It is not difficult to see that, in the new schedule, every machine has a different subset of jobs assigned to it compared with the original schedule, and so at least one job must have been migrated per machine. Thus, the migrated total load is at least the load of the smallest 2k + 1 jobs, which implies that the needed migration factor is at least