GALINI: an extensible solver for mixed-integer quadratically-constrained problems

Many industrial relevant optimization problems can be formulated as Mixed-Integer Quadratically Constrained Problems. This class of problems are difficult to solve because of 1) the non-convex bilinear terms 2) integer variables. This thesis develops the Python library \suspect{} for detecting special structure (monotonicity and convexity) of Pyomo models. This library can be extended to provide specialized detection for complex expressions. As a motivating example, we show how the library can be used to detect the convexity of the reciprocal of the log mean temperature difference. This thesis introduces GALINI: a novel solver that is easy to extend at runtime with new 1) cutting planes, 2) primal heuristics, 3) branching strategies, 4) node selection strategies, and 5) relaxations.GALINI uses Pyomo to represent optimization problems, this decision makes it possible to integrate with the existing Pyomo ecosystem to provide, for example, building blocks for relaxations. We test the solver on two large datasets and show that the performance is comparable to existing open source solvers. Finally, we present a library to formulate pooling problems, a class of network flow problems, using Pyomo. The library provides a mechanism to automatically generate the PQ-formulation for pooling problems. Since the library keeps the knowledge of the original network, it can 1) use a mixed-integer programming primal heuristic specialized for the pooling problem to find a feasible solution, and 2) generate valid cuts for the pooling problem. We use this library to develop an extension for GALINI that uses the mixed-integer programming primal heuristic to find a feasible solution and that generates cuts at every node of the branch & cut algorithm. We test GALINI with the pooling extensions on large scale instances of the pooling problem and show that we obtain results that are comparable to or better than the best available commercial solver on dense instances.Open Acces

Branching strategies for mixed-integer programs containing logical constraints and decomposable structure

Decision-making optimisation problems can include discrete selections, e.g. selecting a route, arranging non-overlapping items or designing a network of items. Branch-and-bound (B&B), a widely applied divide-and-conquer framework, often solves such problems by considering a continuous approximation, e.g. replacing discrete variable domains by a continuous superset. Such approximations weaken the logical relations, e.g. for discrete variables corresponding to Boolean variables. Branching in B&B reintroduces logical relations by dividing the search space. This thesis studies designing B&B branching strategies, i.e. how to divide the search space, for optimisation problems that contain both a logical and a continuous structure. We begin our study with a large-scale, industrially-relevant optimisation problem where the objective consists of machine-learnt gradient-boosted trees (GBTs) and convex penalty functions. GBT functions contain if-then queries which introduces a logical structure to this problem. We propose decomposition-based rigorous bounding strategies and an iterative heuristic that can be embedded into a B&B algorithm. We approach branching with two strategies: a pseudocost initialisation and strong branching that target the structure of GBT and convex penalty aspects of the optimisation objective, respectively. Computational tests show that our B&B approach outperforms state-of-the-art solvers in deriving rigorous bounds on optimality. Our second project investigates how satisfiability modulo theories (SMT) derived unsatisfiable cores may be utilised in a B&B context. Unsatisfiable cores are subsets of constraints that explain an infeasible result. We study two-dimensional bin packing (2BP) and develop a B&B algorithm that branches on SMT unsatisfiable cores. We use the unsatisfiable cores to derive cuts that break 2BP symmetries. Computational results show that our B&B algorithm solves 20% more instances when compared with commercial solvers on the tested instances. Finally, we study convex generalized disjunctive programming (GDP), a framework that supports logical variables and operators. Convex GDP includes disjunctions of mathematical constraints, which motivate branching by partitioning the disjunctions. We investigate separation by branching, i.e. eliminating solutions that prevent rigorous bound improvement, and propose a greedy algorithm for building the branches. We propose three scoring methods for selecting the next branching disjunction. We also analyse how to leverage infeasibility to expedite the B&B search. Computational results show that our scoring methods can reduce the number of explored B&B nodes by an order of magnitude when compared with scoring methods proposed in literature. Our infeasibility analysis further reduces the number of explored nodes.Open Acces

Approximation algorithms for process systems engineering

Designing and analyzing algorithms with provable performance guarantees enables efficient optimization problem solving in different application domains, e.g.\ communication networks, transportation, economics, and manufacturing. Despite the significant contributions of approximation algorithms in engineering, only limited and isolated works contribute from this perspective in process systems engineering. The current paper discusses three representative, NP-hard problems in process systems engineering: (i) pooling, (ii) process scheduling, and (iii) heat exchanger network synthesis. We survey relevant results and raise major open questions. Further, we present approximation algorithms applications which are relevant to process systems engineering: (i) better mathematical modeling, (ii) problem classification, (iii) designing solution methods, and (iv) dealing with uncertainty. This paper aims to motivate further research at the intersection of approximation algorithms and process systems engineering