#### 3.1. Simplex method

The simplex method for an LP problem (4) enumerates problem restrictions while solving the LP dual of each restriction to obtain a bound. It can be interpreted as a local search as well as constraint-directed search.

#### 3.2. Branch and bound as constraint-directed search

Like the simplex method, branch-and-bound methods for discrete optimization are local search methods that use constraint-directed search. Unlike the simplex method, the local search mechanism solves a relaxation dual. Both interpretations can lead to significant improvements in the classical branch-and-bound algorithm.

To view the search as constraint-directed, suppose we find that a leaf node subproblem is infeasible, perhaps by trying to solve its LP relaxation. At this point, we backtrack. An alternate interpretation of backtracking is that we create a nogood constraint . We then generate the next node of the tree by assigning values to variables that satisfy all the nogood constraints created so far, continuing until the subproblem is solved or proved infeasible. The nogood constraints ensure that we do not examine the same leaf node twice. If the subproblem is solved, we are done. Otherwise, we continue generating leaf nodes in this fashion until no assignment satisfies all of the nogood constraints, at which point the search is exhaustive. Any search tree can be built in this way.

So far, the inference dual does not play a role in the creation of nogood constraints. We may be able to strengthen the nogoods, however, by examining the proof of infeasibility that solves the inference dual of the subproblem or its relaxation. We may find, for example, that only some of the variable settings appear as premises of the proof, perhaps . Then we can create a strengthened nogood constraint . This may allow us to skip an entire section of the branching tree. This is known as “backjumping,” a special case of “dynamic backtracking” (Ginsberg, 1993; Ginsberg and McAllester, 1994; McAllester, 1993). It is the basis for clause learning in satisfiability algorithms, discussed in section 'Clause learning for satisfiability solvers'.

Constraint-directed search can be specialized to integer programing (Hooker, 2000), where it is sometimes referred to as “conflict analysis.” Suppose we wish to solve the problem

- (14)

The LP relaxation of the subproblem at a given leaf node is

- (15)

where *p* and *q* are lower and upper bounds imposed by branching (Fig. 2). If , the variable has been fixed. We associate dual variables with the three constraints in (15). If the subproblem relaxation (15) is infeasible, its LP dual is solved by a tuple that proves infeasibility because and . This can guide future branching. If *p* and *q* are, respectively, the lower and upper branching bounds at a subsequent node of the tree, the subproblem at that node can be feasible only if

- (16)

This can be treated as a nogood constraint. Suppose we wish to branch on a variable with a fractional value in the solution of (15). A left branch defined by is feasible only if setting satisfies (16), which is to say

- (17)

So the left branch can be eliminated if this inequality is violated, and analogously for the right branch. This test can be performed repeatedly at a given node by substituting into (17) the dual solution obtained at each infeasible leaf node encountered so far. The idea can be extended to feasible leaf nodes and strengthened in various ways (Hooker, 2012).

This type of bounding enables backjumping in an integer programing search tree. Although backjumping is an old idea (Gaschnig, 1978; Stallman and Sussman, 1977), constraint-directed branching has only recently been implemented in an integer programing solver (Achterberg, 2007; Sandholm and Shields, 2006).

#### 3.3. Branch and bound as dual local search

The generation of a branch-and-bound tree can be regarded as a local search algorithm for solving a relaxation dual. This opens the possibility of applying local search ideas to define branching strategies. It also suggests how a branch-and-bound method can gracefully transition to a heuristic method.

Branching trees are built by adding one child node at a time. This in effect defines a neighborhood of each incomplete tree *T* that consists of trees obtained by adding one child node to some node of *T*. The choice of which node to add is therefore a choice of which element of the neighborhood to select. Because adding a node never results in a weaker bound, local search in this context always results in monotone nondecreasing bounds. In a discrete optimization problem, a local search converges finitely to the best possible bound. For example, adding any of the unexplored nodes in Fig. 3 creates a neighboring tree.

One well-known strategy for node selection is strong branching (Bixby et al., 1995), which adds to *T* the node at which the relaxation provides the largest bound. (The relaxation value may be estimated by using pseudocosts [Benichou et al., 1971; Gautier and Ribiere, 1977].) This is in effect a strategy for selecting a tree in the neighborhood of *T*. There are, however, other ways to design a local search, which result in different and perhaps novel node selection rules. For example, one can use uphill search by selecting the neighboring tree that maximizes . This corresponds to none of the traditional node selection rules, including strong branching, depth-first search, breadth-first search, iterative deepening, and limited discrepancy search.

Uphill search can be used in Fig. 3. Adding node 5 proves the bound as shown in Fig. 4, which is an improvement. Adding node 10 replaces with two tighter bounds as in Fig. 5, but the overall minimum of 4 does not improve. Enumeration of all neighboring trees reveals that the tree of Fig. 4 yields the greatest improvement in the bound.

A tree-building strategy designed to solve the relaxation dual is not necessarily a good strategy for finding feasible solutions. For example, an uphill search tends to add shallow nodes to the tree, which are not likely to yield feasible solutions. However, this is a fundamental difficulty of using the same tree search to find feasible solutions and prove optimality; that is, using the same tree search to solve the primal and relaxation duals. One escape from this dilemma is to use a primal heuristic that finds feasible solutions in parallel with a branching tree that finds bounds. Primal heuristics have in fact become a standard feature of branch-and-bound solvers.

The use of a primal heuristic allows one to design a local search method that is best suited for the relaxation dual. By running the two heuristics in parallel, the optimal value can be bracketed by increasingly tight upper bounds from the primal heuristic and lower bounds from the dual heuristic. The dual heuristic can also contribute upper bounds when the solution of the relaxation at a leaf node is integral. An exact solution is obtained when the tightest upper and lower bounds coincide, which in the worst case will occur when the dual heuristic runs to completion. One could also design a primal algorithm that becomes exhaustive search if it runs long enough, such as iterative deepening or limited discrepancy search. The branch-and-bound mechanism becomes a heuristic method simply by terminating the primal and dual algorithms when acceptably tight bounds are obtained.

#### 3.4. Clause learning for satisfiability solvers

Clause learning is essential to the success of state-of-the-art satisfiability solvers (Beame et al., 2003; Gomes, 2008; Moskewicz et al., 2001). It is a straightforward case of constraint-directed search that relies on the inference dual.

Before branching at each node, “unit resolution” is applied to the clause set at that node. Unit resolution is an inference method that operates by removing unit clauses. Thus, if the clause set contains a unit clause consisting of the literal , it concludes that must be true, deletes all clauses that contain (because they are satisfied), and deletes the literal wherever it occurs (because it cannot be true). A unit clause is treated analogously. The process continues until no unit clauses remain. If unit resolution generates the empty clause, the clause set is unsatisfiable, and the search backtracks. If no clauses remain after unit resolution, the clause set is satisfied, and the search terminates. If neither occurs, the search branches on a variable that remains in the clause set.

If the subproblem at a node is unsatisfiable, the unit resolution proof of the empty clause solves an inference dual, namely, the inference dual in which the inference method is unit resolution. We can formulate a nogood constraint by identifying the branching-induced unit clauses that serve as premises in the proof. For example, Fig. 6 shows a branching tree for the satisfiability problem below:

Fixing yields a unit resolution proof of infeasibility in which and serve as premises. We therefore generate the nogood constraint , which in this context is known as a “conflict clause.” Backtracking, we fix and obtain the conflict clause , which combines with the first conflict clause to obtain the resolvent . We must now backjump to level 2 of the tree to satisfy this conflict clause, which accelerates the search. Setting already creates infeasibility and the conflict clause , which resolves with to yield *x*_{1}. Only one more solution is possible, which creates infeasibility and the conflict clause . This resolves with *x*_{1} to obtain the empty clause, which means that no more solutions satisfy the conflict clauses, and the search is complete. In practice, conflict clauses are rapidly identified by finding certain types of cuts in an “implication graph” (Gomes, 2008), but this process corresponds to constructing a unit resolution proof of infeasibility.

Note that next leaf node can always be generated by assigning values to variables so as to satisfy the conflict clauses so far generated, until unit resolution detects infeasibility or satisfaction. In fact, the branching framework can be dropped altogether, and the algorithm can proceed purely as constraint-directed search. However, because the conflict clauses are clauses, they can simply be added to the constraint set, which allows unit resolution to detect infeasibility sooner. Some solvers that operate along these lines may nonetheless abandon the search tree framework and proceed in a mode similar to pure constraint-directed search.

A DPLL algorithm with clause learning is a special case of dynamic backtracking. A slight generalization of this process results in partial-order dynamic backtracking (Bliek, 1998; McAllester, 1993), which is also a form of constraint-directed search. The main point here is that DPLL with clause learning has basically the same algorithmic structure as the simplex method, branch and bound with conflict analysis, and—as we see next—Benders decomposition.

#### 3.5. Benders decomposition

Benders decomposition (Benders, 1962) is constraint-directed search in which the inference dual is the LP dual, and the nogood constraints are known as “Benders cuts.” It is distinguished by the fact that the subproblem is an LP and always contains the same variables. These variables are carefully chosen to define a subproblem that is easy to solve.

Once Benders decomposition is seen as a special case of constraint-directed search, one can substitute different kinds of inference duals for the LP dual and obtain Benders cuts for a wide variety of subproblems, not just LPs. The resulting method might be called “logic-based” Benders decomposition (Hooker, 2000; Hooker and Ottosson, 2003; Hooker and Yan, 1995), because Benders cuts are based on the logical form of the optimality proof that solves the dual. The method has been applied to a wide variety of problems, often with substantial improvement over the previous state of the art (surveyed in Hooker 2012). We will see in section 'Tabu search' that tabu search has a similar structure, and this may allow importation of Benders techniques into a local search framework.

The classical Benders method is applied to a problem of the form

- (22)

which has the subproblem

- (23)

The LP dual of the subproblem is

Assuming the subproblem (23) is feasible, the dual solution in iteration *k* proves a nogood bound on *v* for any *y*:

This is the classical Benders cut. When (23) is infeasible, the dual solution proves infeasibility because and . So the next solution *y* can be feasible only if

which becomes the Benders cut.

Algorithms having this same structure can solve a wide variety of problems. To use an example from Hooker (2007b), suppose that jobs can be processed in any of shops . We wish to assign jobs to shops, and schedule the jobs in each shop, so as to minimize makespan. Job *j* has processing time in shop *i*, consumes resources at rate , and has deadline . Shop *i* has available resources . Suppose, for example, if jobs 1, 2, and 3 are assigned to a shop 1 with maximum resources , where the processing time and resource consumption of each job are illustrated in Fig. 7. The time windows are given in Fig. 7. The minimum makespan schedule for this shop is shown in Fig. 7, with makespan 7. Similar schedules are computed for jobs assigned to other shops.

for each *i*. If all jobs assigned to a shop have the same release time, the cut can be strengthened to

The master problem is

In the example of Fig. 7, the Benders cut for shop 1 is

where . Analysis of the optimality proof (inference dual) for shop 1 reveals that only jobs 2 and 3 play a role in the proof. We can therefore strengthen the cut by letting .

This approach can reduce solution time by several orders of magnitude relative to mixed integer and constraint programing solvers (Hooker, 2007b; Yunes et al., 2010). It can be converted to a heuristic method simply by terminating it when the optimal value of the master problem is close to the best subproblem makespan obtained so far. Another option is to drop the oldest Benders cuts so that the number of cuts never exceeds a limit, much as is done in tabu search. The master problem therefore plays the role of a tabu list, as discussed in section 'Tabu search'.