User:Bmears11/mysandbox/Integer Linear Programming/branch and cut

Branch and cut (sometimes written as branch-and-cut) is a method of combinatorial optimization for solving integer linear programs, that is, linear programming problems where some or all the unknowns are restricted to integer values. Branch and cut involves running a branch and bound algorithm and using cutting planes to tighten the LP relaxations. Note that if cuts are only used to tighten the initial LP relaxation, the algorithm is called cut and branch.

Description of the Algorithm
The method solves the linear program without the integer constraint using the regular simplex algorithm. When an optimal solution is obtained, and this solution has a non-integer value for a variable that is supposed to be integer, a cutting plane algorithm may be used to find further linear constraints which are satisfied by all feasible integer points but violated by the current fractional solution. These inequalities may be added to the linear program, such that resolving it will yield a different solution which is hopefully "less fractional"

At this point, the branch and bound part of the algorithm is started. The problem is split into multiple (usually two) versions The new linear programs are then solved using the simplex method and the process repeats. During the branch and bound process, non-integral solutions to LP relaxations serve as upper bounds and integral solutions serve as lower bounds. A node can be pruned if an upper bound is lower than an existing lower bound. Further, when solving the LP relaxations, additional cutting planes may be generated, which may be either global cuts, i.e., valid for all feasible integer solutions, or local cuts, meaning that they are satisfied by all solutions fulfilling the side constraints from the currently considered branch and bound subtree.

The algorithm is summarized below. The algorithm assumes the ILP is a maximization problem.


 * 1) Add the initial ILP to $$L$$, the list of active problems
 * 2) Set $$x* = \text{null}$$ and $$v* = -\infty$$
 * 3) while the $$L$$ is not empty
 * 4) Select and remove a problem from $$L$$
 * 5) Solve the relaxation of the problem.
 * 6) If the solution is infeasible, go back to 3. Otherwise denote the solution by $$x$$ with objective value $$v$$.
 * 7) If $$v>v*$$ and $$x$$ is integer, set $$v*\leftarrow v, x* \leftarrow x$$ and go back to 3.
 * 8) If $$v\le v*$$, go back to 3.
 * 9) If desired, search for cutting planes that are violated by $$x$$. If any are found, add them to the solution and return to 3.2.
 * 10) Branch to partition the problem into new problems with restricted feasible regions. Add these problem to $$L$$ and go back to 3
 * 11) return $$x*$$

Branching Strategies
An important step in the branch and cut algorithm is the branching step. At this step, there are a variety of branching heuristics that can be used. The branching strategies described below all involve what is called branching on a variable.  Branching on a variable involves choosing a variable, $$x_i$$, with a fractional value, $$x_i'$$, in the optimal solution  to the current LP relaxation and then adding the constraints $$x_i\le \lfloor x_i' \rfloor$$ and $$ x_i \ge \lceil x_i' \rceil$$
 * Most Infeasible Branching This branching strategy chooses the variable with the fractional part closest to 0.5.
 * Pseudo Cost Branching The basic idea of this strategy is to keep track for each variable $$x_i$$ the change in the objective function when this variable was previously chosen as the variable to branch on. The strategy then chooses the variable that is predicted to have the most change on the objective function based on past changes when it was chosen as the branching variable.  Note that pseudo cost branching is initially uninformative in the search  since few variables have been branched on.
 * Strong Branching Strong branching involves testing which of the candidate variable gives the best improvement to the objective function before actually branching on them. Full strong branching tests all candidate variables and can be computationally expensive.  The computational cost can be reduced by only considered a subset of the candidate variables and not solving each of the corresponding LP relaxations to completion.

There are also a large number of variations of these branching strategies, such as using strong branching early on when pseudo cost branching is relatively uninformative and then switching to pseudo cost branching later when there is enough branching history for pseudo cost to be informative.