*Article* **Dynamic Restructuring Framework for Scheduling with Release Times and Due-Dates**

### **Nodari Vakhania**

Centro de Investigación en Ciencias, Universidad Autónoma del Estado de Morelos, Morelos 62209, Mexico; nodari@uaem.mx

Received: 8 October 2019; Accepted: 12 November 2019; Published: 14 November 2019

**Abstract:** Scheduling jobs with release and due dates on a single machine is a classical strongly NP-hard combination optimization problem. It has not only immediate real-life applications but also it is effectively used for the solution of more complex multiprocessor and shop scheduling problems. Here, we propose a general method that can be applied to the scheduling problems with job release times and due-dates. Based on this method, we carry out a detailed study of the single-machine scheduling problem, disclosing its useful structural properties. These properties give us more insight into the complex nature of the problem and its bottleneck feature that makes it intractable. This method also helps us to expose explicit conditions when the problem can be solved in polynomial time. In particular, we establish the complexity status of the special case of the problem in which job processing times are mutually divisible by constructing a polynomial-time algorithm that solves this setting. Apparently, this setting is a maximal polynomially solvable special case of the single-machine scheduling problem with non-arbitrary job processing times.

**Keywords:** scheduling algorithm; release-time; due-date; divisible numbers; lateness; bin packing; time complexity

#### **1. Introduction**

Scheduling jobs with release and due-dates on single machine is a classical strongly NP-hard combination optimization problem according to Garey and Johnson [1]. In many practical scheduling problems, jobs are released non-simultaneously and they have individual due-dates by which they ideally have to complete. Since the problem is NP-hard, the existing exact solution algorithms have an exponential worst-case behavior. The problem is important not only because of its immediate real-life applications, but also because it is effectively used as an auxiliary component for the solution of more complex multiprocessor and shop scheduling problems.

Here, we propose a method that can, in general, be applied to the scheduling problems with job release times and due-dates. Based on this method, we carry out a detailed study of the single-machine scheduling problem disclosing its useful structural properties. These properties give us more insight into the complex nature of the problem and its bottleneck feature that makes it intractable. At the same time, the method also helps us to expose explicit conditions when the problem can be solved in polynomial time. Using the method, we establish the complexity status of the special case of the problem in which job processing times are mutually divisible by constructing a polynomial-time algorithm that solves this setting. This setting is a most general polynomially solvable special case of the single-machine scheduling problem when jobs have restricted processing times but job parameters are not bounded: if job processing times are allowed to take arbitrary values from set {*p*, 2*p*, 3*p*, ... }, for an integer *p*, the problem remains strongly NP-hard [2]. At the same time, the restricted setting may potentially have practical applications in operating systems (we address this issue in more detail in Section 12).

**Problem description.** Our problem, commonly abbreviated in the scheduling literature as 1|*rj*|*L*max (the notation suggested by Graham et al. [3]), can be stated as follows. There are given *n* jobs {1, 2, ... , *n*} and a single machine. Each job *j* has (uninterruptible) *processing time pj*, *release time rj* and *due-date dj*: *pj* is the time required by job *j* on the machine; *rj* is the time moment by which job *j* becomes available for scheduling on the machine; and *dj* is the time moment, by which it is desirable to complete job *j* on the machine (informally, the smaller is job due-date, the more urgent it is, and the late completion is penalized by the objective function).

The problem restrictions are as follows. The first basic restriction is that the machine can handle at most one job at a time.

A *feasible schedule S* is a mapping that assigns to every job *j* its starting time *tj*(*S*) on the machine, such that

$$t\_j(S) \ge r\_j \tag{1}$$

and

$$t\_{\dot{f}}(S) \ge t\_k(S) + p\_{k\prime} \tag{2}$$

for any job *k* included earlier in *S* (for notational simplicity, we use *S* also for the corresponding job-set).

The inequality in Equation (1) ensures that no job is started before its release time, and the inequality in Equation (2) ensures that no two jobs overlap in time on the machine.

$$c\_{\bar{\jmath}}(S) = t\_{\bar{\jmath}}(S) + p\_{\bar{\jmath}}$$

is the *completion time* of job *j* in schedule *S*.

The *delay* of job *j* in schedule *S* is

$$t\_{\vec{j}}(S) - r\_{\vec{j}}.$$

An optimal schedule is a feasible schedule minimizing the maximum job *lateness*

$$L\_{\text{max}} = \max\{j|c\_j - d\_j\}$$

(besides the lateness, there exist other due-date oriented objective functions). *L*max(*S*) (*Lj*(*S*), respectively) stands for the maximum job lateness in schedule *S* (the lateness of job *j* in *S*, respectively). The objective is to find an optimal schedule.

Adopting to the standard three-field scheduling notation, we abbreviate the special case of problem 1|*rj*|*L*max with divisible job processing times by 1|*pj* : *divisible*,*rj*|*L*max. In that setting, we restrict job processing times to the mutually divisible ones: given any two neighboring elements in a sequence of job processing times ordered non-decreasingly, the first one exactly divides the second one (this ratio may be 1). A typical such sequence is formed by the integers each of which is (an integer) power of 2 multiplied by an integer *p* ≥ 1.

**A brief introduction to our method.** Job release times and due-dates with due-date orientated objective functions compose a sloppy combination for most of the scheduling problems in the sense that it basically contributes to their intractability. In such problems, the whole scheduling horizon can be partitioned, roughly, into two types of intervals, the rigid one and the flexible ones. In an optimal schedule, every rigid interval (that potentially may contribute to the optimal objective value) is occupied by a specific set of (urgent) jobs, whereas the flexible intervals can be filled out by the rest of the (non-urgent) jobs in different ways. Intuitively, the "urgency" of a job is determined by its due-date and the due-dates of close-by released jobs; a group of such jobs may form a rigid sequence in a feasible schedule if the differences between their due-dates are "small enough". The remaining jobs are to be "dispelled" in between the rigid sequences.

This kind of division of the scheduling horizon, which naturally arises in different machine environments, reveals an inherent relationship of the scheduling problems with a version of bin packing problem and gives some insight into a complicated nature of the scheduling problems with job release times and due-dates. As shown below, this relationship naturally yields a general algorithmic framework based on the binary search.

A bridge between the scheduling and the bin packing problems is constructed by a procedure that partitions the scheduling horizon into the rigid and the flexible intervals. Exploring a recurrent nature of the scheduling problem, we develop a polynomial-time recursive procedure that partitions the scheduling horizon into the rigid and flexible intervals. After this partition, the scheduling of the rigid intervals is easy but scheduling of the flexible intervals remains non-trivial. Optimal scheduling of the flexible intervals, despite the fact that these intervals are formed by non-urgent jobs, remains NP-hard. To this end, we establish further structural properties of the problem, which yield a general algorithmic framework that may require exponential time. Nevertheless, we derive a condition when the framework will find an optimal solution in polynomial time. This condition reveals a basic difficulty that would face any polynomial-time algorithm to create an optimal solution.

Some kind of compactness property for the flexible segments may be guaranteed if they are scheduled in some special way. In particular, we show that the compactness property can be achieved by an underlying algorithm that works for the mutually divisible job processing times. The algorithm employs some nice properties of a set of mutually divisible numbers.

In terms of time complexity, our algorithmic framework solves problem 1|*rj*|*L*max in time *O*(*n*<sup>2</sup> log *n* log *p*max) if our optimality condition is satisfied. Whenever during the execution of the framework the condition is not satisfied, an additional implicit enumeration procedure can be incorporated (to maintain this work within a reasonable size, here we focus solely to exact polynomial-time algorithms). Our algorithm for problem 1|*pj* : *divisible*,*rj*|*L*max yields an additional factor of *O*(*n* log *p*max), so its time complexity is *O*(*n*<sup>3</sup> log *n* log *p*<sup>2</sup> max).

**Some previous related work.** Coffman, Garey and Johnson [4] previously showed that some special cases of a number of weakly NP-hard bin packing problems with divisible item sizes can be solved in polynomial time (note that our algorithm implies a similar result for a strongly NP-hard scheduling problem). We mention briefly some earlier results concerning our scheduling problem. As to the exponential-time algorithms, the performance of venerable implicit enumeration algorithms by McMahon and Florian [5] and Carlier [6] has not yet been surpassed. There is an easily seen polynomial special case of the problem when all job release times or due-dates are equal (Jackson [7]), or all jobs have unit processing times (Horn [8]). If all jobs have equal integer length *p*, the problem <sup>1</sup>|*pj* <sup>=</sup> *<sup>p</sup>*,*rj*|*L*max can also be solved in polynomial time *<sup>O</sup>*(*n*<sup>2</sup> log *<sup>n</sup>*). Garey et al. [9] described how the union and find tree with path compression can be used to reduce the time complexity to *O*(*n* log *n*). The problem 1|*pj* ∈ {*p*, 2*p*},*rj*|*L*max, in which job processing times are restricted to *p* and 2*p*, for an integer *p*, can also be solved in polynomial *O*(*n*<sup>2</sup> log *n* log *p*) time [10]. If we bound the maximum job processing time *pmax* by a polynomial function in *n*, *P*(*n*) = *O*(*nk*), and the maximal difference between the job release times by a constant *R*, then the problem 1/*pmax* < *P*, |*rj* − *ri*| < *R*/*L*max remains polynomially solvable [2]. When *P*(*n*) is a constant or it is *O*(*n*), the time complexity of the algorithm by [2] is *<sup>O</sup>*(*n*<sup>2</sup> log *<sup>n</sup>* log *<sup>p</sup>*max); for *<sup>k</sup>* <sup>≥</sup> 2, it is *<sup>O</sup>*(*nk*+<sup>1</sup> log *<sup>n</sup>* log *<sup>p</sup>*max). The algorithm becomes pseudo-polynomial without the restriction on *p*max and it becomes exponential without the restriction on job release times. In another polynomially solvable special case the jobs can be ordered so that *d*<sup>1</sup> ≤···≤ *dn* and *d*<sup>1</sup> − *αr*<sup>1</sup> − *βp*<sup>1</sup> ≥···≥ *dn* − *αrn* − *βpn*, for some *α* ∈ [0, +∞) and *β* ∈ [0, 1] Lazarev and Arkhipov [11]. The problem allows fast *O*(*n* log *n*) solution if for any pair of jobs *j*, *i* with *ri* > *rj* and *di* < *dj*, *dj* − *rj* − *pj* ≤ *di* − *ri* − *pi*, and if *ri* + *pi* ≥ *rj* + *pj* then *di* ≥ *dj* [12].

**The structure of this work.** This paper consists of two major parts. In Part 1, an algorithmic framework for a single machine environment and a common due-date oriented objective function, the maximum job lateness, is presented, whereas, in Part 2, the framework is finished to a polynomial-time algorithm for the special case of the problem with mutually divisible job processing times. In Section 2, we give a brief informal introduction to our method. Section 3 contains a brief overview of the basic concepts and some basic structural properties that posses the schedules enumerated in the framework. In Section 4, we study recurrent structural properties of our schedules, which permit the partitioning

of the scheduling horizon into the two types of intervals. In Section 5, we describe how our general framework is incorporated into a binary search procedure. In Section 6, we give an aggregated description of our main framework based on the partitioning of the scheduling horizon into the flexible and the rigid segments, and show how the rigid segments are scheduled in an optimal solution. In Section 7, we describe a procedure which is in charge of the scheduling of the non-urgent segments, and formulate our condition when the main procedure will deliver an optimal solution. This completes Part 1. Part 2 consists of Sections 8–11, and is devoted to the version of the general single-machine scheduling problem with mutually divisible job processing times (under the assumption that the optimality condition of Section 7 is not satisfied). In Section 8, we study the properties of a set of mutually divisible numbers that we use to reduce the search space. Using these properties, we refine our search in Section 9. In Section 10, we give the final examples illustrating the algorithm for divisible job processing times. In Section 11, we complete the correctness proof of that algorithm. The conclusions in Section 12 contain final analysis, possible impact, extensions and practical applications of the proposed method and the algorithm for the divisible job processing times.

#### **2. An Informal Description of the General Framework**

In this section, we give a brief informal introduction to our method (the reader may choose to skip it and go to formal definitions of the next section). We mention above the ties of our scheduling problem with a version of bin packing problem, in which there is a fixed number of bins of different capacities and the objective is to find out if there is a feasible solution respecting all the bin capacities. To see the relationship between the bin packing and the scheduling problems, we analyze the structure of the schedules that we enumerate. In particular, the scheduling horizon will contain two types of sequences formed by the "urgent" jobs (that we call kernels) and the remaining sequences formed by the "non-urgent" jobs (that we call bins). A key observation is that a kernel may occupy a quite restricted time interval in any optimal schedule, whereas the bin intervals can be filled out by the non-urgent jobs in different ways. In other words, the urgent jobs are to be scheduled within the rigid time intervals, whereas non-urgent ones are to be dispelled within the flexible intervals. Furthermore, the time interval within which each kernel is to be scheduled can be "adjusted" in terms of the delay of its earliest scheduled job. In particular, it suffices to consider the feasible schedules in which the earliest job of a kernel *K* is delayed by at most some magnitude, e.g., *δK*; *δ<sup>K</sup>* ∈ [0, Δ*K*], where Δ*<sup>K</sup>* is the initial delay of the earliest scheduled job of that kernel (intuitively, Δ*<sup>K</sup>* can be seen as an upper bound on the possible delay for kernel *K*, a magnitude, by which the earliest scheduled job of kernel *K* can be delayed without surpassing the minimal so far achieved maximum job lateness). As shown below, for any kernel *K*, Δ*<sup>K</sup>* < *p*max = max*j*{*pj*}. Observe that, if *δ<sup>K</sup>* = 0, i.e., when we restrict our attention to the feasible schedules in which kernel *K* has no delay, the lateness of the latest scheduled job of that kernel is a lower bound on the optimal objective value. In this way, we can calculate the time intervals which are to be assigned to every kernel relatively easily. The bins are formed by the remaining time intervals. The length of a bin, i.e., that of the corresponding time interval, will not be prior fixed until the scheduling of that bin is complete (roughly, because there might be some valid range for the "correct" Δ*K*s).

Then, roughly, the scheduling problem reduces to finding out if all the non-kernel jobs can "fit" feasibly (with respect to their release times) into the bins without surpassing the currently allowable lateness for the kernel following that bin; recall that the "allowable lateness" of kernel *K* is determined by *δK*. We "unify" all the *δK*s to a single *δ* (common for all the kernels), and carry out binary search to find an optimal *δ* within the interval [0, max*<sup>K</sup>* Δ*<sup>K</sup>* (the minimum *δ* such that all the non-kernel jobs fit into the bins; the less is *δ*, the less is the imposed lateness for the kernel jobs).

Thus, there is a fixed number of bins of different capacities (which are the lengths of the corresponding intervals in our setting), and the items which are to be assigned to these bins are non-kernel jobs. We aim to find out if these items can feasibly be packed into these bins. A simplified version of this problem, in which no specified time interval with each bin is associated and the items can be packed in any bin, is NP-hard. In our version, whether a job can be assigned to a bin depends, in a straightforward way, on the interval of that bin and on the release time of that job (a feasible packing is determined according to these two parameters).

If the reader is not yet too confused, we finally note that the partition of jobs into kernel and non-kernel ones is somewhat non-permanent: during the execution of our framework, a non-kernel job may be "converted" into a kernel one. This kind of situation essentially complicates the solution process and needs an extra treatment. Informally, this causes the strong NP-hardness of the scheduling problem: our framework will find an optimal solution if no non-kernel job converts to a kernel one during its execution (the so-called instance of Alternative (b2)). We observe this important issue in later sections, starting from Section 7.

#### **3. Basic Definitions**

This subsection contains definitions which consequently gain in structural insight of problem 1|*rj*|*L*max (see, for instance, [2,13]). First, we describe our main schedule generation tool. Jackson's extended heuristics (Jackson [7] and Schrage [14]), also referred to as the *Earliest Due-date* heuristics (ED-heuristics), is commonly used for scheduling problems with job release times and due-dates. ED-heuristics is characterized by *n* scheduling times: these are the time moments at which a job is assigned to the machine. Initially, the earliest scheduling time is set to the minimum job release time. Among all jobs released by a given scheduling time (the jobs available by that time moment), one with the minimum due-date is assigned to the machine (ties can be broken by selecting a longest job). Iteratively, the next scheduling time is the maximum between the completion time of the latest assigned so far job to the machine and the minimum release time of a yet unassigned job (note that no job can be started before the machine gets idle, and no job can be started before its release time). Among all jobs available by each scheduling time, a job with the minimum due-date is determined and is scheduled on the machine at that time. Thus, whenever the machine becomes idle, ED-heuristics schedules an available job giving the priority to a most urgent one. In this way, it creates no gap that can be avoided (by scheduling some already released job).

#### *3.1. Structural Components in an ED-Schedule*

While constructing an ED-schedule, a *gap* (an idle machine-time) may be created (a maximal consecutive time interval during which the machine is idle; by our convention, there occurs a 0-length gap (*cj*, *ti*) if job *i* is started at its release time immediately after the completion of job *j*.

An ED-schedule can be seen as a sequence of somewhat independent parts, the so-called *blocks*; each block is a consecutive part in that schedule that consists of a sequence of jobs successively scheduled on the machine without any gap in between any neighboring pair of them; a block is preceded and succeeded by a (possibly a 0-length) gap.

As shown below in this subsection, by modifying the release times of some jobs, ED-heuristics can be used to create different feasible solutions to problem 1|*rj*|*L*max. All feasible schedules that we consider are created by ED-heuristics, which we call ED-schedules. We construct our initial ED-schedule, denoted by *σ*, by applying ED-heuristics to the originally given problem instance. Then, we slightly modify the original problem instance to generate other feasible ED-schedules.

**Kernels.** Now, we define our kernels and the corresponding bins formally. Recall that kernel jobs may only occupy restricted intervals in an optimal schedule, whereas the remaining bin intervals are to be filled in by the rest of the jobs (the latter jobs are more flexible because they may be "moved freely" within the schedule, without affecting the objective value to a certain degree, as we show below).

Let *B*(*S*) be a block in an ED-schedule *S* containing job *o* that realizes the maximum job lateness in that schedule, i.e.,

$$L\_o(S) = \max\_{\nearrow} \{ L\_j(S) \} = L\_{\max}(S). \tag{3}$$

Among all jobs in block *B*(*S*) satisfying Equation (3), the latest scheduled one is called an *overflow job* in schedule *S*.

A *kernel* in schedule *S* is a longest continuous job sequence ending with an overflow job *o*, such that no job from this sequence has a due-date greater than *do* (for notational simplicity, we use *K* also for the corresponding job-set). For a kernel *<sup>K</sup>*, we let *<sup>r</sup>*(*K*) = min*i*∈*K*{*ri*}. We may observe that the number of kernels in schedule *S* equals to the number of the overflow jobs in it. Besides, since every kernel is contained within a single block, it may include no gap. We denote by *K*(*S*) the earliest kernel in schedule *S*. The following proposition states an earlier known fact from [13]. Nevertheless, we also give its proof as it gains some intuition on the used here techniques.

**Proposition 1.** *The maximum lateness of a job of kernel K in ED-schedule S is the minimum possible if the earliest scheduled job of that kernel starts at time r*(*K*)*. Hence, if schedule S contains a kernel with this property, then it is optimal.*

**Proof.** By the definition, for any job *j* ∈ *K*, *dj* ≤ *do* (job *j* is no-less urgent than the overflow job *o*), whereas note that the maximum lateness of a job of kernel *K* in schedule *S* is *Lo*(*S*). At the same time, the jobs in kernel *K* form a tight (continuous) sequence without any gap. Let *S* be a complete schedule in which the order of jobs of kernel *K* differs to that in schedule *S* and let job *o* realizes the maximum lateness of a job of kernel *K* in schedule *S* . Then, from the above observations and the fact that the earliest job of kernel *K* starts at its release time in schedule *S*, it follows that

$$L\_{\boldsymbol{\sigma}}(\mathcal{S}) \le L\_{\boldsymbol{\sigma}'}(\mathcal{S}').$$

Hence,

$$L\_{\text{max}}(S') \ge L\_o(S) = L\_{\text{max}}(S) \tag{4}$$

and schedule *S* is optimal.

**Emerging jobs.** In the rest of this section, let *S* be an ED-schedule with kernel *K* = *K*(*S*) and with the overflow job *o* ∈ *K* such that the condition in Proposition 1 does not hold. That is, there exists job *e* with *de* > *do* scheduled before all jobs of kernel *K* that imposes a forced delay (right-shift) for the jobs of that kernel. By creating an alternative feasible schedule in which job *e* is rescheduled after kernel *K*, this kernel may be (re)started earlier, i.e., the earliest scheduled job of kernel *K* may be restarted earlier than the earliest scheduled job of that kernel has started in schedule *S*. We need some extra definitions before we define the so-obtained alternative schedule formally.

Suppose job *i* precedes job *j* in ED-schedule *S*. We say that *i pushes j* in *S* if ED-heuristics may reschedule job *j* earlier if job *i* is forced to be scheduled after job *j*.

If (by the made assumption immediately behind Proposition 1) the earliest scheduled job of kernel *K* does not start at its release time, then it is immediately preceded and pushed by Job *l* with *dl* > *do*, the so-called *delaying emerging* job for kernel *K* (we use *l* exclusively for the delaying emerging job).

Besides the delaying emerging job, there may exist job *e* with *de* > *do* scheduled before kernel *K* (hence before Job *l*) in schedule *S* pushing jobs of kernel *K* in schedule *S*. Any such job as well as Job *l* is referred to as an *emerging job* for *K*.

We denote the set of emerging jobs for kernel *K* in schedule *S* by *E*(*K*). Note that *l* ∈ *E*(*K*) and since *S* is an ED-schedule, *re* < *r*(*K*), for any *e* ∈ *E*(*K*), as otherwise a job of kernel *K* with release time *r*(*K*) would have been included at the starting time of job *e* in schedule *S*.

Besides jobs of set *E*(*K*), schedule *S* may contain job *j* satisfying the same parametric conditions as an emerging job from set *E*(*K*), i.e., *dj* > *do* and *rj* < *r*(*K*), but scheduled after kernel *K*. We call such a job a *passive emerging job* for kernel *K* (or for the overflow job *o*) in schedule *S*. We denote the set of all the passive emerging jobs for kernel *K* = *K*(*S*) by *EP*(*K*).

Note that any *j* ∈ *EP*(*K*) is included in block *B*(*S*) (the block in schedule *S* containing kernel *K*) in schedule *S*. Note also that, potentially, any job *j* ∈ *EP*(*K*) can be feasibly scheduled before kernel *K* as well. A job not from set *E*(*K*) ∪ *EP*(*K*) is a *non-emerging* job in schedule *S*.

In summary, all jobs in *E*(*K*) ∪ *EP*(*K*) are less urgent than all jobs of kernel *K* and any of them may be included before or after that kernel within block *B*(*S*). The following proposition is not difficult to prove (e.g., see [13]).

**Proposition 2.** *Let S be a feasible schedule obtained from schedule S by the rescheduling a non-emerging job of schedule S after kernel K. Then, The inequality in Equation* (4) *holds.*

**Activation of an emerging job.** Because of the above proposition, it suffices to consider only the rearrangements in schedule *S* that involve the jobs from set *E*(*K*) ∪ *EP*(*K*). As the first pass, to restart kernel *K* earlier, we may create a new ED-schedule *Se* obtained from schedule *S* by the rescheduling an emerging job *e* ∈ *E*(*K*) after kernel *K* (we call this operation the *activation* of job *e* for kernel *K*). In ED-schedule *Se*, besides job *e*, all jobs in *EP*(*K*) are also scheduled (remain to be scheduled) after kernel *K*. Technically, we create schedule *Se* by increasing the release times of job *e* and jobs in *EP*(*K*) to a sufficiently large magnitude (e.g., the maximum job release time in kernel *K*), so that, when ED-heuristics is newly applied, neither job *e* nor any of the jobs in set *EP*(*K*) will be scheduled before any job of kernel *K*.

It is easily seen that kernel *K* (regarded as a job-set) restarts earlier in ED-schedule *Se* than it has started in schedule *S*. In particular, the earliest job of kernel *K* is immediately preceded by a gap and starts at time *r*(*K*) in schedule *Sl*, whereas the earliest scheduled job of kernel *K* in schedule *S* starts after time *r*(*K*) (the reader may have a look at the work of Vakhania, N. [13] for more details on the relevant issues).

*L***-schedules.** We call a complete feasible schedule *S<sup>L</sup>* in which the lateness of no job is more than threshold *L*, an *L-schedule*. In schedule *S*, job *i* is said to *surpass the L-boundary* if *Li*(*S*) > *L*.

The magnitude

$$
\lambda\_i(S) = L\_i(S) - L \tag{5}
$$

is called the *L-delay* of job *i* in schedule *S*.

#### *3.2. Examples*

We illustrate the above introduced notions in the following two examples.

**Example 1.** *We have a problem instance with four jobs* {*l*, 1, 2, 3}*, defined as follows: rl* = 0, *pl* = 16, *dl* = 100, *r*<sup>1</sup> = 5, *p*<sup>1</sup> = 2, *d*<sup>1</sup> = 8*, r*<sup>2</sup> = 4, *p*<sup>2</sup> = 4, *d*<sup>2</sup> = 10*, r*<sup>3</sup> = 3, *p*<sup>3</sup> = 8, *d*<sup>3</sup> = 12*.*

The initial ED-schedule *σ* is illustrated in Figure 1. There is a single emerging job in that schedule, which is the delaying emerging Job *l* pushing the following scheduled Jobs 1–3, which constitute the kernel in *σ*; Job 3 is the overflow job *o* in schedule *σ*, which consists of a single block. *L*max(*σ*) = *L*3(*σ*) = 30 − 12 = 18.

ED-schedule *σl*, depicted in Figure 2, is obtained by activating the delaying emerging Job *l* in schedule *σ* (the release time of Job *l* is set to that of job 1 and ED-heuristics is newly applied). Kernel in that schedule is formed by Jobs 1 and 2, Job 2 is the overflow job with *L*max(*σl*) = *L*2(*σl*) = 17 − 10 = 7, whereas Job 3 becomes the delaying emerging job in schedule *σl*.

**Figure 1.** The initial ED-schedule *σ* for Example 1.

**Figure 2.** The ED-schedule *σ<sup>l</sup>* for Example 1.

**Example 2.** *In our second (larger) problem instance, we have eight jobs* {*l*, 1, 2, . . . , 7}*, defined as follows: rl* = 0, *pl* = 32, *dl* = 50, *r*<sup>1</sup> = 3, *p*<sup>1</sup> = 4, *d*<sup>1</sup> = 23*, r*<sup>2</sup> = 10, *p*<sup>2</sup> = 2, *d*<sup>2</sup> = 22*, r*<sup>3</sup> = 11, *p*<sup>3</sup> = 8, *d*<sup>3</sup> = 20*, r*<sup>4</sup> = 0, *p*<sup>4</sup> = 8, *d*<sup>4</sup> = 67*, r*<sup>5</sup> = 54, *p*<sup>5</sup> = 4, *d*<sup>5</sup> = 58*, r*<sup>6</sup> = 54, *p*<sup>6</sup> = 4, *d*<sup>6</sup> = 58*, r*<sup>7</sup> = 0, *p*<sup>7</sup> = 8, *d*<sup>7</sup> = 69*.*

The initial ED-schedule *σ* is illustrated in Figure 3. Job *l* is the delaying emerging job, and Jobs 4 and 7 are passive emerging jobs. The kernel *K*<sup>1</sup> = *K*(*σ*) is formed by Jobs 3, 2, and 1 (Job 1 being the overflow job).

ED-schedule *σ<sup>l</sup>* is depicted in Figure 4. There arises a (new) kernel *K*<sup>2</sup> = *K*(*σl*) formed by Jobs 5 and 6, whereas Job 4 is the delaying emerging job (Job 7 is the passive emerging job for both, kernels *<sup>K</sup>*<sup>1</sup> and *<sup>K</sup>*2). Job 6 is the overflow job, with *<sup>L</sup>*max(*σl*) = *<sup>L</sup>*6(*σl*) = <sup>68</sup> <sup>−</sup> <sup>58</sup> <sup>=</sup> 10.

 - 

**Figure 3.** The initial ED-schedule *σ* for Example 2.

 - -- 

**Figure 4.** ED-schedule *σ<sup>l</sup>* for Example 2.

#### **4. Recurrent Substructures for Kernel Jobs**

In this section, we describe a recursive procedure that permits us to determine the rigid intervals of a potentially optimal schedule (as we show below, these intervals not necessarily coincide with kernel intervals detected in ED-schedules). The procedure relies on an important recurrent substructure property, which is also helpful for the establishment of the ties of the scheduling problem with bin packing problems.

We explore the recurrent structure of our scheduling problem by analyzing ED-schedules. To start with, we observe that in ED-schedule *Sl* (where *l* is the delaying emerging job for kernel *K* = *K*(*S*)), the processing order of the jobs in kernel *K* can be altered compared to that in schedule *S*. Since the time interval that was occupied by Job *l* in schedule *S* gets released in schedule *Sl*, some jobs of kernel *K* may be scheduled within that interval (recall that by the construction, no job from *EP*(*K*) may occupy that interval). In fact, the processing order of jobs of kernel *K* in schedules *S* and *Sl* might be different: recall from Section 3 that a job *j* ∈ *K* with *rj* = *r*(*K*) will be included the first within

the above interval in schedule *Sl* (whereas kernel *K* in schedule *S* is not necessarily initiated by job *j*; the reader may compare ED-schedules of Figures 1 and 2 and those of Figures 3 and 4 of Examples 1 and 2, respectively).

We call job *j* ∈ *K anticipated* in schedule *Sl* if it is rescheduled to an earlier position in that schedule compared to its position in schedule *S* (in ED-schedules of Figures 2 and 4, Job 3 and Jobs 1 and 2, respectively, are the anticipated ones). In other words, job *j* surpasses at least one job *i* in schedule *Sl* such that *i* has surpassed *j* in schedule *S* (we may easily observe that, due to ED-heuristics, this may only happen if *qj* < *qi*, as otherwise job *j* would have been included before job *i* already in schedule *S*). Recall from Section 3 that the earliest scheduled job of kernel *K* is immediately preceded by a newly arisen gap in schedule *Sl* (in ED-schedules of Figures 2 and 4 it is the gap [0, 3)). Besides, a new gap in between the jobs of kernel *K* may also arise in schedule *Sl* if there exists an anticipated job since, while rescheduling the jobs of kernel *K*, there may occur a time moment at which some job of that kernel completes but no other job is available in schedule *Sl*. Such a time moment in ED-schedule of Figure 4 is 7, which is extending up to the release Time 10 of Job 2 resulting in a new gap [7, 10) arising within the jobs of kernel *K*1.

It is apparent now that jobs of kernel *K* (kernel *K*<sup>1</sup> in the above example) may be redistributed into several continuous parts separated by the gaps in schedule *Sl* (the first such part in ED-schedule of Figure 4. consists of the anticipated Job 1 and the second part consists of Jobs 2 and 3, where Job 2 is another anticipated job).

If there arises an anticipated job so that the jobs of kernel *K* are redistributed into one or more continuous parts in schedule *Sl*, then kernel *K* is said to *collapse*; if kernel *K* collapses into a single continuous part, then this continuous part and kernel *K*, considered as job-sets, are the same, but the corresponding job sequences are different because of an anticipated job. It follows that, if kernel *K* collapses, then there is at least one anticipated job in schedule *Sl* that converts to the delaying emerging job in that schedule (recall from Proposition 1 that schedule *S* is optimal if it possesses no delaying emerging job).

Throughout this section, we concentrate our attention to the part of schedule *Sl* initiating at the starting time of Job *l* in schedule *S* and containing all the newly arisen continuous parts of kernel *K* in that schedule that we denote by *Sl*[*K*]. We treat this part as an independent ED-schedule consisting of solely the jobs of the collapsed kernel *K* (recall that no job distinct from a job of kernel *K* may be included in schedule *Sl* until all jobs of kernel *K* are scheduled, by the definition of that schedule). For the instance of Example 1 with *S* = *σ*, schedule *σl*[*K*] is the part of the ED-schedule of Figure 2 that initiates at at Time 0 and ends at Time 17. For the instance of Example 2, schedule *σl*[*K*1] starts at Time 0 and ends at Time 20 (see Figure 4).

We distinguish three different types of continuous parts in schedule *Sl*[*K*]. A continuous part that consists of only anticipated jobs (contains no anticipated job, respectively) is called an *anticipated* (*uniform*, respectively) continuous part. A continuous part which is neither anticipated nor uniform is called *mixed* (hence, mixed continuous part contains at least one anticipated and one non-anticipated job).

We observe that in ED-schedule of Figure 2 schedule *σl*[*K*] consists of a single mixed continuous part with the anticipated Job 3, which becomes the new delaying emerging job in that schedule. Schedule *σl*[*K*1] of Example 2 (Figure 4) consists of two continuous parts, the first of which is anticipated with a single anticipated Job 1, and the second one is mixed with the anticipated Job 2. The latter job becomes the delaying emerging job in schedule *σl*[*K*1] and is followed by Job 3, which constitutes the unique kernel in schedule *σl*[*K*1].

#### *Substructure Components*

The decomposition of kernel *K* into the continues parts has the recurrent nature. Indeed, we easily observe that schedule *Sl*[*K*] has its own kernel *K*<sup>1</sup> = *K*((*Sl*)[*K*]). If kernels *K* and *K*<sup>1</sup> (considered as sequences) are different, then the decomposition process naturally continues with kernel *K*<sup>1</sup> (otherwise, it ends by Point (4) of Proposition 3). For instance, in Example 1, kernel *K*<sup>1</sup> is constituted by Jobs 1 and 2 (Figure 2) and, in Example 2, it is constituted by Job 3 (see Figure 4) (in Lemma 4, we show that schedule *Sl*[*K*] may contain only one kernel, which is from the last continuous part of that schedule). In turn, if kernel *K*<sup>1</sup> possesses the delaying emerging job, it may also collapse, and this process may recurrently be repeated. This gives the rise to a recurrent substructure decomposition of kernel *K*. The process continues as long as the next arisen kernel may again collapse, i.e., it possesses the delaying emerging job. Suppose there is the delaying emerging job *l*<sup>1</sup> for kernel *K*<sup>1</sup> in schedule *Sl*[*K*]. We recurrently define a (sub)schedule *Sl*,*l*<sup>1</sup> [*K*, *K*1] of schedule *Sl*[*K*] containing only jobs of kernel *K*<sup>1</sup> and in which the delaying emerging job *l*<sup>1</sup> is activated for that kernel, similarly to what is done for schedule *Sl*[*K*]. This substructure definition applies recursively as long as every newly derived (sub)schedule contains a kernel that may collapse, i.e., it possesses the delaying emerging job (this kernel belongs to the last continuous part of the (sub)schedule, as we prove in Lemma 4). This delaying emerging job is activated and the next (sub)schedule is similarly created.

We refer to the created is this (sub)schedules as the substructure *components* arisen as a result of the collapsing of kernel *K* and the following arisen kernels during the decomposition process. As already specified, the first component in the decomposition is *Sl*[*K*] with kernel *K*<sup>1</sup> = *K*(*Sl*[*K*]), the second one is *Sl*,*l*<sup>1</sup> [*K*, *K*1] with kernel *K*<sup>2</sup> = *K*(*Sl*,*l*<sup>1</sup> [*K*, *K*1]), the third one is *Sl*,*l*1,*l*<sup>2</sup> [*K*, *K*1, *K*2], with kernel *K*<sup>3</sup> = *K*(*Sl*,*l*1,*l*<sup>2</sup> [*K*, *K*1, *K*2]), where *l*<sup>2</sup> is the delaying emerging job of kernel *K*2, and so on, with the last *atomic component* being *Sl*,*l*1,...,*lk* [*K*, *K*1, ... , *Kk*] such that the kernel *K*<sup>∗</sup> = *K*(*Sl*,*l*1,...,*lk* [*K*, *K*1, ... , *Kk*]) of that component has no delaying emerging job (here, *lk* is the delaying emerging job of kernel *Kk*). Note that the successively created components during the decomposition form an embedded substructure in the sense that the set of jobs that contains each next generated component is a proper subset of that of the previously created one: substructure component *Sl*,*l*1,...,*lj* [*K*, *K*1, ... , *Kj*], for any *<sup>j</sup>* <sup>≤</sup> *<sup>k</sup>*, contains only jobs of kernel *Kj*, whereas clearly <sup>|</sup>*Kj*<sup>|</sup> <sup>&</sup>lt; <sup>|</sup>*Sl*,*l*1,...,*lj*−<sup>1</sup> [*K*, *<sup>K</sup>*1, ... , *Kj*−1]<sup>|</sup> (as kernel *Kj* does not contain, at least, job *lj*, i.e., no activated delaying emerging job pertains to the next generated substructure component).

Below, we give a formal description of the procedure that generates the complete decomposition of kernel *K*, i.e., it creates all the substructure components of that kernel.

PROCEDURE Decomposition(*S*, *K*, *l*)

{*S* is an ED-schedule with kernel *K* and delaying emerging Job *l*} WHILE *Sl*[*K*] is not atomic DO BEGIN *S* := *Sl*[*K*]; *K* := the kernel in component *Sl*[*K*]; *l* := the delaying emerging job of component *Sl*[*K*]; CALL PROCEDURE Decomposition(*S*, *K*, *l*) END.

We illustrate the decomposition procedure on our two problem instances.

**Example 1 (continuation).** In the decomposition of kernel *K*(*σ*) of Example 1, in ED-schedule of Figure 2, kernel *K*<sup>1</sup> of substructure component *Sl*[*K*] consists of Jobs 1 and 2, and Job 3 is the corresponding delaying emerging job. Figure 5 illustrates schedule *σl*,3 obtained from schedule *σ<sup>l</sup>* of Figure 2 by the activation of the (second) emerging Job 3 (which, in fact, is optimal for the instance of Example 1, with *Lmax*(*σl*,3) = *L*3(*σl*,3) = 18 − 12 = 6). A new substructure component *Sl*,3[*K*, *K*1] consisting of jobs of kernel *K*<sup>1</sup> is a mixed continuous part with the anticipated Job 2. Kernel *K*<sup>2</sup> of that component consists of Job 1, whereas Job 2 is the delaying emerging job for that sub-kernel (*L*1(*σl*,3) = 10 − 8 = 2). Figure 6 illustrates ED-schedule *σl*,3,2 that contains the next substructure component *Sl*,3,2[*K*, *K*1, *K*2] consisting of Job 1. Substructure component *Sl*,3,2[*K*, *K*1, *K*2] is uniform and is the last atomic component in the decomposition, as it possesses no delaying emerging job and forms the last (atomic) kernel *K*<sup>3</sup> in the decomposition (with no delaying emerging job). *Lmax*(*Sl*,3,2[*K*, *K*1, *K*2]) = *L*1(*σl*,3,2) = 7 − 8 = −1. Note that the kernel in component *Sl*,3,2[*K*, *K*1, *K*2]

coincides with that component and is not a kernel in ED-schedule *σl*,3,2 (the overflow job in that schedule is Job 3 with *Lmax*(*σl*,3,2) = *L*3(*σl*,3,2) = 19 − 12 = 7).

$$\begin{array}{c|c|c} \mu \mu \mu \mu \mu & \frac{2}{3} & \frac{1}{3} & \frac{3}{13} & & & & \\ \hline \hline \text{ $\S = $ } & \mathbf{8} & \mathbf{10} & & & & \mathbf{13} \\ \hline \hline \text{ $\S = $ } & \mathbf{8} & \mathbf{10} & & & & \mathbf{13} \\ \hline \end{array}$$

**Figure 5.** ED-schedule representing the second substructure component in the decomposition of kernel *K* for Example 1.

**Figure 6.** ED-schedule representing the third (atomic) substructure component in the decomposition of kernel *K* for Example 1.

**Example 2 (continuation).** Using this example, we illustrate the decomposition of two different kernels, which are denoted by *K*<sup>1</sup> and *K*<sup>2</sup> abvoe. In the decomposition of kernel *K*1, in ED-schedule *σ<sup>l</sup>* of Figure 4, we have two continuous parts in substructure component *Sl*[*K*1], the second of which contains kernel *K*<sup>1</sup> <sup>1</sup> consisting of Job 3; the corresponding delaying emerging job is Job 2. The next substructure component *Sl*,2[*K*1, *K*<sup>1</sup> <sup>1</sup>] consisting of Job 3 (with the lateness 19 − 20 = −1) is uniform and it is an atomic component that completes the decomposition of kernel *K*1. This component can be seen in Figure 7 representing ED-schedule *σl*,2 obtained from schedule *σ<sup>l</sup>* of Figure 4 by the activation of the emerging Job 2 for kernel *K*<sup>1</sup> 1.

Once the decomposition of kernel *K*<sup>1</sup> is complete, we detect a new kernel *K*<sup>2</sup> consisting of Jobs 5 and 6 in the ED-schedule *σl*,2 depicted in Figure 7 (the same kernel is also represented in the ED-schedule *σ<sup>l</sup>* of Figure 4). Kernel *K*<sup>2</sup> possesses the delaying emerging Job 4. The first substructure component *S*4[*K*2] in the decomposition of kernel *K*<sup>2</sup> consists of a single uniform continuous part, which forms also the corresponding kernel *K*<sup>2</sup> <sup>1</sup>. The latter kernel has no delaying emerging job and the component *S*4[*K*2] is atomic (see Figure 8).

$$\underbrace{\begin{array}{c} \mu \mu \frac{1}{3} \\ \text{55} \\ \end{array}}\_{\text{i}^{1}} \# \underbrace{\begin{array}{c} \mu \\ \text{55} \\ \end{array}}\_{\text{i}^{1}} \underbrace{\begin{array}{c} \mu \\ \text{55} \\ \end{array}}\_{\text{i}^{1}} \underbrace{\begin{array}{c} \mu \\ \text{55} \\ \end{array}}\_{\text{i}^{1}} \underbrace{\begin{array}{c} \mu \\ \text{55} \\ \end{array}}\_{\text{i}^{1}} \underbrace{\begin{array}{c} \mu \\ \text{55} \\ \end{array}}\_{\text{i}^{1}} \underbrace{\begin{array}{c} \mu \\ \text{55} \\ \end{array}}\_{\text{i}^{1}} \underbrace{\begin{array}{c} \mu \\ \text{55} \\ \end{array}}\_{\text{i}^{1}} \underbrace{\overbrace{\mu \mu \end{array}}\_{\text{i}^{1}} \underbrace{\overbrace{\mu \mu \end{array}}\_{\text{i}^{1}} \underbrace{\overbrace{\mu \mu \end{array}}\_{\text{i}^{1}} \underbrace{\overbrace{\mu \mu \end{array}}\_{\text{i}^{1}} \underbrace{\overbrace{\mu \mu \end{array}}\_{\text{i}^{1}} \underbrace{\overbrace{\overbrace{\mu \mu \}}\_{\text{i}^{1}} \underbrace{\overbrace{\overbrace{\mu \mu \}}\_{\text{i}^{1}}}\_{\text{i}^{1}} \underbrace{\overbrace{\overbrace{\overbrace{\overbrace{\overbrace{\overbrace{\overbrace{\overbrace{\overleft}{\overleft}{\overleft}{\overleft}{\overleft}{\overleft}{\overleft}{\overleft}{\overleft}{\overleft}{\overleft}{\over{\overleft}{\overleft}{\overleft(\overleft$$

**Figure 7.** ED-schedule representing the second (atomic) substructure component in the decomposition of kernel *K*<sup>1</sup> and kernel *K*<sup>2</sup> for Example 2.

$$\begin{array}{ccccc}\mu\_{\frac{1}{3}} & \mu\_{\frac{1}{3}} & \mu\_{\frac{2}{3}} & \mu\_{\frac{3}{3}} & \mu\_{\frac{4}{3}} & \mu\_{\frac{5}{3}} \\ \hline \frac{1}{6} & \mu\_{\frac{1}{3}} & & & & \mu\_{\frac{1}{3}} & \mu\_{\frac{2}{3}} \\ \hline \end{array}$$

**Figure 8.** ED-schedule representing the atomic substructure components for kernels *K*<sup>1</sup> and *K*<sup>2</sup> for Example 2.

We need a few auxiliary lemmas to prove the validity of the decomposition procedure. For notational simplicity, we state them in terms of schedule *S* with kernel *K* and the component *Sl*[*K*] (instead of referring to an arbitrary component *Sl*,*l*1,...,*lj* [*K*, *K*1, ... , *Kj*] with kernel *Kj*+<sup>1</sup> and the following substructure component *Sl*,*l*1,...,*lj*,*lj*+<sup>1</sup> [*K*, *K*1, ... , *Kj*, *Kj*+1]). The next proposition immediately follows from the definitions.

#### **Proposition 3.** *Suppose kernel K collapses. Then:*


**Lemma 1.** *Let A be an anticipated continuous part in component Sl*[*K*]*. Then for any job j* ∈ *A,*

$$L\_j(\mathcal{S}\_l[K]) < L\_{\max}(\mathcal{S}\_l[K]),$$

*i.e., an anticipated continuous part may not contain kernel K*(*Sl*[*K*])*.*

**Proof.** Let *G* be the set of all jobs which have surpassed job *j* in schedule *S* and were surpassed by *j* in *Sl*[*K*] (recall the definition of an anticipated part). For any job *i* ∈ *G*, *dj* ≥ *di* since job *j* is released before jobs in set *G* and it is included after these jobs in ED-schedule *S*. This implies that *Lj*(*Sl*[*K*]) < *Li*(*Sl*[*K*]) ≤ *L*max(*Sl*[*K*]). The lemma is proved.

**Lemma 2.** *A uniform continuous part U in component Sl*[*K*] *(considered as an independent ED-schedule), may contain no delaying emerging job.*

**Proof.** Schedule *U* has no anticipated job, i.e., the processing order of jobs in *U* in both schedules *S* and *Sl*[*K*] is the same. Observe that *U* constitutes a sub-sequence of kernel *K* in schedule *S*. However, kernel *K* has a single delaying emerging Job *l* that does not belong to schedule *Sl*[*K*]. Since *U* is part of *Sl*[*K*] and it respects the same processing order as schedule *S*, it cannot contain the delaying emerging job.

**Lemma 3.** *Suppose a uniform continuous part U* ∈ *Sl*[*K*] *contains a job realizing the maximum lateness in component Sl*[*K*]*. Then,*

$$L\_{\text{max}}(\mathcal{U}) \le L\_{\text{max}}(S^{\text{opt}}),\tag{6}$$

*i.e., the lateness of the corresponding overflow job is a lower bound on the optimal objective value.*

**Proof.** Considering part *U* as an independent schedule, it may contain no emerging job (Lemma 2). At the same time, the earliest scheduled job in *U* starts at its release time since it is immediately preceded by a gap, and the lemma follows from Proposition 1.

**Lemma 4.** *Only a job from the last continuous part C* ∈ *Sl*[*K*] *may realize the maximum job lateness in schedule Sl*[*K*]*.*

**Proof.** The jobs in the continuous part *C*: (i) either were the latest scheduled ones from kernel *K* in schedule *S*; or (ii) the latest scheduled ones of schedule *S* have anticipated the corresponding jobs in *C* in schedule *Sl*[*K*]. In Case (ii), these anticipated jobs may form part of *C* or be part of a preceding continuous part *P*. In the latter sub-case, due to a gap in between the continuous parts in *Sl*[*K*], the jobs of continuous part *P* should have been left-shifted in schedule *Sl*[*K*] no less than the jobs in continuous part *C* and our claim follows. The former sub-case of Case (ii) is obviously trivial. In Case (i), similar to in the earlier sub-case, the jobs from the continuous parts preceding *C* in *Sl*[*K*] should have been left-shifted in *Sl*[*K*] no less than the jobs in *C* (again, due to the gap in between the continuous parts). Hence, none of them may have the lateness more than that of a job in continuous part *C*.

**Proposition 4.** *PROCEDURE Decomposition*(*S*, *K*, *l*) *finds the atomic component of kernel K in less than κ*/2 *iterations, where κ is the number of jobs in kernel K. The kernel of that atomic component is formed by a uniform continuous part, which is the last continuous part of that component.*

**Proof.** With every newly created substructure component during the decomposition of a kernel with *κ* jobs, the corresponding delaying emerging job is associated. At every iteration of the procedure, the delaying emerging job is activated, and that job does not belong to the next generated component. Then, the first claim follows as every kernel contains at least one job. Hence, the total number of the created components during all calls of the collapsing stage is bounded above by *κ*/2.

Now, we show the second claim. From Lemma 4, the last continuous part of the atomic component contains the overflow job of that component. Clearly, the last continuous part of any component cannot be anticipated, whereas any mixed continuous part (seen as an independent schedule) contains an emerging job, hence a component with the last mixed continuous part cannot be atomic. Then, the last continuous part of the atomic component is uniform (see Point (2) in Proposition 3), and since it possesses no delaying emerging job (Lemma 2), it wholly constitutes the kernel of that component.

From here on, let *K*<sup>∗</sup> = *K*(*Sl*,*l*1,...,*lk* [*K*, *K*1, ... , *Kk*]), where *Sl*,*l*1,...,*lk* [*K*, *K*1, ... , *Kk*] is the atomic component in the decomposition of kernel *K*, and let *ω*∗ be the overflow job in kernel *K*∗. By Proposition 4, *K*∗ (the *atomic kernel* in the decomposition) is the only kernel in the atomic component *Sl*,*l*1,...,*lk* [*K*, *K*1,..., *Kk*] and is also the last uniform continuous part of that component.

**Corollary 1.** *There exists no L-schedule if*

$$L\_{\max}(\mathbb{K}^\*) = L\_{\omega^\*}\left(S\_{l\_\cdot l\_1,\dots,l\_k}[\mathbb{K}, \mathbb{K}\_1,\dots,\mathbb{K}\_k]\right) > L.$$

*In particular, L*max(*K*∗) *is a lower bound on the optimum objective value.*

**Proof.** By Lemma 4 and Proposition 4, kernel *K*∗ is the last continuous uniform part of the atomic component *Sl*,*l*1,...,*lk* [*K*, *K*1,..., *Kk*]). Then, by Proposition 4 and the inequality in Equation (6),

$$L\_{\mathsf{max}}(K^\*) = L\_{\mathsf{max}}(S\_{l, l\_1, \dots, l\_k}[K, K\_1, \dots, K\_k] \le L\_{\mathsf{max}}(S^{\mathsf{opt}}).$$

**Theorem 1.** *PROCEDURE Decomposition*(*S*, *K*, *l*) *forms all substructure components of kernel K with the last atomic component and atomic kernel K*<sup>∗</sup> *in time O*(*κ*<sup>2</sup> log *κ*) *(where κ is the number of jobs in kernel K).*

**Proof.** First, observe that, for any non-atomic component *Sl*,*l*1,...,*lj* [*K*, *K*1, ... , *Kj*] (*j* < *k*) created by the procedure, the kernel *Kj*+<sup>1</sup> = *K*(*Sl*,*l*1,...,*lj* [*K*, *K*1, ... , *Kj*]) of that component is within its last continuous part (Lemma 4). This part cannot be anticipated or uniform (otherwise, it would not have been non-atomic). Thus, the last continuous part *M* in that component is mixed and hence it contains an anticipated job. The latest scheduled anticipated job in *M* is the delaying emerging job *lj*+<sup>1</sup> for kernel *Kj*+<sup>1</sup> in the continuous part *M*. Then, the decomposition procedure creates the next component *Sl*,*l*1,...,*lj*,*lj*+<sup>1</sup> [*K*, *K*1, ... , *Kj*, *Kj*+1] in the decomposition (consisting of the jobs of kernel *Kj*+1) by activating job *lj*+<sup>1</sup> for kernel *Kj*+1.

Consider now the last atomic component *Sl*,*l*1,...,*lk* [*K*, *K*1, ... , *Kk*]. By Proposition 4, atomic kernel *K*<sup>∗</sup> of component *Sl*,*l*1,...,*lk* [*K*, *K*1,..., *Kk*] is the last uniform continuous part in that component. By the inequality in Equation (6), *L*max(*Sl*,*l*1,...,*lk* [*K*, *K*1, ... , *Kk*]) = *L*max(*K*∗) is a lower bound on the optimal objective value and hence the decomposition procedure may halt: the atomic kernel *K*∗ cannot be decomposed and the maximum job completion time in that kernel cannot be further reduced. Furthermore, if *L*max(*K*∗) > *L*, then there exists no *L*-schedule (Corollary 1).

As to the time complexity, the total number of iterations (recursive calls of PROCEDURE Decomposition(*S*, *K*, *l*)) is bounded by *κ*/2 (where *κ* is the number of jobs in kernel *K*, see Proposition 4). At every iteration *i*, kernel *Ki*+<sup>1</sup> and job *li*+<sup>1</sup> can be detected in time linear in the number of jobs in component *Sl*,*l*1,...,*li* [*K*, *K*1, ... , *Ki*], and hence the condition in WHILE can be verified with the same

cost. Besides, at iteration *i*, ED-heuristics with cost *O*(*κ* log *κ*) is applied, which yields the overall time complexity *O*(*κ*<sup>2</sup> log *κ*) of PROCEDURE Decomposition(*S*, *K*, *l*).

**Corollary 2.** *The total cost of the calls of the decomposition procedure for all the arisen kernels in the framework is O*(*n*<sup>2</sup> log *n*)*.*

**Proof.** Let *K*1, ... , *Kk* be all the kernels that arise in the framework. For the purpose of this estimation, assume *κ*, *kκ* ≤ *n*, is the number of jobs in every kernel (this will give an amortized estimation). Since every kernel is processed only once, the the total cost of the calls of the decomposition procedure for kernels *K*1,..., *Kk* is then

$$kO(\kappa^2 \log \kappa) \le \frac{n}{\kappa} O(\kappa^2 \log \kappa) < O(n^2 \log n).$$

#### **5. Binary Search**

In this section, we describe how binary search can be beneficially used to solve problem 1|*rj*|*L*max. Recall from the previous section that PROCEDURE Decomposition(*S*, *K*, *l*) extracts the atomic kernel *K*∗ from kernel *K* (recall that *l* is the corresponding delaying emerging job—without loss of generality, assume that it exists, as otherwise the schedule *S* with *K*(*S*) = *K* is optimal by Proposition 1). Notice that, since the kernel of every created component in the decomposition is from its last continuous part (Lemma 4), there is no intersection between the continuous parts of different components excluding the last continuous part of each component. All the continuous parts of all the created components in the decomposition of kernel *K* except the last continuous part of each component are merged in time axes resulting in a partial ED-schedule which initiates at time *r*(*K*) and has the number of gaps equal to the number of its continuous parts minus one (as every two neighboring continuous parts are separated by a gap). It includes (feasibly) all the jobs of kernel *K* except ones from the atomic kernel *K*∗ (that constitutes the last continuous part of the atomic component, see Proposition 4). By merging this partial schedule with the atomic kernel *K*∗, we obtain another feasible partial ED-schedule consisting of all the jobs of kernel *K*, which we denote by *S*∗[*K*]. We extend PROCEDURE Decomposition(*S*, *K*, *l*) with this construction. It is easy to see that the time complexity of the procedure remains the same. Thus, from here on, we let the output of PROCEDURE Decomposition(*S*, *K*, *l*) be schedule *S*∗[*K*].

Within the gaps in partial schedule *S*∗[*K*], some *external* jobs for kernel *K*, ones not in schedule *S*∗[*K*], will be included. During such an expansion of schedule *S*∗[*K*] with the external jobs, the right-shift (a forced delay) of the jobs from that schedule by some constant units of time, which is determined by the current trial *δ* in the binary search procedure, will be allowed (in this section, we define the interval from which trial *δ*s are taken).

At an iteration *h* of the binary search procedure with trial *δh*, one or more kernels may arise. Iteration *h* starts by determining the earliest arisen kernel, which, as we show below, depends on the value of trial *δh*. This kernel determines the initial partition of the scheduling horizon into one kernel and two non-kernel (bin) intervals. Repeatedly, during the scheduling of a non-kernel interval, a new kernel may arise, which is added to the current set of kernels at iteration *h*. Every newly arisen kernel is treated similarly in a recurrent fashion. We denote by K the set of kernels detected by the current state of computation at iteration *h* (omitting parameter *h* for notational simplicity). For every newly arisen kernel *K* ∈ K, PROCEDURE Decomposition(*S*, *K*, *l*) is invoked and partial schedule *S*∗[*K*] is expanded by external jobs. Destiny feasible schedule of iteration *h* contains all the extended schedules *S*∗[*K*], *K* ∈ K.

The next proposition easily follows from the construction of schedule *S*∗[*K*], Lemma 4 and Corollary 1:

**Proposition 5.** *K*∗ = *K*(*S*∗[*K*]) *(K*∗ *is the only kernel in schedule S*∗[*K*]*) and*

$$L\_{\mathsf{max}}(S^\*[K]) = L\_{\mathsf{max}}(K^\*) \le L\_{\mathsf{max}}(S^{\mathsf{opt}})\_{\mathsf{rev}}$$

*i.e., L*max(*S*∗[*K*]) *is a lower bound on the optimum objective value.*

$$L^\*\_{\max} = \max\_{K \in \mathcal{K}} \{ L\_{\max}(K^\*) \}.$$

*is a stronger lower bound on the objective value.*

Now, we define an important kernel parameter used in the binary search. Given kernel *K* ∈ K, let

$$\delta(K^\*) = L^\*\_{\text{max}} - L\_{\text{max}}(K^\*) \ge 0,\tag{7}$$

i.e., *δ*(*K*∗) is the amount of time by which the starting time of the earliest scheduled job of kernel *K*∗ can be right-shifted (increased) without increasing lower bound *L*∗ max. Note that for every *K* ∈ K, *δ*(*K*∗) + *L*max(*K*∗) is the same magnitude.

**Example 2 (continuation).** For the problem instance of Example 2, *L*max(*K*1<sup>∗</sup> ) = *L*3(*σl*,2) = <sup>19</sup> <sup>−</sup> <sup>20</sup> <sup>=</sup> <sup>−</sup>1, *<sup>L</sup>*max(*K*2<sup>∗</sup> ) = *<sup>L</sup>*6(*σl*,2,4) = <sup>62</sup> <sup>−</sup> <sup>58</sup> <sup>=</sup> 4; hence, *<sup>δ</sup>*(*K*1<sup>∗</sup> ) = 5 and *δ*(*K*2<sup>∗</sup> ) = 0 (recall that atomic kernel *K*1<sup>∗</sup> consists of a single Job 3, and atomic kernel *K*2<sup>∗</sup> consists of Jobs 5 and 6; hence, the lower bound *L*∗ max = 4 is realized by atomic kernel *K*2<sup>∗</sup> ).

**Proposition 6.** *Let S be a complete schedule and* K *be the set of the kernels detected prior to the creation of schedule S. The starting time of every atomic kernel K*∗*, K* ∈ K*, can be increased by δ*(*K*∗) *time units (compared to its starting time in schedule S*∗[*K*]*) without increasing the maximum lateness L*max(*S*)*.*

**Proof.** Let (*K* )∗, *K* ∈ K, be an atomic kernel that achieves lower bound *L*<sup>∗</sup> max, i.e., *L*max((*K* )∗) = *L*∗ max (equivalently, *δ*((*K* )∗) = 0). By Equation (7), if the completion time of every job in atomic kernel *K*<sup>∗</sup> = (*K* )∗ is increased by *δ*(*K*∗), the lateness of none of these jobs may become greater than that of the overflow job from kernel (*K* )∗, which proves the proposition as *L*max(*S*) ≥ *L*<sup>∗</sup> max.

We immediately obtain the following corollary:

**Corollary 3.** *In an optimal schedule S*opt*, every atomic kernel K*∗*, K* ∈ K*, starts either no later than at time r*(*K*∗) + *δ*(*K*∗) *or no later than at time r*(*K*∗) + *δ*(*K*∗) + *δ, for some δ* ≥ 0*.*

An extra delay *δ* might be unavoidable for a proper accommodation of the non-kernel jobs. Informally, *δ* is the maximum extra delay that we will allow for every atomic kernel in the iteration of the binary search procedure with trial value *δ*. For a given iteration in the binary search procedure with trial *δ*, the corresponding threshold, an upper limit on the currently allowable maximum job lateness, *Lδ*-*boundary* (or *L*-boundary) is

$$L\_{\delta} = L\_{\max}^\* + \delta = L\_{\max}(K^\*) + \delta(K^\*) + \delta \ (K \in \mathcal{K}).\tag{8}$$

We call *L<sup>δ</sup>* − *schedule* a feasible schedule in which the maximum lateness of any job is at most *L<sup>δ</sup>* = *L*<sup>∗</sup> max + *δ* (see Equation (8)).

Note that, since to every iteration a particular *δ* corresponds, the maximum allowable lateness at different iterations is different. The concept of the overflow job at a given iteration is consequently redefined: such a job *must* have the lateness greater than *Lδ*. Note that this implicitly redefines also the notation of a kernel at that iteration of the binary search procedure.

It is not difficult to determine the time interval from which the trial *δ*s can be derived. Let Δ be the delay of kernel *K*(*σ*) imposed by the delaying emerging Job *l* in initial ED-schedule *σ*, i.e.,

$$
\Delta = \mathfrak{c}\_l(\sigma) - r(\mathcal{K}(\sigma)).\tag{9}
$$

**Example 1 (continuation).** For the problem instance of Example 1, for instance, Δ = 16 − 3 = 13 (see Figure 1).

#### **Proposition 7.**

$$L\_{\text{max}}(\sigma) - L\_{\text{max}}^\* \le \Delta. \tag{10}$$

**Proof.** This is a known property that easily follows from the fact that no job of kernel *K*(*σ*) could have been released by the time *tl*(*σ*), as otherwise ED-heuristics would have been included the former job instead of Job *l* in schedule *σ*.

Assume, for now, that we have a procedure that, for a given *L*-boundary (see Equation (8)), finds an *L*-schedule *S<sup>L</sup>* if it exists, otherwise, it outputs a "no" answer.

Then, the binary search procedure incorporates the above verification procedure as follows. Initially, for *δ* = Δ, *L*∗ max + Δ-schedule *σ* already exists. For *δ* = 0 with *L* = *L*<sup>∗</sup> max, if there exists no *L*∗ max-schedule then the next value of *δ* is [Δ/2]. Iteratively, if an *L*-schedule with *L* = *L*<sup>∗</sup> max + *δ* for the current *δ* exists, the *δ* is increased correspondingly, otherwise it is decreased correspondingly in the binary search mode.

**Proposition 8.** *The L-schedule S<sup>L</sup> corresponding to the minimum L* = *L*<sup>∗</sup> max + *δ found in the binary search procedure is optimal.*

**Proof.** First, we show that trial *δ*s can be derived from the interval [0, Δ]. Indeed, the left endpoint of this interval can clearly be 0 (potentially yielding a solution with the objective value *L*∗ max). By the inequality in Equation (10), the maximum job lateness in any feasible ED-schedule in which the delay of some kernel is more than Δ would be no less than *L*max(*σ*), which obviously proves the above claim.

Now note that the minimum *L*-boundary yields the minimal possible lateness for the kernel jobs subject to the condition that no non-kernel job surpasses *L*-boundary. This obviously proves the proposition.

By Proposition 8, the problem 1|*rj*|*L*max can be solved, given that there is a verification procedure that, for a given *L*-boundary, either constructs *Lδ*-schedule *SL<sup>δ</sup>* or answers correctly that it does not exist. The number of iterations in the binary search procedure is bounded by log *p*max as clearly, Δ < *p*max. Then, note that the running time of our basic framework is log *p*max multiplied by the running time of the verification procedure. The rest of this paper is devoted to the construction of the verification procedure, invoked in the binary search procedure for trial *δ*s.
