Computational Evaluation of Cut-Strengthening Techniques in Logic-Based Benders’ Decomposition

Cut-strengthening techniques have a significant impact on the computational effectiveness of the logic-based Benders’ decomposition (LBBD) scheme. While there have been numerous cut-strengthening techniques proposed, very little is understood about which techniques achieve the best computational performance for the LBBD scheme. This is typically due to implementations of LBBD being problem specific, and thus, no systematic study of cut-strengthening techniques for both feasibility and optimality cuts has been performed. This paper aims to provide guidance for future researchers with the presentation of an extensive computational study of five cut-strengthening techniques that are applied to three different problem types. The computational study involving 3000 problem instances shows that cut-strengthening techniques that generate irreducible cuts outperform the greedy algorithm and the use of no cut strengthening. It is shown that cut strengthening is a necessary part of the LBBD scheme, and depth-first binary search and deletion filter are the most effective cut-strengthening techniques.


Introduction
Logic-based Benders' decomposition (LBBD) is a generalisation of classical Benders' decomposition. Removing the requirement of linear programming subproblems in classical Benders' decomposition, LBBD extends this popular mathematical programming approach to be applied to problems where the subproblem is an optimisation problem of any form. First proposed by Hooker and Ottosson [1], LBBD handles this generalisation by making use of logical deductions from subproblem solutions to generate Benders' cuts. This is particularly useful when integrating mathematical optimisation and constraint programming. Logical deductions from solving a constraint program can be used to generate cuts in the form of no-good inequalities for addition to a mathematical optimisation problem. While no-good inequalities are general in their application, they are typically weak-causing slow convergence of the LBBD scheme. Numerous cut-strengthening techniques have been proposed to address this limitation of the LBBD scheme. However, no systematic investigation into the effectiveness of cut-strengthening techniques of both feasibility and optimality no-good Benders' cuts has previously been performed.
The computational effectiveness of the LBBD is strongly dependent on the cuts generated during the search procedure. The number of cuts and their quality has an impact on the solution times for the master problem and the number of LBBD iterations [2]. Numerous works have shown that the use of cut-strengthening techniques significantly improves the computational effectiveness of the LBBD scheme. A systematic analysis performed by Karlsson and Rönnberg [3]-covering a selection of cut-strengthening techniques and application areas-highlighted the computational benefits to the LBBD scheme when applying cut strengthening to feasibility cuts. An important result from Karlsson and Rönnberg [3] is that there is no single best technique for all problem types. However, the greedy cut-strengthening approach was typically outperformed by most of the other considered techniques.
This paper aims to act as a guide for future researchers applying LBBD and cut-strengthening techniques. To this end, the main contributions are as follows: • An indepth discussion and evaluation of cut-strengthening techniques applied to both feasibility and optimality cuts. • An investigation into the computational effectiveness of five cut-strengthening techniques commonly used to enhance the LBBD scheme. In particular, the greedy algorithm, deletion filter, additive method, additive/deletion filter, and the depth-first binary search will be evaluated. • Detailed computational experiments covering three different problem typescumulative facility scheduling with fixed costs, single-facility scheduling with a segmented timeline, and vehicle routing with location congestion-will provide a broad overview of the cut-strengthening techniques. • The first systematic investigation into how the efficacy of cut-strengthening techniques is strongly correlated to the problem type. • The code related to the LBBD schemes for each of the problem types and the cut-strengthening techniques is freely available.
This paper is structured as follows: An overview of the literature related to the strengthening of feasibility and optimality cuts in LBBD will be presented in Sect. 2. Section 3 presents a brief introduction to LBBD and describes the cut-strengthening techniques investigated and evaluated in this paper. The problem types under investigation will be presented in Sect. 4. In addition to no-good optimality cuts, analytic Benders' cuts are also generated for the considered problem types. A brief derivation of the analytic Benders cuts is presented in Sect. 5. The main contributions of this paper are the results from computational experiments. Section 6 demonstrates the effectiveness of the cut-strengthening techniques by evaluating the solution run times and the average size of the generated cuts. Finally, concluding comments are given in Sect. 7.

Literature Background
Cut strengthening is one of the most common acceleration techniques for Benderslike algorithms [4]. The benefit of applying cut strengthening in an LBBD scheme has been demonstrated in Karlsson and Rönnberg [3,5], Lam et al. [6], Lindh et al. [7], Hooker [8,9], Riedler and Raidl [10], Benini et al. [11], and Sadykov [12]. The literature shows that applying cut strengthening reduces the computational time of the solution process. Both feasibility and optimality cuts can be generated in an LBBD scheme. Strengthening feasibility cuts in the context of LBBD can be described as finding a subset of master variables that cause infeasibility of the subproblem in the current solution. Strengthening optimality cuts within LBBD means finding a subset of variables that contribute to the optimal value of the subproblem.
A greedy approach to strengthen feasibility cuts is used by Hooker [9], Benini et al. [11], and Coban and Hooker [13]. Hooker [9] solves a cumulative facility scheduling problem, where the master problem assigns jobs to facilities and the subproblem schedules them. A single-facility scheduling problem with a segmented timeline is solved in Coban and Hooker [13], where the master problem assigns jobs to time segments and the subproblem schedules them. Our paper evaluates the greedy algorithm, solving both problems from Coban and Hooker [13] and Hooker [9] for different objective types. While fast and easy to implement, our computational experiments will show that the greedy approach is often outperformed by other cut-strengthening techniques.
Riedler and Raidl [10] and Lam et al. [6] apply a cut-strengthening algorithm that has the same structure as a deletion filter. Riedler and Raidl [10] solve a selective dial-a-ride problem and suggest using the cut-strengthening algorithm twice, the second time in reverse order, in an effort to increase chances of obtaining a strengthened feasibility cut of smaller cardinality. Lam et al. [6] present results from applying the deletion filter algorithm to strengthen feasibility cuts to a range of problems, including planning and scheduling, vehicle routing with location congestion, and facility location. The vehicle routing with location congestion problem is used for the computational study in this paper, where we show that deletion filter is one of the best-performing techniques.
Lindh et al. [7] apply cut strengthening in their LBBD scheme to solve a short-term scheduling problem for a cut-and-fill mine. The paper presents two algorithms for finding irreducible feasibility cuts and both of them rely on first using a greedy strategy for finding a strengthened cut, and thereafter applying a deletion filter to obtain an irreducible cut. In the first algorithm, the greedy strategy is inspired by an additive/deletion filter. In the second algorithm, the greedy strategy is problem-specific and designed to quickly find a rather strong cut that can then be further strengthened. Karlsson and Rönnberg [5] use the depth-first binary search (DFBS) to strengthen feasibility cuts. The authors propose a new acceleration technique for an LBBD scheme to solve an avionic scheduling problem. The acceleration technique extends the use of DFBS to aid the heuristic search for feasible solutions. The output of the cut-strengthening technique is an irreducible cut containing the variables that cause infeasibility. This information is used to select the subsets of variables that were not included in the strengthened cut and can be part of a feasible solution. Our computational evaluation demonstrates that the DFBS algorithm is one of the best-performing cut-strengthening algorithms.
Cambazard et al. [14] use the iterative conflict detection algorithm QuickXplain [15] to strengthen feasibility cuts. QuickXplain first identifies an irreducible set of constraints, from which the set of variables needed to form a no-good cut is extracted. QuickXplain has limited use when the infeasibility of the subproblem is caused by a global constraint. If a global constraint is in the obtained irreducible set of the constraints, all variables connected to a global constraint are included in the no-good cut, making the strengthened cut less effective.
Sadykov [12] proposes a branch-and-bound-type algorithm to strengthen nogood cuts. The proposed algorithm is a modified version of the Carlier algorithm [16]. The algorithm is implemented within a hybrid branch-and-check [17] scheme to solve a scheduling problem to minimise the weighted number of late jobs on a single machine. The limitation of the modified Carlier algorithm is that the feasibility checks used by the algorithm are only valid for the singlemachine scheduling problem. Our study is focused on general cut-strengthening techniques, therefore the modified Carlier algorithm is not within the scope of this paper.
In the conference paper [3], Karlsson and Rönnberg evaluate various cutstrengthening techniques on feasibility cuts within an LBBD scheme. The authors provide computational results based on three different problem formulations, including cumulative facility scheduling with fixed costs, single machine scheduling with sequence-dependent setup times and multiple time windows, and vehicle routing with location congestion. The DFBS, deletion filter, and the greedy algorithms are evaluated. The computational results, based on over 2000 instances, show that applying the DFBS algorithm and the deletion filter algorithm achieves the best computational time for the chosen applications. Our paper extends the contribution in Karlsson and Rönnberg [3] by including the strengthening of optimality cuts and considering additional problem formulations.

Logic-Based Benders' Scheme and Cut Strengthening
The cut-strengthening techniques evaluated in this paper can be applied to a variety of LBBD schemes. To facilitate the general discussion of cut-strengthening techniques, we present a generic problem formulation and decision scheme. Furthermore, this formulation will be used in the mathematical description of applications, highlighting the general nature of the evaluated approaches.

Logic-Based Benders' Decomposition
LBBD can be applied to problems of the form The feasible set of the problem is given by constraint sets A(x), H(y), and C(x, y) and the domains of the variables x and y, given by D x and D y , respectively. An important characteristic of problem (1) is that upon fixing the values of x, the remaining problem, which is only with respect to y, becomes 'easy' to solve. The resulting problem, denoted by [SP(x) ], is termed the subproblem, where x is a fixed solution for x.
The subproblem takes the form To obtain a bound on f (x, y) an inference dual of the subproblem is defined and solved. The inference dual is the problem of obtaining the tightest possible lower bound on f (x, y) from C(x, y), H(y) , and D y : where A P ⟹ B means that proof P deduces B from A, and P is a family of proofs. The solution of the dual is a proof P, that gives the tightest possible bound v on f(x, y) when x =x ; for details, see Hooker [9]. Since there are no restrictions on the (1) type of the constraints C(x, y) and H(y), and the function f(x, y), the inference dual can be obtained for any kind of optimisation problem. When the function f(x, y) is restricted to depend only on the variables x, the objective function f (x, y) of the subproblem [SP(x )] becomes a constant, making the subproblem a feasibility problem. When function f(x, y) depends on both variables x and y, the subproblem is an optimisation problem.
A lower bound on f(x, y) can be provided by a bounding function B̄x(x) , that is defined using a proof P. The main idea of LBBD is to apply the reasoning used for obtaining the value v to deduce the bounding function B̄x(x) on f(x, y) for any values of x. The subscript x indicates the solution used to obtain the bounding function. The bounding function B̄x(x) has two properties [9]: (1).
It is convenient to regard v as an infinite value if the subproblem [SP(x) ] is infeasible. Using this assumption, a strong duality property holds for the dual: the optimal value of the subproblem is always equal to the optimal value of its inference dual [1].

Solution Procedure
The solution procedure iterates between solving the master problem and the subproblem. The master problem is solved to obtain trial values of x, and the subproblem is solved to give feedback in the form of cuts. Let z * and v k be the optimal objective values of the master problem and the subproblem, respectively, in iteration k. In any iteration of the solution procedure, z * provides a lower bound on the objective value of (1), and v = min{v 1 , ...,v k−1 } provides an upper bound. The value of z * increases monotonically for each iteration, while values v k can increase or decrease. The algorithm repeats until z * is equal to v.
The master problem in iteration k of the solution procedure is where relaxations of constraints present in the subproblems, but also auxiliary variables and constraints.

Problem Structure
The cut-strengthening techniques investigated in this paper assume a problem structure where (i) the master problem variables are binary and (ii) only the variable values x j = 1 , j ∈ J = {j|x j = 1} enforce constraints C(x, y) on variables y. Constraints C(x, y) then take the form meaning that a value x j = 1 enforces constraints C j (y) on variables y. When the value of an x j is changed to 0, constraints C j (y) no longer restrict variables y. This allows to obtain a relaxation of the subproblem by changing the value of an x j to 0. Therefore, the constraints facilitate cut-strengthening techniques based on the evaluation of subproblem relaxations obtained by iteratively changing variable values x j = 1 , j ∈ J = {j|x j = 1} to x j = 0 . When constraints C j (y) are connected through master variables only, the subproblem can be separated.
To simplify notation, we use the objective function formulation given by The formulation allows to separate the objective functions of the master problem and the subproblem.

Cut Generation
Let x k be the master problem solution in iteration k. Based on the subproblem solution, Benders' cuts are generated for both infeasible and feasible subproblems. If the subproblem is infeasible, the assignment x k is eliminated by the following disjunction: This disjunction can be formulated as a Benders' feasibility cut in the form of a linear inequality, also commonly referred to as a no-good cut where J(x k ) is a subset of J , such that J(x k ) = {j ∈ J|x k j = 1}. If the subproblem has an optimal solution, the optimality cuts, referred to as value cuts, can also be formulated analogous to no-good cuts. Let v * = h(x k ) + v(y * ) , be the optimal value of the subproblem in iteration k, where y * is the optimal solution to the subproblem for x k . Then, a value cut z ≥ B x k (x) must bound f(x, y) for any solution x by the value B x k (x k ) = v * . The no-good formulation of this cut is given by The right-hand side of the inequality (3) is a bounding function B x k (x) . The function B x k (x) satisfies Property 1 because for any feasible solution (x, y), it provides a valid lower bound on f(x, y) [1,9]. The lower bound is valid only because the optimal solution f(x, y) is positive. The function B x k (x) satisfies Property 2 because B x k (x k ) = v * . Any feasible solution (x, y) of the problem then satisfies f (x, y) ≥ B x k (x) . The inequality (3) provides the tightest bound when all the values of x j for j ∈ J(x k ) are equal to 1.

Subproblem Separation
Subproblem separation is a common strategy used to accelerate the LBBD scheme. Separation is possible when problem exhibits a bordered block diagonal structure, such that the master variables define the border. Fixing variables x to trial values makes blocks separable. The subproblem [SP(x k )] then decouples into a separate problem [SP i (x k ) ] for each such block i: Solving subproblem i generates cuts that only include variables from J i . It has been highlighted in Karlsson and Rönnberg [3] and Ciré et al. [2] that separating the subproblem significantly improves the runtime of the LBBD scheme. Not all of the problems considered in this study are separable.

Cut-Strengthening Techniques
The cut-strengthening algorithms presented in this section attempt to strengthen feasibility and optimality cuts by reducing the number of variables included in the corresponding constraint. The main idea behind all of the algorithms is to find a subset of J(x) , denoted by J(x) , where the corresponding variables induce a subproblem with an optimal objective equal to v . The set J(x) is identified by systematically solving subproblem [SP(x )] with trial values corresponding to different subsets of J(x) . Different trial values lead to different relaxations of subproblem [SP(x)]. The problem structure described in Sect. 3.1 allows to obtain a relaxation of the subproblem by changing trial values of decision variables to 0. The choice of trial values depends on the cut-strengthening algorithm.
Cut-strengthening techniques can be divided into two groups by the types of the cuts that they provide, irreducible or not. The cuts are categorised using the following definition [3].
has an optimal value v , such that v =v , and if for each x such that J(x) ⊂ J(x) , it holds that [SP(x) ] has an optimal value ṽ <v.
Note that there can be multiple sets J(x) meeting the irreducibility criteria, and the sets often share overlapping subsets J(x) . Hence, an irreducible cut does not need to be of smallest cardinality, and it is typically possible to derive more than one irreducible cut from a single master problem solution.
In the following, we present the greedy algorithm, deletion filter, additive method, additive/deletion filter, and the DFBS cut-strengthening algorithms. The deletion filter, additive method, additive/deletion filter, and the DFBS algorithm will ensure that the strengthened cut is irreducible, while the greedy algorithm will not. The cut-strengthening algorithms are described for the strengthening of value cuts. The same search principle can be applied to strengthening feasibility cuts. The special case of feasibility cuts is treated in Karlsson and Rönnberg [3].
Note that most cut-strengthening algorithms can be tailored to a specific problem by specifying the order in which the variables (x j ) j∈J(x) get selected to form subsets. To maintain generality in our comparison, we do not exploit this possibility and rely on using a random order.

Greedy Algorithm
The greedy algorithm searches for a subset of variables by evaluating a single index at a time until the objective value of the relaxed subproblem becomes less than v , and the search stops. An index j ∈ J(x) is selected in each iteration, and the assignment x j = 0 is made, for the indices that have not been selected the assignments remain equal to 1. The subproblem is then solved. If the optimal objective value of the relaxed subproblem is equal to v , the assignment x j = 0 becomes permanent, and the next iteration is performed. Otherwise, if the optimal objective value is less than Algorithm 1 The greedy cut-strengthening algorithm v , the value of x j is restored to 1 and the greedy algorithm terminates. Thereafter, the resulting cut is returned. The resulting cut is not guaranteed to be irreducible since the algorithm does not evaluate all of the indices. The pseudo-code for the greedy algorithm is given in Algorithm 1.

Deletion Filter
The deletion filter is a cut-strengthening algorithm that returns an irreducible cut. The algorithm is based on the deletion filter for finding an IIS in linear programs [18]. There is one iteration for each j ∈ J(x) where the subproblem with the assignment x j = 0 is evaluated. If the optimal value of the subproblem is equal to v , the assignment x j = 0 is made permanent in the remaining iterations and in the final subset. If the optimal value of the subproblem is not equal to v , the assignment is permanently changed to x j = 1 , both in the remaining iterations and in the final subset. Since there can be more than one irreducible subset, the order in which the assignments are evaluated determines the resulting subset [18]. A pseudocode for the deletion filter algorithm that finds an irreducible value cut is given in Algorithm 2.

Additive Method
The additive method was introduced for detecting IIS in linear programming by Tamiz et al. [19]. Chinneck [20] provided a simplified version of the algorithm that can be applied to a general set of constraints.
The search starts with three sets. An empty set I is introduced to store variables that are identified to belong to an IIS. An initially empty set T is a test set that comprises the set I and the candidate variables in each iteration. The set S is equal to the set of all variables at the start of the search. Then, in each iteration, one variable x j = 1 , j ∈ S is added to the set T and subproblem [SP(T)] is evaluated, where Algorithm 2 The deletion filter algorithm [SP(T)] is a subproblem relaxation corresponding to assignments x j = 1 , j ∈ T . If the optimal value of subproblem is less than v , the variable is added to the set T, and the next iteration starts. Otherwise, the variable is added to the set I and removed from the set S. Subproblem [SP(I)] is then evaluated. If the optimal value of subproblem [SP(I)] is equal to v , the search terminates with an irreducible subset of variables I; otherwise, the next iteration starts with T equal to the set I. A pseudo-code for the additive method that finds an irreducible value cut is given in Algorithm 3.

Additive/Deletion Filter
The additive/deletion filter is a hybrid method based on an additive method and a deletion filter. The algorithm returns an irreducible cut. The additive/deletion filter can be considered as a way of removing a large set of assignments before applying a deletion filter. The first step of the additive part of the algorithm is to make the assignment x j = 0 for all j ∈ J(x) . Then, in each iteration, the assignment x j = 1 is made for one index j until the optimal value of the subproblem is equal to v . Thus, some of the assignments not contributing to the optimal value are removed. The Algorithm 3 The additive method algorithm resulting subset is denoted as x ′ . The deletion filter is then applied to x ′ . A pseudocode for the additive/deletion algorithm is presented in Algorithm 4.

Depth-First Binary Search (DFBS)
The DFBS cut-strengthening algorithm is similar to the deletion filter algorithm, but instead of evaluating only a single index at a time, subsets of indices are evaluated.
The output from the search is an irreducible subset of variables I that defines an irreducible cut. The search starts with the set I being empty. Let v k be the optimal value of the subproblem in iteration k. The set of variables that are the current candidates for being included in I is denoted by T and initially T = J(x) . The variables that are not among the current candidates are stored in an auxiliary set S. Initially, S is an empty set. In each iteration, the goal is to identify a single index to add to set I by reducing set T until it contains only one index. Set T is split into sets T 1 and T 2 in each iteration. The algorithm then evaluates [SP(T 1 ∪ I ∪ S)] , if the optimal value is equal to the original value, the indices that belong to set T 2 are not considered in the subsequent iterations and the update T = T 1 is made. Otherwise, T is set to be equal T 2 , S stores T 1 . Whenever an index is added to I, [SP(I)] is evaluated and if the optimal value of [SP(I)] is equal to v k the algorithm terminates. Otherwise, the next iteration is performed.
The final subset is guaranteed to be irreducible. By exploring a subset of variables at a time, there is a possibility to decrease the number of subproblems that need to be solved. Note that the way T is split into two subsets is not specified by the algorithm. Defining the strategy of splitting the set can influence the practical performance of the algorithm. The pseudo-code for DFBS is given in Algorithm 5, and it is based on the presentation in [21] for finding an IIS for a mathematical program. This type of algorithm is one of the components of the infeasibility analyser QuickXplain, described in Junker [22], and is used to strengthen cuts in Cambazard et al. [14]. Fig. 1 illustrates DFBS applied to the set J = {1, 2, 3, 4, 5, 6, 7, 8} . Let v be the objective value of [ SP(J) ]. Set T is initially equal to J , and sets S and I are empty. Set T is randomly split into

Example 1 The example presented in
Since v ′ is equal to the original objective v, set T 1 is stored as the new set T and set T 2 is not considered in the following iterations. Next, T = {3, 4, 5, 6} is Algorithm 5 The DFBS cut-strengthening algorithm

Problems and Modelling
The cut-strengthening techniques are evaluated using problems arising from manufacturing and supply chain management contexts. Specifically, we consider the cumulative facility scheduling, single-facility (disjunctive) scheduling, and vehicle routing problems. An important feature of these problems is that they can be separated into assignment and scheduling components. LBBD is well suited for these kinds of problems since the assignment problem, which is routinely solved as a MIP, forms the master problem, and the scheduling problem, which is particularly amenable to CP, forms the subproblem.

Cumulative Facility Scheduling with Fixed Costs
An LBBD scheme for cumulative facility scheduling with fixed costs was introduced in Hooker [9]. The problem is to first allocate a set of jobs J = {1, ..., n} to a set of facilities F where the jobs are then scheduled for processing. Each job j ∈ J is assigned to exactly one facility f ∈ F . It takes processing time p jf to finish job j at facility f and uses resources at the rate c jf . The scheduled jobs can run simultaneously within one facility, but their total resource consumption at facility f cannot exceed capacity C f at any time. Each job can only be scheduled to start after its release time r j , and the job must be finished before its deadline d j .
Let the variable x jf take the value 1 if job j is assigned to facility f, and 0 otherwise. Let y jf be the start time of job j at facility f. The cumulative facility scheduling problem, in the form of problem (1), is given by (1), ensure that each job is assigned to exactly one facility. Constraints (6) correspond to H(y), and Constraints (7) correspond to C(x, y). Constraints (6) control the resource consumption, and Constraints (7) ensure that the jobs are processed within a specified time window. The domain D x is given by Constraints (8), and domain D y is given by Constraints (9).
The master problem in iteration k is given by the following assignment problem: Let x k jf be the solution of the master problem in iteraiton k. The subproblem is then given by a scheduling problem which can be separated into a scheduling problem for each facility f ∈ F . Different objective functions are considered for the cumulative scheduling problem by defining the two components h(x) and v(y) of the objective function (4): minimising the total cost of production, minimising the makespan of jobs, and minimising total tardiness of jobs. In the case where the objective function comprises only master variables, the subproblem is a feasibility problem; otherwise, it is solved as an optimisation problem.

Minimising the Total Cost
Assigning job j to facility f incurs cost F jf . The total cost in the context of a cumulative scheduling problem is the cost of assigning all of the jobs j to facilities. The objective function that minimises the total cost is given by the two components: The objective function is present only in the master problem, and the subproblem checks the feasibility of the assignments with respect to the facility capacity and time window constraints.
Hooker [9] shows that it is important to include a relaxation of the subproblem (11) in the formulation of the master problem (10). In this case, the [Valid inequalities] in problem (10) contain a relaxation of constraints (6)-(7) as follows. Let J(t 1 , t 2 ) = j ∈ J|t 1 ≤ r j , d j ≤ t 2 be a set of jobs with time windows that fit in a given time interval (t 1 , t 2 ) . Since the capacity of facility f per time unit is C f , the total amount of resource available at facility f in the interval (t 1 , . This can be formulated as Only feasibility Benders' cuts are generated for this problem formulation, which are constructed as follows. Let x k be the master problem solution in iteration k, if subproblem (11) is feasible, then (x k , y k ) is the optimal solution to the original problem. Otherwise, let J kf = {j|x k jf = 1} be the set of jobs assigned to facility f in iteration k and define Benders' cut in the form of a no-good inequality (2) as

Minimising Makespan
In the cumulative scheduling problem, the makespan is defined as the time the last job ends across all facilities. The objective function for minimising makespan is given by the components The master problem is strengthened by [Valid inequalities] that provide a lower bound on the makespan M based on the total resource consumption of jobs assigned to facility f. These are given by Since the objective function contains subproblem variables, the subproblem is an optimisation problem. As such, the subproblem generates two types of Benders' cuts. If the subproblem for facility f is infeasible, a feasibility cut in the form of no-good inequality (2) is generated. Otherwise, if the subproblem is feasible and has an optimal makespan M * kf , an optimality cut is generated. The cut (13) provides the tightest bound on M when all of the jobs in J kf are assigned to facility f.

Minimising Total Tardiness
Tardiness is defined as the time by which a job overruns its deadline. The objective function that defines the total tardiness of all jobs is given by the objective components The objective function can be linearised by introducing auxiliary variables T and T f that denote the total tardiness across all facilities and tardiness of each facility f, respectively. The total tardiness is minimised in the master problem with the following constraint enforced: The master problem can be strengthened by [Valid inequalities]. For each job i ∈ J , let J(0, d i ) be the set of jobs that finish before its deadline d i . Based on the resource consumption of the jobs, the total tardiness T f of jobs j ∈ J(0, d i ) assigned to facility f is bounded below by [Valid inequalities] can be derived from the bound (14). These are given by [Valid inequalities] can also include a second relaxation of the subproblem given by where T fi is a tardiness of job i on facility f and U fi is the big-M term. These inequalities provide a valid bound only when the jobs are indexed in the order of increasing deadlines d 1 ≤ ... ≤ d n , and is the permutation of indices so that p (1) ≤ ... ≤ p (n) ; see details in Hooker [9].
Generation of optimality cuts is based on the same principle as the cuts given by inequality (13). Let T * fk be the minimum tardiness on facility f in iteration k when the jobs in J fk are assigned to it. Then, Benders' cut in iteration k is given by Benders' cut can be generated for each facility f ∈ F and added to the master problem.

Single-Facility Scheduling with a Segmented Timeline
A single-facility scheduling problem is a problem of assigning start times y j to a set of jobs J to run at a single facility. Each job j ∈ J has a processing time p j and must be processed within its time window defined by a release time r j and a deadline d j . This problem does not decompose naturally. Therefore, the time horizon is divided into segments to decompose the problem into assignment and scheduling components. We study a variation of a single-facility scheduling problem with a segmented timeline that is presented in Coban and Hooker [13]. The main difference to the formulation in Coban and Hooker [13] is that not all of the jobs have to be scheduled. First, the jobs are assigned to the segments, then scheduled within each segment. The time horizon is divided into m segments with the start and end times [a s , a s+1 ] for s ∈ S = {1, ..., m} . Let x js take the value 1 if job j is assigned to segment s and 0 otherwise, and let y j be the start time of job j. Note that there is a penalty for not processing a job. Since the problem is to minimise an objective function, if a job j ∈ J is not processed, a term 2p j with the corresponding processing time is added to the objective. We introduce an auxiliary variable u j , which takes value 1 if job is not processed and 0 otherwise.
The single-facility scheduling problem can be formulated in a form corresponding to (1) as Constraints (16) correspond to A(x) and ensure that all jobs are assigned to no more than one segment. Constraint (17) corresponds to H(y) and ensures that jobs do not overlap and run sequentially. Constraints (18)- (19) correspond to C(x, y). Constraints (18) ensure the time windows of jobs are observed. Constraints (19) ensure jobs are processed within the time segments. The domains D x and D y are given by Constraints (20) and (22) respectively.
The master problem in iteration k is given by The master problem is augmented by [Valid inequalities] that contain the relaxation described in Coban and Hooker [13]. The relaxation ensures that jobs running in time interval [t 1 , t 2 ] have a total processing time of no more than t 2 − t 1 . For each segment s ∈ S , it is sufficient to enumerate all distinct intervals [r j , d i ] with r j < d i for i, j ∈ J . In order to obtain a tight inequality, we consider effective bounds of the intervals within a time segment. If the given release time r j is in the interval [a s , a s+1 ] , the effective release time is equal to the given release time. If r j < a s , the effective release time is DISJUNCTIVE((y j |j ∈ J), (p j |j ∈ J)), where J(r j , d i ) is the set of jobs whose time windows fall within time interval [r j , d i ].
The subproblem decomposes into a scheduling problem for each segment: Depending on the objective function h(x) + v(y) , the subproblem is either solved as an optimisation problem or a feasibility problem. Our study includes finding a feasible schedule, minimising makespan, and minimising tardiness.

Finding a Feasible Schedule
The problem to find a feasible schedule results in master and subproblems that are both feasibility problems. Since unassigned jobs are penalised, the objective function h(x) + v(y) is replaced by the penalty term 2 ∑ j∈J p j u j . Similar to cumulative facility scheduling (), the master problem is an assignment problem.
Let x k be the master problem solution in iteration k. If the subproblem has a solution y k , then the pair (x k , y k ) is the solution to problem defined by Eqs. (15)- (22). Otherwise, feasibility cuts are generated for each segment s. Let J ks = {j|x k js = 1} be the set of jobs that are assigned to segment s in iteration k. The feasibility cuts are given by

Minimising Makespan
The objective function to minimise makespan, similar to the one presented for cumulative scheduling, is given by the components and the penalty term 2 ∑ j∈J p j u j . The penalty term adds 2p j to the objective value for each unassigned job j. To linearise the objective function, we introduce auxiliary r sj = max{min{r j , a s+1 }, a s } andd si = min{max{d i , a s }, a s+1 }.
min v(y) s.t. DISJUNCTIVE((y j |i ∈ J), (p j |i ∈ J)), ∑ j∈J ks h(x) = 0 and v(y) = max j∈J (y j + p j ), variables M s , which denote the makespan for each segment s, and auxiliary variable M, which denotes the makespan over all segments. In addition to [Valid inequalities] (24), the master problem for the minimising makespan can be strengthened by the following bound for each distinct r j and each segment s The subproblem can be separated into an optimisation problem for each segment s. If the subproblem is infeasible, feasibility cuts in the form of (26) are generated. If the subproblem in iteration k has a solution and M * ks is the minimum makespan for segment s, an optimality cut is given by The cut indicates that the makespan M cannot be lower than M * ks unless at least one job is removed from J ks .

Minimising Total Tardiness
The objective function to minimise tardiness is given by the components and the penalty term 2 ∑ j∈J p j u j . We introduce auxiliary variables T s to linearise the objective function. Variables T s denote the total tardiness for each segment s, and the total tardiness over all segments T = ∑ s∈S T s is minimised in the master problem. Since the deadlines are now due dates, the time window constraints (18) are modified to The [Valid inequalities] in the master problem (23) contain a modified version of the relaxation (24), where the effective deadline is replaced by the end of a segment. Let r sj be the effective release time of job j on segment s, and let J(r j , ∞) be the set of jobs with time windows after release time r j of job j. The [Valid inequalities] require the total processing time of jobs j ∈ J(r j , ∞) that are assigned to segment s to not exceed a s+1 −r sj . The inequalities are given by h(x) = 0 and v(y) = ∑ j∈J max{y j + p j − d j , 0}, The master problem can also be strengthened by the following bound for tardiness: Since the subproblem is an optimisation problem, either a feasibility cut in the form of (26) or an optimality cut is generated. If the subproblem has an optimal solution in iteration k, let T * ks be the minimum tardiness on segment s. If T * ks > 0 , we have the following optimality cut:

Vehicle Routing Problem with Location Congestion
The problem is to deliver goods from a central depot to various locations using a set of vehicles subject to vehicle capacity and location congestion constraints. The vehicle routing problem with location congestion was introduced in Lam and Van Hentenryck [23], and a LBBD scheme for solving it was derived in Lam et al. [6].
Let R be the set of requests for goods and let L be the set of locations. Each request i ∈ R is to be delivered to one location l i ∈ L within a time window defined by a release time and a deadline, denoted by r i and d i , respectively. The set R l = {i ∈ R|l i = l} is the set of all requests at location l ∈ L . Each request i ∈ R has weight q i , and the maximum weight a vehicle can carry is Q. Each vehicle requires the use of one piece of equipment for processing time p i to unload the goods. Each location has a fixed set of equipment, and the total number is denoted by C l . As such, there is a limited capacity at each of the locations.
This vehicle routing problem decomposes into routing and scheduling components. The vehicle routing problem with location congestion formulation is given by (1), ensure that each request is assigned to exactly one vehicle. The Cumulative Constraints (30) correspond to H(y) and enforce capacity limit at each location. Constraints (31)-(32) correspond to C(x, y) in problem (1). The vehicle weight limits are enforced by Constraints (31). Constraints (32) ensure that vehicles start unloading goods within arrival time windows corresponding to each request. Since all of the vehicles are identical and each node has exactly one incoming and outgoing arc, there is no need to represent the vehicles explicitly. The number of the arcs outgoing from (or incoming to) the central depot gives the number of vehicles used in a solution.

Constraints (28)-(29), which correspond to A(x) in problem
The master problem in iteration k is given by The [Valid inequalities] comprise Constraints (31)-(32). They state that for a vehicle that travels along arc (i, j), the accumulated weight of goods delivered after request j cannot be smaller than the accumulated weight after request i. Similarly, unloading at node j cannot start before unloading at node i. Note that [Valid inequalities] are added to the master problem regardless of the type of the objective function.
Let x k be the master problem solution in iteration k, then the subproblem is given by

Minimising Total Travel Time
The goal is to minimise the total time all of the vehicles use to deliver goods and return to the central depot. The objective function is given by the components Since the objective function does not depend on the subproblem variables, the subproblem is solved as a feasibility problem. Therefore, only feasibility cuts are generated. Let J k = {(i, j) ∈ A|x k ij = 1} be the set of arcs that were selected in the master problem solution in iteration k. A feasibility cut is given by

Minimising Makespan
The goal is to minimise the time the last vehicle delivers goods and returns to the central depot. The objective function is given by The objective function can be linearised by introducing the auxiliary variable M that denotes makespan, which is minimised in the master problem.
Using the solution to the subproblem, either an optimality or feasibility cut is generated. If the subproblem is infeasible, a feasibility cut in the form of inequality (36) is generated. If the subproblem has an optimal solution with objective value M * k in iteration k, an optimality cut similar to inequality (13) is generated. This cut is given by s.t. CUMULATIVE((y start i |i ∈ R l ), (p i |i ∈ R l ), (1|i ∈ R l ), C l ), l ∈ L,

Minimising Total Tardiness
The tardiness of a request is defined as the time by which the delivery overruns its deadline, and the total tardiness is the total time by which all of the requests overrun their delivery deadlines. Since the requests are allowed to be delivered past their deadlines, the deadlines are replaced by due dates. The objective function to minimise the total tardiness is given by the components An auxiliary variable T, which denotes the total tardiness, is introduced to linearise the objective function. The variable T is minimised in the master problem.
Using the solution to the subproblem, either an optimality or feasibility cut is generated. If the subproblem is infeasible, the feasibility cut (36) is generated. Otherwise, if the subproblem has an optimal solution with objective value T * k in iteration k, an optimality cut similar to the one for minimising the makespan is generated. This optimality cut is given by The optimality cut provides a tight bound T * k on the total tardiness T when all of the arcs (i, j) ∈ J k are added to the route.

Analytic Benders' Cuts
It is possible to generate a type of Benders' cut that is based on the subproblem structure, termed analytic Benders' cuts. The aim of analytic Benders' cuts is to address the limitation of optimality cuts of form (3), where a tight bound is only given when each variable in J has the value 1. In contrast, analytic Benders' cuts improve the bound when some of the decision variables change their values from 1 to 0. The analytic cuts can be generated by analysing how changing the values of the decision variables affects the objective value. These cuts can be used along with the optimality cuts of type (3) or as an alternative. The analytic cuts can also be strengthened using the cut-strengthening techniques described in Sect. 3.2. Necessary assumptions to use analytic Bender's cuts are given in the following. All of the analytic cuts used in this study are based on the derivation given in Hooker [9] and in Coban and Hooker [13]. We expect that it is possible to generate analytic Benders' cuts for the vehicle routing problem with local congestion. However, since no such cuts have been previously presented in the literature, and the derivation of new types of cuts is out of the scope of this paper, no results are presented.

Cumulative Scheduling
Let J fk be the set of tasks assigned to facility f in iteration k, and M * fk be the corresponding minimum makespan. In the derivation of these cuts, it is assumed that all of the release times are equal to 0 and that the deadlines have different values. If one or more job assignments are removed from facility f, the resulting minimum makespan M f is bounded by The bound complies with the properties of the bounding function outlined in Sect. 3.1. When the supbroblem has an optimal solution with the minimum makespan M * fk , an analytic Benders' cut of form (37) can be generated instead of or alongside an optimality cut of form (13).
Analytic Bender's cuts for the minimum tardiness problem are derived based on the same principle as the analytic cuts (37) for the minimising makespan problem. Let T * fk be the minimum tardiness corresponding to J fk . An analytic cut that bounds the total tardiness T over all facilities is given by

Disjunctive Scheduling
Let J sk be the set of jobs assigned to segment s in iteration k and let M * sk be the corresponding minimal makespan. Define J sk = j ∈ J sk |r j ≤ a s as the set of jobs in J sk with release times before segment s. If one or more jobs from J sk are no longer assigned to segment s in the subsequent iterations, a lower bound on the resulting makespan M s is provided by an analytic cut: The second sum in the left-hand side takes care of the case when jobs from J sk ∖J sk are removed from segment s; see details in Coban and Hooker [13].
For the minimising tardiness problem. Let be the last release time of jobs assigned to segment s, or the start time of the segment a s , whichever is greater. Note that, if all the jobs assigned after the greatest release time are processed before the next segment, i.e., if holds, the problem is feasible. Based on inequality (40), the analytic Benders' cut for minimising tardiness on segment s is where T * sk is the minimal tardiness on segment s in iteration k. The total tardiness over all segments is then bounded by

Computational Evaluation
The effectiveness of the cut-strengthening techniques, described in Section 3.2, is evaluated in a series of computational experiments. The first experiment solves the cumulative scheduling problem for three objective functions given in Sect Each experiment comprises one problem that only generates feasibility cuts and two problems that generate both feasibility and value cuts. We extend the computational experiments from the conference paper [3] by adding an analysis of problems that generate value cuts. Moreover, two types of value cuts are analysed-strengthened optimality cuts and analytic Benders' cuts. Each corresponding problem is solved twice with respect to the type of generated value cuts. The cut-strengthening techniques are applied to both types of cuts. In the case when the subproblem can be separated into independent problems, we also make a comparison between solving these independent problems individually and solving them together as one large problem, referred to as solving the split or no-split subproblem, respectively.
The comparison of cut-strengthening techniques will be performed by evaluating the run time and the size of the strengthened cuts.
The LBBD scheme is implemented in Python 3.8, and the MIP and CP models are solved using Gurobi Optimizer version 9.1.2 and IBM ILOG CP Optimizer version 20.1, respectively. All tests have been carried out on a computer with two Intel Xeon Gold 6130 processors (16 cores, 2.1 GHz each) and 96 GB RAM. Each instance was given a total time of 20 min, and the MIP-gaps are set to 0 for the master problems.

Instances
The instances are either taken from the literature or generated in line with descriptions in the literature, but with new parameter settings. All instances can be accessed, either directly or via reference, from our repository 1 . For the cumulative facility scheduling problem with fixed costs, referred to as Problem 4.1, we use 336 instances from Hooker [9]. For the single machine scheduling problem with sequence-dependent setup times and multiple time windows, referred to as Problem 4.2, we use instances generated based on the description in Coban and Hooker [13]. For the vehicle routing problem with location congestion, referred to as Problem 4.3, we use 450 instances from Lam et al. [6].

Computational Effectiveness
To evaluate the effectiveness of the cut-strengthening techniques, we first look at their impact on the run time of the LBBD scheme. We then look at the average size of the cuts generated by the cut-strengthening techniques. Additional data is provided in Tables 1, 2 For the run time plots, the horizontal axis gives the time, and the vertical axis gives the percentage of solved instances. A point (x, y) on the curve means that y% of instances can be solved in less than x seconds. The cut size figures are histograms, a point (x, y) means average cut size x has frequency y, where the frequency y is the number of generated cuts. Since the type of a value cut does not influence the size of the cut, we only differentiate the histograms by the type of the subproblem. In the figures below, the additive/deletion filter and no cut strengthening are referred to as adel and none, respectively.
The experiments evaluating the effect of cut strengthening on analytic cuts show results very similar to results for strengthened optimality cuts. For the sake of brevity, the results and discussion related to analytic cuts have been moved to Appendix 1.

Minimising Makespan for Cumulative Facility Scheduling Problem
It can be seen in Fig. 2a for the split subproblem that the most instances are solved to optimality when applying the deletion filter and DFBS. Specifically, 65.48% and 64.29% of instances, respectively. This result is closely followed by additive/deletion filter and greedy method with very similar profiles in Fig. 2a and the respective percentages of solved instances of 63.99% and 63.39%. An analysis of the experiment data shows that the additive/deletion filter and DFBS spend more time solving subproblems than deletion filter. The additive/deletion filter and DFBS respectively spend 107.05 s and 113.21 s of run time, while deletion filter spends 81.17 s. This might suggest that the random order of variables is negatively affecting the efficiency of DFBS and additive/deletion filter. Since the deletion filter checks every variable, it is not affected by randomness. Similar to deletion filter, the greedy method spends 84.19 s. However, Fig. 3 shows that the greedy method generates cuts of higher density, which lead to a master problem that is harder to solve.
Interestingly, applying cut-strengthening techniques to the no-split subproblem has the same impact on the results as splitting the subproblem with no cut strengthening. The DFBS, deletion filter, additive/deletion filter, and additive method used for the no-split subproblem, with the respective percentages of solved instances of 58.93%, 54.17%, 56.25%, and 54.46%, achieve similar results to splitting the subproblem and applying no cut strengthening with 54.46% of solved instances. The weak effectiveness of the greedy algorithm for the no-split subproblem can be explained by the high density of the cuts, as can be seen in Fig. 4. The cuts generated by the greedy algorithm are less sparse compared to other techniques. They substantially increase the number of iterations and the master problem run time. In other words, the time spent strengthening the cuts using the greedy algorithm does not pay off.

Minimising Tardiness for Cumulative Facility Scheduling Problem
The first thing to notice in the run time Fig. 5 is that the split subproblem gives significantly higher results than the no-split subproblem. The best effectiveness for the no-split subproblem is shown in Fig. 5b by the deletion filter with 7.44% of solved instances. However, this result is considerably different to effectiveness when splitting the subproblems, with the lowest result of 25.6% of solved instances that corresponds to no cut strengthening. The deletion filter shows the best result when splitting the subproblem with 37.2% of instances solved. This result is followed by additive/deletion, DFBS, and additive with 36.31%, 36.12%, and 35.71% of solved instances, respectively. The greedy algorithm with 30.36% of solved instances is notably behind other algorithms. The results in Fig. 6 show that all of the algorithms except for the greedy method are similar in terms of the average size of the cuts.
The median values of number of variables per cut for DFBS, additive/deletion filter, additive, and deletion filter are 3.30, 3.31, 3.32, and 3.37, respectively. Whereas, the greedy method and no cut strengthening have respective median values of 4.44 Similarly, the greedy algorithm generates the most dense cuts for the no-split subproblem, as can be seen in Fig. 7. The nature of the objective function is likely to be the reason of the poor performance of the greedy algorithm.
Since total tardiness is the sum of lateness of each job, it is likely to be affected by the removal of an assignment. This is different from the total makespan. Since the total makespan is the time the last job ends, removing one assignment is not as likely to decrease the objective. The greedy algorithm does not remove many assignments in the search process before tardiness of the subproblem decreases. This leads to the cut not having reduced its size. The generated dense cuts then lead to the increased number of Bender's iterations. The relative effectiveness for each of the strengthening technqiues is similar for both the strengthened and analytic cuts. However, the results presented in Appendix 2 demonstrate that analytic cuts for the split subproblem perform relatively poorly with less instances solved to optimality compared to strengthened optimality cuts, an observation that is also reported by Hooker [9].

Minimising Total Cost for Cumulative Facility Scheduling Problem
Similar to the previous experiments, a considerable rise in computational effectiveness of the LBBD scheme comes from splitting the subproblem, as can be seen in run time Fig. 8. At the same time, applying cut-strengthening to the split subproblem still gives a significant boost to the results: the deletion filter, DFBS, additive/ deletion filter, and the greedy algorithm with the respective percentages of 74.70%, 74.11%, 72.91%, and 72.32% outperform no cut strengthening and additive method with 65.17% and 65.47% of solved instances, respectively. Interestingly, Fig. 9 shows that DFBS, deletion filter, and additive/deletion filter have very similar histograms of average cut sizes with the same median value of 4. The median values for the additive method, greedy method, and no cut strengthening are 5.67, 6.38, and 7.52 variables per cut, respectively. Although the greedy algorithm generates denser cuts than the additive method, the number of subproblems it performs is lower. The greedy algorithm and the additive method solve 59.3 and 163.1 subproblems, Fig. 7 Cumulative scheduling: average size of optimality cuts for the minimising tardiness problem with no-split subproblem respectively. This is likely to be the reason of the relatively good performance of the greedy algorithm. Overall, the results for the most of the cut-strengthening techniques for the split-subproblem do not differ much in terms of run time.
In contrast to the split subproblem, the difference in effectiveness is more pronounced for the no-split subproblem. The additive/deletion method for the no-split subproblem outperforms all other cut-strengthening techniques with 63.39% of instances solved to optimality. The additive/deletion filter, DFBS, and the deletion filter have similar sparsity of the feasibility cuts, as shown in Fig. 10. However, additive/deletion filter has a lower number of subproblems solved per instance compared to the deletion filter and DFBS. This indicates that additive/deletion filter is successful in removing variables not contributing to infeasibility early on. The effectiveness of the additive/deletion filter also compares to the split subproblem with no cut strengthening.

Minimising Makespan for Disjunctive Scheduling Problem
The run time results in Fig. 11a show that using cut-strengthening techniques does not accelerate the LBBD scheme for the split subproblem. In fact, using the greedy method or no cut strengthening outperforms all of the other techniques. The results  Fig. 12 show that on average all of the techniques fail to reduce the size of the cuts. This implies that master variables are already split into minimal subsets and cannot be reduced further. Therefore, the time spent on cut strengthening is not compensated, as can be seen in the run time profiles in Fig. 11a. By contrast, Fig. 13 shows that all of the cut-strengthening techniques, except for the greedy, give a significant rise in effectiveness for the no-split subproblem. This can be explained by significant difference in the sparsity of the generated cuts. The DFBS, deletion filter, additive/deletion filter, and the additive method have the median of 2 for average cut size, compared to 38 and 75 for the greedy algorithm and no cut strengthening, respectively. The sparsity of the irreducible cuts can be explained by the fact that only one job at a time can be processed, and the suboptimality of the solution is likely to be caused by the few jobs with the greatest processing end times. The greedy algorithm generates cuts that are stronger than the original; however, they are not strong enough to compensate for the time spent on the search. On the other hand, the DFBS is by far the best-performing cut-strengthening technique. DFBS solves 95.41% of instances, which is about the same as 95.20% using no cut strengthening for the split subproblem. This can be explained by the low number of iterations and subproblems solved: DFBS solves 28.28 subproblems in 4.91 iterations, compared to 49.38 subproblems in 5.14 iterations by additive/ deletion filter and 90.94 subproblems in 5.02 iterations by deletion filter. This result suggests that the search strategy employed by the DFBS is more effective compared to the deletion filter and the additive/deletion filter. The comparison of the split and no-split results shows that DFBS can be used instead of splitting the subproblem, and vice versa.

Minimising Tardiness for Disjunctive Scheduling Problem
The most noticeable observation from the run time Fig. 14 is that cut strengthening is not an effective way to accelerate the solution. Only splitting the subproblem makes a meaningful impact on the ability to solve the instances. When using no cut strengthening, splitting the subproblems solves 48.13% of the instances to optimality. This is compared to 1.88% of instances solved to optimality when no splitting of the subproblems is performed. Another striking observation is that the   Fig. 15 for the split subproblem are similar for all of the cutstrengthening techniques including no cut strengthening. This suggests that, as in the case for the minimising makespan problem, the master variables are already split into minimal subsets. Similar to previous experiments, the greedy algorithm reduces the cut density the least, as can be seen in Fig. 16. It can also be seen that although the additive method generates sparse cuts, it fails to solve many instances. This is due to the long time it takes to find the irreducible feasibility cuts. The additive method solves 2075.5 subproblems on average, while other methods solve in the range of 129.75 − 507.5 subproblems.

Finding a Feasible Schedule for Disjunctive Scheduling Problem
It can be seen from the comparison of the run time in Fig. 17 that splitting the subproblem is more effective in accelerating the solution process than cut strengthening. As in the case for other objective functions, Fig. 18 shows that all of the cut-strengthening techniques generate cuts of similar size for the split subproblem. Within 9.98 s, all of the cut-strengthening techniques, including none, solve at least 87.7% of instances. Nevertheless, cut-strengthening techniques still have a substantial impact on the solution process when the subproblem is not split. Similar to the results for the minimising makespan problem, all of the cut-strengthening techniques except for the greedy method increase the percentage of solved instances compared to using no cut strengthening by at least 39.79%. The most effective algorithms for the no-split subproblem

Minimising Makespan for Vehicle Routing Problem
The first thing to notice in Fig. 20a is that 53.11% of instances terminate after a single iteration regardless of the cut-strengthening technique applied. The reason is that The infeasibility of the master problem is detected before adding any feasibility cuts, and the infeasibility of the subproblem is detected without any restriction on the master problem variables. The subproblem infeasibility is checked before the initialisation of the LBBD scheme. When using no cut strengthening, no instances are solved to optimality. Although the greedy algorithm improves that result by solving 59.33% of instances to optimality, it still performs poorly compared to other cut-strengthening techniques. Interestingly, cut-strengthening techniques with similar search processes show similar results. The additive/deletion filter and additive method solve 91.11% and 88.89% of instances to optimality, respectively. The deletion filter and DFBS are the most effective, solving 99.55% of instances to optimality. Figure 21 shows that the average size of the generated cuts is similar for the deletion filter, DFBS, additive/deletion filter, and the additive method. However, the deletion filter tends to have fewer Bender's iterations than other cut-strengthening techniques-30.68 iterations compared to 62.64, 65.27, and 65.73 by DFBS, additive/deletion filter, and additive method, respectively. This suggests that the cuts generated by the deletion filter are more effective. At the same time, DFBS has a smaller number of subproblems solved-697.14 compared to 1344.53, 1475.92, and 2676.89 when using additive/deletion filter, deletion filter, and additive method, respectively. That implies that DFBS generates less effective cuts, but in a shorter time. Therefore,

Minimising Total Tardiness for Vehicle Routing Problem
As can be seen in Fig. 20b, the share of infeasible instances is smaller than for the minimising makespan problem. This is due to jobs being allowed to run past their deadlines. The job deadlines would otherwise cause infeasibility of valid inequalities in the master problem. All of the 6.89% of instances that terminate after a single iteration have an infeasible subproblem. When using no cut strengthening or the greedy method, no instances are solved to optimality. DFBS, surprisingly, has a small impact on the computational performance and solves 10.44% of instances. Somewhat better results are shown by the additive method and additive/deletion filter, with both solving 20.67% of instances. However, the additive method has a better run time profile than the additive/deletion filter. This is likely due to a greater number of iterations performed by additive/deletion filter-197.71 compared to 61.71 by additive method. The deletion filter significantly boosts the performance with 41.33% of instances solved. Figure 22 shows that the DFBS, deletion filter, and the additive method have a similar average cut size. However, the deletion filter solves fewer subproblems-820.79 compared to 3823.91 and 6036.35 by additive method and DFBS, respectively. Moreover, the deletion filter performs the smallest number of iterations-27.06 compared to 61.71, 165.76, and 197.91 by additive method, DFBS, and additive/deletion filter, respectively. That implies that the deletion filter generates stronger cuts, and its search method is the best suited for the given instances.

Minimising Total Travel Time for Vehicle Routing Problem
Similar to the minimising makespan problem, 53.11% of instances are detected to be infeasible after a single iteration. No other instances are solved to optimality when using no cut strengthening, as can be seen in Fig. 20c. The greedy method improves this result by 12.66% with 65.77% of solved instances. Notably, other techniques under investigation show substantial improvement in computational effectiveness. Namely, using DFBS solves 100% of the given instances. This result is followed by deletion filter and additive method both solving 95.55% of instances. Although the additive/deletion filter solves 91.55% of instances, it has a better run time profile than the additive method. This is due to a lower number of iterations and subproblems solved-20.99 iterations and 533.29 subproblems compared to 26.36 and 1510.15 by the additive method. All of these four cutstrengthening techniques have similar results in terms of the average cut size, as can be seen in Fig. 23. We also note that these cut-strengthening techniques lead to similar numbers of Benders' iterations. This suggests that the generated cuts have similar effectiveness. However, DFBS on average solves 286.65 of subproblems-a much lower number than the other three techniques. That implies that DFBS is more efficient in generating cuts of similar size. Overall, the marginal difference in the run time of the cut-strengthening techniques is caused by the different efficiency of the search strategies.

Concluding Remarks
This paper investigates the impact of various cut-strengthening techniques on the computational effectiveness of the LBBD scheme. Namely, the greedy algorithm, deletion filter, additive method, additive/deletion filter, and the depth-first binary search were evaluated. The evaluation is based on computational experiments that solve the cumulative facility scheduling problem, the single-facility scheduling with a segmented timeline problem, and the vehicle routing with local congestion problem. The three types of problems with various objective functions have been solved applying the cut-strengthening techniques within the LBBD scheme. The previous work of Karlsson and Rönnberg [5] is extended by including problem formulations that require generating both feasibility and optimality cuts. Additionally, the cut-strengthening techniques were applied to two types of value cutsno-good optimality cuts and analytic Benders' cuts. For the problem formulations that allow subproblem separation, the comparison is made between applying the cut-strengthening techniques to the separated subproblem and applying them to one large subproblem. When summarising the results, the following can be observed. The cut-strengthening techniques, such as DFBS, deletion filter, additive/deletion filter, and additive, that generate irreducible cuts tend to outperform the greedy algorithm and no cut strengthening. This is mostly due to sparsity of the irreducible cuts. We also note that the Overall, DFBS and deletion filter have the best computational effectiveness. Although DFBS and deletion filter generate cuts of the same size and strength as additive/deletion filter and the additive method, they solve lower number of subproblems. Therefore, DFBS and deletion filter have lower subproblem solution time. This implies that DFBS and deletion filter are more efficient in identifying irreducible cuts.
Another observation is that the separation of the subproblem does not always strongly dominate cut strengthening in terms of benefiting the solution process. In fact, there are cases when splitting the subproblem and applying cut strengthening are interchangeable. Therefore, some of the techniques can benefit the solution process significantly even if the subproblem is not separable. For example, the vehicle routing problem does not naturally separate the subproblem, and the computational results show that it is imperative to use cut strengthening.
The results show that the difference in performance between the cut-strengthening techniques comes from the efficiency of the search strategy. It would be relevant to investigate the impact of the order of variables on the search strategy. Another observation is that the cut-strengthening techniques have different results depending on the type of the objective function. It may also be worth analysing how the objective function could be exploited to improve the effectiveness of the techniques.

Minimising Makespan for Cumulative Facility Scheduling Problem
As can be seen in Fig. 24a, the deletion filter and the greedy algorithm give the best performance for the split subproblem with 66.7% of the instances solved to optimality for both methods. Similarly, the DFBS and the additive/deletion with respective percentages of solved instances of 64.58% and 63.69% show better results than the additive method and no cut strengthening. Given that splitting the subproblem gives the performance rise from 24.11 to 54.46% for no cut strengthening, we can tell that substantial time improvement comes from the subproblem separation. Figure 24b shows that all of the cut-strengthening techniques except for the greedy algorithm used for the no-split subproblem either outperform or match the performance of the split subproblem with no cut strengthening.

Minimising Tardiness for Cumulative Facility Scheduling Problem
It can be seen in Fig. 25b that the deletion filter shows the best performance for the no-split subproblem with 7.4% of instances solved to optimality. This results is notably lower than 10.71% of solved instances that correspond to no cut strengthening for the split subproblem. The deletion filter shows the best result for the split subproblem with 27.67% of solved instances.

Minimising Makespan for Disjunctive Scheduling Problem
Using no cut strengthening for the split subproblem solves 94.79% for analytic cuts. The additive/deletion filter, the best-performing algorithm for analytic cuts, improves the results by 0.83% with 95.62% of solved instances. Another interesting observation is that using the additive method for the split subproblem solves 93.13% of instances, which is worse than no cut strengthening. The cut size Fig. 12 shows that the additive method generates cuts of similar size to other cut-strengthening techniques. However, it performs many more subproblems. As a results, it spends much more time solving the subproblems. All of the cut-strengthening techniques except for the greedy have a considerable impact on the computational performance. Using the DFBS for the no-split

Minimising Tardiness for Disjunctive Scheduling Problem
Using analytic cuts for the split subproblem solves 46.88% of instances compared to 1.67% for the no-split subproblem. It appears that the impact of cut-strengthening techniques does not differ much when comparing split and no-split results. For example, the deletion filter gives a performance rise of 2.91% of instances solved for the split subproblem and 2.71% of instances solved for the no-split subproblem Fig. 27.