Annals of Operations Research

, Volume 210, Issue 1, pp 245–272

Single-facility scheduling by logic-based Benders decomposition

Authors

  • Elvin Coban
    • Tepper School of BusinessCarnegie Mellon University
    • Tepper School of BusinessCarnegie Mellon University
Article

DOI: 10.1007/s10479-011-1031-z

Cite this article as:
Coban, E. & Hooker, J.N. Ann Oper Res (2013) 210: 245. doi:10.1007/s10479-011-1031-z

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

Logic-based Benders decomposition is based on the concept of an inference dual. Consider an optimization problem
$$\begin{array}{l}\min f(x) \\[3pt]C(x) \\[3pt]x\in D\end{array} $$
(1)
where 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:
$$\begin{array}{l}\max v \\[3pt]C(x) \stackrel{P}{\vdash} (f(x) \geq v)\\[3pt]v\in \mathbb{R}, \quad P\in \mathcal{P}\end{array} $$
(2)
Here \(C(x) \stackrel{P}{\vdash} (f(x) \geq v)\) indicates that proof 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{cxAxb, 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 cxv when the surrogate uAxub dominates cxv; that is, uAc and ubv. The dual therefore maximizes v subject to uAc, ubv, and u≥0. Equivalently, it maximizes ub subject to uAc and u≥0, which is the classical LP dual.

Logic-based Benders decomposition applies to problems of the form
$$\begin{array}{l}\min f(x,y) \\[3pt]C(x,y) \\[3pt]x\in D_x, \quad y\in D_y\end{array} $$
(3)
Fixing x to \(\bar{x}\) defines the subproblem
$$\begin{array}{l}\min f(\bar{x},y) \\[3pt]C(\bar{x},y)\\[3pt]y\in D_y\end{array} $$
(4)
Let proof 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 kth master problem is
$$\begin{array}{l}\min v \\[3pt]v \geq B_{x^i}(x),\quad i=1, \ldots, k-1 \\[3pt]x\in D_x\end{array}$$
(5)
where x1,…,xk−1 are the solutions of the first k−1 master problems. The optimal value vk 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 vk 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
$$\begin{array}{l}\min f(x) + cy \\[3pt]g(x) + Ay \geq b \\[3pt]x\in D_x,\quad y\geq 0\end{array} $$
(6)
The subproblem is an LP:
$$\begin{array}{l}\min f(\bar{x})+cy \\[3pt]Ay\geq b-g(\bar{x}) \\[3pt]y\geq 0\end{array} $$
(7)
whose inference dual is the LP dual. Its solution u defines a surrogate \(uAy\geq u(b-g(\bar{x}))\) that dominates cyv and therefore deduces that \(f(\bar{x})+cy\geq f(\bar{x}) +u(b-g(\bar{x}))\). The same u deduces f(x)+cyf(x)+u(bg(x)) for any x, and we have the classical Benders cut vf(x)+u(bg(x)). When the subproblem is infeasible, the dual has an extreme ray solution u that proves infeasibility because uA≤0 and u(bg(x))>0. The Benders cut is therefore u(bg(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 xj’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 jJ. Then the optimal value of the subproblem is at least v so long as \(x_{j}=\bar{x}_{j}\) for jJ. This yields a nogood cut \(v\geq B_{\bar{x}}(x)\) with
$$B_{\bar{x}}(x) =\left\{ \begin{array}{l@{\quad}l}v^* & \mbox{if $x_{j}=\bar{x}_{j}$ for $j\in J$}\\[6pt]-\infty & \mbox{otherwise}\end{array}\right.$$
If the subproblem is infeasible, then perhaps \(x_{j}=\bar{x}_{j}\) for jJ appear as premises in the proof of infeasibility. A nogood cut states simply that \(x_{j}\neq \bar{x}_{j}\) for some jJ.

Further analysis of the optimality proof may yield analytic Benders cuts that provide useful bounds when \(x_{j}\neq \bar{x}_{j}\) for some jJ. 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

In the unsegmented problem, there are n jobs to be processed, and each job j has release time rj, deadline (or due date) dj, and processing time pj. If we let J={1,…,n}, the problem is to assign each job jJ a start time sj so that time windows are observed:
$$r_j\leq s_j\leq d_j-p_j,\quad j\in J$$
and jobs run consecutively:
$$s_j+p_j\leq s_k \quad \mbox{or} \quad s_k+p_k\leq s_j,\quad \mbox{all $j,k\in J$ with $j\neq k$}$$
We minimize makespan by minimizing maxjJ{sj+pj}. To minimize tardiness, we drop the deadline constraints sjdjpj and minimize
$$\sum_{j\in J} \max\{s_j+p_j-d_j, 0\} $$
(8)
The segmented problem is the same except for the additional constraint that each job must be completed within one segment [ai,ai+1] of the time horizon:
$$a_i\leq s_j\leq a_{i+1}-p_j\quad \mbox{for some $i\in I$, all $j\in J$}$$
Notation is summarized in Table 1.
Table 1

Nomenclature for the segmented problem

Indices

jJ

job

iI

segment of the time horizon

tT

time

Sets

J

set of jobs ({1,2,…,n})

I

set of segments

T

set of discrete times

Tjt

set of discrete times at which job j running at time t can start

Ji

set of jobs assigned to segment i by the master problem

J(t1,t2)

set of jobs whose time windows fall within [t1,t2]

Parameters

rj

release time of job j

dj

deadline (or due date) of job j

pj

processing time of job j

ai

start time of segment i

\(\bar{y}_{ij}\)

solution value of yij in the master problem

\(\tilde{r}_{ij}\)

starting time of the effective time window of job j on segment i

\(\tilde{d}_{ij}\)

ending time of the effective time window of job j on segment i

ϵij

slack of job j on segment i

\(\bar{r}\)

tuple of distinct release times

\(\bar{d}\)

tuple of distinct deadlines

\(M_{i}^{*}\)

minimum makespan of segment i

Variables

sj

start time of job j

zjt

=1 if job j starts at time t

M

makespan over all segments

Mi

makespan of segment i

Tj

tardiness of job j

vj

segment in which job j is processed

yij

=1 if job j is processed in segment i

4.1 MILP formulation

In the discrete-time MILP formulation of the problem, binary variable zjt=1 when job j starts at time t. Let T be the set of discrete times, and assume rj,djT for each j. The unsegmented problem is written
$$\begin{array}{@{\qquad\qquad\qquad\qquad\ \,\,}l@{\qquad\qquad\qquad\qquad\ \,\,}l}\min \mbox{[objective function]} & \mbox{(a)}\\[3pt]{\displaystyle \sum_{t\in T} z_{jt} = 1, \quad j\in J} & \mbox{(b)}\\[12pt]{\displaystyle \sum_{j\in J} \sum_{\bar{t} \in T_{jt}} z_{j\bar{t}} \leq 1, \quad t\in T} & \mbox{(c)} \\[12pt]z_{jt} = 0,\quad \mbox{all}\ t\in T\ \mbox{with}\ t<r_j, \quad j\in J & \mbox{(d)}\\[3pt]z_{jt} = 0, \quad \mbox{all}\ t\in T\ \mbox{with}\ t>d_j-p_j, \quad j\in J & \mbox{(e)}\\[3pt]z_{jt}\in \{0,1\}, \quad j\in J, t \in T & \mbox{(f)}\end{array} $$
where \(T_{jt}=\{\bar{t}\;|\;t-p_{j}+1\leq \bar{t} \leq t\}\). Constraint (b) 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
$$M \geq (t + p_j)z_{jt}, \quad j\in J, \ t\in T $$
The tardiness problem minimizes ∑jJTj subject to (b)–(d), (f), and
$$\begin{array}{l}{\displaystyle T_j \geq \sum_{t\in T} (t + p_j)z_{jt} - d_j, \quad j\in J} \\[12pt]T_j \geq 0, \quad j\in J\end{array}$$
(9)
where Tj is the tardiness of job j.
The segmented problem consists of the above and the additional constraints
$$z_{jt} = 0, \quad \mbox{for } t= a_{i+1}-p_j+1, \ldots, a_{i+1}-1, \ \mbox{all } i\in I,\ j\in J$$
(10)

4.2 CP formulation

In principle, a CP model of the unsegmented problem is quite simple. Again letting sj be the start time of job j, a model is
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ11_HTML.gif
(11a)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ12_HTML.gif
(11b)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ13_HTML.gif
(11c)
where s=(s1,…,sn) and p=(p1,…,pn) in constraint (11c), and where noOverlap is a global constraint that requires the jobs to run sequentially. The makespan problem minimizes maxjJ{sj+pj} 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 vj with domain I that indicates which segment job j is assigned. We then add to (11a)–(11c) the constraints
$$a_{v_j} \leq s_j \leq a_{v_j+1}-p_j, \quad j\in J$$

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 [ai,ai+1] for iI.

5.1 Master problem

The master problem is an MILP formulation in which binary variable yij=1 when job j is assigned to segment i.
$$\begin{array}{l}{\displaystyle \sum_{i\in I} y_{ij} = 1, \quad j\in J} \\[12pt]\mbox{Benders cuts} \\[3pt]\mbox{Relaxation} \\[3pt]y_{ij} \in \{0,1\}, \quad j\in J, \ i\in I\end{array} $$
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 \(\bar{y}_{ij}\) of the master problem, let \(J_{i}=\{j\;|\;\bar{y}_{ij}=1\}\) be the set of jobs it assigns to segment i. The subproblem decomposes into a scheduling problem for each segment:
$$\begin{array}{l}\left.\begin{array}{l}r_j \leq s_j \leq d_j - p_j \\[3pt]a_i \leq s_j \leq a_{i+1}-p_j\end{array}\right\},\quad j\in J_i \\[12pt]\mbox{noOverlap}(s(i,\bar{y}),p(i,\bar{y}))\end{array} $$
where \(s(i,\bar{y})\) is the tuple of variables sj for jJi, 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

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:
$$\sum_{j\in J_i} (1- y_{ij}) \geq 1 $$
This cut is quite weak, however, because it can be satisfied by omitting just one job in Ji 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
$$\sum_{j\in \bar{J}_i} (1-y_{ij}) \geq 1 $$
Unfortunately, standard CP solvers do not provide this kind of dual information. We therefore seek to identify heuristically a smaller set \(\bar{J}_{i}\) that creates infeasibility. A simple heuristic is to remove jobs from Ji 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 Ji (Algorithm 1). This requires repeated solution of each subproblem, but the time required to do so tends to be small in practice.
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Fig1_HTML.gif
Algorithm 1

Strengthening nogood cuts for the feasibility problem

This heuristic may be more effective if jobs less likely to lead to feasibility are removed first. Let the 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
$$\begin{array}{l}\tilde{r}_{ij} = \max\{ \min\{r_j,a_{i+1}\}, a_i \} \\[6pt]\tilde{d}_{ij} = \min\{ \max\{d_j,a_i\}, a_{i+1} \}\end{array}$$
Let the slack of job j on segment i be
$$\epsilon_{ij} = (\tilde{d}_{ij} - \tilde{r}_{ij}) - p_j$$
We can remove the jobs in order of decreasing slack, which means they are indexed so that
$$\epsilon_{i1} \geq \cdots \geq \epsilon_{ik}$$

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.

A simple relaxation in the present case requires that jobs be scheduled so that for every time interval [t1,t2], the set J(t1,t2) of jobs whose time windows fall within [t1,t2] has total processing time at most t2t1. Thus
$$J(t_1,t_2) = \{j\in J \mid t_1\leq r_j, \ d_j\leq t_2 \}$$
It suffices to enumerate, for each segment, distinct intervals of the form [rj,dk] for all j,k with rjdk. So we have the relaxation
$$\sum_{\ell\in J(r_j,d_k)} \hspace{-2ex} p_{\ell}y_{i\ell} \leq \tilde{d}_{ik} - \tilde{r}_{ij}, \quad \mbox{all $i\in I$ and all distinct $[r_{j},d_{k}]$}$$
Algorithm 2 generates a relaxation with fewer redundant constraints. Note that it fixes yij=0 when job j’s time window does not overlap segment i.
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Fig2_HTML.gif
Algorithm 2

Generating a relaxation for the segmented feasibility problem

6 Unsegmented feasibility problem

We now suppose that the jobs are not required to fit inside segments of the time horizon. We create segments [ai,ai+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

Let continuous variable xij indicate the amount of time that job j processes during segment i. Then
$$\begin{array}{l}{\displaystyle \sum_{i\in I} x_{ij} = p_j,\quad j\in J} \\[12pt]x_{ij}\geq 0, \quad i\in I,\ j\in J\end{array} $$
(12)
The assignment of jobs (or portions of jobs) to segments is governed by several binary variables as introduced in Table 2.
Table 2

Additional nomenclature for the unsegmented problem

Sets

Ji0

set of jobs that are fully processed in segment i

Parameters

\(\bar{x}_{ij}\)

solution value of xij in the master problem

\(\bar{y}_{ij}\)

solution value of yij in the master problem

\(\bar{y}_{ijk}\)

solution value of yijk in the master problem, for k∈{0,1,2,3}

\(\bar{a}_{i}\)

updated start time of the segment i

Variables

xij

amount of time job j is processed during segment i

yij

=1 if at least a portion of job j is processed in segment i

yij0

=1 if all of job j is processed in segment i

yij1

=1 if a portion of job j is processed at the start of segment i

yij2

=1 if a portion of job j is processed at the end of segment i

yij3

=1 if a portion of job j is processed throughout segment i

αi

=1 if \(x_{ij} \leq \bar{x}_{ij}\) and segment i begins while job j is in process

βi

=1 if \(x_{ij} \leq \bar{x}_{ij}\) and segment i ends while job j is in process

γi

=1 if \(x_{ij_{1}}+x_{ij_{2}} \leq x_{i}^{*}\) and segment i begins while job j1 is in process and ends while job j2 is in process

We have the constraints
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ15_HTML.gif
(13a)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ16_HTML.gif
(13b)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ17_HTML.gif
(13c)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ18_HTML.gif
(13d)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ19_HTML.gif
(13e)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ20_HTML.gif
(13f)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ21_HTML.gif
(13g)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ22_HTML.gif
(13h)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ23_HTML.gif
(13i)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ24_HTML.gif
(13j)
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equ25_HTML.gif
(13k)
Constraint (13a) ensures that every job is assigned to at least one segment. Constraints (13b) define yij. 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 xij with the binary variables, note that we have the following disjunction for each i,j:
$$\left(\begin{array}{@{}c@{}}y_{ij}=0 \\x_{ij}=0\end{array}\right) \vee \left(\begin{array}{@{}c@{}}y_{ij0}=1 \\x_{ij} = p_j\end{array}\right) \vee \left(\begin{array}{@{}c@{}}y_{ij1}=1 \\x_{ij} \leq p_j\end{array}\right) \vee \left(\begin{array}{@{}c@{}}y_{ij2}=1 \\x_{ij} \leq p_j\end{array}\right) \vee \left(\begin{array}{@{}c@{}}y_{ij3}=1 \\x_{ij} = a_{i+1}-a_i\end{array}\right)$$
Using the standard convex hull formulation of a disjunction of linear systems (Jeroslow 1987), this becomes:
$$\begin{array}{l}x_{ij1} \leq p_jy_{ij1}, \quad x_{ij2} \leq p_jy_{ij2} \\[6pt]x_{ij} = p_jy_{ij0}+x_{ij1}+x_{ij2}+ (a_{i+1}-a_i)y_{ij3}\\[6pt]x_{ij1}, x_{ij2}\geq 0\end{array} $$
(14)
The master problem consists of (12)–(13a13k), (14) for all iI and jJ, 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 \(\bar{y}_{ij},\bar{y}_{ij0},\bar{y}_{ij1},\bar{y}_{ij2},\bar{x}_{ij}\) for all i,j. Define
$$\begin{array}{l}J_i = \{j\mid\bar{y}_{ij}=1\} \\[6pt]J_{i0} = \{j\mid \bar{y}_{ij0}=1\}\end{array}$$
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
$$\begin{array}{l}\left.\begin{array}{l}r_j \leq s_j \leq d_j - p_j \\[6pt]\bar{a}_i \leq s_j \leq \bar{a}_{i+1}-p_j\end{array}\right\},\quad j\in J_{i0} \\[12pt]\mbox{noOverlap}(s(i,\bar{y}_0),p(i,\bar{y}_0))\end{array} $$
(15)
where
$$\begin{array}{l}{\displaystyle \bar{a}_i = \left\{\begin{array}{l@{\quad}l}a_i + \bar{x}_{ij_1}, & \mbox{if $\bar{y}_{ij_{1}1}=1$ for some $j_{1}\in J$} \\[6pt]a_i, & \mbox{otherwise}\end{array}\right.} \\[12pt]{\displaystyle \bar{a}_{i+1} = \left\{\begin{array}{l@{\quad}l}a_{i+1} - \bar{x}_{ij_2}, & \mbox{if $\bar{y}_{ij_{2}2}=1$ for some $j_{2}\in J$} \\[6pt]a_{i+1}, & \mbox{otherwise}\end{array}\right.}\end{array}$$
Also \(s(i,\bar{y}_{0})\) is the tuple of variables sj for jJi0, and similarly for \(p(i,\bar{y}_{0})\). Note that if a portion of some job j3 spans the entire segment (\(\bar{y}_{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.
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Fig3_HTML.gif
Algorithm 3

Generating a relaxation for the unsegmented feasibility problem

6.2 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
    $$\sum_{j\in J_{i0}} (1-y_{ij0}) \geq 1 $$
    (16)
    This can be strengthened as in the segmented problem by removing some jobs that are not necessary for infeasibility (Algorithm 1 with Ji0 replacing Ji).
  • Case 2. There is a partial job only at the start of the segment (say, job j1). 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}\).
    • 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}}^{*}<\bar{x}_{ij_{1}}\), because otherwise segment i would be feasible.
    • Case 2b. \(x_{ij_{1}}^{*}=0\). Here, job j1 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 cut
      $$\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)
      The cut can be strengthened by removing jobs in Ji0 until \(x^{*}_{ij_{1}}\geq \bar{x}_{ij_{1}}\) (Algorithm 4).
      https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Fig4_HTML.gif
      Algorithm 4

      Strengthening nogood cuts for the unsegmented feasibility problem

  • Case 3. There is a partial job only at the end of the segment (say, job j2). 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 cut
      $$\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)
      The cut can be strengthened by removing jobs in Ji0 until \(x_{ij_{2}}^{*} \geq \bar{x}_{ij_{2}}\).
  • Case 4. There are two partial jobs in the segment, namely j1 at the start and j2 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 4b. The modified subproblem is feasible but \(x_{i}^{*}=0\). Then j1 and j2 must be removed as the first and last jobs if the other jobs are completely processed, and we have the Benders cuts
      https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equv_HTML.gif
    • 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) j1 or j2 must be removed as the first or last job if the other jobs are completely processed:
      https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equw_HTML.gif
      This cut can be strengthened by removing jobs from Ji0 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

The master problem for segmented makespan problem is
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equx_HTML.gif
Given a solution \(\bar{y}_{ij}\) of the master problem, the subproblem decomposes into a minimum makespan problem for each segment i. It minimizes Mi subject to Sect. 5.1 and
$$M_i\geq s_j + p_j, \quad \mbox{all $j\in J$ with $\bar{y}_{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 ai. 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.
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 rj:
$$M\geq \tilde{r}_{ij} + \hspace{-2ex} \sum_{\ell\in J(r_j,\infty)}x_{i\ell}, \quad i\in I,\ j\in J$$
Algorithm 5 generates a relaxation with fewer redundant constraints.
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Fig5_HTML.gif
Algorithm 5

Generating a relaxation for the makespan problem

7.2 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
$$M \geq M_i^*\biggl(1 - \sum_{j\in J_i} (1-y_{ij})\biggr)$$
This says that the makespan for subproblem i cannot be less than \(M_{i}^{*}\) unless at least one job is removed from Ji. The cut can be strengthened to
$$M \geq M_i^*\biggl(1 - \sum_{j\in \bar{J}_i} (1-y_{ij})\biggr) $$
(19)
where \(\bar{J}_{i}\subset J_{i}\) is a smaller set of jobs that results in the same minimum makespan \(M_{i}^{*}\). A simple heuristic for computing \(\bar{J}_{i}\) appears as Algorithm 6. The jobs can be removed in order of increasing \(\tilde{r}_{ij}+p_{j}\), and we therefore index the jobs in Ji so that
$$\tilde{r}_{i1} + p_1 \leq \cdots \leq \tilde{r}_{ik} + p_k$$
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Fig6_HTML.gif
Algorithm 6

Strengthening nogood cuts for the makespan problem

Another way to obtain additional cuts is to use a two-tiered bound. Let Mi(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 Zi be the set of jobs that can be removed, one at a time, without affecting makespan, so that
$$Z_i = \{j\in J_i \mid M_i(J_i\setminus \{j\}) = M_i^* \}$$
Then for each i we have the cut
$$M \geq M_i(J_i\setminus Z_i) \biggl( 1 - \sum_{j\in J_i\setminus Z_i} (1-y_{ij})\biggr)$$
in addition to (19). This cut is redundant and should be deleted when \(M_{i}(J_{i}\setminus Z_{i})=M_{i}^{*}\).

7.3 Analytic Benders cuts

The reasoning we use to obtain analytic Benders cuts is similar to that used in Hooker (2007b). Let Pi 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 Ji 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
$$M_i^* - \hat{M}_i \leq p_S + \max_{j\in J_i'} \{\tilde{d}_{ij}\} - \min_{j\in J_i'} \{\tilde{d}_{ij} \} $$
(20)
where pS=∑jSpj.
Consider any optimal solution of \(\hat{P}_{i}\) and extend it to a solution s of Pi 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 Pi, 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
$$\hat{M}_i + p_S + \max_{j\in J_i'} \{d_j\} - \min_{j\in J_i'} \{d_j\} > \max_{j\in J_i'} \{d_j\} $$
(21)
Because \(M_{i}^{*}\leq \max_{j\in J_{i}'} \{d_{j}\}\), (21) implies (20).
Thus if the jobs in \(S\subset J_{i}'\) are removed from segment 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
$$M \geq M_i^* -\biggl(\sum_{j\in J_i'} p_j(1-y_{ij}) + \max_{j\in J_i'} \{d_j\} - \min_{j\in J_i'} \{d_j\}\biggr) - M_i^*\sum_{j\in J_i''} (1-y_{ij}) $$
(22)
when one or more jobs are removed from segment i, and \(M\geq M_{i}^{*}\) otherwise, provided yij=1 for at least one jJi. The second summation in (22) takes care of the case where one or more jobs in \(J_{i}''\) are removed. If yij=0 for all jJi, the cut is simply M≥0.
We can linearize this cut by writing the following for each i:
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equae_HTML.gif
where binary variable qi=1 when yij=0 for all jJi. The cut can be strengthened by replacing Ji, \(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

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 Mi subject to (15) and
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equaf_HTML.gif
The relaxation is the same as for the segmented makespan problem.

8.1 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 \;|\;\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 cut
    $$M \geq M^*_i\biggl(1 - \sum_{j\in J_i} (1-y_{ij0})\biggr)$$
    This cut can be strengthened as in the segmented problem. We also have the cut
    $$M \geq M_i(J_i\setminus Z_i) \biggl( 1 - \sum_{j\in J_i\setminus Z_i} (1-y_{ij0})\biggr)$$
    where Zi is computed as before.
  • Case 2. A partial job j2 is assigned to the end of the segment. In this case the minimum makespan on the segment is \(M_{i}^{*}=a_{i+1}\) unless j2 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 j1 at the start. The nogood cut is
    $$M \geq M^*_i\biggl(1 - (1-y_{ij_11}) - \sum_{j\in J_{i0}} (1-y_{ij0})\biggr)$$
    which can be strengthened by heuristically removing jobs from Ji0.

8.2 Analytic Benders cuts

To analyze the subproblem more deeply we partition Ji0 as follows:
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equaj_HTML.gif
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:
    https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equak_HTML.gif
    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 j1 at the start of the segment. We will investigate the effect on makespan of reducing job j1’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 jJi starts at its release time in the optimal solution s of the subproblem on segment i. That is, \(s_{j}^{*}=r_{j}\) for some jJi0. Let k be the first such job. We may assume that j1 and all jobs between j1 and k are scheduled contiguously in s (i.e., there is no idle time between them). Now suppose the jobs between j1 and k are scheduled δ earlier, and δ is increased to the value δ at which one of these jobs hits its release time. Thus
      $$\delta^* = \min_{j\in J_{i0}} \bigl\{s_j^* - \tilde{r}_{ij} \mid s_j^* < s_k\bigr\}$$
      This increases by δ 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 j1’s processing time is reduced by δ, assuming no jobs are removed from segment i.
      To write the corresponding Benders cut, let pmin be the processing time of the shortest job that can be moved into the gap Δi+δ. Thus
      $$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\}$$
      Then the minimum makespan remains \(M_{i}^{*}\) if pmini+δ (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
      https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equan_HTML.gif
      where ϵ>0 is a small number. When ηi=1, this cut is of no value, but a simpler cut becomes useful:
      $$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})$$
      It says that the jobs after j1 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 jJi0. 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 Ji0 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 that
      $$\delta_0 = \min_{j\in J_{i0}} \{s^*(0)-\tilde{r}_{ij}\}$$
      Now define
      $$\delta_k = \delta_{k-1} + \min_{i\in J_{i0}} \{s^*(\delta_{k-1}) - \tilde{r}_{ij}\}$$
      and let k be the smallest k for which \(M_{i}^{*}(\delta_{k} +\epsilon)=M_{i}^{*}(\delta)\). Then we generate the Benders cut
      https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equar_HTML.gif
      where λi∈{0,1}. This cut is useless when λi=1, but the following cut is helpful in this case:
      $$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})$$
      After generating these cuts, we move to Case 3a.

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

The master problem for the segmented tardiness problem is
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equat_HTML.gif
Given a solution \(\bar{y}_{ij}\) of the master problem, the subproblem for each segment i is:
$$\begin{array}{l}{\displaystyle \min \sum_{j\in J_i} \max\{s_j + p_j - d_j,0\}} \\[12pt]\left.\begin{array}{l}r_j \leq s_j \\[6pt]a_i \leq s_j \leq a_{i+1}-p_j\end{array}\right\} \quad j\in J_i \\[12pt]\mbox{noOverlap}(s(i,\bar{y}),p(i,\bar{y}))\end{array}$$
(24)
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 ai+1 of the segments. We have the relaxation
$$\sum_{\ell\in J(r_j,\infty)} p_{\ell}y_{i\ell} \leq a_{i+1} - \tilde{r}_{ij},\quad i\in I, \ j\in J$$
Algorithm 7 generates a relaxation with fewer redundant constraints.
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Fig7_HTML.gif
Algorithm 7

Generating a relaxation for the tardiness problem

We also use a bound on tardiness that is developed in Hooker (2007b).
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Equav_HTML.gif
Here Hij={1,…,j}∖(J(0,ai)∪J(ai+1,∞)) is the set of jobs with time windows that overlap segment i. The jobs are indexed so that d1≤⋯≤dn, and π is a permutation of the indices for which pπ(1)≤⋯≤pπ(n).

9.2 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
$$T_i \geq T_i^*\biggl(1 - \sum_{j\in \bar{J}_i} (1-y_{ij})\biggr) $$
(25)
where \(\bar{J}_{i}\subset J_{i}\) is a smaller set of jobs that result in the same minimum tardiness \(T_{i}^{*}\). A simple heuristic for computing \(\bar{J}_{i}\) appears as Algorithm 8. The jobs can be removed in order of decreasing tightness ϵij, but note that ϵij can be negative.
https://static-content.springer.com/image/art%3A10.1007%2Fs10479-011-1031-z/MediaObjects/10479_2011_1031_Fig8_HTML.gif
Algorithm 8

Strengthening nogood cuts for the tardiness problem

Another way to strengthen the cuts is to use a two-tiered bound similar to the makespan case. Let Ti(J) be the minimum makespan that results when jobs in J are assigned to segment i. If we define
$$Z_i = \{j\in J_i \mid T_i(J_i\setminus \{j\}) = T_i^* \}$$
then we have the cut
$$T_i \geq T_i(J_i\setminus Z_i) \biggl( 1 - \sum_{j\in J_i\setminus Z_i} (1-y_{ij})\biggr)$$
in addition to (25). This cut is redundant and should be deleted when \(T_{i}(J_{i}\setminus Z_{i})=T_{i}^{*}\).

9.3 Analytic Benders cuts

Let Pi be the subproblem on a segment i with a feasible schedule, and let \(T_{i}^{*}\) be the minimum tardiness of Pi. 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 SJi are removed from Pi. 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
$$r^{\max}_i=\max\{\max\{r_j\mid j\in J_i\},a_i\}$$
be the last release time of the jobs in Ji, or ai, whichever is larger. Because Pi is feasible, we know \(r^{\max}_{i}\leq a_{i+1}\).
Let \(\hat{M}_{i}\) be the makespan of an optimal solution of \(\hat{P}_{i}\). We construct a solution Fi of Pi 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 Fi is at most
$$r^{\max}_i+\sum_{\ell\in J_i} p_{\ell} $$
because in the worst case, all the jobs in the optimal solution of \(\hat{P}_{i}\) are scheduled after \(r^{\max}_{i}\). The tardiness incurred in Fi by each job jS is therefore at most
$$\biggl( r^{\max}_i + \sum_{\ell\in J_i} p_{\ell} - d_j \biggr)^+$$
where (α)+=max{α,0}. Thus the total tardiness of Fi is at most
$$\hat{T}_i + \sum_{j\in S} \biggl( r^{\max}_i + \sum_{\ell\in J_i} p_{\ell} - d_j \biggr)^+ $$
(26)
Fi is feasible if all the jobs finish before ai+1. So we know Fi is feasible if
$$r^{\max}_i + \sum_{\ell \in J_i} p_{\ell} \leq a_{i+1} $$
(27)
In this case, the tardiness (26) is an upper bound on \(T_{i}^{*}\), and we have
$$\hat{T}_i \geq T_i^* - \sum_{j\in S} \biggl( r^{\max}_i + \sum_{\ell\in J_i} p_{\ell} - d_j \biggr)^+$$
This leads to the Benders cut
$$\hat{T}_i \geq \left\{\begin{array}{l@{\quad}l}{\displaystyle T_i^* - \sum_{j\in J_i} \biggl(r_i^{\max} + \sum_{\ell \in J_i} p_{\ell} - d_j\biggr)^+ \hspace{-1ex} (1-y_{ij}),}& \mbox{if (27) holds} \\[12pt]{\displaystyle T_i^*\biggl(1-\sum_{j\in J_i} (1-y_{ij})\biggr),} & \mbox{otherwise}\end{array}\right. $$

10 Problem generation

We generated random instances by selecting parameters uniformly from intervals as follows:
$$\begin{array}{l}r_j \in [0,\alpha R] \\[6pt]d_j-r_j \in [\gamma_1 \alpha R, \gamma_2 \alpha R] \\[6pt]p_j \in [0,\beta(d_j-r_j)]\end{array}$$
where 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.
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.
Table 3

Parameters for generation of problem instances

 

Segmented problems

Unsegmented

Feasibility

Makespan

Tardiness

Feas. & Makespan

α

0.5

γ1

0.5 for tight windows

0.25

0.25 for wide windows

γ2

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.

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 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 4

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

181a

45

2.7

420a

147

11

63a

471a

20

100

199a

58

4.3

600a

600

17

547a

177a

11

120

272a

137

4.8

600a

600

39

600a

217a

2.9

140

306a

260a

6.8

600a

432a,b

33

600a

373a

5.0

160

314a

301a

8.0

600a

359a

14

   

180

600a

350a,b

4.8

600a

557a,b

5.3

   

200

600a

b

5.8

600a

600a,b

6.6

   

aSolution terminated at 600 seconds for some or all instances

bMILP solver ran out of memory for some or all instances, which are omitted from the average solution time

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

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

180a

59

9.0

1.5

94

3.7

100

0.14

37

3.8

360a

403a

14

79a

594a

85a

120

0.13

61

5.0

540a

600a

25

600a

251a

183a

140

61a

175

7.0

600a

600a

107

600a

160a

4.3

160

540a

216a

4.8

600a

562a

157

   

180

600a

375a,b

4.5

600a

535a

10

   

200

600a

b

5.5

600a

560a

6.9

   

aSolution terminated at 600 seconds for some or all instances

bMILP solver ran out of memory for some or all instances, which are omitted from the average solution time

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

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

376a

8.7

100

0.25

35

7.0

1.1

600a

21

120

0.43

57

23

0.4

600a

93

140

0.72

97

65

1.2

600a

115

160

420a

188

9.0

241a

549a

67

180

123a

307a

79

61a

600a

168

200

180a

410a

29

180a

587a

21

aSolution terminated at 600 seconds for some or all instances

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.

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

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

−4a

37

60

6

0

 wide windows

7

99

62

36

8

Unsegmented:

 makespan

12

64

76

59

8

aReflects three very negative outliers

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.

Copyright information

© Springer Science+Business Media, LLC 2011