Single machine scheduling problems with uncertain parameters and the OWA criterion

In this paper a class of single machine scheduling problems is discussed. It is assumed that job parameters, such as processing times, due dates, or weights are uncertain and their values are specified in the form of a discrete scenario set. The Ordered Weighted Averaging (OWA) aggregation operator is used to choose an optimal schedule. The OWA operator generalizes traditional criteria in decision making under uncertainty, such as the maximum, average, median or Hurwicz criterion. It also allows us to extend the robust approach to scheduling by taking into account various attitudes of decision makers towards the risk. In this paper a general framework for solving single machine scheduling problems with the OWA criterion is proposed and some positive and negative computational results for two basic single machine scheduling problems are provided.


Introduction
Scheduling under uncertainty is an important and extensively studied area of operations research and discrete optimization. The importance of this research direction results from the fact that in many real-world problems the precise values of parameters in scheduling models are not known in advance. Thus, instead of possessing the exact values of the parameters, decision makers have rather a set of all their possible realizations, called a scenario set.
In some cases an additional information with this scenario set is available. If a probability distribution in the scenario set is known, then stochastic approach can be used, which typically consists in minimizing the expected solution cost (see, e.g. [22]). The unknown probability distribution can be upper bounded by a possibility distribution, which leads to possibilistic (fuzzy) scheduling problems (see, e.g [12]). Finally, if no additional information with scenario set is provided, then robust approach is usually used (see, e.g. [15]). In the robust optimization, we seek a solution minimizing a cost in the worst case, which usually leads to applying the minmax or minmax regret criterion for choosing a solution.
The robust approach to decision making is often regarded as too conservative or pessimistic. It follows from the fact, that the minmax criterion takes only the worst-case scenarios into account, ignoring the information connected with the remaining scenarios. This criterion also assumes that decision makers are very risk averse, which is not always true. These drawbacks of the minmax criterion are well known in decision theory, and a detailed discussion on this topic can be found, for example, in [18]. In this paper we will assume that a scenario set associated with scheduling problem is specified by enumerating all possible scenarios. Such a representation of scenario sets is called a discrete uncertainty representation and has been described, for instance, in [15]. Our goal is to generalize the minmax approach to scheduling problems under uncertainty by using the Ordered Weighted Averaging aggregation operator (OWA for short) introduced by Yager in [28]. The OWA operator is widely applied to aggregate criteria in multiobjective decision problems (see, e.g., [6,9,21]) but it can also be applied to choose a solution under the discrete uncertainty representation by identifying scenarios with objectives in a natural way. The OWA operator generalizes the classical criteria used in decision making under uncertainty such as the maximum, minimum, average, median, or Hurwicz criterion [18]. So, by using OWA we can extend the minmax approach, typically used in the robust optimization. Furthermore, the weights used in the OWA operator allows us to model various attitudes of decision makers towards a risk.
Since we generalize the minmax approach to single machine scheduling problems under the discrete uncertainty representation, let us briefly recall the known results in this area (see also [13] for a survey). The minmax version of the single machine scheduling problem with the total flow time criterion has been studied in [29], where it has been shown that the problem is NP-hard even for two processing time scenarios and strongly NP-hard when the number of processing time scenarios is a part of the input (the unbounded case). A generalization of this problem, with the weighted sum of completion times criterion, has been recently discussed in [20,24] where, in particular, several inapproximability results for that problem have been established. We will describe these results in more detail later in this paper. In [2] the minmax version of the single machine scheduling problem with the maximum weighted tardiness criterion has been discussed, where it has been shown that some special cases of the problem are polynomially solvable. In this paper, we generalize and extend the algorithms proposed in [2]. In [1,2] the minmax version of the single machine scheduling problem with the number of late jobs criterion has been investigated. It has been shown in [2] that the problem is NP-hard for deterministic due dates and two processing time scenarios. On the other hand, it has been shown in [1] that the problem with unit processing times and the number of due date scenarios being a part of the input is strongly NP-hard and hard to approximate within a factor less than 2. In a more general version of this problem the weighted sum of late jobs is minimized. This problem is known to be NP-hard for two weight scenarios [3], strongly NP-hard and hard to approximate within any constant factor if the number of weight scenarios is a part of the input [11].
This paper is organized as follows. Section 2 presents a formulation of the general problem under consideration as well as some its special cases. The next two sections discuss two basic single machine scheduling problems. Namely, Section 3 explores the problem with the maximum weighted tardiness cost function and Section 4 investigates the problem in which the cost function is the weighted sum of completion times. We show that both problems have various computational properties which depend on the weight distribution in the OWA operator. For some weight distributions the problems are polynomially solvable, while for other ones they become strongly NP-hard and are also hard to approximate.

Problem formulation
Let J = {J 1 , . . . , J n } be a set of jobs which must be processed on a single machine. For simplicity of notations, we will identify job J j with its index j. The set of jobs may be partially ordered by some precedence constraints. The notation i → j means that processing of job j cannot start before processing of job i is completed (job j is called a successor of job i). For each job j the following parameters may be specified: a nonnegative processing time p j , a nonnegative due date d j and a nonnegative weight w j . The due date d j expresses a desired completion time of j and the weight w j expresses the importance of job j relative to the other jobs in the system. In all scheduling models discussed in this paper we assume that all the jobs are ready for processing at time 0, in other words, each job has a release date equal to 0. We also assume that each job must be processed without any interruptions, so we consider only nonpreemptive models. Under these assumptions we can define a schedule π as a feasible permutation of the jobs, in which the precedence constraints among the jobs are preserved. The set of all feasible schedules will be denoted by Π.
Let us denote by C j (π) the completion time of job j in schedule π. We will use f (π) to denote a cost of schedule π. The value of f (π) depends on job completion times and may also depend on job due dates or weights. In this paper we will investigate two basic scheduling problems, in which the cost function is the maximum weighted tardiness, i.e. f (π) = max j∈J w j [C j (π) − d j ] + (we use the notation [x] + = max{0, x}) and the weighted sum of completion times, i.e. f (π) = j∈J w j C j (π). In the deterministic case, we wish to find a feasible schedule which minimizes the cost f (π), that is: We now study a situation in which some or all problem parameters are ill-known. Let S be a vector of the problem parameters which may occur. The vector S is called a scenario. We will use p j (S), d j (S) and w j (S) to denote the processing time, due date, and weight of job j under scenario S. A parameter is deterministic (precisely known) if its value is the same under each scenario. Let a scenario set Γ = {S 1 , . . . , S K } contain all possible scenarios, where K > 1. In this paper, we distinguish the bounded case, where K is bounded by a constant and the unbounded case, where K is a part of the input. Now, the completion time of job j in π and the cost of π depend on scenario S i ∈ Γ and will be denoted by C j (π, S i ) and f (π, S i ), respectively.
Since scenario set Γ contains more than one scenario, an additional criterion is required to choose a reasonable solution. In this paper we suggest to use the Ordered Weighted Averaging aggregation operator (OWA for short) proposed by Yager in [28]. We now describe this criterion. Let (f 1 , . . . , f K ) be a vector of real numbers. Let us introduce a vector of weights v v v = (v 1 , . . . , v K ) such that v j ∈ [0, 1] for all j ∈ [K] ([K] stands for the set {1, . . . , K}) and v 1 + · · · + v K = 1. Let σ be a permutation of [K] such that f σ(1) ≥ f σ(2) ≥ · · · ≥ f σ(K) . The OWA operator is defined as follows: The OWA operator has several natural properties which follow directly from its definition (see, e.g. [9]). Since it is a convex combination of the cost functions, min(f 1 , . . . , . . , f K ) = a and symmetric, i.e. its value does not depend on the order of the values f j , j ∈ [K]. The OWA operator generalizes some important criteria used in decision making under uncertainty. If v 1 = 1 and v j = 0 for j = 2, . . . , K, then OWA becomes the maximum. If v K = 1 and v j = 0 for j = 1, . . . , K − 1, then OWA becomes the minimum. In general, if v k = 1 and v j = 0 for j ∈ [K] \ {k}, then OWA is the kth largest element among f 1 , . . . , f K . In particular, when k = K/2 + 1, the kth element is the median. If v j = 1/K for all j ∈ [K], i.e. when the weights are uniform, then OWA is the average (or the Laplace criterion). Finally, if v 1 = α and v K = 1 − α for some fixed α ∈ [0, 1] and v j = 0 for the remaining weights, then we get the Hurwicz pessimism-optimism criterion.
We now use the OWA operator to aggregate the costs of a given schedule π under scenarios in Γ. Let us define where σ is a permutation of [K] such that f (π, S σ(1) ) ≥ · · · ≥ f (π, S σ(K) ). In this paper we examine the following optimization problem: Min-Owa P : min π∈Π OWA(π).
We will also investigate the special cases of the problem, which are listed in Table 1. Table 1: Special cases of Min-Owa P. Name of the problem Weight distribution Min-Max P v 1 = 1 and v j = 0 for j = 2, . . . , K Min-Min P v K = 1 and v j = 0 for j = 1, . . . , K − 1 Min-Average Notice that Min-Owa P can be consistent with a concept of robustness. Namely, the risk averse decision makers should choose nonincreasing weights, i.e. such that v 1 ≥ v 2 ≥ · · · ≥ v K . In the extreme case, this leads to the maximum criterion and the Min-Max P problem. However, the OWA operator allows us to weaken the maximum criterion by taking more scenarios into account As we will see in the next sections, the complexity of Min-Owa P depends on the properties of the underlying deterministic problem P and the weights v 1 , . . . , v K . One general and easy observation can be made. Namely, if P is solvable in T (n) time, then Min-Min P is solvable in O(K · T (n)) time. Indeed, in order to solve the Min-Min P problem it is enough to compute an optimal schedule π k under each scenario S k , k ∈ [K], and choose the one which has the minimum value of f (π k , S k ), k ∈ [K]. For the remaining problems listed in Table 1 no such general result can be established and their complexity depends on a structure of the deterministic problem P.

The maximum weighted tardiness cost function
The cost of schedule π under S i is the maximum weighted tardiness under S i , i.e. f (π, S i ) = max j∈J w j T j (π, S i ). The underlying deterministic problem P is denoted by 1|prec| max w j T j in Graham's notation [7]. In this section we will also discuss a special case of this problem, denoted by 1||T max , with unit job weights and no precedence constraints between the jobs. The deterministic 1|prec| max w j T j problem can be solved in O(n 2 ) time by the well known algorithm designed by Lawler [16]. It follows directly from the Lawler's algorithm that 1||T max can be solved in O(n log n) time by applying the EDD rule, i.e. by ordering the jobs with respect to nondecreasing due dates.
This section contains the following results. We will consider first the case when K is unbounded (K is a part of the input). We will show that the problems of minimizing the average cost or median of the costs are then strongly NP-hard and also hard to approximate. On the other hand, we will prove that the problems of minimizing the maximum cost or the Hurwicz criterion are solvable in polynomial time. We will consider next the problem with a constant K. It turns out that in this case the general problem of minimizing the OWA criterion can be solved in pseudopolynomial time. Finally, we will propose an approximation algorithm, which can be efficiently applied to some particular weight distributions in the OWA criterion.

Hardness of the problem
The following theorem characterizes the complexity of the problem: Theorem 1. If the number of scenarios is unbounded, then (i) Min-Average 1||T max is strongly NP-hard and not approximable within 7/6 − for any > 0 unless P=NP, (ii) Min-Median 1||T max is strongly NP-hard and not at all approximable unless P=NP.
Furthermore, both assertions remain true even for jobs with unit processing times under all scenarios.
Proof. We show a polynomial time approximation preserving reduction from the Min k-Sat problem, which is defined as follows. We are given boolean variables x 1 , . . . , x n and a collection of clauses C 1 , . . . , C m , where each clause is a disjunction of at most k literals (variables or their negations). We ask if there is an assignment to the variables which satisfies at most L < m clauses. This problem is strongly NP-hard even for k = 2 (see [4,14,19]) and its optimization (minimization) version is hard to approximate within 7/6 − for any > 0 when k = 3 (see [4]). We first consider assertion (i). Given an instance of Min 3-Sat, we construct the corresponding instance of Min-Average 1||T max in the following way. We create two jobs J x i and J x i for each variable x i , i ∈ [n]. The processing times and weights of all the jobs under all scenarios are equal to 1. The due dates of J x i and J x i depend on scenario and will take the value of either 2i − 1 or 2i. Set K = m and form K scenario set Γ in the following way.
if neither x i nor x i appears in C k , then the due dates of J x i and J x i are set to 2i. A sample reduction is shown in Table 2. Finally, we fix v k = 1/m for all k ∈ [K]. Let us define a subset of the schedules Π ⊆ Π such that each schedule π ∈ Π is of . Observe that Π contains exactly 2 n schedules and each such a schedule defines an assignment to the variables such that Assume that the answer to Min 3-Sat is yes. So, there is an assignment to the variables which satisfies at most L clauses. Choose schedule π ∈ Π which corresponds to this assignment. It is easily seen that if clause C k is not satisfied, then all jobs in π under S k are on-time and the maximum tardiness in π under S k is 0. On the other hand, if clause C k is satisfied, then the maximum tardiness of π under S k is 1. In consequence 1 K k∈[K] f (π, S k ) ≤ L/m. Assume now that there is a schedule π such that 1 K k∈[K] f (π, S k ) ≤ L/m. Notice that L/m < 1 by the nonrestrictive assumption that L < m. We first show that π must belong to Π . Suppose that π / ∈ Π and let J i (J i ) be the last job in π which is not placed properly, i.e. J i , Since π ∈ Π and all processing times are equal to 1 it follows that f (π, S k ) ∈ {0, 1} for all k ∈ [K]. Consequently, the maximum tardiness in π is equal to 1 under at most L scenarios and the assignment corresponding to π satisfies at most L clauses. The above reduction is approximation-preserving and the inapproximability result immediately holds.
In order to prove assertion (ii), it suffices to modify the previous reduction. Assume first that L < m/2 . We then add to scenario set Γ additional m − 2L scenarios with the due dates equal to 0 for all the jobs. So the number of scenarios K is 2m − 2L. We fix v m−L+1 = 1 and v k = 0 for the remaining scenarios. Now, the answer to Min 3-Sat is yes, if and only if there is a schedule π whose maximum tardiness is positive under at most L + m − 2L = m − L scenarios. According to the definition of the weights OWA(π) = 0. Assume that L > m/2 . We then add to Γ additional 2L − m scenarios with the due dates to n for all the jobs. The number of scenarios K is then 2L. We fix v L+1 = 1 and v k = 0 for all the remaining scenarios. Now, the answer to Min 3-Sat is yes, if and only if there is a schedule π whose cost is positive under at most L scenarios. According to the definition of the weights OWA(π) = 0. We thus can see that it is NP-hard to check whether there is a schedule π such that OWA(π) ≤ 0 and the theorem follows.
The next theorem characterizes the problem complexity when job processing times and due dates are deterministic and only job weights are uncertain.
Theorem 2. If the number of scenarios is unbounded, then (ii) Min-Median 1|| max w j T j is strongly NP-hard and not at all approximable unless P=NP.
Furthermore, both assertions are true when all jobs have unit processing times under all scenarios and all job due dates are deterministic.
Proof. As in the proof of Theorem 1, we show a polynomial time reduction from the Min 3-Sat problem. We start by proving assertion (i). We create two jobs J x i and J x i for each variable x i . The processing times of these jobs under all scenarios are 1 and their due dates are equal to 2i − 1. Now for each clause C k = (l 1 ∨ l 2 ∨ l 3 ) we form the weight scenario S k as follows: for each q = 1, 2, 3, if l q = x i , then the weight of J x i is 1 and the weight of J x i is 0; if l q = x i , then the weight of J x i is 1 and the weight of J x i is 0; if neither x i nor x i appears in C k , then the weights of J x i and J x i are 0. We also add one additional scenario S m+1 under which the weight of each job is equal to m. We set K = m + 1 and fix v k = 1/(m + 1) for each k ∈ [K]. We define the subset of schedules Π ⊆ Π as in the proof of Theorem 1.
We will show that the answer to Min 3-Sat is yes if and only if there is a schedule π such that OWA(π) ≤ (m+L)/(m+1). Assume that the answer to Min 3-Sat is yes. Let π ∈ Π be the schedule corresponding to the assignment which satisfies at most L clauses (see the proof of Theorem 1). It is easy to verify that f (π, S k ) = 0 if C k is not satisfied and f (π, S k ) = 1 if C k is satisfied. Furthermore, f (π, S m+1 ) = m. Hence OWA(π) ≤ (m + L)/(m + 1). Assume now that OWA(π) ≤ (m+L)/(m+1). Then π must belong to Π since otherwise f (π, S m+1 ) ≥ 2m and OWA(π) ≥ 2m/(m + 1), which contradicts the assumption that L < m. It must hold f (π, S m+1 ) = m and f (π, S i ) ∈ {0, 1} for each i ∈ [K]. Consequently f (π, S i ) = 1 under at most L scenarios, which means that the assignment corresponding to π satisfies at most L clauses and the answer to Min 3-Sat is yes.
The proof of assertion (ii) is very similar to the corresponding proof in Theorem 1.

Polynomially and pseudopolynomially solvable cases
In this section we identify some special cases of the Min-Owa 1|prec| max w j T j problem which are polynomially or pseudopolynomially solvable.

The maximum criterion
It has been shown in [2] that Min-Max 1|prec|T max is solvable in O(Kn 2 ) time. In this section, we will show that more general version of the problem with arbitrary nonnegative job weights, Min-Max 1|prec| max w j T j , is solvable in O(Kn 2 ) time as well. In the construction of the algorithm, we will use some ideas from [10,27]. Furthermore, the algorithm with some minor modifications will be a basis for solving other special cases of Min-Owa 1|prec| max w j T j . In this section the OWA operator is the maximum, so OWA(π) = max i∈[K] f (π, S i ). By interchanging the maximum operators and some easy transformations, we can express the value of OWA(π) as follows: Fix a nonempty subset of jobs D ⊆ J and define The following proposition immediately follows from the fact that all job processing times and weights are nonnegative: Let pred(π, j) be the set of jobs containing job j and all the jobs that precede j in π. Since C j (π, S i ) = k∈pred(π,j) p k (S i ), the maximum cost of π over Γ can be expressed as follows (see (1) and (2)): OWA(π) = max j∈J F j (pred(π, j)).
Consider the algorithm shown in the form of Algorithm 1.
Algorithm 1 Algorithm for solving Min-Max 1|prec| max w j T j . Proof. Let π be the schedule returned by the algorithm. It is clear that π is feasible. Let us renumber the jobs so that π = (1, 2, . . . , n). Let σ be an optimal minmax schedule. Assume that σ(j) = j for j = k + 1, . . . , n, where k is the smallest position among all the optimal minmax schedules. If k = 0, then we are done, because π = σ is optimal. Assume that k > 0, and so k = σ(k) = i. Let us move the job k just after i in σ and denote the resulting schedule as σ (see Figure 1). Schedule σ is feasible, because π is feasible.
From the above three cases and equality (3), we conclude that so σ is also optimal, which contradicts the minimality of k. Computing

The Hurwicz criterion
In this section we explore the problem with the Hurwicz criterion. We will examine the case in which α ∈ (0, 1) as the boundary cases with α equal to 0 (the minimum criterion) or 1 (the maximum criterion) are solvable in O(Kn 2 ) time.
Proof. The Hurwicz criterion can be expressed as follows: f (π, S i ).

Let us define
Hence min π∈Π OWA(π) = min min π∈Π H k (π), and the problem of minimizing the Hurwicz criterion reduces to solving K auxiliary problems consisting in minimizing H k (π) for a fixed k ∈ [K]. Let us fix k ∈ [K] and t ≥ 0, and define Π k (t) = {π ∈ Π : f (π, S k ) ≤ t} ⊆ Π as the set of feasible schedules whose cost under S k is at most t. Define Ψ k (t) = min f (π, S i ).
Hence min π∈Π H k (π) = min where t = min π∈Π f (π, S k ) (for t < t it holds Π k (t) = ∅), and t = min π∈Π max i∈[K] f (π, S i ), which is due to the fact that max i∈[K] f (π, S i ) ≥ f (π, S k ). Computing the value of Ψ k (t) for a given t ∈ [t, t] can be done by a slightly modified Algorithm 1. It is enough to replace line 6 of Algorithm 1 with the following line: 6 : find j ∈ D k (t), which has no successor in D, and has a minimum value of F j (D), The proof of the correctness of the modified algorithm is almost the same as the proof of Theorem 3. It is sufficient to define a feasible schedule π as the one satisfying the precedence constraints and the additional constraint f (π, S k ) ≤ t. Hence, if the algorithm returns a feasible schedule, then it must be optimal. The algorithm fails to compute a feasible schedule when D k (t) = ∅ in line 6'. In this case, at least one job in D = ∅ must be completed not earlier than p(S k ) = j∈D p j (S k ) and f (π, S k ) > t for all schedules π ∈ Π, which means that Π k (t) = ∅. Clearly, the modified algorithm has the same O(Kn 2 ) running time.
Note that Ψ k is a nonincreasing step function on [t, ∞), i.e. a constant function on . . , l, t 1 = t. Thus, αΨ k (t) + (1 − α)t, α ∈ (0, 1), is a piecewise linear function on [t, ∞), a linear increasing function on each subinterval [t v , t v ), v ∈ [l], and attains minimum at one of the points t 1 , . . . , t l . The functions Ψ k (t) and αΨ k (t) + (1 − α)t for k = 3 are depicted in the example shown in Figure 2. We have t 1 = 18, t 2 = 26, t 3 = 60 and the function αΨ 3 (t) + (1 − α)t is minimized for t = 26. Since π 2 = (1, 4, 2, 5, 3) is an optimal solution to Ψ 3 (26), we conclude that π 2 minimizes H 3 (π).  Observe that the value of t minimizing αΨ k (t)+(1−α)t can be found in pseudopolynomial time by trying all integers in the interval [t, t]. We now show how to find the optimal value of t in polynomial time. We first compute t 1 = min π∈Π f (π, S k ), and the value of Ψ k (t 1 ) by the modified Algorithm 1. Let us denote by π 1 the resulting optimal schedule, π 1 ∈ Π k (t 1 ). In the sample problem shown in Figure 2, t 1 = 18, π 1 = (2, 4, 5, 3, 1), and Ψ 3 (t 1 ) = 91. Our goal now is to compute the value of t 2 . Choose the iteration of the modified Algorithm 1, in which the position of job j is fixed in π 1 . The job j satisfies the condition stated in line 6'. We can now compute the smallest value of t, t > t 1 , for which job j violates this condition and must be replaced by some other job in D k (t). In order to do this it suffices to try all values t i = w i (S k )[p(S k ) − d i (S k )] + for i ∈ D \ {j} and fix t * j as the smallest among them which violates the condition in line 6' (if the condition holds for all t i , then t * j = ∞). Repeating this procedure for each job we get the set of values t * 1 , . . . , t * n and t 2 is the smallest value among them. Consider again the sample problem presented in Figure 2. When job 1 is placed at position 5 in π 1 , it satisfies the condition in line 6' for t = 18. In fact, it holds D 3 (t 1 ) = {1}. Since D = {1, 2, 3, 4, 5}, we now try the values t 2 = 91, t 3 = 26, t 4 = 126, and t 5 = 60. The condition in line 6' is violated for t = t 3 = 26 as D 3 (26) = {1, 3} and F 3 (D) < F 1 (D). Hence t * 1 = 26. In the same way we compute the remaining values t * 2 , . . . , t * 5 . It turns out that t * 1 = 26 is the smallest among them, thus t 2 = 26. The value of t 3 can be found in the same way. We compute an optimal schedule π 2 corresponding to Ψ k (t 2 ) and repeat the previous procedure.
Consider the sequence of schedules π l , π l−1 , . . . , π 1 , where π v minimizes Ψ k (t v ). Schedule π v−1 can be obtained from π v by moving the position of at least one job in π v , say j, whose current position becomes infeasible as t decreases, to the left. Furthermore the position of j cannot increase in all the subsequent schedules π v−2 , . . . , π 1 , because the function f (π, S k ) is nondecreasing (if j cannot be placed at ith position, then it also cannot be placed at positions i + 1, . . . , n). Hence, if π l is the last schedule, then the position of job π l (i) can be decreased at most i − 1 times which implies l = O(n 2 ). Hence problem (4) can be solved in O(Kn 4 ) time and Min-Hurwicz 1|prec| max w j T j is solvable in O(K 2 n 4 ) time.

The kth largest cost criterion
In this section we investigate the Min-Quant(k) 1|prec| max w j T j problem. Thus our goal is to minimize the kth largest schedule cost. It is clear that this problem is polynomially solvable when k = 1 or k = K. It is, however, strongly NP-hard and not at all approximable when k is a function of K, in particular, when the median of the costs is minimized (see Theorem 1). We now explore the case when k is constant.
Proof. The algorithm works as follows. We enumerate all the subsets of scenarios of size k − 1. For each such a subset, say C, we solve Min-Max 1|prec| max w j T j for the scenario set Γ \ C, using Algorithm 1, obtaining a schedule π C . Among the schedules computed we return π C for which the maximum cost over Γ \ C is minimal. It is straightforward to verify that this schedule must be optimal. The number of subsets which have to be enumerated is K k−1 . For each such a subset we solve Min-Max 1|prec| max w j T j with scenarios set Γ \ C, which requires O((K − k + 1)n 2 ) time and the theorem follows.
The algorithm suggested in the proof of Theorem 5 is efficient when k is close to 1 or close to K. When k is a function of K, then this running times becomes exponential and may be prohibitive in practice. In Section 3.3, we will use this algorithm to construct an approximation algorithm for the general Min-Owa 1|prec| max w j T j problem.

The OWA criterion -the bounded case
In Section 3.1, we have shown that for the unbounded case Min-Owa 1|prec| max w j T j is strongly NP-hard and not at all approximable unless P=NP. In this section we investigate the case when K is constant. Without loss of generality we can assume that all the parameters are nonnegative integers. Let f max be an upper bound on the maximum weighted tardiness of any job under any scenario. By Proposition 1 and equality (3) we can fix f max = max j∈J F j (J).
Proof. Let t t t = (t 1 , . . . , t K ) be a vector of nonnegative integers. Let Π(t t t) ⊆ Π be a subset of the set of feasible schedules such that π ∈ Π(t t t) if f (π, S i ) ≤ t i for all i ∈ [K], i.e. the maximum weighted tardiness in π under S i does not exceed t i . Consider the following auxiliary problem. Given a vector t t t, check if Π(t t t) is not empty and if so, return any schedule π t t t ∈ Π(t t t). We now show that this auxiliary problem can be solved in polynomial time. Given t t t, we first form scenario set Γ by specifying the following parameters for each S i ∈ Γ and j ∈ J: The scenario set Γ can be determined in O(Kn) time. We solve Min-Max 1|prec| max w j T j with the scenario set Γ by Algorithm 1 obtaining schedule π. If the maximum cost of π over Γ is 0, then π t t t = π; otherwise Π(t t t) is empty. Since Min-Max 1|prec| max w j T j is solvable in O(Kn 2 ) time, the auxiliary problem is solvable in O(Kn 2 ) time as well. We now show that there exists a vector t t t * = (t * 1 , . . , such that each π t t t * ∈ Π(t t t * ) minimizes OWA(π). Let π * be an optimal schedule and let t * t * t * = (t * 1 , . . . , t * K ) be a vector such that t * i = f (π * , S i ) for i ∈ [K]. Clearly, t * i ∈ {0, . . . , f max } for each i ∈ [K] and π * ∈ Π(t * t * t * ). By the definition of t * t * t * , it holds owa v v v (t * t * t * ) = OWA(π * ). For any π ∈ Π(t * t * t * ) it holds . From the monotonicity of OWA we conclude that each π ∈ Π(t * t * t * ) must be optimal. The algorithm enumerates all possible vectors t t t and computes π t t t ∈ Π(t t t) if Π(t t t) is nonempty. A schedule π t t t with the minimum value of owa v v v (t t t) is returned. The number of vectors t t t which must be enumerated is at most f K max . Hence the problem is solvable in pseudopolynomial time provided that K is constant and the running time of the algorithm is O(f K max Kn 2 ).

Approximation algorithm
When K is a part of the input, i.e. in the unbounded case, then the exact algorithm proposed in Section 3.2.4 may be inefficient. Notice, that due to Theorem 1, no efficient approximation algorithm can exist for Min-Owa 1|prec| max w j T j in this case unless P=NP. We now prove the following result, which can be used to obtain an approximate solution in some special cases of the weight distributions in the OWA operator.
Proof. Let σ be a sequence of [K] such that f (π, S σ(1) ) ≥ · · · ≥ f (π, S σ(K) ) and ρ be a sequence of [K] such that f (π, S ρ(1) ) ≥ · · · ≥ f (π, S ρ(K) ). It holds: From the definition ofπ and the assumption that v k > 0 we get Hence OWA(π) ≤ (1/v k )OWA(π). To see that the bound is tight consider an instance of the problem with K scenarios and 2K jobs. The job processing times and weights are equal to 1 under all scenarios. The job due dates are shown in Table 3. We fix v i = (1/K) for each i ∈ [K]. Table 3: An example of due date scenario set for which the approximation algorithm achieves a ratio of 1/v k .
Since v 1 > 0, we solve Min-Max 1|prec| max w j T j . As a result we can obtain the schedule π = (J 2 , J 1 , J 4 , J 3 , . . . , J 2K , J 2K−1 ) whose average cost over all scenarios is 1. But the average cost of the optimal schedule π * = (J 1 , J 2 , J 3 , J 4 , . . . , J 2K−1 , J 2K ) is 1/K. We now show several consequences of Theorem 7. Observe first that if v 1 > 0, then we can use Algorithm 1 to obtain the approximate schedule in polynomial time.
Consider now the case of nondecreasing weights, i.e. v 1 ≥ v 2 ≥ · · · ≥ v K . Recall that nondecreasing weights are used when the idea of robust optimization is adopted. Namely, larger weights are assigned to larger schedule costs. Since in this case the inequality v 1 ≥ 1/K must hold, we get the following result: Corollary 2. If the weights are nonincreasing, then Min-Owa 1|prec| max w j T j is approximable within 1/v 1 ≤ K.
Finally, the following corollary is an immediate consequence of the previous corollary: Corollary 3. Min-Average 1|prec| max w j T j is approximable within K.

The weighted sum of completion times cost function
Let the cost of schedule π under scenario S i be the weighted sum of completion times in S i , i.e. f (π, S i ) = j∈J w j (S i )C j (π, S i ). Using the Graham's notation, the deterministic version of the problem is denoted by 1|prec| w j C j . We will also examine the special cases of this problem with no precedence constraints between the jobs, i.e. 1|| w j C j and all job weights equal to 1, i.e. 1|| C j . It is well known that 1|prec| C j is strongly NP-hard for arbitrary precedence constraints [17]. It is, however, polynomially solvable for some special cases of the precedence constraints such as in-tree, out-tree or sp-graph (see, e.g. [5]). If there are no precedence constraints between the jobs, then an optimal schedule can be obtained by ordering the jobs with respect to nondecreasing ratios p j /w j , which reduces to the SPT rule when all job weights are equal to 1.
In this section, we will show that if the number of scenarios is a part of the input, then Min-Owa 1|| w j C j is strongly NP-hard and not at all approximable. This is the case when the weights in the OWA criterion are nondecreasing, or OWA is the median. We then propose several approximation algorithms which will be valid for nonincreasing weights and the Hurwicz criterion.

Hardness of the problem
The Min-Max 1|| w j C j and Min-Max 1|| C j problems have been recently investigated in literature, and the following results have been established: Theorem 9 ( [20]). If the number of scenarios is unbounded, then (i) Min-max 1|| w j C j is strongly NP-hard and not approximable within O(log 1−ε n) for any ε > 0 unless the problems in NP have quasi-polynomial time algorithms.
We now show that the general case is much more complex.
Theorem 10. If the number of scenarios is unbounded, then Min-Owa 1|| w j C j is strongly NP-hard and not at all approximable unless P=NP.
Proof. We show a polynomial time reduction from the Min 2-Sat problem which is known to be strongly NP-hard (see the proof of Theorem 1). Given an instance of Min 2-Sat, we construct the corresponding instance of Min-Owa 1|| w j C j in the following way. We associate two jobs J x i and J x i with each variable x i , i ∈ [n]. We then set K = m and form scenario set Γ in the following way. Scenario S k corresponds to clause C k = (l 1 ∨ l 2 ). For q = 1, 2, if l q = x i , then the processing time of J x i is 0, the weight of J x i is 1, the processing time of J x i is 1, and the weight of J x i is 0; if l q = x i , then the processing time of J x i is 1, the weight of J x i is 0, the processing time of J x i is 0 and the weight of J x i is 1. If neither x i nor x i appears in C k , then both processing times and weights of J x i and J x i are set to 0. We complete the reduction by fixing v 1 = v 2 = · · · = v L = 0 and v L+1 = . . . v K = 1/(m − L). A sample reduction is presented in Table 4. We now show that there is an assignment to the variables which satisfies at most L clauses if and only if there is a schedule π such that OWA(π) = 0. Assume that there is an assignment x i , i ∈ [n], that satisfies at most L clauses. According to this assignment we build a schedule π as follows. We first process n jobs J z i , z i ∈ {x i , x i }, which correspond to false literals z i , i ∈ [n], in any order and then the rest n jobs that correspond to true literals z i , i ∈ [n], in any order. Choose a clause C k = (l 1 ∨ l 2 ) which is not satisfied. It is easy to check that the cost of the schedule π under scenario S k is 0. Consequently, there are at most L Table 4: Processing times and weights (p j (S i ), w j (S i )) corresponding to the formula (x 1 ∨

Approximation algorithms
In this section we show several approximation algorithms for Min-Owa 1|prec| w j C j . We will explore the case in which the weights in the OWA criterion are nonincreasing, i.e. v 1 ≥ v 2 ≥ · · · ≥ v K . We will then apply the obtained results to the Hurwicz criterion. Observe, that the case with nondecreasing weights, i.e. v 1 ≤ v 2 ≤ · · · ≤ v K , is not at all approximable (see the proof of Theorem 10). We first recall a well known property (see, e.g. [20]) which states that each problem with uncertain processing times and deterministic weights can be transformed into an equivalent problem with uncertain weights and deterministic processing times (and vice versa). This transformation is cost preserving and works as follows. Under each scenario S i , i ∈ [K], we invert the role of processing times and weights obtaining scenario S i . The new scenario set Γ contains scenario S i for each i ∈ [K]. We also invert the precedence constraints, i.e. if i → j in the original problem, then j → i in the new one. It can be easily shown that the cost of schedule π under S is equal to the cost of the inverted schedule π = (π(n), . . . , π(1)) under S . Consequently OWA(π) under Γ equals OWA(π ) under Γ . Notice that if the processing times are deterministic in the original problem, then the weights become deterministic in the new one (and vice versa). Let w max , w min , p max , p min be the largest (smallest) weight (processing time) in the input instance. We first consider the case then both processing times an weights can be uncertain. We prove the following result: Theorem 11. If v 1 ≥ v 2 ≥ · · · ≥ v K and the deterministic 1|prec| w j C j problem is polynomially solvable, then Min-Owa 1|prec| w j C j is approximable within K · min{ wmax w min , pmax p min }.
In [20] a 2-approximation algorithm for Min-Max 1|prec| w j C j has been recently proposed, provided that either job processing times or job weights are deterministic (they do not vary among scenarios). In this section we will show that this algorithm can be extended to Min-Owa 1|prec| w j C j under the additional assumption that the weights in the OWA operator are nonincreasing, i.e. v 1 ≥ v 2 ≥ · · · ≥ v K . The idea of the approximation algorithm is to design a mixed integer programming formulation for the problem, solve its linear relaxation and construct an approximate schedule based on the optimal solution to this relaxation.
Assume now that job processing times are deterministic and equal to p j under each scenario S i , i ∈ [K]. Let δ ij ∈ {0, 1}, i, j ∈ [n], be binary variables such that δ ij = 1 if job i is processed before job j in a schedule constructed. The vectors of all feasible job completion times (C 1 , . . . , C n ) can be described by the following system of constraints [23]: V C : C j = p j + i∈J\{j} δ ij p i j ∈ J δ ij + δ ji = 1 i, j ∈ J, i = j δ ij + δ jk + δ ki ≥ 1 i, j, k ∈ J δ ij = 1 i → j δ ij ∈ {0, 1} i, j ∈ J Let us denote by V C the relaxation of V C, in which the constraints δ ij ∈ {0, 1} are replaced with 0 ≤ δ ij ≤ 1. It has been proved in [25,26] (see also [8]) that each vector (C 1 , . . . , C n ) that satisfies V C also satisfies the following inequalities: In order to build a MIP formulation for the problem, we will use the idea of a deviation model introduced in [21]. Let σ be a permutation of [K] such that f (π, S σ(1) ) ≥ · · · ≥ f (π, S σ(K) ) and let θ k (π) = k i=1 f (π, S σ(i) ) be the cumulative cost of schedule π. Define v i = v i − v i+1 for i = 1, . . . , K − 1 and v K = v K . An easy verification shows that OWA(π) = K k=1 v k θ k (π). (10) Lemma 1. Given π, the value of θ k (π) can be obtained by solving the following linear programming problem: min Proof. Consider the following linear programming problem: It is easy to see that an optimal solution to (12) can be obtained by setting β σ(i) = 1 and α σ(i) = 0 for i = 1 . . . k, β σ(i) = 0 and α σ(i) = 1 for i = k + 1, . . . K, where σ is such that f (π, S σ(1) ) ≥ · · · ≥ f (π, S σ(K) ). This gives us the maximum objective function value equal to θ k (π). To complete the proof it is enough to observe that (11) is the dual linear program to (12).
If v 1 ≥ v 2 ≥ · · · ≥ v K , then v i ≥ 0 and (8), (10), (11) lead to the following mixed integer programming formulation for the problem: In order to construct the approximation algorithm we will also need the following easy observation:

Conclusion and open problems
In this paper we have proposed a new approach to scheduling problems with uncertain parameters. The key idea is to use the OWA operator to aggregate all possible values of the schedule cost. The weights in OWA allows decision makers to take their attitude towards a risk into account. In consequence, the main advantage of the proposed approach is to weaken the very conservative minmax criterion, traditionally used in robust optimization. Apart from proposing a general framework, we have discussed the computational properties of two basic single machine scheduling problems. We have shown that they have various computational and approximation properties, which make their analysis very challenging. However, there is still a number of open problems regarding the considered cases. For the problem with the maximum weighted tardiness criterion we do not know if the problem is weakly NP-hard when the number of scenarios is constant (the bounded case). It may be also the case that the pseudopolynomial algorithm designed for a fixed K can be converted into a polynomial one by using a similar idea as for the Hurwicz criterion. We also do not know if the problem with the average criterion admits an approximation algorithm with a constant worst-case ratio (we only know that it is approximable within K and not approximable within a ratio less than 7/6). For the problem with the weighted sum of completion times criterion the complexity of Min-Average 1|| w j C j with uncertain processing times and weights is open. The framework proposed in this paper can also be applied to other scheduling problems, for example to the single machine scheduling problem with the sum of late jobs criterion (the minmax version of this problem was discussed in [1, 2]).