Nonlinear branch-and-bound

A nonlinear branch-and-bound algorithm is created with the same principles in mind as its lin- ear version. The problem’s integral relaxation is solved. If the solution is fractional, branching on the integral variables is executed, which excludes the fractional optimal point and the two subproblems are solved and so on – it is an implementation of the classical divide-and-conquer principle. The problems can be displayed in a tree structure where each node corresponds to a problem with a set of fixed integral variables, cf. Figure 3.14. Using only branching, the algorithm would not perform much better than any enumeration method described in Section 3.12.1. However, nodes can be pruned due to several observations:

1. Lower bounds are obtained for each subproblem automatically as the integer relaxation NLP is solved – non-convex problems need to be solved globally for this to hold. This bound describes the best achievable value for this problem and all subproblems. If an integral possibly suboptimal solution to the original MINLP is known, it can be used to prune parts of the tree, which cannot generate a better solution.

2. Infeasible nodes can be pruned and their corresponding subtree can be disregarded since subproblems cannot become feasible again.

3. Nodes with integral solutions also do not need to be examined any further since they already realize the best solution obtainable for all subproblems that could be created from these nodes.

These pruning rules prevent the whole tree from being searched. In practice, most MINLP solvers contain a branch-and-bound framework. There are several choices when implement- ing these algorithms, which shall just briefly be mentioned here. The algorithms may combine all those choices and change between different settings as they progress.

b b ω₁= 0 b ω2= 0 l

integer point, new UB

ω3= 0 b ω3= 1 b ω2= 1 b ω₁= 1 b ω3= 0 r pruned due to UB ω2= 0 b ω2= 1 r infeasible subproblem ω3= 1

Figure 3.14: Branch-and-bound tree

The branching rules, i.e., how child nodes are generated from a node with a fractional solu- tion, are freely selectable for the implementation as long as the fractional solution is infeasible for both child problems. There are several different branching strategies presented in [37] for nonlinear branch-and-bound and in [2] for linear branch-and-bound, which can directly be translated for MINLP algorithms. One example is maximum fractional branching, where dichotomy branching is done on the variable with the maximum distance from an integral value. A second strategy is strong branching where the child nodes are solved for all integer variables with fractional value in the relaxation. Then, the variable to branch on is chosen

with the evaluation of the degradation, i.e., the increase in the lower bound, of both sub- problems, if both subproblems are feasible. Infeasible subproblems can be used to tighten a node or even to prune it. Pseudocost branching does not compute the correct degradations by solving all subproblems, but keeps a history of achieved degradations for all variables and solved subproblems as pseudocosts, which measure a degradation per unit of fractionality. These pseudocosts are used with the current fractionalities to estimate the effect that branch- ing on a certain variable would have and the variable is chosen based on a certain criterion. A combination of strong branching and pseudocost branching is reliability branching, which uses strong branching early until reliable pseudocosts are derived and then uses pseudocosts. Another, less often used branching strategy is branching on general disjunctions, which is for example used for SOS1-constraints.

A second choice for the implementation are the node selection rules, i.e., which of all open subproblems is solved next? The general methodologies are depth-first search and best-first

search, which choose the deepest or shallowest nodes, respectively. Depth-first search focuses

on finding good integral solutions fast and has to manage only a small-sized tree, while best- first search focuses on finding the best solution as fast as possible but often has very large sets of open subproblems. An often used strategy combines the two methods: the diving strategy implements depth-first search until an integral solution is found, then backtracks to the best open subproblem and starts a new depth-first search from there on. For this part of the algorithm, methods from linear branch-and-bound frameworks, as presented in [2, 124], may be adopted to the nonlinear setting. However, their performance can differ from the linear setting. An example is that there are no good warm-start techniques for MINLP with interior point methods and hence the application of depth-first search in this context loses its advantage coming from the usage of the dual simplex in the linear case, cf. [37].

An important part of the branch-and-bound algorithm is the pruning step, which is stronger when good integral solutions are known. A possibility of getting these solutions are heuristics. Heuristics are naturally also very important when algorithms need to be stopped before com- pletion due to time constraints, since then at least a good feasible solution can be returned after the algorithm is stopped. There are certain heuristics that are based on the fractional solution of a subproblem and try to find a close integral solution. One such strategy is MILP-

based rounding, cf. [133], where a close integral solution in the `1-norm is computed for a polyhedral approximation of the original problem. This integral solution is put into the MINLP, all integral variables are fixed and a solution of the original MINLP is derived. The

feasibility pump heuristic is a close relative, cf. [35]. There are lots of other heuristics and also

the diving strategy for node selection implicitly is a heuristic, cf. [17] for detailed descriptions of several heuristics.

Cutting planes, cf. Section 3.12.3, can easily be included into a branch-and-bound algorithm to obtain a branch-and-cut algorithm. After solving each subproblem, the solution can be cut off via the cutting plane approach. This is repeated until a certain threshold is reached, then branching on the remaining problem is done. Usually, more cuts are generated close to the

root node since they are applicable for large parts of the branching tree. Deeper in the tree, less effort is spent on local cuts since those would only be valid for a smaller subtree.

An alternative to the full nonlinear branch-and-bound algorithm is the LP/NLP-based branch- and-bound algorithm introduced in [147]. It is also a close relative to the outer approxi- mation technique described in Section 3.12.2. As explained there, it uses an MILP master problem with first-order TAYLORseries approximations of the nonlinear functions. Instead of resolving the master problem, only one master problem is solved. Once an integer point is reached, the NLP is solved that corresponds to this setting of integer variables. The solution is used to update all open nodes of the master problem with a new outer approximation and it is additionally used to enhance the global upper bound if feasible. An implementation of this technique can be found in LEYFFER’s thesis [119]. The general idea can also be extended to Generalized BENDER’s Decomposition and all other methods that only focus on the addition of cutting planes.