# Single-facility scheduling by logic-based Benders decomposition

## Authors

## Abstract

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.

### Keywords

Logic-based Benders decompositionConstraint programmingMixed integer programmingSingle-facility schedulingMakespanTardinessFeasibility## 1 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, 2005a, 2005b, 2006, 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.

## 2 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.

Additional applications of logic-based Benders include logic circuit testing (Hooker and Yan 1995), propositional satisfiability (Hooker and Ottosson 2003), multistage facility scheduling (Harjunkoski and Grossmann 2002), dispatching of automated guided vehicles (Corréa et al. 2004), steel production scheduling (Harjunkoski and Grossmann 2001), real-time scheduling of computer processors (Cambazard et al. 2004), traffic diversion (Chu and Xia 2004), batch scheduling in a chemical plant (Maravelias and Grossmann 2004a, 2004b) (and, in particular, polypropylene batch scheduling (Timpe 2002)), stochastic constraint programming (Tarim and Miguel 2006), customer service with queuing (Terekhov et al. 2005), and scheduling of distributed processors for computation (Benini et al. 2005; Cambazard et al. 2004).

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, 2005a, 2005b, 2006, 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.

## 3 Logic-based Benders decomposition

*inference dual*. Consider an optimization problem

*C*(

*x*) represents a constraint set containing variables

*x*, and

*D*is the domain of

*x*(such as ℝ

^{n}or ℤ

^{n}). The inference dual is the problem of finding the tightest lower bound on the objective function that can be deduced from the constraints:

*P*deduces

*f*(

*x*)≥

*v*from

*C*(

*x*). The domain of variable

*P*is a family \(\mathcal{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 \(\mathcal{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.

*x*to \(\bar{x}\) defines the subproblem

*P*solve the inference dual of the subproblem by deducing the bound \(f(\bar{x},y)\geq v^{*}\). A Benders cut \(v\geq B_{\bar{x}}(x)\) is derived by identifying a bound \(B_{\bar{x}}(x)\) that the same proof

*P*deduces for any given

*x*. Thus, in particular, \(B_{\bar{x}}(\bar{x})=v^{*}\). The

*k*th master problem is

*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*.

*u*defines a surrogate \(uAy\geq u(b-g(\bar{x}))\) that dominates

*cy*≥

*v*

^{∗}and therefore deduces that \(f(\bar{x})+cy\geq f(\bar{x}) +u(b-g(\bar{x}))\). The same

*u*deduces

*f*(

*x*)+

*cy*≥

*f*(

*x*)+

*u*(

*b*−

*g*(

*x*)) 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.

*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}=\bar{x}_{j}\) for

*j*∈

*J*. Then the optimal value of the subproblem is at least

*v*

^{∗}so long as \(x_{j}=\bar{x}_{j}\) for

*j*∈

*J*. This yields a nogood cut \(v\geq B_{\bar{x}}(x)\) with

*j*∈

*J*appear as premises in the proof of infeasibility. A nogood cut states simply that \(x_{j}\neq \bar{x}_{j}\) for some

*j*∈

*J*.

Further analysis of the optimality proof may yield *analytic* Benders cuts that provide useful bounds when \(x_{j}\neq \bar{x}_{j}\) 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}=\bar{x}_{j}\) are dropped. All of these techniques are illustrated below.

## 4 The problem

*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:

_{j∈J}{

*s*

_{j}+

*p*

_{j}}. To minimize tardiness, we drop the deadline constraints

*s*

_{j}≤

*d*

_{j}−

*p*

_{j}and minimize

*a*

_{i},

*a*

_{i+1}] of the time horizon:

Nomenclature for the segmented problem

Indices | |

| job |

| segment of the time horizon |

| time |

Sets | |

| set of jobs ({1,2,…, |

| set of segments |

| set of discrete times |

| set of discrete times at which job |

| set of jobs assigned to segment |

| set of jobs whose time windows fall within [ |

Parameters | |

| release time of job |

| deadline (or due date) of job |

| processing time of job |

| start time of segment |

\(\bar{y}_{ij}\) | solution value of |

\(\tilde{r}_{ij}\) | starting time of the effective time window of job |

\(\tilde{d}_{ij}\) | ending time of the effective time window of job |

| slack of job |

\(\bar{r}\) | tuple of distinct release times |

\(\bar{d}\) | tuple of distinct deadlines |

\(M_{i}^{*}\) | minimum makespan of segment |

Variables | |

| start time of job |

| =1 if job |

| makespan over all segments |

| makespan of segment |

| tardiness of job |

| segment in which job |

| =1 if job |

### 4.1 MILP formulation

*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

*M*subject to (b)–(f) and

_{j∈J}

*T*

_{j}subject to (b)–(d), (f), and

*T*

_{j}is the tardiness of job

*j*.

### 4.2 CP formulation

*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).

## 5 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*.

### 5.1 Master problem

*y*

_{ij}=1 when job

*j*is assigned to segment

*i*.

*i*. The subproblem decomposes into a scheduling problem for each segment:

*s*

_{j}for

*j*∈

*J*

_{i}, and similarly for \(p(i,\bar{y})\). The subproblems are solved by CP.

In each iteration of the Benders algorithm, the master problem is solved for \(\bar{y}\). 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.

### 5.2 Benders cuts

*i*is a nogood cut that prevents assigning the same jobs (perhaps among others) to that segment in subsequent iterations:

*J*

_{i}from the future assignments to segment

*i*. The cut can be strengthened by identifying a smaller set \(\bar{J}_{i}\subset J_{i}\) of jobs that appear as premises in the proof of infeasibility for segment

*i*. This yields the cut

*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.

*effective time window*\([\tilde{r}_{ij},\tilde{d}_{ij}]\) of job

*j*on segment

*i*be its time window adjusted to reflect the segment boundaries. Thus

*slack*of job

*j*on segment

*i*be

### 5.3 Relaxation

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.

*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

*r*

_{j},

*d*

_{k}] for all

*j*,

*k*with

*r*

_{j}≤

*d*

_{k}. So we have the relaxation

*y*

_{ij}=0 when job

*j*’s time window does not overlap segment

*i*.

## 6 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.

### 6.1 Master problem

*x*

_{ij}indicate the amount of time that job

*j*processes during segment

*i*. Then

Additional nomenclature for the unsegmented problem

Sets | |

| set of jobs that are fully processed in segment |

Parameters | |

\(\bar{x}_{ij}\) | solution value of |

\(\bar{y}_{ij}\) | solution value of |

\(\bar{y}_{ijk}\) | solution value of |

\(\bar{a}_{i}\) | updated start time of the segment |

Variables | |

| amount of time job |

| =1 if at least a portion of job |

| =1 if all of job |

| =1 if a portion of job |

| =1 if a portion of job |

| =1 if a portion of job |

| =1 if \(x_{ij} \leq \bar{x}_{ij}\) and segment |

| =1 if \(x_{ij} \leq \bar{x}_{ij}\) and segment |

| =1 if \(x_{ij_{1}}+x_{ij_{2}} \leq x_{i}^{*}\) and segment |

*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.

*x*

_{ij}with the binary variables, note that we have the following disjunction for each

*i*,

*j*:

*i*∈

*I*and

*j*∈

*J*, Benders cuts, and a relaxation. The Benders cuts are described in the next section.

*i*,

*j*. Define

*i*is

*s*

_{j}for

*j*∈

*J*

_{i0}, and similarly for \(p(i,\bar{y}_{0})\). Note that if a portion of some job

*j*

_{3}spans the entire segment (\(\bar{y}_{ij_{3}3}=1\)), the constraint set is empty.

### 6.2 Benders cuts

*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 cutThis can be strengthened as in the segmented problem by removing some jobs that are not necessary for infeasibility (Algorithm 1 with$$\sum_{j\in J_{i0}} (1-y_{ij0}) \geq 1 $$(16)*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 \(x_{ij_{1}}=\bar{x}_{ij_{1}}\). That is, we maximize \(x_{ij_{1}}\) subject to (15) with \(\bar{a}_{i}=a_{i}\) and \(\bar{a}_{i+1}=a_{i+1}\).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}}^{*}<\bar{x}_{ij_{1}}\), because otherwise segment*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.

*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$$(1-y_{ij_11}) + \sum_{j\in J_{i0}} (1-y_{ij0}) \geq 1 $$*Case 2c*. \(x^{*}_{ij_{1}}>0\). Now the Benders cut can say that either \(x_{ij_{1}}\leq \bar{x}_{ij_{1}}\) or one of the other jobs must be dropped. We introduce 0-1 variable*α*_{i}that is 1 when \(x_{ij_{1}}\leq \bar{x}_{ij_{1}}\). Then we have the cutThe cut can be strengthened by removing jobs in$$\begin{array}{l}{\displaystyle \alpha_i + \sum_{j\in J_{i0}} (1-y_{ij0}) \geq 1} \\[12pt]x_{ij_1} \leq \bar{x}_{ij_1} + p_{j_1}(1-\alpha_i) \\[3pt]\alpha_i \in \{0,1\}\end{array} $$(17)*J*_{i0}until \(x^{*}_{ij_{1}}\geq \bar{x}_{ij_{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 \(\bar{a}_{i}=a_{i}\) and \(\bar{a}_{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$$(1-y_{ij_22}) + \sum_{j\in J_{i0}} (1-y_{ij0}) \geq 1 $$*Case 3c*. \(x^{*}_{ij_{2}}>0\). We have the cutThe cut can be strengthened by removing jobs in$$\begin{array}{l}{\displaystyle \beta_i + \sum_{j\in J_{i0}} (1-y_{ij0}) \geq 1} \\[12pt]x_{ij_2} \leq \bar{x}_{ij_2} + p_{j_2}(1-\beta_i)\\[3pt]\beta_i \in \{0,1\}\end{array} $$(18)*J*_{i0}until \(x_{ij_{2}}^{*} \geq \bar{x}_{ij_{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 \(\bar{a_{i}}=a_{i}\) and \(\bar{a}_{i+1}=a_{i+1}\).*Case 4a*. The modified subproblem is infeasible. We use cut (16) and strengthen it as before.*Case 4c*. The modified subproblem is feasible and \(0<x_{i}^{*}<\bar{x}_{ij_{1}}+\bar{x}_{ij_{2}}\). In this case the Benders cuts says that either (a) \(x_{ij_{1}}+x_{ij_{2}}\leq 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: This cut can be strengthened by removing jobs from*J*_{i0}until \(x_{i}^{*}\geq \bar{x}_{ij_{1}} + \bar{x}_{ij_{2}}\).*Case 4d*. The modified subproblem is feasible and \(x_{i}^{*} \geq\bar{x}_{ij_{1}}+\bar{x}_{ij_{2}}\). Then if \(x^{*}_{ij_{1}}, x^{*}_{ij_{2}}\) are defined as before, we must have either \(x^{*}_{ij_{1}}<\bar{x}_{ij_{1}}\) as in Case 2, or \(x^{*}_{ij_{2}}<\bar{x}_{ij_{2}}\) 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\(^{\mbox{\scriptsize o}}\) line. If \(x^{*}_{ij_{1}}<\bar{x}_{ij_{1}}\), we add cut (17) as in Case 2c. If \(x^{*}_{ij_{2}}<\bar{x}_{ij_{2}}\), we add cut (18) as in Case 3c. Either cut can be strengthened as before.

## 7 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).

### 7.1 Master problem

*i*. It minimizes

*M*

_{i}subject to Sect. 5.1 and

*a*

_{i}. If \(M_{i}^{*}\) is the minimum makespan on segment

*i*, the optimal value of the original problem is \(\max_{i\in I}M_{i}^{*}\). Note that if no jobs are assigned to segment

*i*, the constraint set is empty, and \(M_{i}^{*}=-\infty\). Obviously, the latest segment that contains one or more jobs controls the overall makespan.

*r*

_{j}:

### 7.2 Strengthened nogood cuts

*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

*i*cannot be less than \(M_{i}^{*}\) unless at least one job is removed from

*J*

_{i}. The cut can be strengthened to

*J*

_{i}so that

*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

*i*we have the cut

### 7.3 Analytic Benders cuts

*P*

_{i}be the minimum makespan problem on segment

*i*, with minimum makespan \(M_{i}^{*}\). Let \(J_{i}'=\{j\in J_{i} \mid r_{j}\leq a_{i}\}\) be the set of jobs in

*J*

_{i}with release times before segment

*i*, and let \(J_{i}''=J_{i}\setminus J_{i}'\). Suppose we remove the jobs in \(S\subset J_{i}'\) from segment

*i*and let \(\hat{M}_{i}\) be the minimum makespan of the problem \(\hat{P}_{i}\) that remains. We first show that

*p*

_{S}=∑

_{j∈S}

*p*

_{j}.

*s*of

*P*

_{i}by scheduling the tasks in

*S*sequentially after \(\hat{M}_{i}\). Because \(S\subset J_{i}'\), these jobs start after their release time. The makespan of

*s*is \(\hat{M}_{i} + p_{S}\). If \(\hat{M}_{i}+ p_{S} \leq \min_{j\in J_{i}'} \{\tilde{d}_{ij}\}\), then

*s*is clearly feasible for

*P*

_{i}, which means \(M_{i}^{*}\leq \hat{M}_{i} + p_{S}\) and (20) follows. On the other hand, if \(\hat{M}_{i}+p_{S} > \min_{j\in J_{i}'} \{\tilde{d}_{ij}\}\), we have

*i*, we have from (20) a lower bound on the resulting optimal makespan \(\hat{M}_{i}\). If one or more jobs in \(J_{i}''\) are removed, this bound is no longer valid. We have the following Benders cut

*i*, and \(M\geq 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.

*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 \(\bar{J}_{i}\), \(\bar{J}_{i}'\), and \(\bar{J}_{i}''\), where \(\bar{J}_{i}\) is computed as in Algorithm 6, \(\bar{J}_{i}'=\{j\in\bar{J}_{i} \;|\; r_{j}\leq a_{i}\}\), and \(\bar{J}_{i}''=\bar{J}_{i}\setminus \bar{J}_{i}\).

## 8 Unsegmented makespan problem

*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.

### 8.1 Strengthened nogood cuts

*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 \;|\;\bar{y}_{ij}=1\}\) and \(J_{i0}=\{j\;|\;\bar{y}_{ij0}=1\}\).

*Case 1*. There are no partial jobs in segment*i*. Then we have the nogood cutThis cut can be strengthened as in the segmented problem. We also have the cut$$M \geq M^*_i\biggl(1 - \sum_{j\in J_i} (1-y_{ij0})\biggr)$$where$$M \geq M_i(J_i\setminus Z_i) \biggl( 1 - \sum_{j\in J_i\setminus Z_i} (1-y_{ij0})\biggr)$$*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$$M \geq M_i^*y_{ij_22} $$(23)*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 iswhich can be strengthened by heuristically removing jobs from$$M \geq M^*_i\biggl(1 - (1-y_{ij_11}) - \sum_{j\in J_{i0}} (1-y_{ij0})\biggr)$$*J*_{i0}.

### 8.2 Analytic Benders cuts

*J*

_{i0}as follows: We consider the same three cases as above.

*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 \(\bar{x}_{ij_{1}}\). Let \(\delta=\bar{x}_{ij_{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. ThusThis increases by$$\delta^* = \min_{j\in J_{i0}} \bigl\{s_j^* - \tilde{r}_{ij} \mid s_j^* < s_k\bigr\}$$*δ*^{∗}the gap Δ_{i}between the job*k*′ immediately before*k*and job*k*, where \(\Delta_{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}+*δ*^{∗}. ThusThen the minimum makespan remains \(M_{i}^{*}\) if$$p_{\min} = \min_{j\in J_{i0}}\bigl\{p_j\mid s_j^*>s_k^*, \; \tilde{r}_{ij}+p_j \leq r_k, \; p_j \leq \Delta_i + \delta^*\bigr\}$$*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$$M \geq \biggl( a_i +\sum_{j \in J_{i0}} p_j \biggr)\eta_i + x_{ij_1}- {M_i}^* \sum_ {j \in J_i} (1-y_{ij})$$*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 \(\delta = \bar{x}_{ij_{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 \(\delta\leq \delta_{k^{*}}\).To make this more precise, let*s*^{∗}(*δ*) be the minimum makespan solution on segment*i*when \(x_{ij_{1}}\) is fixed to \(\bar{x}_{ij_{1}}-\delta\) rather than \(\bar{x}_{ij_{1}}\), and let \(M_{i}^{*}(\delta)\) be the corresponding minimum makespan. Let*δ*_{0}be the value of*δ*at which the first job hits its release time, so thatNow define$$\delta_0 = \min_{j\in J_{i0}} \{s^*(0)-\tilde{r}_{ij}\}$$and let$$\delta_k = \delta_{k-1} + \min_{i\in J_{i0}} \{s^*(\delta_{k-1}) - \tilde{r}_{ij}\}$$*k*^{∗}be the smallest*k*for which \(M_{i}^{*}(\delta_{k} +\epsilon)=M_{i}^{*}(\delta)\). 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.$$M \geq a_i \lambda_i + x_{ij_1}+\sum_{j \in J_{i0}}p_j \lambda_i - {M_i}^* \sum_ {j \in J_i} (1-y_{ij})$$

## 9 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.

### 9.1 Master problem

*i*is:

*a*

_{i+1}of the segments. We have the relaxation

*H*

_{ij}={1,…,

*j*}∖(

*J*(0,

*a*

_{i})∪

*J*(

*a*

_{i+1},∞)) is the set of jobs with time windows that overlap segment

*i*. The jobs are indexed so that

*d*

_{1}≤⋯≤

*d*

_{n}, and

*π*is a permutation of the indices for which

*p*

_{π(1)}≤⋯≤

*p*

_{π(n)}.

### 9.2 Strengthened nogood cuts

*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

*ϵ*

_{ij}, but note that

*ϵ*

_{ij}can be negative.

*T*

_{i}(

*J*) be the minimum makespan that results when jobs in

*J*are assigned to segment

*i*. If we define

### 9.3 Analytic Benders cuts

*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 \(\hat{P_{i}}\) be the minimum tardiness problem that results when the jobs in

*S*⊂

*J*

_{i}are removed from

*P*

_{i}. Let \(\hat{T}_{i}\) be the minimum tardiness of \(\hat{P}_{i}\), and \(\hat{F}_{i}\) a solution of \(\hat{P}_{i}\) that achieves tardiness \(\hat{T}_{i}\). Let

*J*

_{i}, or

*a*

_{i}, whichever is larger. Because

*P*

_{i}is feasible, we know \(r^{\max}_{i}\leq a_{i+1}\).

*F*

_{i}of

*P*

_{i}by adding the jobs in

*S*to \(\hat{F}_{i}\). In particular, we schedule the jobs in

*S*contiguously after \(\max\{r^{\max}_{i},\hat{M}\}\), in arbitrary order. The makespan of

*F*

_{i}is at most

*F*

_{i}by each job

*j*∈

*S*is therefore at most

*α*)

^{+}=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

## 10 Problem generation

*R*is the length 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.

*β*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.

Parameters for generation of problem instances

Segmented problems | Unsegmented | |||
---|---|---|---|---|

Feasibility | Makespan | Tardiness | Feas. & Makespan | |

| 0.5 | |||

| 0.5 for tight windows | 0.25 | ||

0.25 for wide windows | ||||

| 1.0 | |||

| Tight windows: | |||

1/20 for 6–8 segs. | 0.025 for ≤13 segs. | 0.05 | 1/15 for 5–8 segs. | |

1/24 for 10 segs. | 0.032 for >13 segs. | 1/20 for 9–12 segs. | ||

1/28 for 12 segs. | 1/30 for 12–16 segs. | |||

1/32 for 14 segs. | 1/35 for >16 segs. | |||

Wide windows: | ||||

0.035 |

## 11 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.

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

Jobs | Feasibility | Makespan | Tardiness | ||||||
---|---|---|---|---|---|---|---|---|---|

CP | MILP | Bndrs | CP | MILP | Bndrs | CP | MILP | Bndrs | |

60 | 0.1 | 14 | 1.9 | 60 | 7.7 | 6.4 | 0.1 | 16 | 3.0 |

80 | 181 | 45 | 2.7 | 420 | 147 | 11 | 63 | 471 | 20 |

100 | 199 | 58 | 4.3 | 600 | 600 | 17 | 547 | 177 | 11 |

120 | 272 | 137 | 4.8 | 600 | 600 | 39 | 600 | 217 | 2.9 |

140 | 306 | 260 | 6.8 | 600 | 432 | 33 | 600 | 373 | 5.0 |

160 | 314 | 301 | 8.0 | 600 | 359 | 14 | |||

180 | 600 | 350 | 4.8 | 600 | 557 | 5.3 | |||

200 | 600 |
| 5.8 | 600 | 600 | 6.6 |

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

Jobs | Feasibility | Makespan | Tardiness | ||||||
---|---|---|---|---|---|---|---|---|---|

CP | MILP | Bndrs | CP | MILP | Bndrs | CP | MILP | Bndrs | |

60 | 0.05 | 12 | 1.9 | 0.2 | 16 | 5.8 | 0.2 | 8.0 | 2.3 |

80 | 0.28 | 22 | 2.5 | 180 | 59 | 9.0 | 1.5 | 94 | 3.7 |

100 | 0.14 | 37 | 3.8 | 360 | 403 | 14 | 79 | 594 | 85 |

120 | 0.13 | 61 | 5.0 | 540 | 600 | 25 | 600 | 251 | 183 |

140 | 61 | 175 | 7.0 | 600 | 600 | 107 | 600 | 160 | 4.3 |

160 | 540 | 216 | 4.8 | 600 | 562 | 157 | |||

180 | 600 | 375 | 4.5 | 600 | 535 | 10 | |||

200 | 600 |
| 5.5 | 600 | 560 | 6.9 |

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

Jobs | Feasibility | Makespan | ||||
---|---|---|---|---|---|---|

CP | MILP | Bndrs | CP | MILP | Bndrs | |

60 | 0.10 | 11 | 2.8 | 0.2 | 24 | 5.1 |

80 | 0.14 | 21 | 3.7 | 0.7 | 376 | 8.7 |

100 | 0.25 | 35 | 7.0 | 1.1 | 600 | 21 |

120 | 0.43 | 57 | 23 | 0.4 | 600 | 93 |

140 | 0.72 | 97 | 65 | 1.2 | 600 | 115 |

160 | 420 | 188 | 9.0 | 241 | 549 | 67 |

180 | 123 | 307 | 79 | 61 | 600 | 168 |

200 | 180 | 410 | 29 | 180 | 587 | 21 |

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 method because the scheduling segments are small enough to result in limited search trees even when propagation is ineffective.

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

Problem class | % reduction | % of instances with reduction | |||
---|---|---|---|---|---|

Average | Maximum | >0% | >20% | >50% | |

Segmented makespan: | |||||

tight windows | 0 | 45 | 46 | 14 | 0 |

wide windows | 12 | 85 | 79 | 46 | 11 |

Segmented tardiness: | |||||

tight windows | −4 | 37 | 60 | 6 | 0 |

wide windows | 7 | 99 | 62 | 36 | 8 |

Unsegmented: | |||||

makespan | 12 | 64 | 76 | 59 | 8 |

## 12 Conclusion

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 problem 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.