PERFORMANCE GUARANTEE OF THE JUMP NEIGHBORHOOD FOR SCHEDULING JOBS ON UNIFORMLY RELATED MACHINES

. We study the worst case performance guarantee of locally optimal solutions for the problem of scheduling jobs on uniformly related parallel machines with the objective of minimizing the total weighted completion time. The quality of locally optimal solutions under the jump neighborhood is analyzed, which consists of iteratively moving a single job from one machine to another, improving the total weighted completion time in each iteration and stopping once improvement is no longer possible. We propose an upper bound for the total weighted completion time for the solutions obtained by this local search, and upper and lower bounds for the performance guarantee of the obtained locally optimal solutions. Additionally, the case of identical parallel machines is analyzed


Introduction
Local search methods are widely used to solve scheduling problems and exhibit good empirical behavior, but little is known about their theoretical worst-case performance.The reader is referred to [3,24] for a survey of performance guarantees and other theoretical aspects of local search for a wide variety of combinatorial problems, including scheduling problems.
The problem of scheduling jobs on uniformly related parallel machines is considered with the objective of minimizing the total weighted completion time.This problem is denoted by || ∑︀     in the three-field scheduling notation [19].More precisely, we are given a set of  jobs to be scheduled on a set of  machines.The jobs must be scheduled without interruption on a single machine, and each machine can process one job at a time.Each job has a non-negative weight and a non-negative processing requirement.
The solution called schedule, is an assignment of jobs to machines together with a sequence of the jobs within each machine.Here, it is considered that the sequence within a machine is always taken to be the decreasing order of weight to processing time requirement ratio, also known as the Smith ratio [28].Therefore, a schedule is fully determined by the assignment of jobs to machines.Given a schedule, we denote by   the completion time of job , with which the total weighted completion time can be computed by ∑︀      , where   is the weight of job .If jobs have unitary weight, the problem consists in minimizing the total completion time ( ∑︀    ).
Two problems have particular interest for our purpose.The first being the particular case where all machines work at the same speed, denoted by  || ∑︀     .The second one is the most general case where the jobs have arbitrary process times, denoted by || ∑︀     .Minimizing the total completion time on parallel machine environments can be solved in polynomial time.The problem || ∑︀   , can be solved by bipartite matching techniques [20].The problem || ∑︀   can be solved in ( log ) [11,21].For the problem  || ∑︀   , complexity decreases to ( log ) [11].If the objective is to minimize the total weighted completion time, the problems are NP-hard [18], even for the case of two identical machines [8,22].
Since for the total weighted completion time objective the problem becomes NP-hard, it is natural to look for approximate solutions.Polynomial time approximation schemes (PTAS) for problems  || ∑︀     and || ∑︀     are studied in [14,27] respectively.While the best approximation reported for || ∑︀     problem is 3/2 − , for  > 1/6000 [4,23].Another approach, vastly implemented in practice and the main focus of this paper is to use local search techniques.There are two important aspects that determine the efficiency of a local search algorithm: neighborhood size and local optimum quality [2].One way to evaluate the quality of a local optimum is by worst-case analysis.Specifically, we study the Jump neighborhood, also known as move or insertion, which is defined as moving a single job from one machine to another.
Given a problem  and a neighborhood structure  , the performance guarantee of a minimization criterion is defined as the maximum possible ratio of a local optimal solution with respect to the global optimum.More precisely, the performance guarantee can be formally defined by: where ℐ is the set of instances of the problem , ℒ  is the set of locally optimal solutions of instance  for neighborhood  , () is the cost of solution  (objective function), and () is the optimal cost for the instance .To determine the performance guarantee for a jump neighborhood, an upper bound is established and then an instance is proposed to establish a lower bound for the performance guarantee.
The study of performance guarantees for locally optimal solutions under a jump neighborhood on parallel machine environments is more extensive for the makespan objective than the total weighted completion time objective.The performance guarantees for the makespan objective has been studied for identical parallel machines [7,15,26], uniformly related parallel machines [9,26] and unrelated parallel machines [26].The performance guarantees considering machine eligibility restrictions for identical and uniformly unrelated parallel machines was studied in [25].
For the total weighted completion time objective, the performance guarantees for the  || ∑︀     problem has been studied in [6], and it was determined that the performance guarantees are at least 1.2 and at most (3−1)/(2).The || ∑︀     problem was studied in [1,12] , establishing that the performance guarantee is at most 2.618.The performance guarantees considering machine eligibility restrictions for identical and uniformly unrelated parallel machines was studied in [12].In [5,26] several related problems are studied.
Other neighborhoods that have been used for scheduling in parallel machine environments include lexjump, push, multi-exchange and split.Lexjump is a polynomial size neighborhood and is an extension of the jump neighborhood used for minimizing the makespan [7,25,26].Push is also a polynomial size neighborhood, which was introduced in [26] for the minimization of makespan on identical and uniformly related parallel machine environments.Multi-exchange is an exponential size neighborhood introduced in [16] for unrelated parallel machine environments, and then used for other parallel machine environments in [26].Split is another exponential size neighborhood introduced in [7] for the minimization of makespan on identical parallel machines.Combined Jump neighborhood with other neighborhoods was studied in [7].
In [1,6,12] the proof techniques used consist of establishing a local optimality condition and then using certain mathematical properties to establish the bound for the performance guarantee.In [1,12] a mapping proposed by Cole et al. [10] is used.With this mapping, a schedule can be mapped into an inner product space so that the norm of the mapping is closely related to the total weighted completion time of the schedule.On the other hand, [6] uses an inequality proposed by Eastman et al. [13].This inequality is presented in Section 2.3.Our proof technique is similar to the one used in [6].
Our results.It is proved that the performance guarantee for locally optimal solutions under jump neighborhood for || ∑︀     problem is at least 1.42285 and at most min {︂ 2 Additionally, it is proved that the performance guarantee for  || ∑︀     is at most (3/2) − (1/2).This bound was known from [6].However, our proof treats the identical parallel machines case as a particular case of the uniformly related parallel machines.We also prove some inequalities for the total weighted completion time of optimal and locally optimal solutions.
The remainder of this paper is structured as follows.We present preliminary background in Section 2. All aspects related to the upper bound for the performance guarantee are included in Section 3. A lower bound for the performance guarantee is presented in Section 4. Finally, Section 5 provides the conclusions.

Notation and problem statement
Throughout this paper, let  be the set of  jobs to be scheduled on a set ℳ of  ≥ 2 machines.Let   and   denote the non-negative processing requirement and weight of job  ∈  respectively.Jobs must be scheduled on a single machine, and each machine can process one job at a time without preemptions.In addition all jobs and machines are available from the beginning.
Machines have different speeds, therefore, let  be the vector for the speeds, with   > 0 as the speed of machine .Then, the processing time for job  on machine  is   /  .From vector , the maximum and minimum speeds are identified,  max and  min respectively.Without loss of generality, the speed and order of the machines is rescaled such that A schedule corresponds to an assignment of jobs to machines represented by a vector , where   gives the machine to which job  is assigned, that is,   =  if job  is assigned to machine  in schedule .As a result of a schedule, each job  ∈  will have a completion time with which the total weighted completion time is computed.Let   (, ) the completion time of job  in schedule  at speeds .The sequencing of jobs for any schedule is solved by the weighted shortest processing time (WSPT) rule ( [28], Thm. 3) which simply sequences jobs in decreasing order of   /  ratio.When there are ties in the ratio, these are broken arbitrarily and to avoid confusion we denote by ≺ the precedence relation of jobs.Therefore, letting   () the set of jobs assigned to machine  in schedule , we can write the completion time of job  in schedule  as Here, for convenience, we have introduced the notation ⪯ to include all predecessors of a job and the job itself.The total weighted completion time and the weighted sum of processing times of schedule  are defined as follows:

Jump neighborhood
We study the Jump neighborhood, also known as move or insertion neighborhood, which is a polynomial size neighborhood.A jump move is defined as moving a single job from one machine to another.A successful jump reduces the objective function.Given a solution, if it is not possible to improve in this way, we have a local optimum and call this solution Jump-Opt.More precisely, let   () be the amount by which (, ) decreases if job  is removed from machine   , and  ′  (, ℎ) the increment in (, ) if job  is moved to machine ℎ.Observe that job  has to be inserted on machine ℎ at the appropriate position (defined by WSPT rule).Thus,

Properties of the optimal schedules
In this section, two properties of the optimal schedules are presented that will be used to establish the upper bounds for the performance guarantees of Jump-Opt solutions.The first one is the inequality presented in Theorem 1 of [13], this is where x is the optimal solution if all machines have unitary speed, (x, 1) is the total weighted completion time of x at unitary speed machines, and is the total weighted completion time, if all jobs are assigned to a single machine that works at unitary speed.
The second inequality is presented in the following lemma.
Lemma 2.1.Given a set of jobs, the optimal total weighted completion time on identical and uniformly related parallel machines at speeds , satisfy Proof.First, note that if x is the optimal solution when all machines have unitary speed, and  * is the optimal solution if machines work at speeds , then (x, 1) ≤ ( * , 1). (2.9) Moreover, from Assumption (2.1) and (2.4), we have Finally, using (2.9) we conclude the proof.

Performance guarantee
Summing over all ℎ ∈ ℳ ∖ {  }, gives Summing over all  ∈  , using (2.4) and (2.5), and grouping some terms, gives us On the other hand, by using (2.1) and (2.8) we have the following three results: )︂ .
From here, the proof is immediate.
Here, our main result is presented, which is based on the performance guarantee of Jump-Opt solutions of || ∑︀     problem determined in [12] and the Lemma 3.2.Note that the performance guarantee of Jump-Opt solutions for || ∑︀     can be considered as an upper bound for the performance guarantee of Jump-Opt solutions for || ∑︀     .From Theorems 1 and 5 of [12] we have that the performance guarantee for || ∑︀     is 1 +  ≈ 2.618, where  is the golden ratio.
From the previous theorem, we have that the upper bound proposed in the Lemma 3.2 will be useful if and only if )︂ .
For two machines this bound is approximately 2.368, and when  grows this bound decreases monotonically and converges to 1.309.

Identical machines
In this section, an upper bound is presented for the performance guarantee of Jump-Opt solutions for the problem of scheduling jobs on identical parallel machines with a total weighted completion time objective.This problem is denoted by  || ∑︀     in the three-field scheduling notation [19].For this case, we have that the machines have the same speed.Without loss of generality, it is assumed that this speed is unitary.Here, the following notations are redefined: )︂ .
This upper bound for the performance guarantee was previously determined by [6], who also show a lower bound of 1.2.

Lower bound
In order to establish a lower bound for the performance guarantee of Jump-Opt solutions, we propose the following instance.Proof.An instance ℐ is considered with  = 3 jobs and  = 3 machines.Jobs have identical weight and processing requirements,  1 =  1 =  and   =   = 1 for  = 2, 3.The processing speed of the machines are  1 = 1,  2 = 2 +2 and  3 = 2.The optimal and Jump-Opt solutions are  * = (3, 1, 2) and  = (2, 3, 3) respectively (Fig. 1 shows a Gantt chart for  * and ).For , the local optimality conditions from (2.6) are reduced to  ≥ 2. Then for  ≥ 2 it is not possible to make jump moves without increasing the total weighted completion time.16 is an approximation to the solution of the problem, where (,) ( * ,) ≈ 1.423.

Conclusion
In this paper we establish an upper bound on the performance guarantee for the Jump neighborhood in uniformly related parallel machines environment with the objective of minimizing the total weighted completion time.The rough idea is to first establish a necessary condition for local optimality that takes the form of a certain inequality.Then we apply some inequalities to obtain the final guarantee.We also propose an instance to establish a lower bound for the performance guarantee.

Theorem 3 . 3 .
The performance guarantee of Jump-Opt solutions for || ∑︀     problem is at most min {︂ 2

Lemma 4 . 1 .
The performance guarantee of Jump-Opt solutions for || ∑︀     is at least 1.423.
The total weighted completion time for  * and  are