On single machine scheduling with processing time deterioration

1. On single machine scheduling with processing time deterioration Valery Gordon United Institute of Informatics Problems of the NASB, Minsk, Belarus;

2. 1. On single machine scheduling with processing time deterioration and precedence constraints • V. Gordon1, C. Potts2 , V.Strusevich3, • J.D. Whitehead2 • 1 United Institute of Informatics Problems of the NASB, Minsk, Belarus; • 2 University of Southampton, School of Mathematics, Southampton, UK • 3 University of Greenwich, School of Computer and Mathematical Sciences, London, UK Plan of the talk • Introduction • Previous results • Scheduling with deterioration under precedence constraints • Priority functions and priority-generating functions • Priority functions for scheduling problems with processing time deterioration • Conclusion

3. Introduction Classical deterministic scheduling models: - processing conditionsare viewed as given constants Real-life situations: - processing conditionsmay vary intime Models with processing time deterioration or with learning: • actual processing time of a job depends onthe place of the job in a schedule Deterioration:-machine is served by a human operator who gets tired; - machine loses the processing quality of its tools if it works long Learning:- the skills of the workers continuously improve by processing one job after the other

4. Processing time deterioration: - the later a job starts, the longer it takes to process it • Positional deterioration: • processing time grows depending on a position of the job in the processing sequence ( either on the number of jobs that have been sequenced before, or on the total processing time of these jobs) • Time deterioration: • processing time grows depending on a start time of the job ( actual processing time of a job depends linearly on its start time in some schedule)

5. Previous Results Single machine scheduling problems with processing time deterioration that can be solved in polynomial time Recent state-of-art reviews: Alidaee, Womer (JORS, 1999, 50); Cheng, Ding, Lin (EJOR, 2004, 152); Biskup(EJOR, 2008, 188) • Positional deterioration • polynomial:pj[r] = pj rA • (processing time of a job depends polynomially on the position in which it is scheduled or, equivalently, on the number of jobs that have been scheduled before) • pj[r]is theactual processing time of a jobjscheduled in the positionr ; A>0. • Introduced by Biscup (EJOR, 1999, 115) • Mosheiov (EJOR, 2001, 132; Math.Comput. Modelling, 2005, 41): LPT rule for minimizing the makespan

6. Positional deterioration • - cumulative:pj[r]= pj(1+ Σkr=-11p[k]) A • (processing time of a job depends polynomially on the total ‘normal’ processing time of jobs that have been sequenced before) • p[k]is the ‘normal’ processing time of a job sequenced in positionk;A ≥ 1 • Introduced (for learning effect) byKuo, Yang (Inform.Processing Lett. 2006, 97) • Problem of minimizing the makespan can be solved in O(nlogn) time by SPT • Time deterioration • (actual processing time of a job depends linearly on its start time in some schedule) • linear time:pj(t)= aj t + pj • Minimizing makespan by sorting jobs in non-increasing order of aj / pj: • Melnikov, Shafransky (Cybernetics, 1980, 15), Browne, Yechiali (OR, 1990, 38), Gawiejnowicz, Pankovska (Inform. Proc. Lett., 1995, 54)

7. Time deterioration - simple linear time:pj(t)= aj t Minimizing the weighted sum of the completion times Σwj Cj by sorting jobs in non-increasing order of-aj / (wj (1+aj)): Mosheiov (Comput.Oper.Res, 1994, 21) - constant rate linear time:pj(t)= a t + pj Minimizing the sum of the completion timesΣCjby sorting jobs in non-decreasing order ofpj(SPT rule): Ng, Cheng, Bachman, Janiak (Inform.Processing Lett., 2002, 81) All these results are obtained for optimal sequencing of independent jobs

8. Scheduling with deterioration under precedence constraints In practice, products are manufactured in a certain order implied, for example, by technological, marketing or assembly requirements. Thus, not all sequences of jobs are feasible or make sense. This can be modelled by imposing the precedence constraints over set of jobs to describe possiblesequences of jobs. Our aim is to identify single machine scheduling problems with processing time deterioration that can be solved in polynomial time, provided that the set of jobs is partially ordered.

9. Priority functions and priority-generating functions • We consider single machine scheduling problems in which schedules can be specified by permutations of jobs. • Index policy or priority rule for independent jobs: • an optimal permutation can be found by assigning certain priorities to jobs and then sorting the jobs in the order of these priorities • The most commonly used index policies: SPT, LPT rules (Smith, 1956; Tanaev, 1965; Rothkopf, 1966 and other) • Priority functions and priority-generating functions: • to handle scheduling problems under precedence constraints (Lawler, Ann.Discrete Math. 1978, 2; Gordon, Shafransky, Proc. Academy of Sci. of Belarus, 1978, 22; Monma, Sidney, Math.Oper.Res. 1979,4) • For systematic exposition of related issues: Chapter 3 in Tanaev, Gordon, Shafransky Scheduling Theory. Single-Stage Systems, Kluwer, 1994

10. Definition.Let παβ=(π'αβπ'') and πβα =(π'βαπ'') be two permutations of n jobs that differ only in the order of the subsequences α and β. For a function F(π) that depends on a permutation, suppose that there exists a function ω(π)such that for any two permutations παβ and πβα the inequality ω(α)>ω(β) implies that F(παβ)≤F(πβα), while the equality ω(α)=ω(β) implies that F(παβ)=F(πβα). In this case, function F is called a priority-generating function, while function ω is called its priority function. The concept of priority-generating function has been independently introduced by Gordon, Shafransky, Proc. Academy of Sci. of Belarus, 1978, 22; Monma, Sidney, Math.Oper.Res. 1979,4. Any priority-generating function can be minimized in O(nlogn) time if the reduction graph of the precedence constraints is series-parallel and is given by its decomposition tree.

11. Priority functions for scheduling problems with processing time deterioration Positional deterioration polynomial:pj[r]= pj r A(processing time of a job depends polynomially on the position in which it is scheduled) Theorem 1.For the single machine problem to minimize the makespan, the objective function is priority-generating if A=1. Its priority function is ω(π) = (Σj|π|=1 pπ(j))/|π|, where π(k) is a job in the k-th position of permutationπ. It is unlikely that a priority function exists for A other than 1: no priority function exists for A=2 . No priority function exists for the problem of minimizing ΣCj .

12. Positional deterioration cumulative:pj[r]= pj(1+ Σkr=-11 p[k]) A(processing time of a job depends polynomially onthe total ‘normal’ processing time of jobs that have been sequenced before) Theorem 2.For the single machine problem to minimize the makespan, any (feasible) permutation of jobs defines an optimal schedule if A=1. The objective function is priority-generating if A=2.Its priority function is ω(π) = Σj|π|=1pπ(j) / Σj|π|=1p2π(j), whereπ(j)is a job in thej-th position of permutationπ. Corollary.For independent jobs, SPT is an optimal index policy. It is unlikely that a priority function exists forA>2: no priority function exists for A=3. No priority function exists for the problem of minimizingΣCj(for A =1, 2 or 3). For this problem, optimal index policy for independent jobs is SPT for any A1.

13. Positional deterioration exponential:pj[r]= pjγr-1(processing time of a job depends exponentially on the position in which it is scheduled) Theorem 3.For the single machine problem to minimize the makespan, the objective function is priority-generating. Its priority function is ω(π) = (Σj|π|=1pπ(j)γj-1)/ (γ|π|-1) For the problem with independent jobs, LPT is an optimal index policy: ω(j) = pj (1-priority function) Theorem 4.For the single machine problem to minimize the sum of completion times of independent jobs, the function ω(j) = pj is a 1-priority function for each γ≥2 . No 1-priority function exists for any γ, 1< γ<2. No priority function exists for the problem of minimizing the sum of completion times.

14. Time deterioration linear time:pj(t)= aj t + pj (processing time of a job depends linearly on its start time in some schedule) Theorem 5.For the single machine problem to minimize the makespan, the objective function is priority-generating. Its priority function is ω(π) = (Πj|π|=1 (1+aπ(j)) - 1) / (Σj|π|=1pπ(j)Πi|π|=j+1(1+aπ(i))) The problem of minimizing the weighted sum of completion times is NP-hard (Bachman, Janiak, Kovalyov, Inform.Proc.Lett. 2002) We show that even for unit processing times a 1-priority function does not exist for this problem simple linear time:pj(t)= pj(1+a t ) For the single machine problem to minimize the weighted sum of completion times, the objective function is priority-generating(Wang, Ng, Cheng, Comp.Oper.Res. 2008)

15. Time deterioration constant rate linear time:pj(t)= a t + pj(processing time of a job depends linearly on its start time in some schedule) Theorem 6.For the single machine problem to minimize the sum of completion times, the objective function is priority-generating.Its priority function is ω(π) = (Σk|π|=1 (1+a) k) / (Σk|π|=1 pπ(k)(1+a) |π| - k) For independent jobs, the problem admits SPT optimal index policy (Ng, Cheng, Bachman, Janiak, Inform.Proc.Lett. 2002). This is follows as a Corollary: If the priority function is calculated for a single job, ω(j) = 1 / pj is a 1-priority function.

17. Problem Complexity ----------------------------------------------------------------------- Positional deterioration polinomial 1 | pj[r]= pj r A , SP | Cmax O(nlogn)for A=1 cumulative 1 |pj[r]= pj(1+ Σkr=-11 p[k]) A , prec | Cmax O(n)for A=1 1 |pj[r]= pj(1+ Σkr=-11 p[k]) A , SP | Cmax O(nlogn)for A=2 1 |pj[r]= pj(1+ Σkr=-11 p[k]) A | ΣCjO(nlogn)forA1 exponential 1 |pj[r]= pjγr-1 , SP | CmaxO(nlogn) 1 |pj[r]= pjγr-1 | ΣCjO(nlogn) forγ ≥ 2

18. Problem Complexity------------------------------------------------------------------- Time deterioration linear time 1 | pj(t)= aj t + pj , SP | CmaxO(nlogn) simple linear time 1 | pj(t)= aj t , prec | Cmax O(n) 1 | pj(t)= aj t , SP | ΣwjCjO(nlogn) 1 | pj(t)= pj (1+at) , SP | ΣwjCjO(nlogn) constant rate linear time 1 | pj(t)= at , SP | ΣCjO(nlogn)

20. 2. Single Machine Scheduling and Due Date Assignment under Positional Deterioration Valery Gordon United Institute of Information Problems, Minsk, Belarus Vitaly Strusevich University of Greenwich, London, U.K.

21. This Part • Single Machine Scheduling • Jobs with Positional Deterioration Effect • Due Date Assignment (DDA) • Admission Control • Cost: • Total Cost of Discarded Jobs • Cost for DDA • Possibly Total Earliness of Scheduled Jobs

22. Motivation The supply chain: a manufacturer and a customer. The manufacturer: wishes that all accepted orders are completed in full and in time to satisfy the customer's demand. The due dates are the subject of negotiation with the customer For the mutually agreed due dates, the manufacturer can discard some of the orders if they cannot be completed in time; in this case a penalty for each discarded order is paid The manufactures uses sensitive equipment, with its production capability changing over time

23. Notation N = {1,…, n} set of jobs to be processed on a single machine pj“normal” processing time of job j If the jobs are processed in accordance with a certain permutation π=(π(1), π(2),…, π(n)), then the processing time of job j= π(r), i.e., the job sequenced in the r-th position is given by pj[r]=pjg(r), g(r) is a function that specifies a positional deterioration effect We assume that g(1)=1 and g(r) ≤ g(r+1) for each r, 1≤ r≤ n-1.

24. Notation: Deterioration Polynomial Deterioration: The actual processing time of a job j that is sequenced in position r is given by pj[r]=pj rA, where A > 0 is a given constant, common for all jobs. Biskup (1999), Mosheiov (2001, 2005) , Gordon et al. (2008) Exponential Deterioration: The actual processing time of a job j that is sequenced in position r is given by pj[r]=pj γr-1, where γ > 1 is a given constant representing a rate of deterioration, common for all jobs Wang (2005), Wang and Xia (2005) , Gordon et al. (2008)

25. Notation Due Date Assignment (DDA): survey by Gordon et al. (2004) Each job j ЄNhas to be assigned a due date dj Given a schedule, let Cj denote the completion time of job j and, provided that Cj≤ dj, define its earliness as Ej = dj - Cj In all problems under consideration: the jobs of set N have to be split into two subsets denoted by NE and NT The jobs of subset NT are essentially discarded, and a penalty αj is paid for a discarded job jЄNT. Only the jobs of set NEare sequenced, and each of these jobs is completed no later than its assigned due date. The purpose is to select the due dates for the jobs and the sequence of the early jobs in such a way that a certain penalty function is minimized.

26. Notation: Objective Functions Sequence of jobs Vector of due dates Total cost of discarded jobs Cost for DDA, Depends on the chosen model Total earliness

27. Objective Functions Due Date Assignment (DDA) Admission Control Scheduling of Deteriorating Accepted Jobs

28. Auxiliary Problem PdE where β is a given positive constant, d(π) is the completion time of the last job π(n) and is treated as a due date commonto all jobs Find a permutation π that minimizes the function

29. Auxiliary Problem PdE Lemma 1

30. Auxiliary Problem PdE Lemma 1 By pairwise interchange argument: Let π be an optimal permutation for Problem PdE. Choose an arbitrary position u, where 1 ≤ u≤ n-1, and introduce a permutation π′ that differs from π by swapping the jobs π(u) and π(u+1). It follows that Δ=f(π)-f(π′) =(pπ(u)-pπ(u+1))(g(u)(β+u-1)-g(u+1)(β+u))

31. Auxiliary Problem PdE Lemma 1 For Problem PdEwith positional deterioration an optimal permutation can be found by LPT rule: g(u+1)/g(u)≥ 1 > (β+u-1)/(β+u)

32. Auxiliary Problem Pd where d(π) is the completion time of the last job π(n) For Problem Pdwith positional deterioration an optimal permutation can be found by LPT rule Find a permutation π that minimizes the function

33. CON: Common Due Date Assignment For the CON model, all due dates are equal, and we select βdas the cost function φ(d), where β is a positive constant. Thus we minimize the objective functions

34. CON: Common Due Date Assignment To minimize the weighted number of discarded jobs with fixed times with respect to a given common due date is NP-hard in the ordinary sense [Karp 1972] CON DDA problems with fixed times admit polynomial time algorithms [De et al. 1991, Kahlbacher and Cheng 1993] CON DDA problems with resource-dependent processing times admit polynomial time algorithms [Shabtay and Steiner (2007)]

35. CON: Common Due Date Assignment Function for Problem Pd Function for Problem PdE Idea: • Fill the sequence from left to right so that the last scheduled job completes exactly at time d • Scan the jobs in LPT order • Try either to discard the job (move to set NT) or schedule it (to put it last among the scheduled jobs, compute its processing time by the deterioration formula, recompute the due date etc.). Accept the best option. • Dynamic programming

36. CON: Illustartion Idea: • Fill the sequence from left to right so that the last scheduled job completes exactly at time d • Scan the jobs in LPT order • Try either to discard the job (move to set NT) or schedule it (to put it last among the scheduled jobs, compute its processing time by the deterioration formula, recompute the due date etc.)

37. CON: Illustartion Idea: • Fill the sequence from left to right so that the last scheduled job completes exactly at time d • Scan the jobs in SPT order • Try either to discard the job (move to set NT) or schedule it (to put it last among the scheduled jobs, compute its processing time by the deterioration formula, recompute the due date etc.)

38. CON: Illustartion Idea: • Fill the sequence from left to right so that the last scheduled job completes exactly at time d • Scan the jobs in LPT order • Try either to discard the job (move to set NT) or schedule it (to put it last among the scheduled jobs, compute its processing time deterioration formula, recompute the due date etc.)

39. CON: Illustartion Idea: • Fill the sequence from left to right so that the last scheduled job completes exactly at time d • Scan the jobs in LPT order • Try either to discard the job (move to set NT) or schedule it (to put it last among the scheduled jobs, compute its processing time deterioration formula, recompute the due date etc.)

40. CON: Illustartion Idea: • Fill the sequence from left to right so that the last scheduled job completes exactly at time d • Scan the jobs in LPT order • Try either to discard the job (move to set NT) or schedule it (to put it last among the scheduled jobs, compute its processing time deterioration formula, recompute the due date etc.)

41. CON: Dynamic Programming = O(n2) Answer: Optimal F1 = min{f(n, r}|0≤r≤n} The DP algorithm uses the states of the form (k, r), where k - the number of jobs that have been considered r, 0 ≤ r ≤ k, - how many of these jobs have been sequenced early A state (k, r) is associated with f(k, r), the smallest value of the objective function in the class of partial schedules for processing k jobs, provided that r of these jobs have been sequenced early, where f(0, 0) = 0 For each k from 1 to n

42. CON: Dynamic Programming = O(n2) 1 ≤ r ≤ k-1 Answer: Optimal F2 = min{f(n, r}|0≤r≤n} The DP algorithm uses the states of the form (k, r), where k - the number of jobs that have been considered r, 0 ≤ r ≤ k, - how many of these jobs have been sequenced early A state (k, r) is associated with f(k, r), the smallest value of the objective function in the class of partial schedules for processing k jobs, provided that r of these jobs have been sequenced early, where f(0, 0) = 0 For each k from 1 to n

43. SLK Due Date Assignment For the SLK model, for each job its due date is computed by increasing its actual processing time by a slack q, common to all jobs. We select βqas the cost function φ(d), where β is a positive constant. Thus we minimize the objective functions

44. SLK Due Date Assignment

45. SLK Due Date Assignment Idea: • Try each job one by one as the on-time job • Scan the remaining jobs in LPT order • Try either to discard the job (move to set NT) or schedule it (to put it right before the on-time job, compute its processing time by the deterioration formula, recompute the due date, the slack etc.). Accept the best option. • Dynamic programming

46. SLK: Dynamic Programming = O(n3) 1 ≤ r ≤ k-1 Answer: Optimal F1 = min{min{f(h, n, r)}, Σαj} The DP algorithm uses the states of the form (h, k, r), where h – the fixed on-time job k - the number of jobs that have been considered r, 0 ≤ r ≤ k, - how many of these jobs have been sequenced early A state (h, k, r) is associated with f(h, k, r), the smallest value of the objective function in this class, where f(0, 0, 0) = 0 For each h, each k from 1 to n (without h)

47. SLK: Dynamic Programming = O(n3) Answer: Optimal F2 = min{min{f(h, n, r)}, Σαj} The DP algorithm uses the states of the form (h, k, r), where h – the fixed on-time job k - the number of jobs that have been considered r, 0 ≤ r ≤ k, - how many of these jobs have been sequenced early A state (h, k, r) is associated with f(h, k, r), the smallest value of the objective function in this class, where f(0, 0, 0) = 0 For each h, each k from 1 to n (without h)

48. Conclusion Polynomial–time dynamic programming algorithms are developed for single machine scheduling problems with deteriorating jobs, admission control and two popular policies of due date assignment (CON and SLK) The scheduled jobs follow the LPT order The results hold for any model of positional deterioration Can be extended to models with a positional learning effect, but in this case extra conditions of the parameters are required