**Yuri N. Sotskov 1,\*, Natalja M. Matsveichuk 2,† and Vadzim D. Hatsura 3,†**


Received: 4 June 2020; Accepted: 29 July 2020; Published: 7 August 2020

**Abstract:** This study addresses a two-machine job-shop scheduling problem with fixed lower and upper bounds on the job processing times. An exact value of the job duration remains unknown until completing the job. The objective is to minimize a schedule length (makespan). It is investigated how to best execute a schedule, if the job processing time may be equal to any real number from the given (closed) interval. Scheduling decisions consist of the off-line phase and the on-line phase of scheduling. Using the fixed lower and upper bounds on the job processing times available at the off-line phase, a scheduler may determine a minimal dominant set of schedules (minimal DS), which is based on the proven sufficient conditions for a schedule dominance. The DS optimally covers all possible realizations of the uncertain (interval) processing times, i.e., for each feasible scenario, there exists at least one optimal schedule in the minimal DS. The DS enables a scheduler to make the on-line scheduling decision, if a local information on completing some jobs becomes known. The stability approach enables a scheduler to choose optimal schedules for most feasible scenarios. The on-line scheduling algorithms have been developed with the asymptotic complexity *O*(*n*2) for *n* given jobs. The computational experiment shows the effectiveness of these algorithms.

**Keywords:** scheduling; job-shop; makespan criterion; uncertain processing times

## **1. Introduction**

Many real-world production planning and scheduling problems have various uncertainties. Different approaches are used for solving the uncertain planning and scheduling problems. In particular, a stability approach [1–4] for solving sequencing and scheduling problems with the interval uncertainty is based on the stability analysis of the optimal job permutations (schedules) to possible variations of the job processing times (durations). In this paper, this approach is applied to the uncertain two-machine job-shop scheduling problem, where a job processing time is only known once the job is completed. Although, the exact value of the job processing time is unknown before scheduling, it is known that the processing time must have a value no less than the lower bound and no greater than the upper bound available before scheduling. It should be noted that uncertainties of the job processing times are due to some external forces in contrast to scheduling problems with controllable processing times [5–7], where the objective is to determine optimal processing times and then to find an optimal schedule for the jobs with the chosen processing times.

#### *1.1. Research Motivation*

It is not realistic to assume processing times are exactly known and fixed for many scheduling problems arising in real-world situations. For such an uncertain scheduling problem, job processing times are random variables. Moreover, it is often hard to obtain probability distributions for all random processing times of the jobs to be processed. In such cases, schedules constructed due to assuming certain probability distributions are often not close to the optimal schedule. Although, the probability distribution of the job processing time may not be known before scheduling, the upper and lower bounds on the job processing time are easy to obtain in most practical scheduling environments. The available information on these lower and upper bounds on the job processing times should be utilized in finding optimal schedules for the scheduling problem with an interval uncertainty.

Since there may not exist a unique schedule that remains optimal for all possible realizations of the job processing times (all possible scenarios), it is desirable to construct a minimal dominant set of schedules (permutations of the jobs to be processed), which dominate all other ones. At the off-line phase of scheduling (i.e., before starting an execution of the constructed schedule), a minimal dominant set of schedules may be determined based on the proven dominance relations [8].

If the constructed minimal dominant set of schedules is a singleton, then a single schedule remaining optimal for all possible scenarios exists. Otherwise, one can reduce the size of the determined minimal dominant set of schedules at the on-line phase of scheduling based on the additional information about completing some jobs. This additional on-line information allows a scheduler to find new dominance relations in order to best execute a schedule. It is clear that on-line scheduling decisions must be realized very quickly. In other words, only polynomial algorithms may be applied at the on-line phase of scheduling.

#### *1.2. Contributions of This Research*

In this paper, it is shown how to determine a minimal dominant set of schedules that would contain at least one optimal schedule for every scenario that is possible. The necessary and sufficient conditions are proven for the existence of a single pair of job permutations, which is optimal for the two-machine job-shop scheduling problem with any possible scenario. The algorithms have been developed for testing a set of the proven sufficient conditions for a schedule dominance and for the realization of a schedule, which is either optimal or very close to optimal one for the factual scenario. The developed algorithms are polynomial in the number *n* of the given jobs. Their asymptotic complexities do not exceed *O*(*n*2). The computational experiments on a large number of randomly generated instances of the uncertain (interval) two-machine job-shop scheduling problem show the efficiency and effectiveness of the developed off-line and on-line algorithms and programs. For different distributions of the factual job processing times, the developed on-line algorithms perform with the maximal errors of the achieved makespan less than 1% provided that *n* ∈ {20, 30, ... , 100}. For all tested classes of the randomly generated instances, the average makespan errors Δ*ave*% for all tested numbers *n* ∈ {10, 20, ... , 100} of jobs J are less than 0.02%. Each tested series of 1000 randomly generated instances was solved within no more than one second.

The paper is organized as follows. Settings of the considered scheduling problems with the interval uncertainty and main notation are introduced in Section 2. A literature review is presented in Section 3. The results published for the uncertain (interval) scheduling flow-shop problem are discussed in Section 3.2. These results are used in Section 4 for finding the optimal job permutations at the off-line phase of scheduling. In Section 4.2, the precedence digraphs are described for determining a minimal dominant set of schedules. An illustrative example is considered in Section 4.3. The on-line phase of scheduling is investigated in Section 5, where two theorems for the dominant sets of schedules have been proven. Section 6 contains the algorithms developed for the on-line phase of scheduling, illustrative examples (Section 6.2) and the discussion of the conducted computational experiments (Section 6.3). Appendix B consists of the tables with the detailed computational results. Some concluding remarks are made in Section 7.

#### **2. Settings of Scheduling Problems and Main Notations**

A set J = {*J*1, *J*2, ..., *Jn*} of the given jobs must be processed on different machines from a set M = {*M*1, *M*2}. All jobs are available for processing from the same time *t* = 0. Using the standard notation *α*|*β*|*γ* [9], this deterministic two-machine job-shop scheduling problem to minimize the makespan is denoted as follows: *J*2|*ni* ≤ 2|*Cmax*, where *α* = *J*2 means a job-shop processing system with two available different machines and *ni* a number of possible stages for processing a job *Ji* ∈ J . The criterion *γ* = *Cmax* determines the minimization of a schedule length (makespan) as follows:

$$\mathbb{C}\_{\max} := \min\_{s \in \mathcal{S}} \mathbb{C}\_{\max}(s) = \min\_{s \in \mathcal{S}} \left\{ \max \{ \mathbb{C}\_i(s) \; : \; \|\_i \in \mathcal{J} \} \right\},\tag{1}$$

where *Ci*(*s*) denotes the completion time-point of the job *Ji* ∈ J in the schedule *s* and *S* denotes a set of all semi-active schedules existing for the deterministic problem *J*2|*ni* ≤ 2|*Cmax*. (A schedule *s* is called a semi-active one [10–12] if the completion time-point *Ci*(*s*) of any job *Ji* ∈ J cannot be reduced without changing an order of the jobs on some machine.)

Let *Oij* denote an operation of the job *Ji* ∈ J processed on the machine *Mj* ∈ M. Each of the available machines can process the job *Ji* ∈ J no more than once, a preemption of the operation *Oij* being not allowed. The job *Ji* ∈ J has its own processing route through the available machines in set M. The partition J = J<sup>1</sup> J<sup>2</sup> J1,2 J2,1 of the jobs is given and fixed, where each job *Ji* ∈ J1,2 must be processed first on machine *M*<sup>1</sup> and then on machine *M*2, i.e., all jobs from the set J1,2 have the same machine route (*M*1, *M*2). Each job *Ji* ∈ J2,1 has an opposite machine route (*M*2, *M*1). The set J*j*, where *j* ∈ {1, 2}, consists of all jobs, which must be processed only on one machine *Mj* ∈ M. The following notation *mh* = |J*h*| will be used, where *h* ∈ {1; 2; 1,2; 2,1}.

In this research, it is investigated the uncertain (interval) two-machine job-shop scheduling problem denoted as *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*, where the duration *pij* of each operation *Oij* is unknown before scheduling. It is only known that the inclusion *pij* ∈ [*lij*, *uij*] holds for any possible realization of the chosen schedule, where *uij* ≥ *lij* ≥ 0. It is also assumed that a probability distribution of the random duration of a job from the set J is also unknown before scheduling. Let a set *T* of all possible scenarios *p* = (*p*1,1, *p*1,2,..., *pn*1, *pn*2) of the job processing times be determined as follows:

$$T = \{ p \quad : \ l\_{i\dot{j}} \le p\_{i\dot{j}} \le u\_{i\dot{j}\prime} \text{ } l\_i \in \mathcal{J} \text{ } \mathcal{M}\_{\dot{j}} \in \mathcal{M} \}.$$

It should be noted that the problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* is mathematically incorrect since one cannot calculate makespan *Cmax*(*s*) in the equality (1) before completing the jobs *Ji* in the set J provided that the strict inequality *uij* > *lij* holds. Moreover, in most cases there does not exist a schedule, which is optimal for all possible scenarios *p* ∈ *T* for the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*. Therefore, one cannot solve most such uncertain (interval) scheduling problems in the generally accepted sense.

In [13], it is proven that the deterministic job-shop problem *J*2|*ni* ≤ 2|*Cmax* is solvable in *O*(*n* log *n*) time. The optimal semi-active schedule for this deterministic problem is determined as the pair (*π* , *π*) of two job permutations (called a Jackson's pair of permutations), where *π* = (*π*1,2, *π*1, *π*2,1) is an optimal permutation of the jobs J<sup>1</sup> J1,2 J2,1 processed on machine *<sup>M</sup>*<sup>1</sup> and *<sup>π</sup>* = (*π*2,1, *<sup>π</sup>*2, *<sup>π</sup>*1,2) is an optimal permutation of the jobs J<sup>2</sup> J1,2 J2,1 on machine *<sup>M</sup>*2. Such an optimal semi-active schedule is presented in Figure 1. In what follows, it is assumed that job *Ji* belongs to the permutation *πh*, if the following inclusion holds: *Ji* ∈ J*h*.

In a Jackson's pair of permutations (*π* , *π*), the optimal order for processing jobs from the set J<sup>1</sup> (from the set J2, respectively) may be arbitrary (due to this, we fix them in the increasing order of their indexes). For the permutation *π*1,2 (permutation *π*2,1, respectively), the following inequality holds:

$$\min\{p\_{i\_\ell 1}, p\_{i\_f 2}\} \le \min\{p\_{i\_f 1}, p\_{i\_\ell 2}\} \tag{2}$$

for all indexes *e* and *f* provided that 1 ≤ *e* < *f* ≤ *m*1,2 (1 ≤ *f* < *e* ≤ *m*2,1, respectively). The permutation *π*1,2 (permutation *π*2,1) is called a Johnson's permutation; see [14].

**Figure 1.** An example of the optimal semi-active schedule without idle times on both machines.

The deterministic scheduling problem *J*2|*ni* ≤ 2|*Cmax* associated with a fixed scenario *p* of the job processing times is an individual deterministic problem. In what follows, this problem is denoted as follows: *J*2|*p*, *ni* ≤ 2|*Cmax*. For any fixed scenario *p* ∈ *T*, there exists a Jackson's pair (*π* , *π*) of permutations, which is optimal for the problem *J*2|*p*, *ni* ≤ 2|*Cmax*, i.e., the equality *C*max(*π* , *π*) = *Cp* max holds, where *<sup>C</sup><sup>p</sup>* max denotes the optimal makespan value for the problem *J*2|*p*, *ni* ≤ 2|*Cmax*.

Let *S*1,2 denote a set of all permutations of *m*1,2 jobs from the set J1,2, where |*S*1,2| = *m*1,2!. The set *S*2,1 is a set of all permutations of *m*2,1 jobs from the set J2,1, |*S*2,1| = *m*2,1!.

Let the set *S* = <*S*1,2, *S*2,1 > be a subset of the Cartesian product (*S*1,2, *π*1, *S*2,1) × (*S*2,1, *π*2, *S*1,2), each element of the set *S* being a pair of job permutations (*π* , *<sup>π</sup>*) <sup>∈</sup> *<sup>S</sup>*, where *<sup>π</sup>* = (*π<sup>i</sup>* 1,2, *<sup>π</sup>*1, *<sup>π</sup><sup>j</sup>* 2,1) and *π* = (*π<sup>j</sup>* 2,1, *<sup>π</sup>*2, *<sup>π</sup><sup>i</sup>* 1,2) with inequalities 1 ≤ *i* ≤ *m*1,2! and 1 ≤ *j* ≤ *m*2,1!. It is known that the set *S* determines all semi-active schedules and vice versa; see [12]. Since index *i* (and index *j*) is the same in each permutation from the pair (*π* , *π*) ∈ *S* and it is a fixed permutation *π*<sup>1</sup> (permutation *π*2), the equality |*S*| = *m*1,2! · *m*2,1! holds. The following definition of a J-solution is used for the uncertain (interval) job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*.

**Definition 1.** *An inclusion-minimal set of the pairs of job permutations S*(*T*) ⊆ *S is called a J-solution for the uncertain job-shop problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the set* J *of the given jobs, if for each scenario p* ∈ *T, the set S*(*T*) *contains at least one pair* (*π* , *π*) ∈ *S of job permutations that is optimal for the individual deterministic problem J*2|*p*, *ni* ≤ 2|*Cmax with a fixed scenario p.*

From Definition 1, it follows that for any proper subset *S* of the set *S*(*T*), *S* ⊂ *S*(*T*), there exists a scenario *p* ∈ *T* such that the set *S* does not contain an optimal pair of job permutations for the individual deterministic problem *J*2|*p* , *ni* ≤ 2|*Cmax* with a fixed scenario *p* .

#### **3. A Literature Review and Closed Results**

It should be noted that the uncertain flow-shop scheduling problem denoted as *F*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* is well studied [15], unlike the uncertain job-shop scheduling problem.

#### *3.1. Approaches to Scheduling Problems with Different Forms of Uncertainties*

For the well-known stochastic approach, it is assumed that the job processing times are random variables with certain probability distributions determined before scheduling. There are two types of the stochastic scheduling problems [10], where one is on stochastic jobs and another is on stochastic machines. In the stochastic job scheduling problem, each job processing time is a random variable with a known probability distribution. With the objective of minimizing the expected makespan value, the flow-shop problem was studied in [16–18]. In the stochastic machine scheduling problem, each job processing time is a constant, while each completion time of the given job is a random variable due to the machine breakdown or machine non-availability. In [19–21], the flow-shop scheduling problems to stochastically minimize either makespan or total completion time were investigated.

If it is impossible to determine probability distributions for all random job processing times, other approaches have to be used [11,22–25]. In the approach of seeking a robust schedule [22,26–28], a decision-maker looks for a schedule that hedges against the worst-case possible scenario.

A fuzzy approach [29–35] allows a scheduler to find best schedules with respect to fuzzy processing times of the jobs to be processed. The work of [35] addresses to the job-shop scheduling problem with uncertain processing times modeled as triangle fuzzy numbers, where the criterion is to minimize the expected makespan value. Based on the disjunctive graph model of the job-shop problem, a definition of criticality is proposed for this job-shop problem along with neighborhood structure for a local search. It is shown that the proposed neighborhood structure has two properties: feasibility and connectivity, which allow a scheduler to improve the efficiency of the local search and to ensure asymptotic convergence (in probability) to a globally optimal solution of the uncertain job-shop problem. The conducted computational experiments supported these theoretical results.

The stability approach was developed in [1,4,36,37] for the *Cmax* criterion, and in [2,38–40] for the total completion time criterion, <sup>∑</sup> *Ci* := <sup>∑</sup>*Ji*∈J *Ci*(*π* ). The aim of this approach is to construct a minimal dominant set *S*(*T*) of schedules, which optimally covers all feasible scenarios *T*. The dominant set *S*(*T*) is used in the multi-phase decision framework; see [41]. The set *S*(*T*) is constructed at the first off-line phase of scheduling. Based on the set *S*(*T*), it is possible to find a schedule remaining optimal for most feasible scenarios. The set *S*(*T*) enables a scheduler to execute best a schedule in most cases of the uncertain flow-shop scheduling problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* [41].

The stability radius of the optimal semi-active schedule was studied in [4], where a formula for calculating the stability radius and corresponding algorithms were described and tested.

In [36], the sufficient conditions were proven when a transposition of the given jobs minimizes the makespan criterion. The work of [42] addressed the objective criterion ∑ *Ci* in the uncertain two-machine flow-shop scheduling problem. The case of separate setup times with the criterion of minimizing a total completion time or makespan was investigated in [43].

For the uncertain flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax*, an additional criterion is often introduced. In particular, a robust schedule minimizing the worst-case deviation from the optimal value was proposed in [44] to hedge against the interval or discrete uncertainties. In [45], a binary NP-hardness was proven for finding a pair (*πq*, *πq*) ∈ *S* of the identical job permutations that minimizes the worst-case absolute regret for the uncertain two-machine flow-shop problem with the criterion *Cmax* and only two possible scenarios. In [46], a branch and bound method was developed for the uncertain job-shop scheduling problem to minimize makespan and optimize robustness based on a mixed graph model and the propositions proposed in [47]. The effectiveness of the developed algorithm was clarified by solving test uncertain job-shop scheduling problems.

The work of [48] addresses robust scheduling for a flexible job-shop scheduling problem with a random machine breakdown. Two objectives makespan and robustness were considered. Robustness was indicated by the expected value of the relative difference between the deterministic and factual makespan values. Two measures for robustness have been developed. The first suggested measure considers the probability of machine breakdowns. The second measure considers the location of float times and machine breakdowns. A multi-objective evolutionary algorithm is presented and experimentally compared with several other existing measures.

A function of predictive scheduling in order to obtain a stable and robust schedule for a shop floor was investigated in [49]. An innovative maintenance planning and production scheduling method has been proposed. The proposed method uses a database to collect information about failure-free times, a prediction module of failure-free times, predictive rescheduling module, a module for evaluating the accuracy of prediction and maintenance performance. The proposed approach is based on probability theory and applied for solving a job-shop scheduling problem. For unpredicted failures, a rescheduling procedure was also developed. The evaluation procedure provides information about the degradation of a performance measure and the stability of a schedule.

The simulation and experimental design methods play a useful role in solving job-shop scheduling problems with uncertain parameters (see survey [50], where many studies about dynamic and static job-shop scheduling problems with material handling are described and systematized).

In [51], a quality robustness and a solution robustness were investigated in order to compare the operational efficiency of the job-shop in the events of machine failures. Two well-known proactive approaches were compared to compute the operational efficiency of the job-shop with unpredicted machine failures. In the computational experiments, the predictive-reactive approach (without a prediction) and the proactive-reactive one (with a prediction) were applied for the job-shop model with possible disruptions. The computational results of computer simulations for the above two approaches were compared in order to select better schedules for reducing costs and waste due to machine failures.

The paper [52] presents a methodological pattern to assess the effectiveness of Order Review and Release (ORR) techniques in a job-shop environment. It is presented a comparison among three ORR approaches, i.e., a time bucketing approach, a probabilistic approach and a temporal approach. Simulation results highlighted that the performances of the ORR techniques tested depend on how perturbed the environment, where they are implemented, is. Based on a computer simulation, it was shown that the ORR techniques greatly differ in their robustness against environment perturbations.

The paper [53] presents an effective heuristic algorithm for the job-shop problem with uncertain arrival times of the jobs, processing times, due dates and part priorities. A separable problem formulation that balances modeling accuracy and solution complexity is described with the goal to minimize expected part tardiness and earliness cost. The optimization is subject to arrival times and operation precedence constraints (for each possible realization), and machine capacity constraints (in the expected value sense). The solution algorithm based on a Lagrangian relaxation and stochastic dynamic programming was developed to obtain dual solutions. The computational complexity of the developed algorithm is only slightly higher than the one without considering uncertainties of the numerical parameters. Numerical testing supported by a simulation demonstrated that near optimal solutions were obtained, and uncertainties are effectively handled for problems of practical sizes.

The published results on the application of the stability approach for the uncertain two-machine flow-shop problem are presented in Section 3.2. These results are described in detail since they are used for the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* in Sections 4–6.

#### *3.2. Closed Results for Uncertain (Interval) Flow-Shop Scheduling Problems*

The uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* is a generalization of the uncertain flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax*, where all given jobs have the same machine route. Two uncertain flow-shop problems are associated with an uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*. In one of these flow-shop problems, an optimal schedule for processing the jobs J1,2 must be determined, i.e., it is assumed that J2,1 = J<sup>1</sup> = J<sup>2</sup> = ∅. In another associated flow-shop problem, an optimal schedule for processing jobs J2,1 must be determined, i.e., it is assumed that J1,2 = J<sup>1</sup> = J<sup>2</sup> = ∅. Our approach to the solution of the uncertain job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* is based on the following remark.

**Remark 1.** *The solution of the uncertain job-shop scheduling problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax may be based on the solutions of the associated flow-shop scheduling problem F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax with the job set* J = J1,2*, where* J2,1 = J<sup>1</sup> = J<sup>2</sup> = ∅*, and that with the job set* J = J2,1 *(i.e.,* J1,2 = J<sup>1</sup> = J<sup>2</sup> = ∅*).*

The sense of Remark 1 becomes clear from Figure 2, where the semi-active schedule *s* for the job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* is presented. Indeed, in Figure 2, the length *Cmax*(*s*) of the schedule *s* is equal to the length of the corresponding semi-active schedule determined for the associated flow-shop scheduling problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J = J1,2. Thus, if one will solve both associated flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J = J1,2 and associated flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J = J2,1, then the original job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* will be also solved.

**Figure 2.** The optimal semi-active schedule for the job-shop scheduling problem.

We next observe in detail the results obtained for the two-machine flowshop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J = J1,2. For using the above notations introduced for the uncertain job-shop problem, we need the following remark for the uncertain flow-shop problem.

**Remark 2.** *The considered problem F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax has the following two mandatory properties:*


The following Theorems 1 and 2 have been proven in [54].

**Theorem 1** ([54])**.** *There exists a J-solution S*(*T*) *for the uncertain flow-shop problem F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax with a fixed order Jv* → *Jw of the jobs Jv and Jw in all permutations πq,* (*πq*, *πq*) ∈ *S*(*T*)*, if and only if at least one of the following two conditions hold:*

$$\|u\_{v1} \le l\_{v2} \text{ and } u\_{v1} \le l\_{w1};\tag{3}$$

$$l\_{w2} \le l\_{w1} \text{ and } u\_{w2} \le l\_{v2}. \tag{4}$$

Theorem 2 provides the necessary and sufficient conditions for existing a single-element J-solution *S*(*T*) = {(*πq*, *πq*)} for the uncertain flow-shop scheduling problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax*. The partition <sup>J</sup> <sup>=</sup> <sup>J</sup> <sup>0</sup> ∪ J <sup>1</sup> ∪ J <sup>2</sup> ∪ J <sup>∗</sup> of the set <sup>J</sup> <sup>=</sup> <sup>J</sup>1,2 is given, where

<sup>J</sup> <sup>0</sup> <sup>=</sup> {*Ji* ∈ J : *ui*<sup>1</sup> <sup>≤</sup> *li*2, *ui*<sup>2</sup> <sup>≤</sup> *li*1}, <sup>J</sup> <sup>1</sup> <sup>=</sup> {*Ji* ∈ J : *ui*<sup>1</sup> <sup>≤</sup> *li*2, *ui*<sup>2</sup> <sup>&</sup>gt; *li*1} <sup>=</sup> {*Ji* ∈J \J <sup>0</sup> : *ui*<sup>1</sup> <sup>≤</sup> *li*2}, <sup>J</sup> <sup>2</sup> <sup>=</sup> {*Ji* ∈ J : *ui*<sup>1</sup> <sup>&</sup>gt; *li*2, *ui*<sup>2</sup> <sup>≤</sup> *li*1} <sup>=</sup> {*Ji* ∈J \J <sup>0</sup> : *ui*<sup>2</sup> <sup>≤</sup> *li*1},

J <sup>∗</sup> = {*Ji* ∈ J : *ui*<sup>1</sup> > *li*2, *ui*<sup>2</sup> > *li*1}.

Note that for each job *Jg* ∈ J 0, the inequalities *ug*<sup>1</sup> <sup>≤</sup> *lg*<sup>2</sup> and *ug*<sup>2</sup> <sup>≤</sup> *lg*<sup>1</sup> imply the equalities *lg*<sup>1</sup> = *ug*<sup>1</sup> = *lg*<sup>2</sup> = *ug*2. Thus, the equalities *pg*<sup>1</sup> = *pg*<sup>2</sup> =: *pg* hold.

**Theorem 2** ([54])**.** *There exists a single-element J-solution S*(*T*) ⊂ *S,* |*S*(*T*)| = 1, *for the uncertain flow-shop problem F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax, if and only if the following two conditions hold:*

*(j) for any pair of jobs Ji and Jj from the set* <sup>J</sup> <sup>1</sup> *(from the set* <sup>J</sup> <sup>2</sup>*, respectively), either ui*<sup>1</sup> <sup>≤</sup> *lj*<sup>1</sup> *or uj*<sup>1</sup> <sup>≤</sup> *li*<sup>1</sup> *(either ui*<sup>2</sup> ≤ *lj*<sup>2</sup> *or uj*<sup>2</sup> ≤ *li*2*, respectively);*

*(jj) inequality* |J ∗| ≤ <sup>1</sup> *holds and for the job Ji*<sup>∗</sup> ∈ J <sup>∗</sup> *both inequalities li*∗<sup>1</sup> <sup>≥</sup> max{*ui*<sup>1</sup> : *Ji* ∈ J <sup>1</sup>}, *li*∗<sup>2</sup> <sup>≥</sup> max{*uj*<sup>2</sup> : *Jj* ∈ J <sup>2</sup>} *hold with inequality* max{*li*∗1, *li*∗2} ≥ *pg valid for each job Jg* ∈ J <sup>0</sup>*.*

Theorem 2 characterizes the simplest case of the uncertain flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax*, i.e., there is a job permutation *π<sup>q</sup>* dominating all others.

Let J ×J denote a Cartesian product of the set <sup>J</sup> . If <sup>J</sup> <sup>0</sup> <sup>=</sup> <sup>∅</sup>, then there exists the following binary relation A≺ ⊆J ×J over the set J = J1,2.

**Definition 2.** *For the jobs Jx* ∈ J *and Jy* ∈ J *, the inclusion* (*Jx*, *Jy*) ∈ A≺ *holds if and only if at least one of the conditions (3) and (4) holds with v* = *x and w* = *y and neither the condition (3) no the condition (4) holds with v* = *y and w* = *x (or at least one of the conditions (3) and (4) holds both with v* = *x and w* = *y and with v* = *y, w* = *x and x* < *y).*

The above relation (*Jx*, *Jy*) ∈ A≺ may be represented as follows: *Jx* ≺ *Jy*. The binary relation A≺ is a strict order [55] that determines the precedence digraph G = (J , A≺) with the vertex set J and the arc set A≺. The permutation *π<sup>q</sup>* = (*Jq*<sup>1</sup> , *Jq*<sup>2</sup> , ... , *Jqn* ), (*πq*, *πq*) ∈ *S*, is a total strict order over the set J . The total strict order determined by the permutation *π<sup>q</sup>* is a linear extension of the partial strict order A≺, if the inclusion (*Jqx* , *Jqy* ) ∈ A≺ implies the inequality *x* < *y*. Let Π(G) denote a set of all permutations *π<sup>q</sup>* ∈ *S*1,2 determining linear extensions of the partial strict order A≺. The equality Π(G) = {*πq*} is characterized in Theorem 2, where the strict order A≺ over the set J is represented as follows: *Jq*<sup>1</sup> ≺ ... ≺ *Jqi* ≺ *Jqi*<sup>+</sup><sup>1</sup> ≺ ... ≺ *Jqn* . The following two claims have been proven in [55].

**Theorem 3** ([55])**.** *For any scenario p* ∈ *T, the set* Π(G) *contains a Johnson's permutation for the deterministic flow-shop problem F*2|*p*|*Cmax with the job set* <sup>J</sup> <sup>=</sup> <sup>J</sup>1,2 <sup>=</sup> <sup>J</sup> <sup>∗</sup> ∪ J <sup>1</sup> ∪ J <sup>2</sup>*.*

**Corollary 1** ([55])**.** *There exists a J-solution S*(*T*) *for the uncertain flow-shop problem F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax with the job set* <sup>J</sup> <sup>=</sup> <sup>J</sup>1,2 <sup>=</sup> <sup>J</sup> <sup>∗</sup> ∪ J <sup>1</sup> ∪ J <sup>2</sup>*, such that the inclusion <sup>π</sup><sup>q</sup>* <sup>∈</sup> <sup>Π</sup>(G) *holds for all pairs of job permutations, where* (*πq*, *πq*) ∈ *S*(*T*)*.*

In [55], it is shown how to determine a minimal dominant set *S*(*T*) = {(*πq*, *πq*)} with *π<sup>q</sup>* ∈ Π(G). The digraph G = (J , A≺) is considered as a condense form of a J-solution for the uncertain flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax*. The above results are used in Sections 4–6 for reducing a size of the dominant set *S*(*T*) for the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*.

#### **4. The Off-Line Phase of Scheduling**

The above setting of the uncertain job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ *n*|*Cmax* implies the following remark.

**Remark 3.** *The factual value p*∗ *ij of the job processing time pij becomes known at the time-point cj*(*i*) *when the operation Oij is completed on the machine Mj* ∈ M*.*

Due to Remark 3, if all jobs J are completed on the corresponding machines from the set M, the durations of all operations *Oij* take on exact values *p*<sup>∗</sup> *ij*, where *lij* ≤ *p*<sup>∗</sup> *ij* ≤ *uij*, and a unique factual scenario *p*<sup>∗</sup> ∈ *T* is realized. A pair of job permutations selected for this realization should be optimal for scenario *p*∗. For constructing such an optimal pair of job permutations, we propose to implement two phases, namely: the off-line phase of scheduling and the on-line phase of scheduling.

The off-line phase is completed before starting a realization of the selected semi-active schedule. At the off-line phase, a scheduler knows the exact lower and upper bounds on the job processing times and the aim is to determine a minimal dominant set of the pairs of job permutations (*π* , *π*).

The on-line phase is started when the corresponding machine starts the processing of the first job in the selected schedule. At this phase, a scheduler can use an additional information on the job processing time, since for each operation *Oij*, the exact value *p*∗ *ij* of the processing time *pij* ∈ *T* becomes known at the completion time *cj*(*i*) of this operation; see Remark 3.

We next consider the off-line phase of scheduling for the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* and describe the sufficient conditions for existing a small dominant set of the semi-active schedules. Along with Definition 1, the following one is also used.

**Definition 3.** *A set of the pairs of job permutations DS*(*T*) ⊆ *S is a dominant set for the uncertain job-shop problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax, if for each scenario p* ∈ *T the set DS*(*T*) *contains at least one optimal pair of job permutations for the individual deterministic job-shop problem J*2|*p*, *ni* ≤ 2|*Cmax with scenario p.*

Obviously, the J-solution is a dominant set for the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*. Before processing the set J of given jobs, a scheduler does not know the exact values of the job processing times. Nevertheless, it is needed to determine an optimal pair of permutations of the jobs J for their processing on the machines M = {*M*1, *M*2}.

In Section 4.1, the sufficient conditions are presented for existing a pair of job permutations (*π* , *π*) such that the equality *DS*(*T*) = {(*π* , *π*)} holds. Section 4.2 contains the sufficient conditions allowing a scheduler to construct a semi-active schedule (if any), which dominates all other schedules in the set *S*. If a singleton *DS*(*T*) = {(*π* , *π*)} does not exist, a scheduler should construct partial strict orders *A*1,2 <sup>≺</sup> and *<sup>A</sup>*2,1 <sup>≺</sup> over set J1,2 and set J2,1; see Section 3.

#### *4.1. Conditions for Existing a Single Optimal Pair of Job Permutations*

The following conditions for existing an optimal pair of job permutations are proven in [8].

**Theorem 4** ([8])**.** *If one of the following conditions either (5) or (6) holds:*

$$\sum\_{I\_i \in \mathcal{I}\_{1,2}} u\_{i1} \le \sum\_{I\_i \in \mathcal{I}\_{2,1} \cup \mathcal{I}\_2} l\_{i2} \text{ and } \sum\_{I\_i \in \mathcal{I}\_{1,2}} l\_{i2} \ge \sum\_{I\_i \in \mathcal{I}\_{2,1} \cup \mathcal{I}\_1} u\_{i1} \tag{5}$$

$$\sum\_{l\_i \in \mathcal{J}\_{2,1}} u\_{i2} \le \sum\_{l\_i \in \mathcal{J}\_{1,2} \cup \mathcal{J}\_1} l\_{i1} \text{ and } \sum\_{l\_i \in \mathcal{J}\_{2,1}} l\_{i1} \ge \sum\_{l\_i \in \mathcal{J}\_{1,2} \cup \mathcal{J}\_2} u\_{i2'} \tag{6}$$

*then any pair of permutations* (*π* , *π*) ∈ *S is a singleton DS*(*T*) = {(*π* , *π*)} *for the uncertain job-shop problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the job set* J = J<sup>1</sup> ∪ J<sup>2</sup> ∪ J1,2 ∪ J2,1*.*

**Corollary 2** ([8])**.** *If the following inequality holds:*

$$\sum\_{J\_j \in \mathcal{J}\_{1,2}} u\_{i1} \le \sum\_{J\_j \in \mathcal{J}\_{2,1} \cup \mathcal{J}\_2} l\_{i2, \prime} \tag{7}$$

*then the set* <{*π*1,2}, *S*2,1>⊆ *S, where π*1,2 *is an arbitrary permutation in the set S*1,2*, is a dominant set for the uncertain job-shop problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the job set* J = J<sup>1</sup> ∪ J<sup>2</sup> ∪ J1,2 ∪ J2,1*.*

**Corollary 3** ([8])**.** *If the following inequality holds:* <sup>∑</sup>*Jj*∈J2,1 *ui*<sup>2</sup> ≤ <sup>∑</sup>*Jj*∈J1,2∪J<sup>1</sup> *li*1, *then the set* < *S*1,2, {*π*2,1} >*, where π*2,1 *is an arbitrary permutation in the set S*2,1*, is a dominant set for the uncertain job-shop problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the job set* J = J<sup>1</sup> ∪ J<sup>2</sup> ∪ J1,2 ∪ J2,1*.*

In order to determine an optimal permutation for processing jobs from the set J2,1 (set J1,2, respectively), we consider the uncertain flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J1,2 ⊆ J and the machine route (*M*1, *M*2), and that with the job set J2,1 ⊆ J and the machine route (*M*2, *M*1). The following theorem has been proven in [8].

**Theorem 5** ([8])**.** *Let the set S* 1,2 ⊆ *S*1,2 *be a set of permutations from the dominant set for the flow-shop problem F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax with the job set* J1,2*, and the set S* 2,1 ⊆ *S*2,1 *be a set of permutations from the dominant set for the flow-shop problem F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax with the job set* J2,1*. Then the set* <*S* 1,2, *S* 2,1 > ⊆ *S is a dominant set for the job-shop problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the job set* J = J<sup>1</sup> ∪ J<sup>2</sup> ∪ J1,2 ∪ J2,1*.*

#### *4.2. Precedence Digraphs Determining a Minimal Dominant Set of Schedules*

Based on Remark 1, the off-line phase of scheduling for the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* may be based on solving the uncertain flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J1,2 and that with the job set J2,1. A criterion for the existence of a single-element J-solution for the uncertain flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* is determined in Theorem 2.

In what follows, it is assumed that the equality <sup>J</sup>1,2 <sup>=</sup> <sup>J</sup> <sup>1</sup> 1,2 ∪ J <sup>2</sup> 1,2 ∪ J <sup>∗</sup> 1,2 holds, i.e., <sup>J</sup> <sup>0</sup> 1,2 = ∅. Using the results presented in Section 3, one can determine a binary relation *A*1,2 <sup>≺</sup> for the uncertain flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J1,2. For the job set J1,2, the binary relation *A*1,2 <sup>≺</sup> determines the digraph *<sup>G</sup>*1,2 = (J1,2, *<sup>A</sup>*1,2 <sup>≺</sup> ) with the vertex set <sup>J</sup>1,2 and the arc set *<sup>A</sup>*1,2 ≺ .

**Definition 4.** *Two jobs Jx* ∈ J1,2 *and Jy* ∈ J1,2*, <sup>x</sup>* <sup>=</sup> *y, are conflict if they are not in the relation <sup>A</sup>*1,2 <sup>≺</sup> *, i.e.,* (*Jx*, *Jy*) <sup>∈</sup> *<sup>A</sup>*1,2 <sup>≺</sup> *and* (*Jy*, *Jx*) <sup>∈</sup> *<sup>A</sup>*1,2 ≺ *.*

Due to Definition 2, for the conflict jobs *Jx* ∈ J1,2 and *Jy* ∈ J1,2, *x* = *y*, relations (3) and (4) do not hold for the case *v* = *x* with *w* = *y*, nor for the case *v* = *y* with *w* = *x*.

**Definition 5.** *The inclusion-minimal set* J*<sup>x</sup>* ⊆ J1,2 *of the jobs is called a conflict set of the jobs, if for any job Jy* ∈ J1,2 \ J*<sup>x</sup> either relation* (*Jx*, *Jy*) <sup>∈</sup> *<sup>A</sup>*1,2 <sup>≺</sup> *or relation* (*Jy*, *Jx*) <sup>∈</sup> *<sup>A</sup>*1,2 <sup>≺</sup> *holds for each job Jx* ∈ J*x.*

There may exist several conflict sets in the set <sup>J</sup>1,2. Let the strict order *<sup>A</sup>*1,2 <sup>≺</sup> for the flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J1,2 be represented as follows:

$$\{\mathbf{l}\_1 \prec l\_2 \prec \dots \prec l\_k \prec \{\mathbf{l}\_{k+1}, \mathbf{l}\_{k+2}, \dots, \mathbf{l}\_{k+r}\} \prec l\_{k+r+1} \prec l\_{k+r+2} \prec \dots \prec l\_{m\_{1,2}}.\tag{8}$$

Here, an optimal permutation for processing jobs from the set {*J*1, *J*2, ... , *Jk*} (for jobs from the set {*Jk*<sup>+</sup>*r*+1, *Jk*<sup>+</sup>*r*+2, ... , *Jm*1,2 }) is as follows: (*J*1, *J*2, ... , *Jk*) ((*Jk*<sup>+</sup>*r*+1, *Jk*<sup>+</sup>*r*+2, ... , *Jm*1,2 ), respectively). All jobs between braces in the presentation (8) constitute the conflict set of the jobs and they are in relation *A*1,2 <sup>≺</sup> with any job located outside the braces. Due to Theorem 3, the set <sup>Π</sup>(*G*1,2) of the permutations generated by the digraph *G*1,2 includes an optimal permutation for each vector *p*1,2 of the processing times of the jobs J1,2. Due to Corollary 1, the set *S*1,2(*T*) = {(*π*1,2, *π*1,2)} with *π*1,2 ∈ Π(*G*1,2) is a J-solution for the flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J1,2. Analogously, the set *S*2,1(*T*) = {(*π*2,1, *π*2,1)} with *π*2,1 ∈ Π(*G*2,1) is a J-solution for the problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set J2,1. Due to Theorem 5, one can determine a dominant set for the job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* with the job set J as follows: <Π(*G*1,2), Π(*G*2,1)> ⊆ *S*; see Remark 1.

The following three theorems are proven in [8], where the notation *<sup>L</sup>*<sup>2</sup> := <sup>∑</sup>*Jj*∈J2,1∪J<sup>2</sup> *lj*<sup>2</sup> is used. These theorems allow a scheduler to reduce the cardinality of a dominant set for the uncertain job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*.

**Theorem 6** ([8])**.** *Let the strict order A*1,2 <sup>≺</sup> *over the set* J1,2 = J <sup>∗</sup> 1,2 ∪ J <sup>1</sup> 1,2 ∪ J <sup>2</sup> 1,2 *be determined as follows: J*<sup>1</sup> ≺ ... ≺ *Jk* ≺ {*Jk*+1, *Jk*+2,..., *Jk*<sup>+</sup>*r*} ≺ *Jk*<sup>+</sup>*r*+<sup>1</sup> ≺ ... ≺ *Jm*1,2 *. If the following inequality holds:*

$$\sum\_{i=1}^{k+r} u\_{i1} \le L\_2 + \sum\_{i=1}^{k} l\_{i2\_{\mathcal{L}}} \tag{9}$$

*then the set S* = <{*π*1,2}, Π(*G*2,1)> ⊂ *S, where π*1,2 ∈ Π(*G*1,2)*, is a dominant set for the job-shop problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the job set* J = J<sup>1</sup> ∪ J<sup>2</sup> ∪ J1,2 ∪ J2,1*.*

**Theorem 7** ([8])**.** *Let the partial strict order A*1,2 <sup>≺</sup> *over the set* J1,2 = J <sup>∗</sup> 1,2 ∪ J <sup>1</sup> 1,2 ∪ J <sup>2</sup> 1,2 *be determined as follows: J*<sup>1</sup> ≺ ... ≺ *Jk* ≺ {*Jk*+1, *Jk*+2,..., *Jk*<sup>+</sup>*r*} ≺ *Jk*<sup>+</sup>*r*+<sup>1</sup> ≺ ... ≺ *Jm*1,2 *. If the inequality*

$$\mu\_{k+s,1} \le L\_2 + \sum\_{i=1}^{k+s-1} (l\_{i2} - u\_{i1}) \tag{10}$$

*holds for each s* ∈ {1, 2, ... ,*r*}, *then the set S* = < {*π*1,2}, *S*2,1 >*, where π*1,2 = (*J*1, ... , *Jk*−1, *Jk*, *Jk*+1, *Jk*+2, ... , *Jk*<sup>+</sup>*r*, *Jk*<sup>+</sup>*r*<sup>+</sup>1, ... , *Jm*1,2 ) ∈ <sup>Π</sup>(*G*1,2)*, is a dominant set for the job-shop problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the job set* J = J<sup>1</sup> ∪ J<sup>2</sup> ∪ J1,2 ∪ J2,1*.*

**Theorem 8** ([8])**.** *Let the partial strict order A*1,2 <sup>≺</sup> *over the set* J1,2 = J <sup>∗</sup> 1,2 ∪ J <sup>1</sup> 1,2 ∪ J <sup>2</sup> 1,2 *have the form J*<sup>1</sup> ≺ ... ≺ *Jk* ≺ {*Jk*+1, *Jk*+2,..., *Jk*<sup>+</sup>*r*} ≺ *Jk*<sup>+</sup>*r*+<sup>1</sup> ≺ ... ≺ *Jm*1,2 *. If the inequality*

$$\sum\_{i=r-s+2}^{r-s+1} l\_{k+i,1} \ge \sum\_{j=r-s+1}^{r} u\_{k+j,2} \tag{11}$$

*holds for each <sup>s</sup>* ∈ {1, 2, ... ,*r*}*, then the set <sup>S</sup>* = < {*π*1,2}, *<sup>S</sup>*2,1 >*, where <sup>π</sup>*1,2 = (*J*1, ... , *Jk*−1, *Jk*, *Jk*+1, *Jk*+2, ... , *Jk*<sup>+</sup>*r*, *Jk*<sup>+</sup>*r*<sup>+</sup>1, ... , *Jm*1,2 ) ∈ Π(*G*1,2)*, is a dominant set for the job-shop problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the job set* J = J<sup>1</sup> ∪ J<sup>2</sup> ∪ J1,2 ∪ J2,1*.*

One can describe the analogs of Theorems 6–8 for reducing the cardinality of a dominant set for the job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* provided that for the flow-shop problem *F*2|*lij* ≤ *pij* ≤ *uij*|*Cmax* with the job set <sup>J</sup>2,1, there exists a partial strict order *<sup>A</sup>*2,1 <sup>≺</sup> over the set J2,1 = J <sup>∗</sup> 2,1 ∪ J <sup>1</sup> 2,1 ∪ J <sup>2</sup> 2,1 with the following form: *J*<sup>1</sup> ≺ ... ≺ *Jk* ≺ {*Jk*+1, *Jk*+2,..., *Jk*<sup>+</sup>*r*} ≺ *Jk*<sup>+</sup>*r*+<sup>1</sup> ≺ ... ≺ *Jm*2,1 .

If the set {*J*1, ... , *Jk*} is empty in the constructed job permutation, then it is needed to check the conditions of Theorem 8. If the set {*Jk*<sup>+</sup>*r*<sup>+</sup>1, ... , *Jm*1,2 } is empty, then one needs to check the conditions of Theorem 7. Note that it is enough to test only one permutation for checking the conditions of Theorem 7 and only one permutation for checking the conditions of Theorem 8; see [8].

#### *4.3. An Illustrative Example*

To illustrate the above results, we consider Example 1 of the uncertain job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* with eight jobs {*J*1, *J*2, ... , *J*8} = J . Let three jobs *J*1, *J*<sup>2</sup> and *J*<sup>3</sup> have the machine route (*M*1, *M*2), jobs *J*6, *J*<sup>7</sup> and *J*<sup>8</sup> have the opposite machine route (*M*2, *M*1), job *J*<sup>4</sup> and job *J*<sup>5</sup> have to be processed only on machine *M*<sup>1</sup> and machine *M*2, respectively. The partition J =

J1,2 ∪ J2,1 ∪ J<sup>1</sup> ∪ J<sup>2</sup> is given, where J1,2 = {*J*1, *J*2, *J*3}, J2,1 = {*J*6, *J*7, *J*8}, J<sup>1</sup> = {*J*4} and J<sup>2</sup> = {*J*5}. The lower and upper bounds on the job processing times are determined in Table 1.


**Table 1.** The numerical input data for Example 1.

To solve this uncertain job-shop scheduling problem, one need to determine an optimal pair (*π* , *π*) of permutations of the eight jobs for their processing on machine *M*<sup>1</sup> and machine *M*2. These permutations *π* and *π* have the following forms: *π* = (*π*1,2, *π*1, *π*2,1), *π* = (*π*2,1, *π*2, *π*1,2).

It is necessary to find four permutations *π*1,2, *π*2,1, *π*<sup>1</sup> and *π*<sup>2</sup> of the jobs from the sets J1,2, J2,1, J<sup>1</sup> and J2, respectively. The permutations *π*<sup>1</sup> and *π*<sup>2</sup> are determined as follows: *π*<sup>1</sup> = (*J*4) and *π*<sup>2</sup> = (*J*5).

We test the sufficient conditions given in Section 4.1. The conditions (5) of Theorem 4 do not hold. For testing the conditions (6) of Theorem 4, one can obtain the following relations:

$$\sum\_{|I\_1\cup\mathcal{I}\_{2,1}|} \mathfrak{u}\_{I2} = \mathfrak{u}\_{6,2} + \mathfrak{u}\_{7,2} + \mathfrak{u}\_{8,2} = 4 + 4 + 4 = 12 \leq \sum\_{|I\_1\cup\mathcal{I}\_{1,2}| \cup \mathcal{I}\_1} l\_{11} = l\_{1,1} + l\_{2,1} + l\_{3,1} + l\_{4,1} = 6 + 8 + 7 + 2 = 23, 4$$

$$\sum\_{l\_1 \in \mathcal{I}\_{2,1}} l\_{l1} = l\_{6,1} + l\_{7,1} + l\_{8,1} = 1 + 1 + 1 = 3\\\stackrel{\scriptstyle \mathcal{I}}{\geq} \sum\_{l\_1 \in \mathcal{I}\_{1,2} \cup \mathcal{I}\_2} u\_{l2} = u\_{1,2} + u\_{2,2} + u\_{3,2} + u\_{5,2} = 7 + 6 + 5 + 3 = 21.1$$

It should be noted that the case when conditions of Theorem 4 hold was considered in [8].

As the first condition in (6) holds, due to Corollary 3, one can construct permutation *π*2,1 = (*J*6, *J*7, *J*8) by arranging the jobs from the set J2,1 in the increasing of their indexes.

For the jobs from the set <sup>J</sup>1,2, the partition <sup>J</sup>1,2 <sup>=</sup> <sup>J</sup> <sup>1</sup> 1,2 ∪ J <sup>2</sup> 1,2 ∪ J <sup>∗</sup> 1,2 holds, where J <sup>∗</sup> 1,2 = {*J*1} and J 2 1,2 = {*J*2, *J*3}. The condition of Theorem 2 holds for these jobs. Therefore, the following optimal permutation: *π*1,2 = (*J*1, *J*2, *J*3) is determined.

Thus, there exists a pair of job permutations (*π* , *π*), where *π* = (*J*1, *J*2, *J*3, *J*4, *J*6, *J*7, *J*8) and *π* = (*J*6, *J*7, *J*8, *J*5, *J*1, *J*2, *J*3), which is optimal for all possible scenarios *p* ∈ *T*. Hence, there exists a single-element dominant set *DS*(*T*) = {(*π* , *π*)} for Example 1 of the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* with the bounds on the job processing times given in Table 1.

The optimal semi-active schedule is constructed for Example 1 at the off-line phase of scheduling, despite of the uncertainty of the job processing times. Such an issue is called as STOP 1 in the scheduling algorithms developed in [8] and used in Section 6 of this paper.

#### **5. The On-line Phase of Scheduling**

Due to Remark 3, if the job *Ji* is completed on the corresponding machine *Mj* ∈ M, the duration of the operation *Oij* takes on exact value *p*∗ *ij*, where *lij* ≤ *p*<sup>∗</sup> *ij* ≤ *uij*. A scheduler can use this information on the duration of the operation *Oij* for a selection of the next job for processing on machine *Mj*. Since it is on-line phase of scheduling, such a selection should be very quick.

It is first assumed that the set *S* = < Π(*G*1,2), {*π*<sup>∗</sup> 2,1}> ⊂ *S*, is a dominant set for the problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* with the job set J . In other words, the optimal permutations for processing all jobs from the set J2,1 are already determined at the off-line phase of scheduling.

Let the strict order *A*1,2 <sup>≺</sup> over the set J1,2 = J <sup>∗</sup> 1,2 ∪ J <sup>1</sup> 1,2 ∪ J <sup>2</sup> 1,2 be determined as follows: *J*<sup>1</sup> ≺ ... ≺ *Jk* ≺ {*Jk*+1, *Jk*+2,..., *Jk*<sup>+</sup>*r*} ≺ *Jk*<sup>+</sup>*r*+<sup>1</sup> ≺ ... ≺ *Jm*1,2 . At the initial time *t* = 0, machine *M*<sup>1</sup> has to start processing jobs from the set {*J*1, ... , *Jk*} in the following optimal order: (*J*1, ... , *Jk*). At the same time *t* = 0, machine *M*<sup>2</sup> has to start processing jobs from the set J2,1 in the order

determined by the permutation *π*∗ 2,1, then jobs from the set J<sup>2</sup> in the arbitrary order, and then jobs from the set {*J*1,..., *Jk*} in the following optimal order: (*J*1,..., *Jk*); see Figure 3.

**Figure 3.** The initial part of the schedule execution.

At the time-point *t* = *c*1(*k*), machine *M*<sup>1</sup> completes the operation *Ok*1. Let J (*i*, *j*) denote a set of all jobs processed on machine *Mj* from the initial part of the schedule till the job *Ji*, e.g., the set of jobs {*J*1, *J*2, ... , *Jk*} is denoted as J (*k*, 1); see Figure 3. Due to Remark 3, at the time-point *t* = *c*1(*k*), the factual values *p*∗ *<sup>i</sup>*<sup>1</sup> of the processing times *pi*<sup>1</sup> of all jobs *Ji* in the set J (*k*, 1) are already known.

Let machine *M*<sup>2</sup> process the job *Jl* ∈ J2,1 ∪ J<sup>2</sup> ∪ {*J*1, *J*2, ... , *Jk*} at the time-point *t* = *c*1(*k*), i.e., *t* = *c*1(*k*) < *c*2(*l*). Let J (*l* − 1, 2) denote a set of all jobs whose processing is completed on machine *<sup>M</sup>*<sup>2</sup> before time-point *<sup>t</sup>* = *<sup>c</sup>*1(*k*). Figure <sup>3</sup> depicts this situation for the job *Jl*−<sup>1</sup> ∈ {*J*1, *<sup>J</sup>*2, ... , *Jk*}⊂J1,2.

The factual values *p*∗ *<sup>i</sup>*<sup>2</sup> of the processing times *pi*<sup>2</sup> of all jobs *Ji* in the set J (*l* − 1, 2) are known at the time-point *t* = *c*1(*k*) > *c*2(*l* − 1), i.e., *pi*<sup>2</sup> = *p*<sup>∗</sup> *<sup>i</sup>*2, while the factual values of the processing times *pj*<sup>2</sup> of other jobs in the set J remain unknown at the time-point *t* = *c*1(*k*) < *c*2(*l*). Thus, at the time-point *t* = *c*1(*k*), the following subset of possible scenarios:

$$T(k, l - 1) = \{ p \in T \; : \; p\_{i1} = p\_{i1'}^\*, \; p\_{j2} = p\_{j2'}^\*, \; l\_i \in \mathcal{J}(k, 1), \; l\_j \in \mathcal{J}(l - 1, 2) \}$$

may be realized instead of the initial set *T* of all possible scenarios; *T*(*k*, *l* − 1) ⊆ *T*.

At the time-point *t* = *c*1(*k*) (it is called a decision-point), a scheduler has to make a decision about the order for processing jobs from the conflict set {*Jk*+1, *Jk*+2, ... , *Jk*<sup>+</sup>*r*}. The sufficient conditions given in Theorems 6 and 7 can be reformulated in the following two theorems. (Note that Theorem 8 cannot be reformulated for the use at the on-line phase of scheduling.)

**Theorem 9.** *Let the set S* = <Π(*G*1,2), {*π*<sup>∗</sup> 2,1}> ⊂ *S be a dominant set for the uncertain problem J*2|*lij* ≤ *pij* <sup>≤</sup> *uij*, *ni* <sup>≤</sup> <sup>2</sup>|*Cmax with the job set* <sup>J</sup> *. Let the strict order <sup>A</sup>*1,2 <sup>≺</sup> *over the set* J1,2 = J <sup>∗</sup> 1,2 ∪ J <sup>1</sup> 1,2 ∪ J <sup>2</sup> 1,2 *be determined as follows: J*<sup>1</sup> ≺ ... ≺ *Jk* ≺ {*Jk*+1, *Jk*+2, ... , *Jk*<sup>+</sup>*r*} ≺ *Jk*<sup>+</sup>*r*+<sup>1</sup> ≺ ... ≺ *Jm*1,2 *. If at the time-point t* = *c*1(*k*)*, the following inequality holds:*

$$\mathfrak{c}\_1(k) + \sum\_{i=k+1}^{k+r} \mathfrak{u}\_{i1} \le \mathfrak{c}\_2(l-1) + \sum\_{\substack{j\_i \in (\mathcal{J}\_{2,1} \cup \dots \cup \mathcal{J}\_{2,1} \cup (k,1)) \ | \mathcal{J}(l-1,2)|}} l\_{i2} \tag{12}$$

*then at the time-point t* = *c*1(*k*)*, the set S* = <{*π*1,2}, {*π*<sup>∗</sup> 2,1}> ⊂ *S, where π*1,2 ∈ Π(*G*1,2)*, is a dominant set for the problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the job set* J *and the set T*(*k*, *l* − 1) *of possible scenarios.* **Proof.** Let *p* be an arbitrary vector from the set *T*(*k*, *l* − 1) of possible scenarios at the time-point *<sup>t</sup>* <sup>=</sup> *<sup>c</sup>*1(*k*). Let *<sup>C</sup><sup>p</sup>* max denote the optimal makespan value for the deterministic job-shop problem *J*2|*p*, *ni* ≤ 2|*C*max with the set J of the given jobs and the vector *p* of the job processing times.

We consider an arbitrary permutation *π*1,2 ∈ Π(*G*1,2) and show that the pair of job permutations (*π* , *π*) = ((*π*1,2, *π*1, *π*<sup>∗</sup> 2,1), (*π*<sup>∗</sup> 2,1, *π*2, *π*1,2)) ∈ *S* is an optimal one for the deterministic job-shop problem *J*2|*p*, *ni* ≤ 2|*C*max with the set J of the jobs and with any vector *p* ∈ *T*(*k*, *l* − 1) of the job processing times, i.e., the equality *C*max(*π* , *π*) = *C<sup>p</sup>* max holds. Since the equality *C*max(*π* , *π*) = max{*c*1(*π* ), *c*2(*π*)} holds, one has to consider two possible cases (*a*) and (*b*).

Case (*a*): It is assumed that *c*1(*π* ) ≥ *c*2(*π*). Then, one can obtain the following equalities:

$$\mathbb{C}\_{\text{max}}(\pi', \pi'') = \mathbb{c}\_1(\pi') = \max \left\{ \sum\_{l\_i \in \mathcal{J}\_{1,2} \cup \mathcal{J}\_{2,1} \cup \mathcal{J}\_1} p\_{i1\prime} \quad \mathbb{C}\_{\text{max}}(\pi\_{2,1}^\*) \right\},\tag{13}$$

where *C*max(*π*<sup>∗</sup> 2,1) is the value of makespan for the deterministic flow-shop problem *F*2|*p*2,1|*C*max with the job set J2,1 and the vector *p*2,1 whose components are equal to the corresponding components of the vector *p*. Due to the conditions of Theorem 9, the permutation *π*∗ 2,1 is optimal for the deterministic flow-shop problem *F*2|*p*2,1|*C*max with the set J2,1 of the given jobs and with vector *p*2,1 of the job processing times. Therefore, *C*max(*π*<sup>∗</sup> 2,1) is an optimal makespan value for the deterministic flow-shop problem *F*2|*p*2,1|*C*max and *C*max(*π*<sup>∗</sup> 2,1) is a minimal completion time for processing all jobs from the set J2,1 on both machines. From the equalities (13), one can obtain the equality *C*max(*π* , *π*) = *C<sup>p</sup>* max.

Case (*b*): It is assumed that *c*1(*π* ) < *c*2(*π*). Then, one can obtain the following equalities:

$$\mathbb{C}\_{\max}(\pi', \pi'') = c\_2(\pi'') = \max \left\{ \sum\_{l\_i \in \mathcal{I}\_{2,1} \cup \mathcal{J}\_{2} \cup \mathcal{J}\_{1,2}} p\_{i2\prime} \quad \mathbb{C}\_{\max}(\pi\_{1,2}) \right\},\tag{14}$$

where *C*max(*π*1,2) is an optimal value of the makespan criterion for the deterministic flow-shop problem *F*2|*p*1,2|*C*max with the job set J1,2 and with the vector *p*1,2 of the job processing times (the components of this vector are equal to the corresponding components of the vector *p*). Since *π*1,2 ∈ Π(*G*1,2), the initial part of the permutation *π*1,2 has the following form: (*J*1, *J*2, ... , *Jk*). For every pair of jobs from the set {*J*1, *J*2,..., *Jk*}, at least one of the conditions, either (3) or (4), holds, see Theorem 1.

Therefore, for the job processing times determined by the vector *p* for the jobs {*J*1, *J*2, ... , *Jk*}, the inequalities (2) hold. Thus, in the permutation *πbeg* 1,2 := (*J*1, *J*2, ... , *Jk*), all the jobs are arranged in the Johnson's order. One can conclude that the following value

$$\mathbb{C}\_{\text{max}}(\pi\_{1,2}^{\text{hyy}}) = \max\_{1 \le m \le k} \left\{ \sum\_{i=1}^{m} p\_{i1} + \sum\_{i=m}^{k} p\_{i2} \right\} \tag{15}$$

determines an optimal makespan value for the deterministic flow-shop problem *F*2|*p beg* 1,2 |*C*max with the job set {*J*1, *J*2, ... , *Jk*} and the corresponding vector *p beg* 1,2 of the job processing times (the components of the vector *p beg* 1,2 are equal to the corresponding components of the vector *<sup>p</sup>*). Therefore, *<sup>C</sup>*max(*πbeg* 1,2 ) is a minimal makespan value for processing jobs of the set {*J*1, *J*2, ... , *Jk*} on both machines. Then, for the time-point *c*2(*k*) when machine *M*<sup>2</sup> completes the operation *Ok*2, one can obtain the following equality:

$$c\_2(k) = \max\left\{ \sum\_{I\_i \in \mathcal{I}\_{2,1} \cup \mathcal{I}\_2 \cup \mathcal{I}\_{1,2}(k,1)} p\_{i2\prime} \mid \mathcal{C}\_{\text{max}}(\pi\_{1,2}^{\text{key}}) \right\}. \tag{16}$$

Due to the inequality (12) and the equality (16), one can obtain the following inequalities for the jobs from the conflict set {*Jk*+1, *Jk*+2,..., *Jk*<sup>+</sup>*r*}:

$$c\_1(k) + \sum\_{i=k+1}^{k+r} p\_{i1} \le c\_1(k) + \sum\_{i=k+1}^{k+r} \mu\_{i1} \le c\_2(l-1) + \sum\_{l\_i \in (\mathcal{J}\_{2,1} \cup \mathcal{J}\_2 \cup \mathcal{J}(k,1))} l\_{i2} \le \tag{17}$$

$$1 \le c\_2(l-1) + \sum\_{\substack{j\_i \in (\mathcal{I}\_{2,1} \cup \mathcal{J}\_2 \cup \mathcal{J}(k,1)) \ | \mathcal{J}(l-1,2)}} p\_{i2} \le \max \left\{ \sum\_{\substack{j\_i \in \mathcal{I}\_{2,1} \cup \mathcal{J}\_2 \cup \mathcal{J}\_{1,2}(k,1)}} p\_{i2}, \quad \mathcal{C}\_{\text{max}}(\pi\_{1,2}^{\text{hyp}}) \right\} = c\_2(k).$$

From the inequalities (17), one can obtain the following inequality:

$$c\_1(k) + \sum\_{i=k+1}^{k+r} p\_{i1} \le c\_2(k). \tag{18}$$

Thus, machine *M*<sup>2</sup> processes all jobs from the conflict set {*Jk*+1, *Jk*+2, ... , *Jk*<sup>+</sup>*r*} without idle times and without an idle before processing the first job from this conflict set for any order of these conflict jobs. Using the inequality (18), one can conclude that the time-point when machine *M*<sup>2</sup> completes the processing of the last job from the conflict set {*Jk*+1, *Jk*+2, ... , *Jk*<sup>+</sup>*r*} in the permutation *π*1,2 is determined as follows:

$$c\_2 = c\_2(k) + \sum\_{i=k+1}^{k+r} p\_{i2\_{i^\*}} \tag{19}$$

where *c*<sup>2</sup> is an optimal makespan value for processing jobs from the set {*J*1, *J*2, ... , *Jk*, *Jk*+1, *Jk*+2,..., *Jk*<sup>+</sup>*r*}. Next, we consider jobs from the set {*Jk*<sup>+</sup>*r*<sup>+</sup>1,..., *Jm*1,2 }.

Let *πend* 1,2 := (*Jk*<sup>+</sup>*r*<sup>+</sup>1, ... , *Jm*1,2 ) denote the permutation of the jobs {*Jk*<sup>+</sup>*r*<sup>+</sup>1, ... , *Jm*1,2 } in the permutation *π*1,2. Analogously as for the job set {*J*1, *J*2,..., *Jk*}, one can obtain that the value of

$$\mathsf{C}\_{\max}(\pi\_{1,2}^{\mathrm{end}}) := \max\_{k+r+1 \le m \le m\_{1,2}} \left\{ \sum\_{i=k+r+1}^{m} p\_{i1} + \sum\_{i=m}^{m\_{1,2}} p\_{i2} \right\} \tag{20}$$

is an optimal makespan value for the deterministic flow-shop problem *<sup>F</sup>*2|*pend* 1,2 |*C*max with the job set {*Jk*<sup>+</sup>*r*<sup>+</sup>1, ... , *Jm*1,2 } and with the vector *<sup>p</sup>end* 1,2 whose components are equal to the components of the vector *p*. Thus, *C*max(*πend* 1,2 ) is a minimal makespan value for processing all jobs from the set {*Jk*<sup>+</sup>*r*<sup>+</sup>1, ... , *Jm*1,2 } on both machines. The time-point when machine *M*<sup>2</sup> completes the processing of the last job from the permutation *π* can be calculated as follows:

*<sup>c</sup>*2(*π*) = max*k*+*<sup>r</sup>* ∑ *i*=1 *pi*<sup>1</sup> + *C*max(*πend* 1,2 ), *c*<sup>2</sup> + *m*1,2 ∑*i*=*k*+*r*+1 *pi*2 = <sup>=</sup> max*k*+*<sup>r</sup>* ∑ *i*=1 *pi*<sup>1</sup> + *C*max(*πend* 1,2 ), *c*2(*k*) + *k*+*r* ∑ *i*=*k*+1 *pi*<sup>2</sup> + *m*1,2 ∑*i*=*k*+*r*+1 *pi*2 = <sup>=</sup> max*k*+*<sup>r</sup>* ∑ *i*=1 *pi*<sup>1</sup> + *C*max(*πend* 1,2 ), max ∑ *Ji*∈J2,1∪J2∪J1,2(*k*,1) *pi*2, *<sup>C</sup>*max(*πbeg* 1,2 ) + *m*1,2 ∑ *i*=*k*+1 *pi*2 = <sup>=</sup> max*k*+*<sup>r</sup>* ∑ *i*=1 *pi*<sup>1</sup> + *C*max(*πend* 1,2 ), ∑ *Ji*∈J2,1∪J2∪J1,2(*k*,1) *pi*<sup>2</sup> + *m*1,2 ∑ *i*=*k*+1 *pi*2, *<sup>C</sup>*max(*πbeg* 1,2 ) + *m*1,2 ∑ *i*=*k*+1 *pi*2 = <sup>=</sup> max *<sup>C</sup>*max(*πbeg* 1,2 ) + *m*1,2 ∑ *i*=*k*+1 *pi*2, *k*+*r* ∑ *i*=1 *pi*<sup>1</sup> + *C*max(*πend* 1,2 ), ∑ *Ji*∈J2,1∪J2∪J1,2 *pi*2 , (21)

where relations (16) and (19) are used.

Due to Theorem 3, the set Π(*G*1,2) contains a Johnson's permutation for the deterministic flow-shop problem *F*2|*p*1,2|*C*max with the job set J1,2 and with the vector *p*1,2 of the job durations. We denote this Johnson's permutation as *π*∗ 1,2. Since *π*<sup>∗</sup> 1,2 ∈ Π(*G*1,2), the permutation *π*<sup>∗</sup> 1,2 has the following form: *π*∗ 1,2 = (*J*1, ... , *Jk*, *J*[*k*+1], *J*[*k*+2], ... , *J*[*k*+*r*], *Jk*<sup>+</sup>*r*<sup>+</sup>1, ... , *Jm*1,2 ), where the set of indexes is determined as follows: {[*k* + 1], [*k* + 2],..., [*k* + *r*]} = {*k* + 1, *k* + 2, . . . , *k* + *r*}.

The optimal makespan value *C*max(*π*<sup>∗</sup> 1,2) can be calculated as follows:

$$\mathbb{C}\_{\text{max}}(\pi\_{1,2}^{\*}) = \max\_{1 \le m \le m\_{1,2}} \left\{ \sum\_{i=1}^{m} p\_{i1} + \sum\_{i=m}^{m\_{1,2}} p\_{i2} \right\} = \max \left\{ \max\_{1 \le m \le k} \left\{ \sum\_{i=1}^{m} p\_{i1} + \sum\_{i=m}^{k} p\_{i2} + \sum\_{i=k+1}^{m\_{1,2}} p\_{i2} \right\},$$

$$\max\_{\left[k+1\right] \le m \le \left[k+r\right]} \left\{ \sum\_{i=1}^{m} p\_{i1} + \sum\_{i=m}^{m\_{1,2}} p\_{i2} \right\}\_{k \to r+r \le m \le m\_{1,2}} \left\{ \sum\_{i=1}^{k+r} p\_{i1} + \sum\_{i=k+r+1}^{m} p\_{i1} + \sum\_{i=m}^{m\_{1,2}} p\_{i2} \right\} =$$

$$= \max \left\{ \mathbb{C}\_{\text{max}}(\pi\_{1,2}^{\text{deg}}) + \sum\_{i=k+1}^{m\_{1,2}} p\_{i2} \right\}\_{[k+1] \le m \le [k+r]} \left\{ \sum\_{i=1}^{m} p\_{i1} + \sum\_{i=m}^{m\_{1,2}} p\_{i2} \right\}\_{r} + \sum\_{i=1}^{k+r} p\_{i1} + \mathbb{C}\_{\text{max}}(\pi\_{1,2}^{\text{rad}}) \right\}\_{r},\tag{22}$$

where relations (15) and (20) are used. From relations (21) and (22), one can obtain the relations

$$c\_2(\pi'') = \max\{\mathbb{C}\_{\max}(\pi\_{1,2}^{\text{key}}) + \sum\_{i=k+1}^{m\_{1,2}} p\_{i2'} \quad \sum\_{i=1}^{k+r} p\_{i1} + \text{C.max}(\pi\_{1,2}^{\text{end}}), \quad \sum\_{j\_1 \in \mathcal{J}\_{2,1} \cup \mathcal{J}\_2 \cup \mathcal{J}\_{1,2}} p\_{i2} \} \le \delta$$

$$\le \max\left\{\mathbb{C}\_{\max}(\pi\_{1,2}^{\text{s}}), \sum\_{j\_1 \in \mathcal{J}\_{2,1} \cup \mathcal{J}\_2 \cup \mathcal{J}\_{1,2}} p\_{i2} \right\}. \tag{23}$$

Therefore, relations (14) and (23) imply the equality *C*max(*π* , *π*) = *C<sup>p</sup>* max.

Thus, in both cases (*a*) and (*b*), the equality *C*max(*π* , *π*) = *C<sup>p</sup>* max holds and the pair of permutations (*π* , *π*) = ((*π*1,2, *π*1, *π*<sup>∗</sup> 2,1),(*π*<sup>∗</sup> 2,1, *π*2, *π*1,2)) is optimal for the deterministic job-shop problem *J*2|*p*, *ni* ≤ 2|*C*max with the scenario *p* ∈ *T*(*k*, *l* − 1). Therefore, the set *S* =<{*π*1,2}, {*π*<sup>∗</sup> 2,1}> contains an optimal pair of job permutations for the job-shop problem *J*2|*p*, *ni* ≤ 2|*C*max with vector *p* ∈ *T*(*k*, *l* − 1) of the job processing times. Since the vector *p* is arbitrarily chosen in the set *T*(*k*, *l* − 1), the set *S* contains an optimal pair of job permutations for each scenario in the set *T*(*k*, *l* − 1).

Due to Definition 3, the set *S* is a dominant set for the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*C*max with the job set J and with the set *T*(*k*, *l* − 1) of possible scenarios.

**Theorem 10.** *Let the set S* = <Π(*G*1,2), {*π*<sup>∗</sup> 2,1}> ⊂ *S be a dominant set for the uncertain job-shop problem <sup>J</sup>*2|*lij* <sup>≤</sup> *pij* <sup>≤</sup> *uij*, *ni* <sup>≤</sup> <sup>2</sup>|*Cmax with the job set* <sup>J</sup> *. Let the partial strict order <sup>A</sup>*1,2 <sup>≺</sup> *over the set* J1,2 = J <sup>∗</sup> 1,2 ∪ J <sup>1</sup> 1,2 ∪ J <sup>2</sup> 1,2 *be determined as follows: J*<sup>1</sup> ≺ ... ≺ *Jk* ≺ {*Jk*+1, *Jk*+2, ... , *Jk*<sup>+</sup>*r*} ≺ *Jk*<sup>+</sup>*r*+<sup>1</sup> ≺ ... ≺ *Jm*1,2 *. If at the time-point t* = *c*1(*k*)*, the following inequalities hold:*

$$c\_1(k) + \sum\_{i=k+1}^{k+s} u\_{i1} \le c\_2(l-1) + \sum\_{\substack{l \in (\mathcal{J}\_{21} \cup \mathcal{J}\_{2} \cup \mathcal{J}(k-1,1)) \mid \mathcal{J}(l-1,2)}} l\_{i2} + \sum\_{i=k}^{k+s-1} l\_{i2} \tag{24}$$

*for all indexes s* ∈ {1, 2, ... ,*r*}, *then at the time-point t* = *c*1(*k*)*, the set S* = < {*π*1,2}, {*π*<sup>∗</sup> 2,1} >*, where <sup>π</sup>*1,2 = (*J*1, ... , *Jk*−1, *Jk*, *Jk*+1, *Jk*+2, ... , *Jk*<sup>+</sup>*r*, *Jk*<sup>+</sup>*r*+1, ... , *Jm*1,2 ) ∈ <sup>Π</sup>(*G*1,2)*, is a dominant set for the uncertain problem J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax with the job set* J *and the set T*(*k*, *l* − 1) *of possible scenarios.*

**Proof.** The proof of this theorem is similar to the above proof of Theorem 9 with the exception of the inequalities (17) and (18). From the condition (24) with *s* = 1, one can obtain the following inequality:

$$c\_1(k) + \mu\_{k+1,1} \le c\_2(l-1) + \sum\_{\substack{j\_i \in \left(\mathcal{J}\_{2,1} \cup \mathcal{J}\_2 \cup \mathcal{J}(k-1,1)\right) \mid \mathcal{I}(l-1,2)}} l\_{i2} + l\_{k2}.\tag{25}$$

Based on the inequality (25), one can obtain the following relations:

$$c\_1(k) + p\_{k+1,1} \le c\_1(k) + \mu\_{k+1,1} \le c\_2(l-1) + \sum\_{l\_l \in (\mathcal{I}\_{2,1} \cup \mathcal{J}\_2 \cup \mathcal{I}(k-1,1))} l\_{l2} + l\_{k2} \le c\_1(l) + \sum\_{l\_l \in (\mathcal{I}\_{2,1} \cup \mathcal{J}\_2 \cup \mathcal{J}\_1)} l\_{l2} + l\_{k2} \le c\_2(l) + \sum\_{l\_l \in (\mathcal{I}\_{2,1} \cup \mathcal{J}\_2 \cup \mathcal{I}\_l)} l\_{l2} + l\_{k2} \le c\_2(l) + \sum\_{l\_l \in (\mathcal{I}\_{2,1} \cup \mathcal{J}\_2)} l\_{l2} + l\_{k2} \le c\_1(l) + \sum\_{l\_l \in (\mathcal{I}\_{2,1} \cup \mathcal{J}\_2)} l\_{l2} + l\_{k2} \le c\_2(l) + \sum\_{l\_l \in (\mathcal{I}\_{2,1} \cup \mathcal{J}\_2)} l\_{l2} + l\_{k2} \le c\_1(l) + \sum\_{l\_l \in (\mathcal{I}\_{2,1} \cup \mathcal{J}\_2)} l\_{l2} + l\_{k2} \le c\_2(l) + l\_{k2} \le c\_1(l) + l\_{k2} \le c\_2(l) + l\_{k2}$$

$$1 \le c\_2(l-1) + \sum\_{j\_i \in \left(\mathcal{I}\_{2,1} \cup \mathcal{I}\_2 \cup \mathcal{J}(k,1)\right) \backslash \mathcal{I}(l-1,2)} p\_{i2} = c\_2(k). \tag{26}$$

Due to relations (26), the following inequality holds:

$$c\_1(k) + p\_{k+1,1} \le c\_2(k). \tag{27}$$

Thus, machine *M*<sup>2</sup> processes the job *Jk*<sup>+</sup><sup>1</sup> in permutation *π*1,2 without an idle time between the jobs *Jk* and *Jk*+1. Analogously, using *s* ∈ {2, 3, ... ,*r*}, one can show that the following inequalities hold:

$$c\_1(k) + p\_{k+1,1} + p\_{k+2,1} \le c\_2(k+1);$$

$$c\_1(k) + p\_{k+1,1} + p\_{k+2,1} + p\_{k+3,1} \le c\_2(k+2);$$

$$\cdots;$$

$$c\_1(k) + \sum\_{i=k+1}^{k+r} p\_{i1} \le c\_2(k+r-1).$$

Therefore, machine *M*<sup>2</sup> processes jobs from the conflict set {*Jk*+1, *Jk*+2, ... , *Jk*<sup>+</sup>*r*} in permutation *π*1,2 without idle times between the jobs *Jk*<sup>+</sup><sup>1</sup> and *Jk*+2, between the jobs *Jk*<sup>+</sup><sup>2</sup> and *Jk*<sup>+</sup><sup>3</sup> and so on, between the jobs *Jk*<sup>+</sup>*r*−<sup>1</sup> and *Jk*<sup>+</sup>*r*. Then, the following relations hold:

$$c\_2 = c\_2(k+r) = c\_2(k+r-1) + p\_{k+r,2} = c\_2(k+r-2) + p\_{k+r-1,2} + p\_{k+r,2} = \dots = c\_2(k) + \sum\_{i=k+1}^{k+r} p\_{i2}$$

leading to the equality (19). The rest of the proof is the same as the rest of the proof of Theorem 9.

It is shown that the pair of job permutations (*π* , *π*) = ((*π*1,2, *π*1, *π*<sup>∗</sup> 2,1), (*π*<sup>∗</sup> 2,1, *π*2, *π*1,2)) ∈ *S* is optimal for the deterministic job-shop problem *J*2|*p*, *ni* ≤ 2|*Cmax* with any vector *p* ∈ *T*(*k*, *l* − 1) of the job processing times. Due to Definition 3, the set *S* is a dominant set for the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* with the job set J and the set *T*(*k*, *l* − 1) of possible scenarios.

It is easy to be convinced that the sufficient conditions given in Theorems 9 and 10 may be tested in polynomial time *O*(*r*2) of the number *r* of the conflict jobs.

Similarly, one can prove analogs of Theorems 9 and 10 if the set *S* = <{*π*<sup>∗</sup> 1,2}, Π(*G*2,1)> ⊂ *S* provided that a dominant set for the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* with the job set <sup>J</sup> and the partial strict order *<sup>A</sup>*2,1 <sup>≺</sup> over the set J2,1 = J <sup>∗</sup> 2,1 ∪ J <sup>1</sup> 2,1 ∪ J <sup>2</sup> 2,1 has the following form: *J*<sup>1</sup> ≺ ... ≺ *Jk* ≺ {*Jk*+1, *Jk*+2,..., *Jk*<sup>+</sup>*r*} ≺ *Jk*<sup>+</sup>*r*+<sup>1</sup> ≺ ... ≺ *Jm*2,1 .

#### **6. Scheduling Algorithms and Computational Results**

The experimental study was performed on a large number of randomly generated instances of the uncertain job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*. The off-line phase of scheduling was based on Algorithms 1 and 2 developed in [8]. Algorithms 1 and 2 are presented in Appendix A.

Algorithms 3–5 are developed for the on-line phase of scheduling. The input for each of these three algorithms includes the output of Algorithms 1 and 2 [8] applied at the off-line phase of scheduling.

Let outputs of Algorithms 1 and 2 [8] applied at the off-line phase of scheduling consist of the optimal permutation *π*1,2 of the jobs J1,2 and the optimal permutation *π*2,1 of the jobs J2,1. In such a case, the single-element dominant set *DS*(*T*) = {(*π*1,2, *π*1, *π*2,1),(*π*2,1, *π*2, *π*1,2)} is already constructed for the considered instance of the uncertain problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*. Therefore, the pair {(*π*1,2, *π*1, *π*2,1),(*π*2,1, *π*2, *π*1,2)} of the job permutations is optimal for the deterministic instance *J*2|*p*, *ni* ≤ 2|*Cmax* with any scenario *p* ∈ *T*. Thus, such an instance of the uncertain problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* is optimally solved by Algorithms 1 and 2 at the off-line phase of scheduling. Hence, there is no need to use the on-line phase of scheduling for such an instance of the uncertain job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*.

In Section 6.1, it shown how to solve instances of the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*, which cannot be optimally solved at the off-line phase of scheduling.

#### *6.1. Algorithms 3–5 for the On-Line Phase of Scheduling*

Let the considered instance of the uncertain job-shop problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* cannot be optimally solved by Algorithms 1 and 2 [8] applied at the off-line phase of scheduling. Thus, due to an application of Algorithm 1 or Algorithm 2, one can obtain one of the following three possible outputs:


Let *B* denote a number of the conflict sets in a partial strict order (in both partial strict orders) for the obtained output (a), (b) or (c). In other words, *B* denotes a maximal number of time-points in the decision-making at the on-line phase of scheduling. Let integer *b*, where *b* ≤ *B*, denote a number of time-points in the decision-making, where optimal orders of the conflict jobs were found using Theorem 9 or Theorem 10. Using these notations, we next describe Algorithm 3 provided that there is no factual processing times of the jobs J in the input of Algorithm 3; see Remark 3.

Let Algorithm 3 terminate at Step 16, i.e., it has not been constructed an optimal pair of job permutations for the factual scenario *p*<sup>∗</sup> ∈ *T* randomly determined after completing the on-line phase of scheduling. Therefore, there is a strictly positive error Δ(*s*) of the objective function *Cmax*(*s*) calculated for the constructed and realized schedule *s*. In such a case, the proven sufficient conditions for the optimality of the schedule *s* do not hold in some decision-points (or in a single decision-point) at the on-line phase of scheduling. If Algorithm 3 terminates at Step 17, then an optimal pair of job permutations has been constructed for the factual scenario *p*<sup>∗</sup> ∈ *T* randomly generated after completing the on-line phase of scheduling. The optimality of this pair of the job permutations was established only after the schedule execution, since the tested sufficient conditions for the optimality of the schedule *s* do not hold in some decision-points (or in a single decision-point).

If Algorithm 3 terminates at Step 18, then the tested sufficient conditions hold for all decision-points considered at the on-line phase of scheduling. Therefore, the constructed pair of job permutations is optimal for all factual scenarios *p*<sup>∗</sup> ∈ *T* which were possible during the on-line phase of scheduling. In this case, the optimal pair of job permutations was established before the end of the schedule execution (after the last decision-point). The described Algorithm 3 must be used if the input (a) is obtained due to the application of Algorithms 1 and 2 [8] at the off-line phase of scheduling. Similarly, one can describe Algorithm 4 with the sufficient conditions from the analogs of Theorems 9 and 10 for their use in the case, when the input (b) is obtained due to the application of Algorithms 1 and 2 at the off-line phase of scheduling.

Similar Algorithm 5 must be used in the case, when the input (c) is obtained due to the application of Algorithms 1 and 2 at the off-line phase of scheduling. In Algorithm 3, a decision-point may occur on machine *M*<sup>1</sup> and on machine *M*<sup>2</sup> simultaneously. Therefore, one has to check the conditions of Theorems 9 and 10 or their analogs alternately for the corresponding conflict sets of the jobs from the set J1,2 and those from the set J2,1.

#### **Algorithm 3** for the on-line phase of scheduling


#### *6.2. The Modified Example with Different Factual Scenarios*

To demonstrate the on-line phase of scheduling based on Algorithm 3, it is considered Example 2 of the problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* with the numerical input data given in Table 1 similarly as for Example 1 with the only one exception. It is assumed that *u*3,2 = 6.

The first part of the off-line phase of scheduling for solving Example 2 is similar to that for Example 1 till checking the conditions of Theorem 2. Indeed, the conditions of Theorem 2 do not hold for the jobs from the set J1,2 since the following strict inequalities hold: *u*2,2 > *l*3,2 and *u*3,2 > *l*2,2.

Due to checking the inequalities (3) and (4), one can determine the binary relation *A*1,2 <sup>≺</sup> over the set J1,2 in the following form: *J*<sup>1</sup> ≺ {*J*2, *J*3}. Thus, the set {*J*2, *J*3} is a conflict set with two jobs; see Definition 5. Then, one can consecutively check the conditions of Theorems 6–8 for the jobs from the set J1,2. After letting *<sup>k</sup>* = 1, *<sup>r</sup>* = 2, one can calculate *<sup>L</sup>*<sup>2</sup> = <sup>∑</sup>*Ji*∈J2,1∪J<sup>2</sup> *li*<sup>2</sup> = *<sup>l</sup>*6,2 + *<sup>l</sup>*7,2 + *<sup>l</sup>*8,2 + *<sup>l</sup>*5,2 = 2 + 3 + 4 + 2 = 11 and then obtain the following relations:

$$\sum\_{i=1}^{k+r} u\_{i1} = u\_{1,1} + u\_{2,1} + u\_{3,1} = 7 + 9 + 9 = 25 \not\le L\_2 + \sum\_{i=1}^{k} l\_{i2} = L\_2 + l\_{1,2} = 11 + 6 = 17.1$$

Thus, the condition of Theorem 6 does not hold for Example 2. Next, one can check the conditions of Theorem 7. Similarly as in the previous case, one can obtain that *L*<sup>2</sup> = 11, *k* = 1, and *r* = 2. Due to the condition (10), one can obtain two inequalities as follows: *s* = 1 and *s* = 2. Then, one can check both permutations of the jobs from the set <sup>J</sup>1,2, which satisfy the partial strict order *<sup>A</sup>*1,2 <sup>≺</sup> , as follows: <sup>Π</sup>(G1,2) = {*π*<sup>1</sup> 1,2, *<sup>π</sup>*<sup>2</sup> 1,2}, where *<sup>π</sup>*<sup>1</sup> 1,2 <sup>=</sup> {*J*1, *<sup>J</sup>*2, *<sup>J</sup>*3} and *<sup>π</sup>*<sup>2</sup> 1,2 = {*J*1, *J*3, *J*2}.

Thus, the permutation *π*<sup>1</sup> 1,2 must be tested. One can obtain the following relations:

$$
\mu\_{2,1} = 9 \le L\_2 + (l\_{1,2} - \mu\_{1,1}) = 11 + (6 - 7) = 10\varphi
$$

$$\mu\_{3,1} = 9 \not\subseteq L\_2 + \sum\_{i=1}^{2} (l\_{i2} - \mu\_{i1}) = L\_2 + (l\_{1,2} - \mu\_{1,1}) + (l\_{2,2} - \mu\_{2,1}) = 11 + (6 - 7) + (5 - 9) = 6.1$$

Hence, the condition of Theorem 7 does not hold for the permutation *π*<sup>1</sup> 1,2. Analogously, for the permutation *π*<sup>2</sup> 1,2, the following relations hold:

$$
\mu\_{3,1} = 9 \le L\_2 + (l\_{1,2} - \mu\_{1,1}) = 11 + (6 - 7) = 10\chi
$$

$$\mu\_{2,1} = 9 \not\subseteq L\_2 + \sum\_{i=1}^{2} (l\_{i2} - u\_{i1}) = L\_2 + (l\_{1,2} - u\_{1,1}) + (l\_{3,2} - u\_{3,1}) = 11 + (6 - 7) + (4 - 9) = 5.1$$

Hence, the condition of Theorem 7 does not hold for the permutation *π*<sup>2</sup> 1,2 as well.

It is impossible to check the condition of Theorem 8, since the conflict set of the jobs {*J*2, *J*3} is located at the end of the partial strict order *A*1,2 <sup>≺</sup> . Thus, the off-line phase of scheduling is completed, and the constructed partial strict order *A*1,2 <sup>≺</sup> is not a linear order. Therefore, there does not exist a pair of permutations of the jobs, which is optimal for any scenario *p* ∈ *T*. In this case, Algorithms 1 and 2 [8] do not terminate with STOP 1. A scheduler needs to use the on-line phase of scheduling for solving Example 2 further.

The output of the off-line phase of scheduling for Example 2 contains the permutation *π*2,1 = (*J*6, *<sup>J</sup>*7, *<sup>J</sup>*8) of the jobs <sup>J</sup>2,1 processed on both machines *<sup>M</sup>*<sup>1</sup> and *<sup>M</sup>*2. The partial strict order *<sup>A</sup>*1,2 <sup>≺</sup> = (*J*<sup>1</sup> ≺ {*J*2, *J*3}) of the jobs J1,2 is constructed. The obtained output (a) of the off-line phase of scheduling shows that Algorithm 3 must be used at the on-line phase of scheduling for solving Example 2.

We next show that Algorithm 3 can be stopped either with STOP 2 (Step 18) or with STOP 3 (Step 17) or with STOP 4 (Step 16) depending on the factual values of the job processing times. Note that *B* = 1; see Algorithm 3.

*Case (j)*: Algorithm 3 is stopped at step 18 (STOP 2).

Consider Step 2 and Step 3 of Algorithm 3. The schedule execution begins as follows: at the initial time-point *t* = 0, machine *M*<sup>1</sup> starts to process operation *O*1,1, while machine *M*<sup>2</sup> starts to process operation *O*6,2. This process is continued until the time-point *t* = 4 when machine *M*<sup>2</sup> completes operation *O*6,2. At this time-point, an exact value of the processing time *p*∗ 6,2 becomes known, namely: *p*∗ 6,2 = 4. Then, machine *M*<sup>2</sup> starts to process operation *O*7,2 and machine *M*<sup>1</sup> continues the processing of operation *O*1,1. At the time-point *t* = 6, machine *M*<sup>1</sup> completes operation *O*1,1. Therefore, an exact value of the duration of operation *O*1,1 becomes known as follows: *p*<sup>∗</sup> 1,1 = 6. At this time-point, a scheduler needs to choose either job *J*<sup>2</sup> or job *J*<sup>3</sup> to be processed next on machine *M*1. Note that machine *M*<sup>2</sup> continues to process the operation *O*7,2 for two time units, wherein *l*7,2 = 3.

Consider Step 4 of Algorithm 3, where the condition (12) of Theorem 9 is checked for the conflict set of jobs {*J*2, *J*3}. Due to equalities *k* = 1, *r* = 2, *c*1(1) = 6, *c*2(6) = 4, one can obtain the following relations: *c*1(1) + *u*2,1 + *u*3,1 = 6 + 9 + 9 = 23 ≤ *c*2(6) + *l*7,2 + *l*8,2 + *l*5,2 + *l*1,2 = 4 + 3 + 4 + 2 + 6 = 19.

At Steps 6 and 7 of Algorithm 3, one can obtain *d*<sup>2</sup> = −4, *d*<sup>3</sup> = −5 and permutation *π<sup>q</sup>* having the following form: *π<sup>q</sup>* = (*J*2, *J*3). At Steps 8 and 9 of Algorithm 3, the conditions of Theorem 10 are checked as follows: *c*1(1) + *u*2,1 = 6 + 9 = 15 ≤ *c*2(6) + *l*7,2 + *l*8,2 + *l*5,2 + *l*1,2 = 4 + 3 + 4 + 2 + 6 = 19;

$$c\_1(1) + \mu\_{2,1} + \mu\_{3,1} = 6 + 9 + 9 = 24 \le c\_2(6) + l\_{7,2} + l\_{8,2} + l\_{5,2} + l\_{1,2} + l\_{2,2} = 4 + 3 + 4 + 2 + 6 + 5 = 24.1$$

At Step 11 of Algorithm 3, one can obtain the following strict order *A*1,2 <sup>≺</sup> = (*J*<sup>1</sup> ≺ *<sup>J</sup>*<sup>2</sup> ≺ *<sup>J</sup>*3) along with the permutation *π*1,2 = (*J*1, *J*2, *J*3). Since *b* = 1 = *B* (see Step 13), Algorithm 3 is stopped at Step 18; see STOP 2. The optimal order of the conflict jobs *J*<sup>2</sup> and *J*<sup>3</sup> is found at the time-point *t* = 6 and the pair of job permutations *π* = (*J*1, *J*2, *J*3, *J*4, *J*6, *J*7, *J*8) and *π* = (*J*6, *J*7, *J*8, *J*5, *J*1, *J*2, *J*3) is optimal for any scenario from the remaining set of possible scenarios *T*(1, 6) = {*p* ∈ *T* : *p*<sup>∗</sup> 1,1 = 6, *p*<sup>∗</sup> 6,2 = 4}.

Thus, an additional information on the exact values of the processing times *p*∗ 6,2 and *p*<sup>∗</sup> 1,1 allows a scheduler to find an optimal order of all conflict jobs. It schould be noted that the optimality of the constructed schedule is proven at the time-point *t* = 6, i.e., before the end of the schedule execution.

At the time-point *t* = 6, machine *M*<sup>1</sup> begins to process operation *O*2,1. Note that all the above checks are performed at the time-point *t* = 6.

*Case (jj)*: Algorithm 3 is stopped at Step 17 (STOP 3).

It is considered another possible realization of the semi-active schedule since another factual processing times are randomly generated at the on-line phase of scheduling for Example 2.

At the time-point *t* = 0, machine *M*<sup>1</sup> begins to process operation *O*1,1, while machine *M*<sup>2</sup> begins to process operation *O*6,2. Let machine *M*<sup>2</sup> complete operation *O*6,2 at the time-point *t* = 2.8. Thus, the exact processing time *p*∗ 6,2 = 2.8 becomes known. Then, machine *M*<sup>2</sup> begins to process operation *O*7,2 and completes this process at the time-point *t* = 6 (i.e., *p*<sup>∗</sup> 7,2 = 3.2), while machine *M*<sup>1</sup> continues processing operation *O*1,1. Let at the time-point *t* = 6.9, machine *M*<sup>1</sup> completes operation *O*1,1 (i.e., *p*∗ 1,1 = 6.9). One needs to choose either job *J*<sup>2</sup> or job *J*<sup>3</sup> to be processed next on machine *M*1. At this time, machine *M*<sup>2</sup> continues to process the operation *O*8,2 since *t* = 6 and (6.9 − 6) = 0.9 < 4 = *l*8,2.

Based on the checking of the condition (12) of Theorem 9 for the conflict set of the jobs, one can obtain the following relations: *k* = 1, *r* = 2, *c*1(1) = 6.9, *c*2(7) = 6;

$$c\_1(1) + \mu\_{2,1} + \mu\_{3,1} = 6.9 + 9 + 9 = 23.9 \not\le c\_2(7) + l\epsilon\_2 + l\epsilon\_2 + l\_{1,2} = 6 + 4 + 2 + 6 = 18.1$$

Similarly as in the previous case *(j)*, one can obtain *d*<sup>2</sup> = −4, *d*<sup>3</sup> = −5, and the permutation *π<sup>q</sup>* having the following form: *π<sup>q</sup>* = (*J*2, *J*3). The conditions of Theorem 10 are checked as follows:

$$c\_1(1) + \mu\_{2,1} = 6.9 + 9 = 15.9 \le c\_2(7) + l\_{8,2} + l\_{5,2} + l\_{1,2} = 6 + 4 + 2 + 6 = 18;$$

*c*1(1) + *u*2,1 + *u*3,1 = 6.9 + 9 + 9 = 24.9 ≤ *c*2(7) + *l*8,2 + *l*5,2 + *l*1,2 + *l*2,2 = 6 + 4 + 2 + 6 + 5 = 23.

Thus, the conditions of Theorem 10 do not hold. At Step 10 of Algorithm 3, one can construct a Johnson's permutation *π<sup>q</sup>* of the conflict jobs based on the inequalities (2) for the processing times of all conflict jobs determined as follows: *pij* = (*uij* + *lij*)/2. For the jobs *J*<sup>2</sup> and *J*3, one can calculate *p*2,1 = 8.5, *p*2,2 = 5.5, *p*3,1 = 8, *p*3,2 = 5 and the Johnson's permutation *π<sup>q</sup>* of the conflict jobs in the following form: *π<sup>q</sup>* = (*J*2, *J*3).

At the time-point *t* = 6.9, one can obtain the pair of permutations *π* = (*J*1, *J*2, *J*3, *J*4, *J*6, *J*7, *J*8) and *π* = (*J*6, *J*7, *J*8, *J*5, *J*1, *J*2, *J*3) of the jobs for their processing on machines M. Therefore, at the time-point *t* = 6, machine *M*<sup>1</sup> begins to process operation *O*2,1. Then, at the time-point *t* = 10, machine *M*<sup>2</sup> completes operation *O*8,2 (the exact processing time *p*∗ 8,2 = 4 becomes known), and then begins to process operation *O*5,2 till the time-point *t* = 12.4 (thus, *p*<sup>∗</sup> 5,2 = 2.4), and then begins to process operation *O*1,2. At the time-point *t* = 15.5, machine *M*<sup>1</sup> completes operation *O*2,1 (i.e., the exact processing time *p*∗ 2,1 = 8.6 becomes known), and then begins to process operation *O*3,1.

Then, at the time-point *t* = 18.7, machine *M*<sup>2</sup> completes operation *O*1,2 (the exact processing time *p*∗ 1,2 = 6.3 becomes known), and then begins to process operation *O*2,2 till the time-point *t* = 23.7 (thus, *p*∗ 2,2 = 5). At this time-point, machine *M*<sup>1</sup> still processes operation *O*3,1. As a result, machine *M*<sup>2</sup> has an idle time in the realized schedule.

At the time-point *t* = 24.5, machine *M*<sup>1</sup> completes operation *O*3,1 (i.e., *p*<sup>∗</sup> 3,1 = 9), and then begins to process operation *O*4,1. Machine *M*<sup>2</sup> begins to process operation *O*3,2 immediately.

At the time-point *t* = 26.5, machine *M*<sup>1</sup> completes operation *O*4,1 (i.e., *p*<sup>∗</sup> 4,1 = 2), and then begins to process operation *O*6,1 till the time-point *t* = 27.5 (i.e., *p*<sup>∗</sup> 6,1 = 1). Then, machine *M*<sup>1</sup> processes operation *O*7,1 till the time-point *t* = 28.5 (i,e., *p*<sup>∗</sup> 7,1 = 1), and then begins to process operation *O*8,1.

At the time-point *t* = 30.5, machine *M*<sup>2</sup> completes operation *O*3,2 (i.e., the exact processing time *p*∗ 3,2 = 6 becomes known). Thus, machine *M*<sup>2</sup> completes to process all jobs in the realized permutation *π* at the time-point *c*2(3) = 30.5. At the time-point *t* = 31.5, machine *M*<sup>1</sup> completes operation *O*8,1 (and the exact processing time *p*∗ 8,1 = 3 becomes known). Thus, machine *M*<sup>1</sup> completes to process all jobs in the realized permutation *π* at the time-point *c*1(8) = 31.5.

All uncertain processing times *p* ∈ *T* took their factual values *p*<sup>∗</sup> *ij* as follows:

$$p^\* = (p\_{1,1}^\*, p\_{1,2}^\*, p\_{2,1}^\*, \dots, p\_{7,2}^\*, p\_{8,1}^\*, p\_{8,2}^\*) = (6.9, 6.3, 8.6, 5, 9, 6, 2, 0, 0, 2.4, 1, 2.8, 1, 3.2, 3, 4).$$

It should be remind that these factual processing times *p*∗ were randomly generated at the time-points of the completions of the corresponding operations; see Remark 3.

For the constructed and realized schedule (*π* , *π*), the equalities *Cmax*(*π* , *π*) = max{*c*1(8), *c*2(3)} = max{31.5, 30.5} = 31.5 hold; see Step 14 of Algorithm 3.

Now, one can check whether the constructed and realized schedule (*π* , *π*) is optimal for the factual vector *p*∗ of the job processing times. To this end, one can construct the pair of Jackson's permutations (*π* <sup>∗</sup>, *<sup>π</sup>* <sup>∗</sup> ) for the deterministic problem *<sup>J</sup>*2|*p*∗, *ni* ≤ <sup>2</sup>|*Cmax* with the factual vector *<sup>p</sup>*<sup>∗</sup> of the job processing times. Then, one can find the optimal makespan value for the deterministic problem *J*2|*p*∗, *ni* ≤ 2|*Cmax* as follows: *Cmax*(*π* <sup>∗</sup>, *π* <sup>∗</sup> ) = 31.5; see Step 15 of Algorithm 3.

The obtained equalities *Cmax*(*π* <sup>∗</sup>, *<sup>π</sup>* <sup>∗</sup> ) = 31.5 = *Cmax*(*π* , *π*) mean that Algorithm 3 has constructed the optimal schedule for the deterministic problem *J*2|*p*∗, *ni* ≤ 2|*Cmax* with the factual vector *p*∗ of the job processing times. However, the optimality of this constructed and realized schedule (*π* , *π*) was established after the execution of the whole schedule (*π* , *π*). Indeed, Algorithm 3 is stopped at Step 17; see STOP 3. The constructed and realized schedule (*π* , *π*) is presented in Figure 4 for case *(jj)* of the randomly generated factual processing times *p*<sup>∗</sup> of the jobs J .

*Case (jjj)*: Algorithm 3 is stopped at Step 16 (STOP 4).

It is considered the same process as in the previous case *(jj)* up to the time-point *t* = 28.5 when machine *M*<sup>1</sup> begins to process operation *O*8,1 (machine *M*<sup>2</sup> processes operation *O*3,2 at this time-point).

Let the equality *p*∗∗ 8,1 = 1 hold for the factual processing time *p*∗∗ 8,1 of the operation *O*8,1 and machine *M*<sup>1</sup> complete operation *O*8,1. Thus, machine *M*<sup>1</sup> completes all operations of the jobs J in the permutation *π* at the time-point 29.5. Therefore, the equality *c*1(8) = 29.5 holds. Similarly as in the previous case, machine *M*<sup>2</sup> completes operation *O*3,2 at the time-point *t* = 30.5. Thus, *p*<sup>∗</sup> 3,2 = 6 and *c*2(3) = 30.5. The factual vector of the job processing times is randomly generated as follows:

$$p^{\*\*} = (p\_{1,1'}^{\*}, p\_{1,2'}^{\*}, p\_{2,1'}^{\*}, \dots, p\_{7,2'}^{\*}, p\_{8,1'}^{\*}, p\_{8,2}^{\*}) = (6.9, 6.3, 8.6, 5, 9, 6, 2, 0, 0, 2.4, 1, 2.8, 1, 3.2, 1, 4).$$

The makespan value for the constructed and realized schedule (*π* , *π*) is determined as follows: *Cmax*(*π* , *π*) = max{*c*1(8), *c*2(3)} = max{29.5, 30.5} = 30.5. However, the optimal makespan value for the deterministic problem *J*2|*p*∗∗, *ni* ≤ 2|*Cmax* with the factual vector *p*∗∗ of the job processing times is equal to 29.7 < 30.5 = *Cmax*(*π* , *π*), since the optimal order of the jobs *J*<sup>2</sup> and *J*<sup>3</sup> is determined as follows: (*J*3, *J*2). Hence, the constructed and realized schedule (*π* , *π*) is not optimal for the factual vector *p*∗∗ ∈ *T* of the job processing times. In this case, Algorithm 3 is stopped at Step 16; see STOP 4.

**Figure 4.** The optimal semi-active schedule for the Example 2 in case (jj).

#### *6.3. Computational Experiments*

We describe the computational experiments and computational results obtained for the tested randomly generated instances of the uncertain problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*. Each tested series consisted of 1000 randomly generated instances with fixed numbers *n* ∈ {10, 20, ... , 100} of the jobs J and the maximum possible errors *δ* ∈ {5%, 10%, 20%, 30%, 40%, 50%, 60%, 70%, 80%, 90%, 100%} of the random durations of the operations *Oij*. The lower bounds *lij* and upper bounds *uij* on the possible values of the durations *pij* of operations *Oij*, *pij* ∈ [*lij*, *uij*], were randomly generated as follows. The lower bound *lij* was randomly chosen from the segment [10, 100000] using a uniform distribution. The upper bound *uij* was determined using the equality *uij* <sup>=</sup> *lij* 1 + *<sup>δ</sup>* 100 . The bounds *lij* and *uij* are decimal fractions with the maximum numbers of digits after the decimal points. The inequality *lij* < *uij* holds for each job *Ji* ∈ J and each machine *Mj* ∈ M.

Algorithms 1 and 2 developed in [8] were used at the off-line phase of scheduling. If the tested instance was not optimally solved using Algorithms 1 and 2, then corresponding Algorithms 3, 4 or 5 was used at the on-line phase of scheduling for solving further the instance of the uncertain problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*. All developed algorithms were coded in C# and tested on a PC with Intel Core i7-7700 (TM) 4 Quad, 3.6 GHz, 32.00 GB RAM.

In the computational experiments, two procedures were used to generate factual durations of the operations *Oij* (a factual duration of the job *Ji* remained unknown until completing this job). In the first part of the computational experiments, the factual duration *p*∗ *ij* of the operation *Oij* was randomly generated using a uniform distribution in the range [*lij*, *uij*]. In the second part of the computational experiments, two distribution laws were used in the experiments to determine the factual scenarios. Namely, we used the gamma distribution with parameters (0.5; 1) (we call it as the distribution law with number 1) and the gamma distribution with parameters (7.5; 1) (we call it as the distribution law

with number 2). For generating factual processing times for each tested instance, the number of the used distribution was randomly chosen from the possible set {1, 2}.

The sufficient conditions proven in Section 5 are verified in polynomial time *O*(*n*2) of the number *n* of the jobs J . Therefore, all series of the tested instances in our computational experiments were solved very quickly (less than one second per a series with 1000 instances).

The experiments include testing of 14 classes of the instances of the uncertain problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* with different ratios of the numbers *m*1, *m*2, *m*1,2 and *m*2,1 (where *n* = *m*<sup>1</sup> + *m*<sup>2</sup> + *m*1,2 + *m*2,1) of the jobs in the subsets J1, J2, J1,2 and J2,1 of the set J , respectively. Every class of the tested instances of the problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* is characterized by the following ratio: *<sup>m</sup>*<sup>1</sup>

$$\frac{m\_1}{n} \cdot 100\% : \frac{m\_2}{n} \cdot 100\% : \frac{m\_{1,2}}{n} \cdot 100\% : \frac{m\_{2,1}}{n} \cdot 100\% \tag{28}$$

of the percentages of the numbers of jobs in the subsets J1, J2, J1,2 and J2,1 of the set J , respectively.

Tables A1–A14 present the computational results obtained for the tested classes of instances with the following ratios (28):

0% : 0% : 10% : 90% (class 1, Table A1); 0% : 0% : 20% : 80% (class 2, Table A2); 0% : 0% : 30% : 70% (class 3, Table A3); 0% : 0% : 40% : 60% (class 4, Table A4); 0% : 0% : 50% : 50% (class 5, Table A5); 5% : 5% : 5% : 85% (class 6, Table A6); 5% : 15% : 5% : 75% (class 7, Table A7); 5% : 20% : 5% : 70% (class 8, Table A8); 10% : 10% : 10% : 70% (class 9, Table A9); 10% : 10% : 40% : 40% (class 10, Table A10); 10% : 20% : 10% : 60% (class 11, Table A11); 10% : 30% : 10% : 50% (class 12, Table A12); 10% : 40% : 10% : 40% (class 13, Table A13); 10% : 60% : 10% : 20% (class 14, Table A14).

All Tables A1–A14 are organized as follows. The procedure for generating factual processing times (the uniform distribution or the gamma distribution) is indicated in the first row of each table. Numbers *n* of the given jobs J in the tested instances of the problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* are presented in the second row. The maximum possible errors *δ* of the randomly generated processing times (in percentages) are presented in the first column. For the fixed maximum possible error *δ*, the obtained computational results are presented in four rows called Stop1, Stop2, Stop3 and Stop4.

The row Stop1 determines the percentage of instances from the tested series, which were optimally solved at the off-line phase of scheduling using either Algorithms 1 or 2 developed in [8]. For such an instance, an optimal pair (*π* , *π*) of the job permutations was constructed before the time-point of starting the first job of the realized schedule, i.e., the equality *Cmax*(*π* , *π*) = *Cmax*(*π*∗, *π*∗∗) holds, where (*π*∗, *π*∗∗) ∈ *S* is an optimal pair of job permutations for the deterministic problem *J*2|*p*∗, *ni* ≤ 2|*Cmax* with the factual scenario *p*<sup>∗</sup> ∈ *T* that is unknown before completing the whole jobs J .

The row Stop2 determines the percentage of instances, which were optimally solved at the on-line phase of scheduling using corresponding Algorithms 3, 4 or 5. For each such an instance, an optimal pair (*π* , *π*) of job permutations for the deterministic problem *J*2|*p*∗, *ni* ≤ 2|*Cmax* associated with the factual scenario *p*<sup>∗</sup> ∈ *T* was constructed by checking sufficient conditions in Theorem 9 or Theorem 10. Remind that the factual scenario *p*<sup>∗</sup> ∈ *T* for the uncertain problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* remains unknown until completing the jobs J .

The row Stop3 determines the percentage of instances, which were optimally solved at the on-line phase of scheduling using Algorithms 3, 4 or 5. In such a case, an optimal pair of job permutations has been constructed for the factual scenario *p*<sup>∗</sup> ∈ *T*. However, the optimality of this pair of job permutations was established only after the execution of the constructed schedule.

The row Stop4 determines the percentage of instances, for which the constructed and realized schedule is not optimal for the deterministic instance *J*2|*p*∗, *ni* ≤ 2|*Cmax* with the factual scenario *p*∗.

#### *6.4. Computational Results*

First of all, it is important to determine a total number of the tested instances, for which 3 (or Algorithms 4 and 5) were completed at Step 18 (STOP 2) or at Step 17 (STOP 3). This number shows how many tested instances of the uncertain job-shop scheduling problem have been optimally solved either with the proofs of their optimality before the completion of processing all jobs J (STOP 2) or the optimality of the obtained schedule was established after the realization of the constructed schedule (STOP 3). For the numbers of jobs from *n* = 10 to *n* = 100 and for each value of the tested errors *δ* of the processing times, average percentages of the instances optimally solved by Algorithms 1, 2, 3, 4 or 5 (these average percentages summarize the values given in rows Stop1 and Stop2 in all Tables A1–A14) are presented in Table 2 and Figure 5.


**Table 2.** Average percentages of the instances whose optimality of the constructed permutations was proven at the off-line and on-line phases of scheduling.

Table 2 shows the total percentages of the optimally solved instances for all classes of the tested instances, for which the optimal schedules were constructed either at the off-line phase of scheduling (STOP 1) or at the on-line phase of scheduling (STOP 2). One can see that for three small values of the maximal errors *δ* ∈ {5%, 10%, 20%} for most classes, more than 90% (up to 100%) of the tested instances were optimally solved. For all tested classes with a maximal error *δ* ≤ 20%, more than 70% tested instances were optimally solved at the off-line or on-line phases of scheduling.

With a further increasing of the maximal error *δ*, the percentage of solved instances drops rapidly. For most tested classes with the maximal error *δ* greater than 70%, the percentage of solved instances is less than 10%. However, these indicators differ for different tested classes. For classes 4, 5, 10, 13 and 14 with maximal errors *δ* ≤ 70%, more than 60% of the tested instances were optimally solved with the proof of the optimality before completing all the jobs. The best computational results are obtained for classes 5, 10 and 14 of the tested instances. More than 80% of the instances from these three classes were optimally solved at the off-line phase of scheduling or at the on-line phases of scheduling provided that the maximal error *δ* of the given job processing times was no greater than 70%, i.e., for *δ* ∈ {5%, 10%, 15%, 20%, 30%, 40%, 50%, 60%, 70%}. For both classes 10 and 14 of the tested instances even with an error *δ* = 100%, more than 70% of the instances were optimally solved.

On the other hand, for both classes 1 and 6 with a maximal error *δ* = 40%, only less than 20% of the tested instances were optimally solved at both off-line phase and on-line phase of scheduling. For classes 1 and 6 with *δ* = 50%, less than 10% of the tested instances were optimally solved. Furthermore, these two classes of instances are most difficult ones to find an optimal schedule with the proof of its optimality before completing all the jobs using the on-line phase and off-line phase

of scheduling. It should be noted that all tested classes of instances demonstrate a monotonic decrease in the percentages of the optimally solved problems with an increase of the values of the maximal error *δ* of the job processing times; see Figure 5.

**Figure 5.** Average percentages of the instances whose optimality of the constructed pair of job permutations was proven at the off-line phase and on-line phase of scheduling.

Let us consider the percentages of the tested instances, for which the optimality of the constructed schedules was proven at the on-line phase of scheduling and the proofs of their optimality being obtained before completing all the jobs. Note that it is novelty of this paper; see rows Stop2 in Tables A1–A14. For all tested numbers of the jobs, *n* ∈ {10, 20, ... , 100}, and for all maximal values of the errors *δ* ∈ {5%, 10%, 20%, ... , 100%} of the job processing times, the average percentages of the instances, which were optimally solved by Algorithms 3, 4 or 5 at the on-line phase of scheduling are presented in Table 3, where only Stop2 is indicated.

It should be noted that the monotonous increase of the percentages of the optimally solved instances takes place only for classes 10 and 14 of the tested instances. For other tested classes of instances, there is a maximum, and for the different classes of the tested instances, these maximal vales being achieved for different maximal values of the errors *δ*. Then the percentages of the optimally solved instances decrease again with the increasing of the maximal values *δ*. The values of the maximal numbers of instances, which optimal solutions have been proven at the on-line phase of scheduling (STOP 2), vary from 0.59% to 8.69% for different classes of instances.

Classes 1–5 are distinguished from the above classes since their maximal numbers of the instances optimally solved at the on-line phase of scheduling vary from 6% to 9%. Average percentages of the instances from these five classes, which were optimally solved by Algorithms 3, 4 or 5 at the on-line phase of scheduling (only Stop2) are shown in Figure 6.

Note that for the difficult classes 1 and 6, the percentages of instances, which were optimally solved at the on-line phase of scheduling with the proofs of their optimality, behave identically with the reaching of the maximum for the maximal error *δ* = 20%. However their maximal values differ, namely: from 2.96% for class 6 up to 8.69% for class 1.


**Table 3.** Average percentages of the instances whose optimality of the constructed permutations was proven at the on-line phase of scheduling.

For the instances, for which the optimality of the constructed schedules was not proven before completing all the jobs J , the relative errors Δ% of the achieved objective function vales for the realized schedules were calculated. Note that the positive errors Δ% may occur only if Algorithm 3 (or Algorithms 4 and 5) have been stopped at Step 16; see STOP 4. For all tested numbers of jobs *n* ∈ {10, 20, ... , 100} and for all maximal values of the errors *δ* ∈ {5%, 10%, 20%, ... , 100%} of the job processing times, the maximal values of Δ*max*% and the average values of Δ*ave*% were calculated separately for instances with uniform distributions (see Table 4) and gamma distributions (see Table 5).

It can be seen that the values of maximal errors Δ*ave*% significantly differ when applying different distribution laws. With using a uniform distribution, the maximal error Δ*max* does not exceed 9%, while when using a gamma distribution, the maximal error Δ*max* could reach a value more than 17%.

It can be seen that for using various distribution laws, Algorithm 3 (Algorithms 4 and 5 as well) terminates at STOP 4 with various combinations of the tested classes and maximal errors *δ*%. If a uniform distribution is used, then for classes 1–2, strictly positive errors Δ*ave*% arise for all values of the tested maximal errors *δ*%. For classes 9–10 and 11–13, such errors appear more often with increasing the maximal error *δ*%.

For a gamma distribution, for all values of *δ*%, the error Δ*ave*% arises only for class 1. For classes 2–4, 6, 8, 10, the error Δ*ave*% arises with the growth of maximal errors *δ*%. For classes 7, 9, 11–13, on the contrary, the error Δ*ave*% is more common for small values of the maximal errors *δ*%.


**Table 4.** Maximal errors Δ*max* and average errors Δ*ave* for all tested instances with factual processing times randomly generated based on a uniform distribution.

As one can see, using the uniform distribution for the generation of the factual job processing times for classes 4, 5, 7, 10, 14, all tested instances were solved optimally using the developed algorithms and two phases of scheduling. In other words, there are no instances, for which corresponding Algorithms 3, 4 or 5 was stopped at Step 16 (STOP 4). However, for the gamma distribution, there are only two such classes 5 and 14. Thus, classes 5 and 14 can be considered as easy ones, while class 1 is the most difficult one. As for class 1, Algorithms 3, 4 and 5 are stopped at Step 16 (STOP 4) for all values of the tested maximal errors *δ*%. Moreover, the maximum makespan error Δ*max*% of more than 5% for the uniform distribution and more than 10% for the gamma distribution is found for classes 1, 9, 11 and 12 of the tested instances (these classes are difficult for the used stability approach).


**Table 5.** Maximal errors Δ*max* and average errors Δ*ave* for all tested instances with factual processing times randomly generated based on a gamma distribution.

Class 13 of the tested instances is a rather strange one. For using the uniform distribution, a maximum makespan error Δ*max*% of more than 5% was obtained, while when for using the gamma distribution, the maximum makespan error Δ*max*% did not reach even 1%. Note that for all tested classes of the instances, the average makespan errors Δ*ave*% for all tested numbers *n* ∈ {10, 20, ... , 100} of jobs J are less than 0.02%.

Maximal relative makespan errors Δ*max*% for each tested class and for all values of the tested maximal errors *δ* are shown in Figure 7 for the instances with uniform distributions and in Figure 8 for the instances with gamma distributions of the factual durations of the given operations.

Figures 7 and 8 also show that the maximal value of the makespan errors Δ*max*% for the constructed and realized schedule for the factual scenarios are achieved for different values of the maximal errors *δ*% for different classes of the tested instances.

**Figure 6.** Average percentages of the instances whose optimality of the constructed pair of job permutations was proven at the on-line phase of scheduling.

**Figure 7.** Maximal errors Δmax for the tested instances with a uniform distribution.

**Figure 8.** Maximal errors Δmax for the tested instances with a gamma distribution.

#### **7. Concluding Remarks**

The uncertain job-shop scheduling problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* attract the attention of practitioners and researchers since this problem is applicable in real-life processing systems for some reduction of production costs due to a better utilization of the available machines and resources.

This paper is a continuation of our previous one [8], where only off-line phase of scheduling was investigated and tested for the uncertain problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* based on the stability approach. In [8], we tested 15 classes of the randomly generated instances *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*. A lot of instances from nine easy classes were optimally solved at the off-line phase of scheduling. If the maximal errors were no greater than 20%, i.e., *δ* ∈ {5%, 10%, 15%, 20%}, then more than 80% of the tested instances were optimally solved at the off-line phase of scheduling. If the maximal error was equal to 50%, i.e., *δ* = 50%, then 45% of the tested instances were optimally solved.

However, less than 5% of the tested instances with maximal possible error *δ* ≥ 20% from six hard tested classes were optimally solved at the off-line phase of scheduling. There were no tested hard instances with the maximal error 50% optimally solved in [8]. All these difficulties were succeeded in Sections 4–6 of this paper, where it is shown that the on-line phase of scheduling allows a scheduler to find either optimal schedule or very close to optimal ones. Additional information on the factual value of the job processing times becomes available once the processing of the job on the machine is completed. Using this information, a scheduler can determine a smaller dominant set of semi-active schedules, which is based on sufficient conditions for schedule dominance. The smaller dominant set enables a scheduler to quickly make an on-line scheduling decision whenever additional information on processing the job becomes available.

In Section 5, it is investigated the optimal pair (*π* , *π*) of job permutations (Theorems 9 and 10). Using the proven analytical results, we derived Algorithms 3–5 for constructing optimal pairs (*π* , *π*) of job permutations for all scenarios *p* ∈ *T* or a small dominant set *S*(*T*) of schedules for the uncertain problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax*. At the off-line scheduling phase, Algorithms 1 and 2 [8] are used to determine the partial strict order *A*1,2 <sup>≺</sup> over the job set <sup>J</sup>1,2 and the partial strict order *<sup>A</sup>*2,1 <sup>≺</sup> over the job set <sup>J</sup>2,1. The constructed precedence digraphs (J1,2, *<sup>A</sup>*1,2 <sup>≺</sup> ) and (J2,1, *<sup>A</sup>*2,1 <sup>≺</sup> ) determine a minimal dominant set *S*(*T*) of schedules.

In Sections 6, it is shown how to use Algorithms 3–5 for constructing a small dominant set of semi-active schedules that enables a scheduler to make a fast decision whenever information on completing some jobs become available. Based on these algorithms, the problem *J*2|*lij* ≤ *pij* ≤ *uij*, *ni* ≤ 2|*Cmax* was solved with very small errors of the obtained objective values. The computational experiments (Section 6.3) show that pairs of job permutations constructed by Algorithms 3–5 are very close to the optimal pairs of job permutations. We tested 14 classes of randomly generated instances. For the tested instances, the percentage of the optimally solved instances slowly decreases with increasing maximal errors *δ* of the processing times. The developed on-line algorithms perform with the maximal errors of the achieved makespan less than 1% if *n* ∈ {20, 30, . . . , 100}. For all tested classes of the instances, the average makespan errors for all numbers *n* ∈ {10, 20, . . . , 100} of the jobs J were less than 0.02%.

In a possible further research, one can continue the study of the uncertain job-shop scheduling problem based on the stability approach. It is useful to improve the developed algorithms and to extend them for other machine environments, such as a single machine or processing systems with parallel machines. It is promising to investigate an optimality region of the semi-active schedule and to develop algorithms for constructing a semi-active schedule with the largest optimality region.

It is also useful to apply the stability approach for solving the uncertain flow-shop and job-shop scheduling problems with |M| ≥ 3 different machines.

**Author Contributions:** Y.N.S. and N.M.M. jointly proved theoretical results; Y.N.S. and N.M.M. jointly conceived and designed the algorithm; V.H. performed the experiments; Y.N.S., N.M.M. and V.D.H. jointly analyzed the data; Y.N.S. and N.M.M. jointly wrote the paper. All authors have read and agreed to the published version of the manuscript.

**Acknowledgments:** We are thankful for useful remarks and suggestions provided by four anonymous reviewers on the earlier drafts of our paper.

**Conflicts of Interest:** The authors declare no conflict of interest.

#### **Appendix A**

Algorithms 1 and 2 Developed in [8].

#### **Algorithm 1**

