Towards a general formulation of lazy constraints

Abstract

Integer programming is an important tool for optimising large-scale industrial processes and problem solving in general. Many industries benefit greatly from the use of integer programming to solve large and complex problems. While general-purpose integer program solvers are becoming increasingly powerful, most problems of interest are too difficult to solve directly, and instead require special treatment, such as a problem decomposition. The difficulty in solving an integer programming problem is directly influenced by the number of constraints, in that problems with more constraints are more difficult to solve than similar problems with fewer constraints.In this thesis, we explore a capability that has been developed since the 1990s, but only recently became available in the high-powered commercial solvers, Gurobi, CPLEX and XPRESS, known as lazy constraints. Also referred to as branch-and-cut, lazy constraints act as a modelling tool that allows the solver to add additional constraints during the solution process. This is often in response to having started with a reduced set of constraints that no longer completely describes the problem, and thus some constraints must be returned to the problem.This thesis attempts to provide preliminary answers to the questions: ``When and where are lazy constraints likely to be useful?'' and ``What are the important implementation issues when using lazy constraints?'' In order to do this we investigate the three main scenarios where using lazy constraints may be beneficial. Each chapter of this thesis covers one of these scenarios with example problems and implementations.The first scenario is the most direct: models that have sets of constraints where many (or all) constraints in the set may be unnecessary. By removing these constraints, we may solve a smaller model that will solve faster than the original, but if we have removed any individual constraints that are necessary, the solutions returned will not be feasible. When a solution to the relaxed problem violates one such constraint, that constraint is added to the relaxed problem and we continue solving. When an optimal solution to the relaxed problem that does not violate any constraints of the original problem is found, we thus have an optimal solution to the original problem.We apply this to several models for a particular problem, the Liner Shipping Fleet Repositioning Problem. In this problem, we move several ships between two locations in such a way as to minimise their movement costs by serving extra demands along the way. There are many capacity constraints in the models, however there are few scenarios where ships actually exceed their capacity. By removing the capacity constraints, the problem solves much faster, and only a very small number (<1%) are actually used.The second scenario is for problems which benefit from Benders decomposition, a problem decomposition first described in 1962. Benders decomposition benefits greatly in most cases from the use of lazy constraints by embedding the formulation in a branch-and-cut framework. Benders decomposition involves removing a number of variables and constraints from a problem, and instead approximating their contribution to the objective through some auxiliary variables. These variables are controlled through additional constraints, called Benders cuts.When solving a problem using Benders decomposition, we need to add multiple rounds of Benders cuts. Originally, one would solve the master problem to or near optimality, one would add cuts, and then one would solve the master problem again. For most problems, the master problem takes the longest to solve, with the cut-generation process being very fast or even trivial. With the use of lazy constraints, one may add Benders cuts during the solution of the master problem, cutting out unnecessary repetition.We apply Benders decomposition to a number of problems, such as the Uncapacitated Facility Location Problem, and demonstrate how large and difficult problems benefit from such a treatment. We also cover some implementation details and other ways of improving the efficiency of Benders decomposition. We show the most important aspects of Benders decomposition are the disaggregation of the sub-problem and the use of lazy constraints.The third scenario is similar to the first: models that have exponentially sized sets of constraints. In these problems, it is especially likely that many of these constraints will be unnecessary. We demonstrate the power of handling these sets lazily for the Travelling Salesman Problem and two puzzles: Anne Bonney (the Pieces of 8) and the Fillomino Puzzle. We also note the interesting parallels between the lazy formulations for these problems and Benders decomposition.Finally, we draw from the experience of the earlier chapters to provide initial answers to our original questions. We also note some interesting areas for future research that show promise. The most significant of these is the combination of lazy constraints and/or Benders decomposition with other decomposition strategies, especially Dantzig-Wolfe decomposition.