Schedule Execution for Two-Machine Job-Shop to Minimize Makespan with Uncertain Processing Times

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(n2) for n given jobs. The computational experiment shows the effectiveness of these algorithms.


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][2][3][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][6][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.

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.

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.

Settings of Scheduling Problems and Main Notations
A set J = {J 1 , J 2 , ..., J n } 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: J2|n i ≤ 2|C max , where α = J2 means a job-shop processing system with two available different machines and n i a number of possible stages for processing a job J i ∈ J . The criterion γ = C max determines the minimization of a schedule length (makespan) as follows: where C i (s) denotes the completion time-point of the job J i ∈ J in the schedule s and S denotes a set of all semi-active schedules existing for the deterministic problem J2|n i ≤ 2|C max . (A schedule s is called a semi-active one [10][11][12] if the completion time-point C i (s) of any job J i ∈ J cannot be reduced without changing an order of the jobs on some machine.) Let O ij denote an operation of the job J i ∈ J processed on the machine M j ∈ M. Each of the available machines can process the job J i ∈ J no more than once, a preemption of the operation O ij being not allowed. The job J i ∈ J has its own processing route through the available machines in set M. The partition J = J 1 J 2 J 1,2 J 2,1 of the jobs is given and fixed, where each job J i ∈ J 1,2 must be processed first on machine M 1 and then on machine M 2 , i.e., all jobs from the set J 1,2 have the same machine route (M 1 , M 2 ). Each job J i ∈ J 2,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 M j ∈ M. The following notation m h = |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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max , where the duration p ij of each operation O ij is unknown before scheduling. It is only known that the inclusion p ij ∈ [l ij , u ij ] holds for any possible realization of the chosen schedule, where u ij ≥ l ij ≥ 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 , . . . , p n1 , p n2 ) of the job processing times be determined as follows: It should be noted that the problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max is mathematically incorrect since one cannot calculate makespan C max (s) in the equality (1) before completing the jobs J i in the set J provided that the strict inequality u ij > l ij 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max . 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 J2|n i ≤ 2|C max 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 1 J 1,2 J 2,1 processed on machine M 1 and π = (π 2,1 , π 2 , π 1,2 ) is an optimal permutation of the jobs J 2 J 1,2 J 2,1 on machine M 2 . Such an optimal semi-active schedule is presented in Figure 1. In what follows, it is assumed that job J i belongs to the permutation π h , if the following inclusion holds: In a Jackson's pair of permutations (π , π ), the optimal order for processing jobs from the set J 1 (from the set J 2 , 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: 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]. The deterministic scheduling problem J2|n i ≤ 2|C max 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: J2|p, n i ≤ 2|C max . For any fixed scenario p ∈ T, there exists a Jackson's pair (π , π ) of permutations, which is optimal for the problem J2|p, n i ≤ 2|C max , i.e., the equality C max (π , π ) = C p max holds, where C p max denotes the optimal makespan value for the problem J2|p, n i ≤ 2|C max . Let S 1,2 denote a set of all permutations of m 1,2 jobs from the set J 1,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 J 2,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 (π , π ) ∈ S, where π = (π i 1,2 , π 1 , π j 2,1 ) and π = (π j 2,1 , π 2 , π i 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 π 1 (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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max . 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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 J2|p, n i ≤ 2|C max 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 J2|p , n i ≤ 2|C max with a fixed scenario p .

A Literature Review and Closed Results
It should be noted that the uncertain flow-shop scheduling problem denoted as F2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max is well studied [15], unlike the uncertain job-shop scheduling problem.

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][17][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][20][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][23][24][25]. In the approach of seeking a robust schedule [22,[26][27][28], a decision-maker looks for a schedule that hedges against the worst-case possible scenario.
A fuzzy approach [29][30][31][32][33][34][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 C max criterion, and in [2,[38][39][40] for the total completion time criterion, ∑ C i := ∑ J i ∈J C i (π ). 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 F2|l ij ≤ p ij ≤ u ij |C max [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 ∑ C i 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 F2|l ij ≤ p ij ≤ u ij |C max , 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 C max 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max in Sections 4-6.

Closed Results for Uncertain (Interval) Flow-Shop Scheduling Problems
The uncertain job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max is a generalization of the uncertain flow-shop problem F2|l ij ≤ p ij ≤ u ij |C max , where all given jobs have the same machine route. Two uncertain flow-shop problems are associated with an uncertain job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max . In one of these flow-shop problems, an optimal schedule for processing the jobs J 1,2 must be determined, i.e., it is assumed that J 2,1 = J 1 = J 2 = ∅. In another associated flow-shop problem, an optimal schedule for processing jobs J 2,1 must be determined, i.e., it is assumed that J 1,2 = J 1 = J 2 = ∅. Our approach to the solution of the uncertain job-shop scheduling problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max is based on the following remark.

Remark 1.
The solution of the uncertain job-shop scheduling problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max may be based on the solutions of the associated flow-shop scheduling problem F2|l ij ≤ p ij ≤ u ij |C max with the job set J = J 1,2 , where J 2,1 = J 1 = J 2 = ∅, and that with the job set J = J 2,1 (i.e., J 1,2 = J 1 = J 2 = ∅).
The sense of Remark 1 becomes clear from Figure 2, where the semi-active schedule s for the job-shop scheduling problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max is presented. Indeed, in Figure 2, the length C max (s) of the schedule s is equal to the length of the corresponding semi-active schedule determined for the associated flow-shop scheduling problem F2|l ij ≤ p ij ≤ u ij |C max with the job set J = J 1,2 . Thus, if one will solve both associated flow-shop problem F2|l ij ≤ p ij ≤ u ij |C max with the job set J = J 1,2 and associated flow-shop problem F2|l ij ≤ p ij ≤ u ij |C max with the job set J = J 2,1 , then the original job-shop scheduling problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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 F2|l ij ≤ p ij ≤ u ij |C max with the job set J = J 1,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 F2|l ij ≤ p ij ≤ u ij |C max has the following two mandatory properties: (i) the set S is a set of n! pairs (π q , π q ) of the identical permutations of n = m 1,2 jobs from the set J = J 1,2 since the machine route for processing all jobs J 1,2 is the same (M 1 , M 2 ); (ii) the J-solution (see Definition 1) is a set of Johnson's permutations of the jobs J = J 1,2 , i.e., for each scenario p ∈ T the set S(T) contains at least one optimal pair (π q , π q ) of identical Johnson's permutations π q such that the inequality (2) holds for all indexes e and f .
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 F2|l ij ≤ p ij ≤ u ij |C max with a fixed order J v → J w of the jobs J v and J w in all permutations π q , (π q , π q ) ∈ S(T), if and only if at least one of the following two conditions hold: u v1 ≤ l v2 and u v1 ≤ l w1 ; u w2 ≤ l w1 and u w2 ≤ l v2 .
Remark 3. The factual value p * ij of the job processing time p ij becomes known at the time-point c j (i) when the operation O ij is completed on the machine M j ∈ M.
Due to Remark 3, if all jobs J are completed on the corresponding machines from the set M, the durations of all operations O ij take on exact values p * ij , where l ij ≤ p * ij ≤ u ij , and a unique factual scenario p * ∈ 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 O ij , the exact value p * ij of the processing time p ij ∈ T becomes known at the completion time c j (i) of this operation; see Remark 3.
We next consider the off-line phase of scheduling for the uncertain job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max , 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 J2|p, n i ≤ 2|C max with scenario p.
Obviously, the J-solution is a dominant set for the uncertain job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max . 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 ≺ and A 2,1 ≺ over set J 1,2 and set J 2,1 ; see Section 3.
In order to determine an optimal permutation for processing jobs from the set J 2,1 (set J 1,2 , respectively), we consider the uncertain flow-shop problem F2|l ij ≤ p ij ≤ u ij |C max with the job set J 1,2 ⊆ J and the machine route (M 1 , M 2 ), and that with the job set J 2,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 F2|l ij ≤ p ij ≤ u ij |C max with the job set J 1,2 , and the set S 2,1 ⊆ S 2,1 be a set of permutations from the dominant set for the flow-shop problem F2|l ij ≤ p ij ≤ u ij |C max with the job set J 2,1 . Then the set < S 1,2 , S 2,1 > ⊆ S is a dominant set for the job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max with the job set J = J 1 ∪ J 2 ∪ J 1,2 ∪ J 2,1 .

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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max may be based on solving the uncertain flow-shop problem F2|l ij ≤ p ij ≤ u ij |C max with the job set J 1,2 and that with the job set J 2,1 . A criterion for the existence of a single-element J-solution for the uncertain flow-shop problem F2|l ij ≤ p ij ≤ u ij |C max is determined in Theorem 2.
Due to Definition 2, for the conflict jobs J x ∈ J 1,2 and J y ∈ J 1,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 x ⊆ J 1,2 of the jobs is called a conflict set of the jobs, if for any job J y ∈ J 1,2 \ J x either relation (J x , J y ) ∈ A 1,2 ≺ or relation (J y , J x ) ∈ A 1,2 ≺ holds for each job J x ∈ J x .
One can describe the analogs of Theorems 6-8 for reducing the cardinality of a dominant set for the job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max provided that for the flow-shop problem F2|l ij ≤ p ij ≤ u ij |C max with the job set J 2,1 , there exists a partial strict order A 2,1 ≺ over the set J 2,1 = J * 2,1 ∪ J 1 2,1 ∪ J 2 2,1 with the following form: If the set {J 1 , . . . , J k } is empty in the constructed job permutation, then it is needed to check the conditions of Theorem 8. If the set {J k+r+1 , . . . , J m 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].

An Illustrative Example
To illustrate the above results, we consider Example 1 of the uncertain job-shop scheduling problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max with eight jobs {J 1 , J 2 , . . . , J 8 } = J . Let three jobs J 1 , J 2 and J 3 have the machine route (M 1 , M 2 ), jobs J 6 , J 7 and J 8 have the opposite machine route (M 2 , M 1 ), job J 4 and job J 5 have to be processed only on machine M 1 and machine M 2 , respectively. The partition J = The lower and upper bounds on the job processing times are determined in Table 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 1 and machine M 2 . These permutations π and π have the following forms: π = (π 1,2 , π 1 , π 2,1 ), π = (π 2,1 , π 2 , π 1,2 ).
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: 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 J 2,1 in the increasing of their indexes.
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.

The On-line Phase of Scheduling
Due to Remark 3, if the job J i is completed on the corresponding machine M j ∈ M, the duration of the operation O ij takes on exact value p * ij , where l ij ≤ p * ij ≤ u ij . A scheduler can use this information on the duration of the operation O ij for a selection of the next job for processing on machine M j . 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 ), {π * 2,1 }> ⊂ S, is a dominant set for the problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max with the job set J . In other words, the optimal permutations for processing all jobs from the set J 2,1 are already determined at the off-line phase of scheduling.
Let the strict order A 1,2 ≺ over the set J 1,2 = J * 1,2 ∪ J 1 1,2 ∪ J 2 1,2 be determined as follows: J 1 ≺ . . . ≺ J k ≺ {J k+1 , J k+2 , . . . , J k+r } ≺ J k+r+1 ≺ . . . ≺ J m 1,2 . At the initial time t = 0, machine M 1 has to start processing jobs from the set {J 1 , . . . , J k } in the following optimal order: (J 1 , . . . , J k ). At the same time t = 0, machine M 2 has to start processing jobs from the set J 2,1 in the order determined by the permutation π * 2,1 , then jobs from the set J 2 in the arbitrary order, and then jobs from the set {J 1 , . . . , J k } in the following optimal order: (J 1 , . . . , J k ); see Figure 3. At the time-point t = c 1 (k), machine M 1 completes the operation O k1 . Let J (i, j) denote a set of all jobs processed on machine M j from the initial part of the schedule till the job J i , e.g., the set of jobs {J 1 , J 2 , . . . , J k } 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 * i1 of the processing times p i1 of all jobs J i in the set J (k, 1) are already known.
denote a set of all jobs whose processing is completed on machine M 2 before time-point t = c 1 (k). The factual values p * i2 of the processing times p i2 of all jobs J i in the set J (l − 1, 2) are known at the time-point t = c 1 (k) > c 2 (l − 1), i.e., p i2 = p * i2 , while the factual values of the processing times p j2 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: 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 {J k+1 , J k+2 , . . . , J k+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 ), {π * 2,1 }> ⊂ S be a dominant set for the uncertain problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max with the job set J . Let the strict order A 1,2 ≺ over the set J 1,2 = J * 1,2 ∪ J 1 1,2 ∪ J 2 1,2 be determined as follows: If at the time-point t = c 1 (k), the following inequality holds: then at the time-point t = c 1 (k), the set S = <{π 1,2 }, {π * 2,1 }> ⊂ S, where π 1,2 ∈ Π(G 1,2 ), is a dominant set for the problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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 t = c 1 (k). Let C p max denote the optimal makespan value for the deterministic job-shop problem J2|p, n i ≤ 2|C max with the set J of the given jobs and the vector p of the job processing times.
Case (a): It is assumed that c 1 (π ) ≥ c 2 (π ). Then, one can obtain the following equalities: where C max (π * 2,1 ) is the value of makespan for the deterministic flow-shop problem F2|p 2,1 |C max with the job set J 2,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 F2|p 2,1 |C max with the set J 2,1 of the given jobs and with vector p 2,1 of the job processing times. Therefore, C max (π * 2,1 ) is an optimal makespan value for the deterministic flow-shop problem F2|p 2,1 |C max and C max (π * 2,1 ) is a minimal completion time for processing all jobs from the set J 2,1 on both machines. From the equalities (13), one can obtain the equality C max (π , π ) = C p max . Case (b): It is assumed that c 1 (π ) < c 2 (π ). Then, one can obtain the following equalities: where C max (π 1,2 ) is an optimal value of the makespan criterion for the deterministic flow-shop problem F2|p 1,2 |C max with the job set J 1,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 , . . . , J k ). For every pair of jobs from the set {J 1 , J 2 , . . . , J k }, 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 , . . . , J k }, the inequalities (2) hold. Thus, in the permutation π beg 1,2 := (J 1 , J 2 , . . . , J k ), all the jobs are arranged in the Johnson's order. One can conclude that the following value determines an optimal makespan value for the deterministic flow-shop problem F2|p beg 1,2 |C max with the job set {J 1 , J 2 , . . . , J k } 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 p). Therefore, C max (π beg 1,2 ) is a minimal makespan value for processing jobs of the set {J 1 , J 2 , . . . , J k } on both machines. Then, for the time-point c 2 (k) when machine M 2 completes the operation O k2 , one can obtain the following equality: Due to the inequality (12) and the equality (16), one can obtain the following inequalities for the jobs from the conflict set {J k+1 , J k+2 , . . . , J k+r }: From the inequalities (17), one can obtain the following inequality: Thus, machine M 2 processes all jobs from the conflict set {J k+1 , J k+2 , . . . , J k+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 2 completes the processing of the last job from the conflict set {J k+1 , J k+2 , . . . , J k+r } in the permutation π 1,2 is determined as follows: where c 2 is an optimal makespan value for processing jobs from the set {J 1 , J 2 , . . . , J k , J k+1 , J k+2 , . . . , J k+r }. Next, we consider jobs from the set {J k+r+1 , . . . , J m 1,2 }. Let π end 1,2 := (J k+r+1 , . . . , J m 1,2 ) denote the permutation of the jobs {J k+r+1 , . . . , J m 1,2 } in the permutation π 1,2 . Analogously as for the job set {J 1 , J 2 , . . . , J k }, one can obtain that the value of is an optimal makespan value for the deterministic flow-shop problem F2|p end 1,2 |C max with the job set {J k+r+1 , . . . , J m 1,2 } and with the vector p 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 {J k+r+1 , . . . , J m 1,2 } on both machines. The time-point when machine M 2 completes the processing of the last job from the permutation π can be calculated as follows: 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 F2|p 1,2 |C max with the job set J 1,2 and with the vector p 1,2 of the job durations. We denote this Johnson's permutation as π * 1,2 . Since π * 1,2 ∈ Π(G 1,2 ), the permutation π * 1,2 has the following form: π * The optimal makespan value C max (π * 1,2 ) can be calculated as follows: where relations (15) and (20) are used. From relations (21) and (22), one can obtain the relations Therefore, relations (14) and (23) imply the equality C max (π , π ) = C p max . Thus, in both cases (a) and (b), the equality C max (π , π ) = C p max holds and the pair of permutations (π , π ) = ((π 1,2 , π 1 , π * 2,1 ), (π * 2,1 , π 2 , π 1,2 )) is optimal for the deterministic job-shop problem J2|p, n i ≤ 2|C max with the scenario p ∈ T(k, l − 1). Therefore, the set S =<{π 1,2 }, {π * 2,1 }> contains an optimal pair of job permutations for the job-shop problem J2|p, n i ≤ 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 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 ), {π * 2,1 } > ⊂ S be a dominant set for the uncertain job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max with the job set J . Let the partial strict order A 1,2 ≺ over the set J 1,2 = J * 1,2 ∪ J 1 1,2 ∪ J 2 1,2 be determined as follows: If at the time-point t = c 1 (k), the following inequalities hold: for all indexes s ∈ {1, 2, . . . , r}, then at the time , is a dominant set for the uncertain problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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: Based on the inequality (25), one can obtain the following relations: Due to relations (26), the following inequality holds: Thus, machine M 2 processes the job J k+1 in permutation π 1,2 without an idle time between the jobs J k and J k+1 . Analogously, using s ∈ {2, 3, . . . , r}, one can show that the following inequalities hold: Therefore, machine M 2 processes jobs from the conflict set {J k+1 , J k+2 , . . . , J k+r } in permutation π 1,2 without idle times between the jobs J k+1 and J k+2 , between the jobs J k+2 and J k+3 and so on, between the jobs J k+r−1 and J k+r . Then, the following relations hold: 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 , π * 2,1 ), (π * 2,1 , π 2 , π 1,2 )) ∈ S is optimal for the deterministic job-shop problem J2|p, n i ≤ 2|C max 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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 = <{π * 1,2 }, Π(G 2,1 )> ⊂ S provided that a dominant set for the uncertain job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max with the job set J and the partial strict order A 2,1 ≺ over the set J 2,1 = J * 2,1 ∪ J 1 2,1 ∪ J 2 2,1 has the following form:

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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max . 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.
Hence, there is no need to use the on-line phase of scheduling for such an instance of the uncertain job-shop scheduling problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max .
In Section 6.1, it shown how to solve instances of the uncertain job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max , which cannot be optimally solved at the off-line phase of scheduling.

Algorithms 3-5 for the On-Line Phase of Scheduling
Let the considered instance of the uncertain job-shop problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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: (a) the permutation π 2,1 of the jobs from set J 2,1 and the partial strict order A 1,2 ≺ of the jobs J 1,2 ; (b) the permutation π 1,2 of the jobs from set J 1,2 and the partial strict order A 2,1 ≺ of the jobs J 2,1 ; (c) the partial strict order A 1,2 ≺ of the jobs J 1,2 and the partial strict order A 2,1 ≺ of the jobs J 2,1 .
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 * ∈ T randomly determined after completing the on-line phase of scheduling. Therefore, there is a strictly positive error ∆(s) of the objective function C max (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 * ∈ 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 * ∈ 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 1 and on machine M 2 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 J 1,2 and those from the set J 2,1 .

Algorithm 3 for the on-line phase of scheduling
Input: Lower bounds l ij and upper bounds u ij on the durations p ij of all operations O ij ∈ J processed on machines M j ∈ M; a permutation π 1 of the jobs J 1 and a permutation π 2 of the jobs J 2 ; an optimal permutation π 2,1 of the jobs from the set J 2,1 ; a partial strict order A 1,2 ≺ of the jobs from the set J 1,2 ; a number B of the conflict sets in the partial strict order A 1,2 ≺ . Output: Permutation π 1,2 of the jobs from the set J 1,2 .
Step 2: UNTIL the completion time-point of the last job in the set J , process the whole linear part of the jobs in the partial strict order A 1,2 ≺ on the machine M 1 till a conflict set of the jobs is met; let t denote a time-point of the completion of the linearly ordered set of jobs.
Step 3: Process jobs of the permutation (π 2,1 , π 2 ) and then process the linear part in the partial strict order A 1,2 ≺ on the machine M 2 up to time-point t.
Step 4: Check the conditions of Theorem 9 for the conflict set of the jobs.
Step 5: IF the sufficient conditions of Theorem 9 hold THEN set b := b + 1 and choose an arbitrary order π q of the conflict jobs GOTO step 11.
Step 6: ELSE set d z = l z2 − u z1 for all conflict jobs J z and partition the conflict jobs J z into two subsets X 1 and X 2 , where J z ∈ X 1 if d z ≥ 0, and J z ∈ X 2 otherwise.
Step 7: Construct the following order π q of the conflict jobs: First, arrange the jobs from the set X 1 in the non-decreasing order of the values of u i1 , then arrange the jobs from the set X 2 in the non-increasing order of the values of l i2 .
Step 8: Check the conditions of Theorem 10 for the constructed permutation of the conflict jobs.
Step 9: IF the sufficient conditions of Theorem 10 hold THEN set b := b + 1 GOTO step 11.
Step 10: Construct a Johnson's permutation π q of the conflict jobs based on the inequalities (2) provided that p ij = (u ij + l ij )/2.
Step 11: Include the permutation π q of the conflict jobs in the strict order A 1,2 ≺ instead of the conflict set of these jobs.
Step 12: RETURN Step 13: IF b = B THEN GOTO step 18.
Step 14: Calculate makespan C max (s) for the schedule s constructed at steps 1 -12; calculate makespan C max (s * ) for the optimal schedule s * polynomially calculated for the corresponding deterministic problem J2|p * , n i ≤ 2|C max , where the factual processing times p * are randomly generated for all jobs J .
Step 16: STOP 4: The constructed schedule s is not optimal for the factual processing times p * of the jobs J .
Step 17: STOP 3: The optimality of the constructed schedule s for the factual processing times p * of the jobs J was established only after the execution of the schedule s.
Step 18: STOP 2: The optimality of the constructed schedule s for the factual processing times p * of the jobs J was proven before the end of the execution of this schedule.

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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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 J 1,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 ≺ over the set J 1,2 in the following form: J 1 ≺ {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 J 1,2 . After letting k = 1, r = 2, one can calculate L 2 = ∑ J i ∈J 2,1 ∪J 2 l i2 = l 6,2 + l 7,2 + l 8,2 + l 5,2 = 2 + 3 + 4 + 2 = 11 and then obtain the following relations: 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 2 = 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 J 1,2 , which satisfy the partial strict order A 1,2 ≺ , as follows: Thus, the permutation π 1 1,2 must be tested. One can obtain the following relations: Hence, the condition of Theorem 7 does not hold for the permutation π 1 1,2 . Analogously, for the permutation π 2 1,2 , the following relations hold: Hence, the condition of Theorem 7 does not hold for the permutation π 2 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 ≺ . Thus, the off-line phase of scheduling is completed, and the constructed partial strict order A 1,2 ≺ 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 , J 7 , J 8 ) of the jobs J 2,1 processed on both machines M 1 and M 2 . The partial strict order A 1,2 ≺ = (J 1 ≺ {J 2 , J 3 }) of the jobs J 1,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.

At
Step 11 of Algorithm 3, one can obtain the following strict order A 1,2 Step 13), Algorithm 3 is stopped at Step 18; see STOP 2. The optimal order of the conflict jobs J 2 and J 3 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 * 1,1 = 6, p * 6,2 = 4}. Thus, an additional information on the exact values of the processing times p * 6,2 and p * 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 1 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 1 begins to process operation O 1,1 , while machine M 2 begins to process operation O 6,2 . Let machine M 2 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 2 begins to process operation O 7,2 and completes this process at the time-point t = 6 (i.e., p * 7,2 = 3.2), while machine M 1 continues processing operation O 1,1 . Let at the time-point t = 6.9, machine M 1 completes operation O 1,1 (i.e., p * 1,1 = 6.9). One needs to choose either job J 2 or job J 3 to be processed next on machine M 1 . At this time, machine M 2 continues to process the operation O 8,2 since t = 6 and (6.9 − 6) = 0.9 < 4 = l 8,2 .
Thus, the conditions of Theorem 10 do not hold. At Step 10 of Algorithm 3, one can construct a Johnson's permutation π q of the conflict jobs based on the inequalities (2) for the processing times of all conflict jobs determined as follows: p ij = (u ij + l ij )/2. For the jobs J 2 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 π q of the conflict jobs in the following form: π q = (J 2 , J 3 ).
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 C max (π , π ) = 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 (π * , π * ) for the deterministic problem J2|p * , n i ≤ 2|C max with the factual vector p * of the job processing times. Then, one can find the optimal makespan value for the deterministic problem J2|p * , n i ≤ 2|C max as follows: C max (π * , π * ) = 31.5; see Step 15 of Algorithm 3.
The makespan value for the constructed and realized schedule (π , π ) is determined as follows: C max (π , π ) = max{c 1 (8), c 2 (3)} = max{29.5, 30.5} = 30.5. However, the optimal makespan value for the deterministic problem J2|p * * , n i ≤ 2|C max with the factual vector p * * of the job processing times is equal to 29.7 < 30.5 = C max (π , π ), since the optimal order of the jobs J 2 and J 3 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.

Computational Experiments
We describe the computational experiments and computational results obtained for the tested randomly generated instances of the uncertain problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max . 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 O ij . The lower bounds l ij and upper bounds u ij on the possible values of the durations p ij of operations O ij , p ij ∈ [l ij , u ij ], were randomly generated as follows. The lower bound l ij was randomly chosen from the segment [10, 100000] using a uniform distribution.
The upper bound u ij was determined using the equality u ij = l ij 1 + δ 100 . The bounds l ij and u ij are decimal fractions with the maximum numbers of digits after the decimal points. The inequality l ij < u ij holds for each job J i ∈ J and each machine M j ∈ 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max . 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 O ij (a factual duration of the job J i remained unknown until completing this job). In the first part of the computational experiments, the factual duration p * ij of the operation O ij was randomly generated using a uniform distribution in the range [l ij , u ij ]. 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 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 C max (π , π ) = C max (π * , π * * ) holds, where (π * , π * * ) ∈ S is an optimal pair of job permutations for the deterministic problem J2|p * , n i ≤ 2|C max with the factual scenario p * ∈ 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 J2|p * , n i ≤ 2|C max associated with the factual scenario p * ∈ T was constructed by checking sufficient conditions in Theorem 9 or Theorem 10. Remind that the factual scenario p * ∈ T for the uncertain problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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 * ∈ 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 J2|p * , n i ≤ 2|C max with the factual scenario p * .

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. 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. 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 δ%.  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).  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.

Concluding Remarks
The uncertain job-shop scheduling problem J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max based on the stability approach. In [8], we tested 15 classes of the randomly generated instances J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max . 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max . At the off-line scheduling phase, Algorithms 1 and 2 [8] are used to determine the partial strict order A 1,2 ≺ over the job set J 1,2 and the partial strict order A 2,1 ≺ over the job set J 2,1 . The constructed precedence digraphs (J 1,2 , A 1,2 ≺ ) and (J 2,1 , A 2,1 ≺ ) 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 J2|l ij ≤ p ij ≤ u ij , n i ≤ 2|C max 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.
Step 1: Determine a partition J = J 1 ∪ J 2 ∪ J 1,2 ∪ J 2,1 of the job set J , permutation π 1 of jobs from set J 1 and permutation π 2 of jobs from set J 2 , arrange the jobs in the increasing order of their indexes.
Step 2: IF the first inequality in condition (5)

of Theorem 4 holds THEN BEGIN
Construct a permutation π 1,2 of jobs from set J 1,2 , arrange them in the increasing order of their indexes; IF the second inequality in condition (5) of Theorem 4 holds THEN construct a permutation π 2,1 of jobs from set J 2,1 , arrange them in the increasing order of their indexes GOTO Step 10 END Step 3: IF the first inequality in condition (6)

of Theorem 4 holds THEN BEGIN
Construct a permutation π 2,1 of jobs from set J 2,1 , arrange them in the increasing order of their indexes; IF the second inequality in condition (6) of Theorem 4 holds THEN construct a permutation π 1,2 of jobs from set J 1,2 , arrange the jobs in the increasing order of their indexes END Step 4: IF both permutations π 1,2 and π 2,1 are constructed THEN GOTO Step 10.
Step 11: RETURN the permutation π 2,1 of jobs from set J 2,1 processed on machines M 1 and M 2 , the partial strict order A 1,2 ≺ of jobs from set J 1,2 GOTO Step 14.
Step 12: RETURN the permutation π 1,2 of jobs from set J 1,2 processed on machines M 1 and M 2 , the partial strict order A 2,1 ≺ of jobs from set J 2,1 GOTO Step 14.
Step 13: RETURN the partial strict order A 1,2 ≺ of jobs from set J 1,2 and the partial strict order A 2,1 ≺ of jobs from set J 2,1 Step 14: STOP 1. Results   Table A1. Computational results for the randomly generated instances with the ratio 0%:0%:10%:90% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .  Table A2. Computational results for randomly generated instances with the ratio 0%:0%:20%:80% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .  Table A3. Computational results for randomly generated instances with the ratio 0%:0%:30%:70% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .  Table A4. Computational results for randomly generated instances with the ratio 0%:0%:40%:60% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .  Table A5. Computational results for randomly generated instances with the ratio 0%:0%:50%:50% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .  Table A6. Computational results for randomly generated instances with the ratio 5%:5%:5%:85% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .  Table A7. Computational results for randomly generated instances with the ratio 5%:15%:5%:75% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .    Table A9. Computational results for randomly generated instances with the ratio 10%:10%:10%:70% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .    Table A10. Computational results for randomly generated instances with the ratio 10%:10%:40%:40% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .    Table A11. Computational results for randomly generated instances with the ratio 10%:20%:10%:60% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .    Table A12. Computational results for randomly generated instances with the ratio 10%:30%:10%:50% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .  Table A13. Computational results for randomly generated instances with the ratio 10%:40%:10%:40% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .  Table A14. Computational results for randomly generated instances with the ratio 10%:60%:10%:20% of the numbers of jobs in the subsets J 1 , J 2 , J 1,2 and J 2,1 of the job set J .