Single-facility scheduling by logic-based Benders decomposition

Logic-based Benders decomposition can combine mixed integer programming and constraint programming to solve planning and scheduling problems much faster than either method alone. We find that a similar technique can be beneficial for solving pure scheduling problems as the problem size scales up. We solve single-facility non-preemptive scheduling problems with time windows and long time horizons. The Benders master problem assigns jobs to predefined segments of the time horizon, where the subproblem schedules them. In one version of the problem, jobs may not overlap the segment boundaries (which represent shutdown times, such as weekends), and in another version, there is no such restriction. The objective is to find feasible solutions, minimize makespan, or minimize total tardiness.


Introduction
Logic-based Benders decomposition (Hooker and Ottosson 2003) is a generalization of Benders decomposition that accommodates a much wider range of problems.In contrast with the classical Benders method, the subproblem can in principle be any combinatorial problem, not necessarily a linear or nonlinear programming problem.For example, it can be a scheduling problem solved by constraint programming (CP), a method well suited to scheduling.
This flexibility has led to the application of logic-based Benders decomposition to planning and scheduling problems that naturally decompose into an assignment and a scheduling portion.The Benders master problem assigns jobs to facilities using mixed integer programming (MILP), and the subproblem uses CP to schedule jobs on each facility.This approach can reduce solution time by several orders of magnitude relative to methods that use MILP or CP alone (Hooker 2004(Hooker , 2005a(Hooker , 2005b(Hooker , 2006(Hooker , 2007b;;Jain and Grossmann 2001;Thorsteinsson 2001).
In this paper, we investigate whether a similar technique can solve pure scheduling problems, which lack the obvious decomposition that one finds in planning and scheduling.Rather than break the problem into facility assignment and job scheduling, we decompose it into smaller scheduling subproblems on segments of the time horizon.The master problem assigns jobs to time segments, and subproblems schedule jobs within each segment.This allows us to deal with long time horizons that would otherwise make the problem intractable.
In particular, we solve single-facility non-preemptive scheduling problems with time windows in which the objective is to find a feasible solution, minimize makespan, or minimize total tardiness.In one version of the problem, which we call the segmented problem, each job must be completed within one time segment.The boundaries between segments might therefore be regarded as weekends or shutdown times during which jobs cannot be processed.In a second version of the problem, which we refer to as unsegmented, jobs can overlap two or more segments.We address both variants.
Obvious cases of single-facility scheduling include machine scheduling in a manufacturing plant or task scheduling in a computer with one processor.Less obvious cases occur when a complex plant is scheduled as one facility, as for example when a paint manufacturing plant must be committed to produce one color at a time (French 1982).A multistage process with a single bottleneck may also result in a single-facility model (Pinedo 1995).
The paper is organized as follows.After a survey of previous work, we present a brief introduction to logic-based Benders decomposition, and state pure MILP and CP models for the single-facility scheduling problem.We then describe a logic-based Benders approach to the segmented feasibility, makespan, and tardiness problems.We do the same for the unsegmented feasibility and makespan problems, for which the Benders cuts are considerably more complex.We then present computational results.We conclude that the relative advantage of the Benders approach increases rapidly as the time horizon and number of jobs grow larger, particularly for segmented feasibility and makespan problems.The Benders method is not necessarily faster on unsegmented instances, but it is more robust and the only method to solve them all.

Previous work
Logic-based Benders decomposition was introduced in Hooker (1995), Hooker and Yan (1995), and a general theory was presented in Hooker (2000), Hooker and Ottosson (2003).Application to planning and scheduling was proposed in Hooker (2000) and first implemented in Jain and Grossmann (2001).
Classical Benders decomposition derives Benders cuts from dual or Lagrange multipliers in the subproblem (Benders 1962;Geoffrion 1972).However, this presupposes that the subproblem is a linear or nonlinear programming problem.Logic-based Benders decomposition has the advantage that Benders cuts can, at least in principle, be obtained from a subproblem of any form by solving its inference dual (Hooker 1996).The solution of the dual is a proof of optimality for fixed values of the master problem variables (whence the name "logic-based").The core idea of Benders decomposition is that this same proof may establish a bound on the optimal value when the master problem variables take other values.The corresponding Benders cut enforces this bound in the master problem.
Logic-based Benders cuts must be designed specifically for each class of problems, but this provides an opportunity to exploit problem structure.The Benders framework is also natural for combining MILP and CP, because one method can be used to solve the master problem and the other the subproblem.This is particularly advantageous when the subproblem is a scheduling problem, for which CP methods are well suited (Baptiste et al. 2001;Hooker 2007a).The combinatorial nature of the scheduling problem is no longer a barrier to generating Benders cuts.
Logic-based Benders cuts have some resemblance to cuts generated in oracle-based optimization (e.g., Babonneau et al. 2007) but differ in several respects.The Benders subproblem contains a different set of variables than the master problem and cuts, while in oracle-based optimization, the subproblem and cuts contain the same variables.The solution of the master problem, rather than a query point, defines the Benders subproblem, and Benders cuts can in principle be derived from any proof of optimality for the subproblem.
In all of these applications, the subproblem is a feasibility problem rather than an optimization problem, which simplifies the task of designing Benders cuts.Effective Benders cuts can nonetheless be developed for optimization subproblems, based on somewhat deeper analysis of the inference dual.This is accomplished for planning and scheduling problems in (Hooker 2004(Hooker , 2005a(Hooker , 2005b(Hooker , 2006(Hooker , 2007b)), where the objective is to minimize makespan, the number of late jobs, or total tardiness.The subproblem is a cumulative scheduling problem, in which several jobs may be processed simultaneously subject to resource constraints.
Other applications of logic-based Benders to optimization include 0-1 programming (Hooker and Ottosson 2003;Chu and Xia 2004), mixed integer/linear programming (Codato and Fischetti 2006), tournament scheduling (Rasmussen 2008;Rasmussen and Trick 2007), location/allocation problems (Fazel-Zarandi and Beck 2009), shift selection with task sequencing (Barlatta et al. 2010), single-and multi-stage batch chemical processes (Maravelias 2006), multimachine assignment scheduling with a branch-and-cut approach (Sadykov and Wolsey 2006), and single-facility scheduling in the present paper.Temporal decomposition similar to that employed here is applied in Bent and Van Hentenryck (2010) to large-scale vehicle routing problems with time windows.However, unlike a Benders method, the algorithm is heuristic and does not obtain provably optimal solutions.In addition, no cuts or nogoods are generated.
To our knowledge, logic-based Benders decomposition has not previously been applied to single-facility scheduling.A broad survey of single-facility scheduling methods for minimizing tardiness can be found in Koulamas (2010), which assumes that all release dates are equal.Four MILP formulations of single-facility scheduling are analyzed in Keha et al. (2009), where it is observed that the discrete-time model is most widely used and yields the tightest bounds.We use this model for our comparisons with pure MILP.

Logic-based Benders decomposition
Logic-based Benders decomposition is based on the concept of an inference dual.Consider an optimization problem where C(x) represents a constraint set containing variables x, and D is the domain of x (such as R n or Z n ).The inference dual is the problem of finding the tightest lower bound on the objective function that can be deduced from the constraints: The domain of variable P is a family P of proofs, and the dual solution is a pair (v, P ).When the primal problem ( 1) is a feasibility problem with no objective function, the dual can be viewed as the problem finding a proof P of infeasibility.
If ( 1) is a linear programming (LP) problem min{cx | Ax ≥ b, x ≥ 0}, the inference dual becomes the classical LP dual (assuming feasibility) for an appropriate proof family P. Namely, each proof P corresponds to a tuple u ≥ 0 of multipliers, and P deduces the bound cx ≥ v when the surrogate uAx ≥ ub dominates cx ≥ v; that is, uA ≤ c and ub ≥ v.The dual therefore maximizes v subject to uA ≤ c, ub ≥ v, and u ≥ 0. Equivalently, it maximizes ub subject to uA ≤ c and u ≥ 0, which is the classical LP dual.
Logic-based Benders decomposition applies to problems of the form min f (x, y) Let proof P solve the inference dual of the subproblem by deducing the bound f ( x, y) ≥ v * .A Benders cut v ≥ B x (x) is derived by identifying a bound B x (x) that the same proof P deduces for any given x.Thus, in particular, where x 1 , . . ., x k−1 are the solutions of the first k − 1 master problems.The optimal value v k of the master problem is a lower bound on the optimal value of (3), and each B x i (x i ) is an upper bound.The algorithm terminates when v k is equal to the minimum of B x i (x i ) over i = 1, . . ., k.
Classical Benders decomposition is the result of applying logic-based Benders decomposition to a problem of the form The subproblem is an LP: whose inference dual is the LP dual.Its solution u defines a surrogate uAy ≥ u(b − g( x)) that dominates cy ≥ v * and therefore deduces that ) for any x, and we have the classical Benders cut v ≥ f (x) + u(b − g(x)).When the subproblem is infeasible, the dual has an extreme ray solution u that proves infeasibility because uA ≤ 0 and u(b − g(x)) > 0. The Benders cut is therefore u(b − g(x)) ≤ 0.
In practice, the solution of the subproblem inference dual is the proof of optimality obtained while solving the subproblem.The simplest type of Benders cut is a nogood cut, which states that the solution of the subproblem cannot be improved unless certain x j 's are fixed to different values.For example, we might observe that only part of the master problem solution appears as premises in the optimality proof, perhaps x j = xj for j ∈ J .Then the optimal value of the subproblem is at least v * so long as x j = xj for j ∈ J .This yields a nogood cut v ≥ B x (x) with If the subproblem is infeasible, then perhaps x j = xj for j ∈ J appear as premises in the proof of infeasibility.A nogood cut states simply that x j = xj for some j ∈ J .Further analysis of the optimality proof may yield analytic Benders cuts that provide useful bounds when x j = xj for some j ∈ J .We may also be able to infer valid cuts by re-solving the subproblem when some of the premises x j = xj are dropped.All of these techniques are illustrated below.

The problem
In the unsegmented problem, there are n jobs to be processed, and each job j has release time r j , deadline (or due date) d j , and processing time p j .If we let J = {1, . . ., n}, the problem is to assign each job j ∈ J a start time s j so that time windows are observed: r j ≤ s j ≤ d j − p j , j ∈ J and jobs run consecutively: We minimize makespan by minimizing max j ∈J {s j + p j }.To minimize tardiness, we drop the deadline constraints s j ≤ d j − p j and minimize The segmented problem is the same except for the additional constraint that each job must be completed within one segment [a i , a i+1 ] of the time horizon:

MILP formulation
In the discrete-time MILP formulation of the problem, binary variable z jt = 1 when job j starts at time t .Let T be the set of discrete times, and assume r j , d j ∈ T for each j .The unsegmented problem is written where requires that every job be assigned a start time.The clique inequality (Fulkerson 1971;Padberg 1973) in (c) ensures that jobs do not overlap.Constraint (d) prevents a job from starting before its release time, and (e) prevents it from ending after its deadline.
The feasibility problem seeks a feasible solution and consists of the constraints (b)-(f).The makespan problem minimizes the makespan M subject to (b)-(f) and The tardiness problem minimizes j ∈J T j subject to (b)-(d), (f), and where T j is the tardiness of job j .
The segmented problem consists of the above and the additional constraints

CP formulation
In principle, a CP model of the unsegmented problem is quite simple.Again letting s j be the start time of job j , a model is where s = (s 1 , . . ., s n ) and p = (p 1 , . . ., p n ) in constraint (11c), and where noOverlap is a global constraint that requires the jobs to run sequentially.The makespan problem minimizes max j ∈J {s j + p j } subject to (11b)-(11c).The tardiness problem minimizes (8) subject to (11b)-(11c) without the upper bound in (11b).
The segmented problem can be formulated by introducing a variable v j with domain I that indicates which segment job j is assigned.We then add to (11a)-(11c) the constraints

Segmented feasibility problem
We now apply logic-based Benders decomposition to the problem of finding a feasible schedule.The master problem assigns jobs to time segments, and the subproblem decouples into a scheduling problem for each segment.We first address the segmented problem, for which the time horizon is already divided into segments [a i , a i+1 ] for i ∈ I .

Master problem
The master problem is an MILP formulation in which binary variable y ij = 1 when job j is assigned to segment i.
Benders cuts are developed below.The master problem also contains a relaxation of the problem, expressed in terms of the master problem variables.This results in more reasonable assignments in the early stages of the Benders algorithm and therefore reduces the number of iterations.The relaxation is described in Sect.5.3 below.
Given a solution ȳij of the master problem, let J i = {j | ȳij = 1} be the set of jobs it assigns to segment i.The subproblem decomposes into a scheduling problem for each segment: where s(i, ȳ) is the tuple of variables s j for j ∈ J i , and similarly for p(i, ȳ).The subproblems are solved by CP.
In each iteration of the Benders algorithm, the master problem is solved for ȳ.If the resulting subproblem is feasible on every segment, the algorithm stops with a feasible solution.Otherwise, one or more Benders cuts are generated for each segment on which the scheduling subproblem is infeasible.These cuts are added to the master problem, and the process repeats.If at some point the master problem is infeasible, so is the original problem.

Benders cuts
The simplest Benders cut for an infeasible segment i is a nogood cut that prevents assigning the same jobs (perhaps among others) to that segment in subsequent iterations: This cut is quite weak, however, because it can be satisfied by omitting just one job in J i from the future assignments to segment i.The cut can be strengthened by identifying a smaller set Ji ⊂ J i of jobs that appear as premises in the proof of infeasibility for segment i.This yields the cut Algorithm 1: Strengthening nogood cuts for the feasibility problem Let Ji = J i = {j 1 , . . ., j k }; for = 1, . . ., k do if the jobs in Ji \ {j } cannot be scheduled on segment i then Remove j from Ji Unfortunately, standard CP solvers do not provide this kind of dual information.We therefore seek to identify heuristically a smaller set Ji that creates infeasibility.A simple heuristic is to remove jobs from J i one at a time, checking each time if the scheduling problem on segment i is still infeasible.If it becomes feasible, the job is restored to J i (Algorithm 1).This requires repeated solution of each subproblem, but the time required to do so tends to be small in practice.
This heuristic may be more effective if jobs less likely to lead to feasibility are removed first.Let the effective time window [r ij , dij ] of job j on segment i be its time window adjusted to reflect the segment boundaries.Thus We can remove the jobs in order of decreasing slack, which means they are indexed so that The convergence of a Benders method can often be accelerated by augmenting the master problem with some valid inequalities in the master problem variables, resulting in a relaxation of the original problem.
A simple relaxation in the present case requires that jobs be scheduled so that for every time interval [t 1 , t 2 ], the set J (t 1 , t 2 ) of jobs whose time windows fall within [t 1 , t 2 ] has total processing time at most t 2 − t 1 .Thus It suffices to enumerate, for each segment, distinct intervals of the form [r j , d k ] for all j, k with r j ≤ d k .So we have the relaxation Algorithm 2 generates a relaxation with fewer redundant constraints.Note that it fixes y ij = 0 when job j 's time window does not overlap segment i.
Algorithm 2: Generating a relaxation for the segmented feasibility problem Let r1 , . . ., rt be the distinct elements of {r 1 , . . ., r n }; Let d1 , . . ., du be the distinct elements of {d 1 , . . ., d n }; for all i do for all j = 1, . . ., t with a i < rj < a i+1 do for all k = 1, . . ., u with dk < a i+1 do Generate the inequality ∈J (r j , dk ) p y i ≤ dk − rj Generate the inequality ∈J (r j ,∞) p y i ≤ a i+1 − rj ; for all k = 1, . . ., u with a i < dk < a i+1 do Generate the inequality ∈J (0, dk ) p y i ≤ dk − a i Generate the inequality p y i ≤ a i+1 − a i ; Set y i = 0 for all ∈ J (0, a i ); Set y i = 0 for all ∈ J (a i+1 , ∞);

Unsegmented feasibility problem
We now suppose that the jobs are not required to fit inside segments of the time horizon.We create segments [a i , a i+1 ] solely for purposes of decomposition, which means that a job can overlap two or more segments.This leads to several cases that complicate the master problem and the Benders cuts.

Master problem
Let continuous variable x ij indicate the amount of time that job j processes during segment i. Then The assignment of jobs (or portions of jobs) to segments is governed by several binary variables as introduced in Table 2.
We have the constraints and segment i begins while job j is in process and segment i ends while job j is in process i and segment i begins while job j 1 is in process and ends while job j 2 is in process Constraint (13a) ensures that every job is assigned to at least one segment.Constraints (13b) define y ij .Constraints (13c) ensure that at most one partial job is processed first, last, or throughout a segment.Constraints (13d)-(13g) require contiguity for the portions of a job.Constraints (13h) say that a job can start, finish, or execute completely in at most one segment.Constraints (13i) give boundary conditions.Constraints (13j) are redundant but tighten the continuous relaxation of the MILP formulation.
To connect x ij with the binary variables, note that we have the following disjunction for each i, j : Using the standard convex hull formulation of a disjunction of linear systems (Jeroslow 1987), this becomes: Algorithm 3: Generating a relaxation for the unsegmented feasibility problem Let r1 , . . ., rt be the distinct elements of {r 1 , . . ., r n }; Let d1 , . . ., du be the distinct elements of {d 1 , . . ., d n }; for all i do for all j = 1, . . ., t with a i < rj < a i+1 do for all k = 1, . . ., u with dk < a i+1 do Generate the inequality ∈J (r j , dk ) p y i 0 ≤ dk − rj Generate the inequality ∈J (r j ,∞) x i ≤ a i+1 − rj ; for all k = 1, . . ., u with a i < dk < a i+1 do Generate the inequality ∈J (0, dk ) x i ≤ dk − a i Generate the inequality x i ≤ a i+1 − a i ; Set y i = 0 for all ∈ J (0, a i ); Set y i = 0 for all ∈ J (a i+1 , ∞); The master problem consists of ( 12)-(13a-13k), ( 14) for all i ∈ I and j ∈ J , Benders cuts, and a relaxation.The Benders cuts are described in the next section.
To formulate the subproblem, suppose that the solution of the current master problem is ȳij , ȳij0 , ȳij1 , ȳij2 , xij for all i, j .Define The subproblem must take into account whether the master problem assigned certain jobs to begin or end a segment.A general formulation of the subproblem on segment i is where ) is the tuple of variables s j for j ∈ J i0 , and similarly for p(i, ȳ0 ).Note that if a portion of some job j 3 spans the entire segment ( ȳij 3 3 = 1), the constraint set is empty.
The relaxation is similar to that for the segmented problem but must account for jobs that run in two or more segments.The relaxation is generated by Algorithm 3.

Benders cuts
The Benders cuts generated for an infeasible segment i depend on whether there are partial jobs assigned to the beginning or end of the segment.
• Case 1.There are no partial jobs in segment i. Then we can use the simple nogood cut This can be strengthened as in the segmented problem by removing some jobs that are not necessary for infeasibility (Algorithm 1 with J i0 replacing J i ).• Case 2. There is a partial job only at the start of the segment (say, job j 1 ).We solve a modified subproblem by maximizing x ij 1 rather than checking for feasibility with That is, we maximize x ij 1 subject to (15) with āi = a i and āi+1 = a i+1 .
-Case 2a.The modified subproblem is infeasible.Because feasibility is not restored by reducing x ij 1 to zero, we again use the cut ( 16) and strengthen it by removing some jobs that are not necessary for feasibility.Suppose now that the modified subproblem is feasible, and let x * ij 1 be the maximum value of x ij 1 .We know x * ij 1 < xij 1 , because otherwise segment i would be feasible.-Case 2b.x * ij 1 = 0. Here, job j 1 must be removed as the first job if the other jobs in the segment are completely processed.We have the Benders cut Now the Benders cut can say that either x ij 1 ≤ xij 1 or one of the other jobs must be dropped.We introduce 0-1 variable α i that is 1 when x ij 1 ≤ xij 1 .Then we have the cut The cut can be strengthened by removing jobs in J i0 until x * ij 1 ≥ xij 1 (Algorithm 4).• Case 3.There is a partial job only at the end of the segment (say, job j 2 ).The cuts are similar to Case 2. The modified subproblem finds the maximum value x * ij 2 of x ij 2 subject to (15) with āi = a i and āi+1 = a i+1 .
-Case 3a.The modified subproblem is infeasible.We use cut ( 16) and strengthen it as before.-Case 3b.x * ij 2 = 0. We have the Benders cut Algorithm 4: Strengthening nogood cuts for the unsegmented feasibility problem Let Ji0 = J i0 = {j 2 , . . ., j k }; for = 2, . . ., k do Let x * ij 1 be the maximum of x ij 1 subject to (15) with āi = a i and We have the cut The cut can be strengthened by removing jobs in J i0 until x * ij 2 ≥ xij 2 .• Case 4.There are two partial jobs in the segment, namely j 1 at the start and j 2 at the end.
We solve a modified subproblem by finding the maximum value x * i of x ij 1 + x ij 2 subject to (15) with āi = a i and āi+1 = a i+1 .
-Case 4a.The modified subproblem is infeasible.We use cut ( 16) and strengthen it as before.-Case 4b.The modified subproblem is feasible but x * i = 0. Then j 1 and j 2 must be removed as the first and last jobs if the other jobs are completely processed, and we have the Benders cuts In this case the Benders cuts says that either (a) x ij 1 + x ij 2 ≤ x * i , or (b) j 1 or j 2 must be removed as the first or last job if the other jobs are completely processed:

Segmented makespan problem
We now address the problem of minimizing makespan when jobs must complete processing within a time segment.The subproblem is itself a minimization problem and therefore generates two types of Benders cuts: strengthened nogood cuts similar to those developed above, and cuts that bound the makespan.The bounding cuts can themselves be based on a nogood principle or a deeper analysis of the inference dual (analytic Benders cuts).
Algorithm 5: Generating a relaxation for the makespan problem Let r1 , . . ., rt be the distinct elements of {r 1 , . . ., r n }; for all i do for all j = 1, . . ., t with a i < rj do Generate the inequality M ≥ rj + ∈J (r j ,∞) x i Generate the inequality M ≥ w i + ∈J x i ; for j = 1, . . ., n do Generate the inequality w i ≥ a i y ij

Master problem
The master problem for segmented makespan problem is

Benders cuts
Relaxation Given a solution ȳij of the master problem, the subproblem decomposes into a minimum makespan problem for each segment i.It minimizes M i subject to Sect.5.1 and M i ≥ s j + p j , all j ∈ J with ȳij = 1 Thus the makespan on a segment is understood to be the completion time of the last job on the segment, not the completion time minus a i .If M * i is the minimum makespan on segment i, the optimal value of the original problem is max i∈I M * i .Note that if no jobs are assigned to segment i, the constraint set is empty, and M * i = −∞.Obviously, the latest segment that contains one or more jobs controls the overall makespan.
The relaxation described for the feasibility problem is also valid for the makespan problem.In addition, we can give the following bound on the makespan for each distinct r j : x i , i ∈ I, j ∈ J Algorithm 5 generates a relaxation with fewer redundant constraints.

Strengthened nogood cuts
If the scheduling problem on segment i is infeasible, we use the same strengthened nogood cuts as in the segmented feasibility problem.If segment i has a feasible schedule with minimum makespan M * i , the simplest nogood cut is Algorithm 6: Strengthening nogood cuts for the makespan problem Let Ji = J i = {j 1 , . . ., j k }; for = 1, . . ., k do if the minimum makespan is M * i when jobs in Ji \ {j } are assigned to segment i then Remove j from Ji This says that the makespan for subproblem i cannot be less than M * i unless at least one job is removed from J i .The cut can be strengthened to where Ji ⊂ J i is a smaller set of jobs that results in the same minimum makespan M * i .A simple heuristic for computing Ji appears as Algorithm 6.The jobs can be removed in order of increasing rij + p j , and we therefore index the jobs in J i so that Another way to obtain additional cuts is to use a two-tiered bound.Let M i (J ) be the minimum makespan that results when jobs in J are assigned to segment i, so that in particular M i (J i ) = M * i .Let Z i be the set of jobs that can be removed, one at a time, without affecting makespan, so that in addition to (19).This cut is redundant and should be deleted when M i (J i \ Z i ) = M * i .

Analytic Benders cuts
The reasoning we use to obtain analytic Benders cuts is similar to that used in Hooker (2007b).Let P i be the minimum makespan problem on segment i, with minimum makespan M * i .Let J i = {j ∈ J i | r j ≤ a i } be the set of jobs in J i with release times before segment i, and let J i = J i \ J i .Suppose we remove the jobs in S ⊂ J i from segment i and let Mi be the minimum makespan of the problem Pi that remains.We first show that where p S = j ∈S p j .Consider any optimal solution of Pi and extend it to a solution s of P i by scheduling the tasks in S sequentially after Mi .Because S ⊂ J i , these jobs start after their release time.The makespan of s is Mi + p S .If Mi + p S ≤ min j ∈J i { dij }, then s is clearly feasible for P i , which means M * i ≤ Mi + p S and ( 20) follows.On the other hand, if Mi + p S > min j ∈J i { dij }, we have Mi + p S + max Thus if the jobs in S ⊂ J i are removed from segment i, we have from ( 20) a lower bound on the resulting optimal makespan Mi .If one or more jobs in J i are removed, this bound is no longer valid.We have the following Benders cut when one or more jobs are removed from segment i, and M ≥ M * i otherwise, provided y ij = 1 for at least one j ∈ J i .The second summation in ( 22) takes care of the case where one or more jobs in J i are removed.If y ij = 0 for all j ∈ J i , the cut is simply M ≥ 0.
We can linearize this cut by writing the following for each i: where binary variable q i = 1 when y ij = 0 for all j ∈ J i .The cut can be strengthened by replacing J i , J i and J i with Ji , J i , and J i , where Ji is computed as in Algorithm 6, J i = {j ∈ Ji | r j ≤ a i }, and J i = Ji \ Ji .

Unsegmented makespan problem
The master problem for the unsegmented makespan problem minimizes makespan M subject to ( 12)-( 14), Benders cuts, and a relaxation.The subproblem on each segment i minimizes makespan M i subject to (15) and The relaxation is the same as for the segmented makespan problem.

Strengthened nogood cuts
If the scheduling problem on segment i is infeasible, we generate the same strengthened nogood cuts as in the unsegmented feasibility problem.Suppose, then, that segment i has a feasible schedule with minimum makespan M * i .As before, we let J i = {j | ȳij = 1} and J i0 = {j | ȳij0 = 1}.
• Case 1.There are no partial jobs in segment i. Then we have the nogood cut This cut can be strengthened as in the segmented problem.We also have the cut where Z i is computed as before.• Case 2. A partial job j 2 is assigned to the end of the segment.In this case the minimum makespan on the segment is M * i = a i+1 unless j 2 is removed from the end.The Benders cut is simply • Case 3.There is no partial job at the end of the segment but a partial job j 1 at the start.The nogood cut is which can be strengthened by heuristically removing jobs from J i0 .

Analytic Benders cuts
To analyze the subproblem more deeply we partition J i0 as follows: We consider the same three cases as above.
• Case 1.There are no partial jobs in segment i.The nogood cut is very similar to that obtained for the segmented case: The cut can be strengthened as before.• Case 2. This yields only the nogood cut (23).
• Case 3.There is no partial job at the end of the segment but there is a partial job j 1 at the start of the segment.We will investigate the effect on makespan of reducing job j 1 's processing time in segment i below its current assignment xij 1 .Let δ = xij 1 − x ij 1 be the amount of the reduction.The Benders cuts generated depend on whether one or more jobs start at their release times in the minimum makespan schedule.
-Case 3a.Some job j ∈ J i starts at its release time in the optimal solution s * of the subproblem on segment i.That is, s * j = r j for some j ∈ J i0 .Let k be the first such job.We may assume that j 1 and all jobs between j 1 and k are scheduled contiguously in s * (i.e., there is no idle time between them).Now suppose the jobs between j 1 and k are scheduled δ earlier, and δ is increased to the value δ * at which one of these jobs hits its release time.Thus This increases by δ * the gap i between the job k immediately before k and job k, where i = r k − s * k − p k .Suppose further that for a given δ ≤ δ * , no job after k is short enough to be moved into the gap i + δ while observing its release time.Then we know that the minimum makespan remains at M * i when job j 1 's processing time is reduced by δ, assuming no jobs are removed from segment i.
To write the corresponding Benders cut, let p min be the processing time of the shortest job that can be moved into the gap i + δ * .Thus Then the minimum makespan remains M * i if p min > i + δ (again assuming no jobs are removed from segment i).We introduce a binary variable η i that is 0 when this inequality is satisfied.This yields the Benders cut where > 0 is a small number.When η i = 1, this cut is of no value, but a simpler cut becomes useful: It says that the jobs after j 1 can at best be scheduled contiguously.-Case 3b.No job starts at its release time in the optimal solution of the subproblem.That is, s * j > r j for all j ∈ J i0 .Thus all jobs are scheduled contiguously.As δ = xij 1 − x ij 1 increases, minimum makespan decreases by an equal amount, at least until a job in J i0 hits its release time.At this point we can increase δ by another and check whether minimum makespan continues to decrease by .If so, we can further increase δ until another job hits its release time, and so forth until makespan stops decreasing at the margin, at which point we revert to Case 3a.We now write a Benders cut that allows makespan to decrease at the same rate δ increases up to δ ≤ δ k * .
To make this more precise, let s * (δ) be the minimum makespan solution on segment i when x ij 1 is fixed to xij 1 − δ rather than xij 1 , and let M * i (δ) be the corresponding minimum makespan.Let δ 0 be the value of δ at which the first job hits its release time, so that and let k * be the smallest k for which M * i (δ k + ) = M * i (δ).Then we generate the Benders cut where λ i ∈ {0, 1}.This cut is useless when λ i = 1, but the following cut is helpful in this case: After generating these cuts, we move to Case 3a.

Segmented tardiness problem
The objective in the tardiness problem is to minimize total tardiness.We study the segmented version of the problem.Analysis of the unsegmented tardiness problem is more complex and is left to future research.

Master problem
The master problem for the segmented tardiness problem is

Benders cuts
Relaxation Given a solution ȳij of the master problem, the subproblem for each segment i is: The relaxation for the feasibility problem must be modified to make it valid for the tardiness problem, because deadlines are now due dates.The only hard deadlines are the upper bounds a i+1 of the segments.We have the relaxation ∈J (r j ,∞) p y i ≤ a i+1 − rij , i ∈ I, j ∈ J Algorithm 7 generates a relaxation with fewer redundant constraints.
We also use a bound on tardiness that is developed in Hooker (2007b).

Strengthened nogood cuts
If the tardiness problem on segment i is infeasible, we use the same strengthened nogood cuts as in the feasibility problem.Otherwise, let T * i be the minimum tardiness.If T * i > 0, we use the strengthened nogood cut where Ji ⊂ J i is a smaller set of jobs that result in the same minimum tardiness T * i .A simple heuristic for computing Ji appears as Algorithm 8.The jobs can be removed in order of decreasing tightness ij , but note that ij can be negative.
Another way to strengthen the cuts is to use a two-tiered bound similar to the makespan case.Let T i (J ) be the minimum makespan that results when jobs in J are assigned to segment i.If we define then we have the cut in addition to (25).This cut is redundant and should be deleted when T i (J i \ Z i ) = T * i .

Analytic Benders cuts
Let P i be the subproblem on a segment i with a feasible schedule, and let T * i be the minimum tardiness of P i .When T * i > 0, we generate an analytic Benders cut as follows.Let Pi be the minimum tardiness problem that results when the jobs in S ⊂ J i are removed from P i .Let Ti be the minimum tardiness of Pi , and Fi a solution of Pi that achieves tardiness Ti .Let be the last release time of the jobs in J i , or a i , whichever is larger.Because P i is feasible, we know r max i ≤ a i+1 .Let Mi be the makespan of an optimal solution of Pi .We construct a solution F i of P i by adding the jobs in S to Fi .In particular, we schedule the jobs in S contiguously after max{r max i , M}, in arbitrary order.The makespan of F i is at most because in the worst case, all the jobs in the optimal solution of Pi are scheduled after r max i .The tardiness incurred in F i by each job j ∈ S is therefore at most where (α) + = max{α, 0}.Thus the total tardiness of F i is at most F i is feasible if all the jobs finish before a i+1 .So we know F i is feasible if In this case, the tardiness ( 26) is an upper bound on T * i , and we have

Problem generation
We generated random instances by selecting parameters uniformly from intervals as follows: where R is the of the time horizon, measured by the number of segments.Thus γ 1 and γ 2 control the width of the time windows, and β controls the processing time relative to the window width.We set parameters as indicated in Table 3.We distinguished tight from wide time windows for segmented problems, because wider windows could result in less effective propagation and/or relaxations.The remaining parameters were chosen to obtain instances that are (a) nontrivial to solve and (b) usually feasible for the optimization problems (less often feasible for the feasibility problems).To accomplish this, we adjusted β and γ 2 empirically to sample instances near a phase transition where average problem difficulty peaks and there is a mix of feasible and infeasible instances.This required adjusting β to different values as the problem scaled up.

Computational results
We formulated and solved the instances with IBM's OPL Studio 6.1, which invokes the ILOG CP Optimizer for CP models and CPLEX for MILP models.We used OPL's script language to implement the Benders method.We generated 10 instances for each problem size and type, for a total of 580 instances.
Tables 4 and 5 display computational results for the segmented problems.The advantage of logic-based Benders increases rapidly as the problem scales up, relative to both CP and a Solution terminated at 600 seconds for some or all instances b MILP solver ran out of memory for some or all instances, which are omitted from the average solution time 5.5 600 a 560 a 6.9 a Solution terminated at 600 seconds for some or all instances b MILP solver ran out of memory for some or all instances, which are omitted from the average solution time MILP.The Benders method failed to solve only 4 of 420 instances within ten minutes, while CP failed to solve 247 and MILP failed to solve 113.Table 6 displays computational results for the unsegmented problems.The Benders method continues to have a substantial advantage over MILP, but it is considerably slower than CP on the easier problems.However, examination of the individual instances reveals that the Benders method is more robust.The Benders method solved all 160 unsegmented instances, while CP failed to solve 20 instances within ten minutes.CP was very fast for the instances it solved (average of 0.79 seconds), but Benders solved the remaining instances in an average of only 5.94 seconds.This suggests that one ought to try CP first, and if it fails to solve the problem in a few seconds, switch to Benders.
The volatility of CP may be due to the fact that filtering and bounds propagation can be effective on a long time horizon when time windows interact in a certain way, but when this does not occur, a huge search tree is generated.This phenomenon may not affect the Benders a Reflects three very negative outliers method because the scheduling segments are small enough to result in limited search trees even when propagation is ineffective.We also investigated the effectiveness of analytic Benders cuts.They incur greater overhead than nogood cuts, because each analytic cut requires multiple inequalities in the master problem.This could offset faster convergence.To test this hypothesis, we re-solved all the instances with nogood cuts but without analytic cuts (Table 7).We found that for segmented problems, the analytic cuts make little difference on the average when time windows are narrow.However, they bring significant and occasionally dramatic reductions in computation time for wide time windows.Because these cuts do no harm (on the average) in either case and are advantageous for wider time windows, it is advisable to use them.As for unsegmented problems, the analytic cuts are clearly beneficial and should be used.

12
We adapted logic-based Benders decomposition to a pure scheduling problem that lacks the natural decomposability of the planning and scheduling problems to which the method has been previously applied.The master assigns jobs to segments of the time horizon rather than to machines or other resources.
We find that for single-facility scheduling, logic-based Benders scales up more effectively than state-of-the-art CP and MILP solvers.This is especially true for the segmented problem, in which jobs are not permitted to overlap segment boundaries.The Benders method solves much larger instances of the feasibility and makespan problems, and its speed advantage increases rapidly as the problem size increases.It is somewhat faster on the tardiness problem.
The Benders master problem becomes more complex for the unsegmented problem, in which jobs may overlap segment boundaries.Benders decomposition continues to dominate MILP while being much slower than CP on most of the smaller instances.However, CP begins to lose its ability to solve instances as they scale up, whereas Benders continues to solve them, usually in a few seconds.Benders is therefore not necessarily the fastest method but clearly the most robust.
CP solves unsegmented instances quickly if it solves them at all.This suggests a strategy of applying CP first, and if it fails to solve the problem with a few seconds, switch to Benders.For segmented instances, Benders is always superior and should be used from the start.
Possible future research includes the development of Benders cuts for the unsegmented tardiness problem.In addition, convergence might be accelerated with the generation of multiple cuts, or by a "warm start" that adds a collection of Benders cuts to the initial master problem, as in Aggoun and Vazacopoulos (2004), Maravelias (2006).The length of time segments might be adjusted dynamically for better performance.Finally, other forms of decomposition can be explored.

Table 1
Nomenclature This cut can be strengthened by removing jobs fromJ i0 until x * i ≥ xij 1 + xij 2 .-Case4d.The modified subproblem is feasible and x * i ≥ xij 1 + xij 2 .Then if x * ij 1 , x * ij 2are defined as before, we must have eitherx * ij 1 < xij 1 as in Case 2, or x * ij 2 < xij2 as in Case 3.This is because the feasible set for (x ij 1 , x ij 2 ) is a box with the upper right corner possibly cut off with a 45 o line.If x * ij 1 < xij 1 , we add cut (17) as in Case 2c.If x * ij 2 < xij 2 , we add cut (18) as in Case 3c.Either cut can be strengthened as before.
Algorithm 7: Generating a relaxation for the tardiness problem Let r1 , . . ., rt be the distinct elements of {r 1 , . . ., r n }; for all i do for all j = 1, . . ., t with a i < rj do

Table 3
Parameters for generation of problem instances

Table 4
Computation times in seconds for the segmented problem with tight time windows.The number of segments is 10% the number of jobs.instances of each size are solved

Table 5
Average computation times in seconds for the segmented problem with wide time windows.The number of segments is 10% the number of jobs.Ten instances of each size are solved

Table 6
Average computation times in seconds for the unsegmented problem.The number of segments is 10% the number of jobs.Ten instances of each size are solved Solution terminated at 600 seconds for some or all instances a

Table 7
Effect of analytic Benders cuts on computation time.The last three columns show the percent of instances in which analytic cuts reduced computation time by more than the stated amount