Documentation

Mixed-Integer Linear Programming Definition

A mixed-integer linear program is a problem with

• Linear objective function, f^Tx, where f is a column vector of constants, and x is the column vector of unknowns

• Bounds and linear constraints, but no nonlinear constraints (for definitions, see Writing Constraints)

• Restrictions on some components of x to have integer values

In mathematical terms, given vectors f, lb, and ub, matrices A and Aeq, corresponding vectors b and beq, and a set of indices intcon, find a vector x to solve

$$\underset{x}{\min }{f}^{T}x\text{ subject to }\{\begin{array}{l}x(\text{intcon})\text{ are integers}\hfill \\ A\cdot x\le b\hfill \\ Aeq\cdot x=beq\hfill \\ lb\le x\le ub.\hfill \end{array}$$

intlinprog Algorithm

• Algorithm Overview

• Linear Program Preprocessing

• Linear Programming

• Mixed-Integer Program Preprocessing

• Cut Generation

• Heuristics for Finding Feasible Solutions

• Branch and Bound

Algorithm Overview

intlinprog uses this basic strategy to solve mixed-integer linear programs. intlinprog can solve the problem in any of the stages. If it solves the problem in a stage, intlinprog does not execute the later stages.

1. Reduce the problem size using Linear Program Preprocessing.

2. Solve an initial relaxed (noninteger) problem using Linear Programming.

3. Perform Mixed-Integer Program Preprocessing to tighten the LP relaxation of the mixed-integer problem.

4. Try Cut Generation to further tighten the LP relaxation of the mixed-integer problem.

5. Try to find integer-feasible solutions using heuristics.

6. Use a Branch and Bound algorithm to search systematically for the optimal solution. This algorithm solves LP relaxations with restricted ranges of possible values of the integer variables. It attempts to generate a sequence of updated bounds on the optimal objective function value.

Linear Program Preprocessing

According to the Mixed-Integer Linear Programming Definition, there are matrices A and Aeq and corresponding vectors b and beq that encode a set of linear inequalities and linear equalities

$$\begin{array}{c}A·x\le b\\ Aeq·x=beq.\end{array}$$

These linear constraints restrict the solution x.

Usually, it is possible to reduce the number of variables in the problem (the number of components of x), and reduce the number of linear constraints. While performing these reductions can take time for the solver, they usually lower the overall time to solution, and can make larger problems solvable. The algorithms can make solution more numerically stable. Furthermore, these algorithms can sometimes detect an infeasible problem.

Preprocessing steps aim to eliminate redundant variables and constraints, improve the scaling of the model and sparsity of the constraint matrix, strengthen the bounds on variables, and detect the primal and dual infeasibility of the model.

For details, see Andersen and Andersen [1] and Mészáros and Suhl [4].

Linear Programming

The initial relaxed problem is the linear programming problem with the same objective and constraints as Mixed-Integer Linear Programming Definition, but no integer constraints. Call x_LP the solution to the relaxed problem, and x the solution to the original problem with integer constraints. Clearly,

f^Tx_LP ≤ f^Tx,

because x_LP minimizes the same function but with fewer restrictions.

This initial relaxed LP (root node LP) and all generated LP relaxations during the branch-and-bound algorithm are solved using linear programming solution techniques.

Mixed-Integer Program Preprocessing

During mixed-integer program preprocessing, intlinprog analyzes the linear inequalities A*x ≤ b along with integrality restrictions to determine whether:

• The problem is infeasible.

• Some bounds can be tightened.

• Some inequalities are redundant, so can be ignored or removed.

• Some inequalities can be strengthened.

• Some integer variables can be fixed.

The IPPreprocess option lets you choose whether intlinprog takes several steps, takes all of them, or takes almost none of them.

The main goal of mixed-integer program preprocessing is to simplify ensuing branch-and-bound calculations. Preprocessing involves quickly preexamining and eliminating some of the futile subproblem candidates that branch-and-bound would otherwise analyze.

For details about integer preprocessing, see Savelsbergh [6].

Cut Generation

Cuts are additional linear inequality constraints that intlinprog adds to the problem. These inequalities attempt to restrict the feasible region of the LP relaxations so that their solution are closer to integers. You control the type of cuts that intlinprog uses with the CutGeneration option.

'basic' cuts include:

• Mixed-integer rounding cuts

• Gomory cuts

• Cliques cuts

• Cover cuts

• Flow cover cuts

'intermediate' cuts include all 'basic' cuts, plus:

• Simple lift-and-project cuts

• Simple pivot-and-reduce cuts

• Reduce-and-split cuts

'advanced' cuts include all 'intermediate' cuts except reduce-and-split cuts, plus:

• Strong Chvatal-Gomory cuts

• Zero-half cuts

Another option, CutGenMaxIter, specifies an upper bound on the number of times intlinprog iterates to generate cuts.

For details about cut generation algorithms (also called cutting plane methods), see Cornuéjols [2].

Heuristics for Finding Feasible Solutions

To get an upper bound on the objective function, the branch-and-bound procedure must find feasible points. A solution to an LP relaxation during branch-and-bound can be integer feasible, which can provide an improved upper bound to the original MILP. There are techniques for finding feasible points faster before and/or during branch-and-bound. These techniques are heuristic, meaning they are algorithms that can succeed, but can also fail. You set the intlinprog heuristics in the Heuristics option. The options are:

• 'rins' — intlinprog searches the neighborhood of the current best integer feasible solution point (if available) to find a new and better solution. See Danna, Rothberg, and Le Pape [3].

• 'rss' — intlinprog applies a hybrid procedure combining ideas from 'rins' and local branching to search for integer feasible solutions.

• 'round' — intlinprog takes the LP solution to the relaxed problem at a node. It rounds the integer components in a way that attempts to maintain feasibility.

• 'none' — intlinprog does not search for a feasible point. It simply takes any feasible point it encounters in its branch-and-bound search.

Branch and Bound

The branch-and-bound method constructs a sequence of subproblems that attempt to converge to a solution of the MILP. The subproblems give a sequence of upper and lower bounds on the solution f^Tx. The first upper bound is any feasible solution, and the first lower bound is the solution to the relaxed problem. For a discussion of the upper bound, see Heuristics for Finding Feasible Solutions.

As explained in Linear Programming, any solution to the linear programming relaxed problem has a lower objective function value than the solution to the MILP. Also, any feasible point x_feas satisfies

f^Tx_feas ≥ f^Tx,

because f^Tx is the minimum among all feasible points.

In this context, a node is an LP with the same objective function, bounds, and linear constraints as the original problem, but without integer constraints, and with particular changes to the linear constraints or bounds. The root node is the original problem with no integer constraints and no changes to the linear constraints or bounds, meaning the root node is the initial relaxed LP.

From the starting bounds, the branch-and-bound method constructs new subproblems by branching from the root node. The branching step is taken heuristically, according to one of several rules. Each rule is based on the idea of splitting a problem by restricting one variable to be less than or equal to an integer J, or greater than or equal to J+1. These two subproblems arise when an entry in x_LP, corresponding to an integer specified in intcon, is not an integer. Here, x_LP is the solution to a relaxed problem. Take J as the floor of the variable (rounded down), and J+1 as the ceiling (rounded up). The resulting two problems have solutions that are larger than or equal to f^Tx_LP, because they have more restrictions. Therefore, this procedure potentially raises the lower bound.

The performance of the branch-and-bound method depends on the rule for choosing which variable to split (the branching rule). The algorithm uses these rules, which you can set in the BranchingRule option:

• 'maxpscost' — Choose the fractional variable with maximal pseudocost.

   Pseudocost

  The peudocost of a variable i is based on empirical estimates of the change in the lower bound when i has been chosen as the branching variable, combined with the fractional part of the i component of the current point x. The fractional part p is in two pieces, the lower part and the upper part:

  p_i^– = x(i) – ⌊x(i)⌋
  p_i⁺ = 1 – p_i^–.

  Let x_i^– be the solution of the linear program restricted to have x(i) ≤ ⌊x(i)⌋, and let the change in objective function be denoted

  Δ_i^– = f^Tx_i^– – f^Tx.

  Similarly, Δ_i⁺ is the change in objective function when the problem is restricted to have x(i) ≥ ⌈x(i)⌉.

  The objective gain per unit change in variable x_i is

  $$d_i^{-}=\frac{{\Delta }_i^{-}}{p_i^{-}}\text{ or }{d}_i^{+}=\frac{{\Delta }_i^{+}}{p_i^{+}}.$$

  Let s_i^– and s_i⁺ be the empirical averages of d_i^– and d_i⁺ during the branch-and-bound algorithm up to this point. The empirical values are initialized to the absolute value of the objective coefficient f(i) for the terms before there are any observations. Then the 'maxpscost' rule is to branch on a node i that maximizes, for some positive weights w⁺ and w^–, the quantity

  w^– * p_i^– * s_i^– + w⁺ * p_i⁺ * s_i⁺.

  Roughly speaking, this rule chooses a coefficient that is likely to increase the lower bound maximally.

• 'mostfractional' — Choose the variable with fractional part closest to 1/2.

• 'maxfun' — Choose the variable with maximal corresponding absolute value in the objective vector f.

After the algorithm branches, there are two new nodes to explore. The algorithm chooses which node to explore among all that are available using one of these rules:

• 'minobj' — Choose the node that has the lowest objective function value.

• 'mininfeas' — Choose the node with the minimal sum of integer infeasibilities. This means for every integer-infeasible component x(i) in the node, add up the smaller of p_i^– and p_i⁺, where

  p_i^– = x(i) – ⌊x(i)⌋
  p_i⁺ = 1 – p_i^–.

• 'simplebestproj' — Choose the node with the best projection.

   Best Projection

  Let x_B denote the best integer-feasible point found so far, x_R demote the LP relaxed solution at the root node, and x denote the node we examine. Let in(x) denote the sum of integer infeasibilities at the node x (see 'mininfeas'). The best projection rule is to minimize

  $$f^{T}x+\frac{f^T{x}_B-f^T{x}_R}{in\left(x_R\right)}in\left(x\right).$$

  If there is no integer-feasible point found so far, set f^Tx_B = 0.

The branch-and-bound procedure continues, systematically generating subproblems to analyze and discarding the ones that won't improve an upper or lower bound on the objective, until one of these stopping criteria is met:

• The algorithm exceeds the MaxTime option.

• The difference between the lower and upper bounds on the objective function is less than the TolGapAbs or TolGapRel tolerances.

• The number of explored nodes exceeds the MaxNodes option.

• The number of integer feasible points exceeds the MaxNumFeasPoints option.

For details about the branch-and-bound procedure, see Nemhauser and Wolsey [5] and Wolsey [7].