## Abstract

Generating polyhedral outer approximations and solving mixed-integer linear relaxations remains one of the main approaches for solving convex mixed-integer nonlinear programming (MINLP) problems. There are several algorithms based on this concept, and the efficiency is greatly affected by the tightness of the outer approximation. In this paper, we present a new framework for strengthening cutting planes of nonlinear convex constraints, to obtain tighter outer approximations. The strengthened cuts can give a tighter continuous relaxation and an overall tighter representation of the nonlinear constraints. The cuts are strengthened by analyzing disjunctive structures in the MINLP problem, and we present two types of strengthened cuts. The first type of cut is obtained by reducing the right-hand side value of the original cut, such that it forms the tightest generally valid inequality for a chosen disjunction. The second type of cut effectively uses individual right-hand side values for each term of the disjunction. We prove that both types of cuts are valid and that the second type of cut can dominate both the first type and the original cut. We use the cut strengthening in conjunction with the extended supporting hyperplane algorithm, and numerical results show that the strengthening can significantly reduce both the number of iterations and the time needed to solve convex MINLP problems.

## Introduction

Mixed-integer nonlinear optimization (MINLP) arises in many applications across engineering, manufacturing, and the natural sciences (Boukouvala et al. 2016). An important MINLP subclass features exclusively convex nonlinearities, i.e. the nonconvexity of the MINLP comes only from the discrete variables (Kronqvist et al. 2019). Convex MINLP is highly relevant in diverse fields including process synthesis (Durán-Peña 1984; Duran and Grossmann 1986a), portfolio optimization (Bienstock 1996; Frangioni and Gentile 2006; Bonami and Lejeune 2009), and constrained layout (Castillo et al. 2005; Sawaya and Grossmann 2007). For MINLP with nonconvex nonlinearities, e.g. heat integration of chemical processes (Duran and Grossmann 1986c) and pooling problems (Misener and Floudas 2009), optimization algorithms assuming convex nonlinearities may generate excellent primal heuristics to the original optimization problem (Duran and Grossmann 1986b; Bonami et al. 2008; D’Ambrosio et al. 2012).

Convex MINLP represents a highly successful subclass of optimization problems, e.g. algorithm developers often develop convex approximations of nonconvex engineering relationships (Geiler et al. 2015) or decompose their optimization problems into a series of convex MINLP problems (Lundell and Westerlund 2018; Nowak et al. 2018). A wide range of efficient solver software is developed specifically for convex MINLP (Grossmann et al. 2002; Bonami et al. 2008; Lastusilta 2011; Bernal et al. 2020; Lundell et al. 2020; Mahajan et al. 2017; Kröger et al. 2018; Melo et al. 2020). The success of convex MINLP derives from the seminal work of Duran and Grossmann (1986b) in developing the outer approximation (OA) algorithm. The work by Duran and Grossmann (1986b) became pivotal in solving convex MINLP problems because of the algorithm’s strong convergence properties for a wide range of problem classes (Quesada and Grossmann 1992; Fletcher and Leyffer 1994) and its speed in solving practical problems (Bonami et al. 2008). In a recent benchmark by Kronqvist et al. (2019) it was shown that several of the most efficient convex MINLP solvers are based on the OA algorithm.

The concept of using an outer approximation of the nonlinear constraints for MINLP problems, developed by (Duran and Grossmann 1986b; Geoffrion 1972), forms the core of several other convex MINLP algorithms, e.g., extended cutting plane (ECP) (Westerlund and Petterson 1995; Westerlund and Pörn 2002), feasibility pump (Bonami and Gonçalves 2012), extended supporting hyperplane (ESH) (Kronqvist et al. 2016), and the center-cut algorithm (Kronqvist et al. 2018a). Further developments of the OA algorithm, incorporating quadratic approximations and regularization, has been presented by Su et al. (2018) and Kronqvist et al. (2018b). These algorithms could commonly be referred to as outer approximation type algorithms, although this classification is seldom used.

This paper focuses on deriving strong cutting planes for convex MINLP problems, resulting in tight outer approximations, by exploiting disjunctive structures in the problem. We use cuts obtained by the ESH algorithm as a basis, and we develop a framework for strengthening the cuts by considering the integer restrictions. The cut strengthening technique is not unique to the ESH algorithm and could also be used with an OA, ECP or generalized Benders decomposition (Geoffrion 1972) framework. The main motivation behind using the ESH algorithm is that the algorithm tends to generate a single strong cut per iteration. The ESH cuts are actually as tight as possible with regards to the nonlinear constraints (Kronqvist et al. 2016), but they do not in general form supporting hyperplanes to the convex hull of all integer feasible solutions. Here we develop a framework for strengthening the ESH cuts, which results in two new types of cuts that are always as tight or tighter than the ESH cut. The new cuts can give both a tighter representation of the nonlinear constraints as well as a tighter continuous relaxation. By obtaining a tighter outer approximation of the nonlinear constraints, we can reduce both the number of iterations and the time needed to solve problems.

Cutting planes that strengthen the continuous relaxation are nowadays an essential part of an efficient mixed-integer linear programming (MILP) solver (Achterberg and Wunderling 2013; Linderoth and Lodi 2011), and there is an active interest in developing similar cuts for convex MINLP. Disjunctive cutting planes for convex MINLP originate from the fundamental contributions of Ceria and Soares (1999) and Stubbs and Mehrotra (1999), and further developments are presented in (Trespalacios and Grossmann 2016). Lift-and-project cuts were first introduced in MILP by Balas et al. (1993), and this technique has later been adopted within convex MINLP. By linearizing the constraints, a polyhedral outer approximation can be used to derive lift-and-project cuts through a cut generating LP (Zhu and Kuno 2006; Bonami 2011; Kılınç et al. 2017; Serra 2020). An alternative approach is presented by Lodi et al. (2019), where they obtain cuts directly by solving cut generating conic programs. Other types of cuts used within MINLP includes different types of mixed-integer rounding cuts (Gomory 1960; Atamtürk and Narayanan 2010), reformulation linearization technique (RLT) based cuts (Sherali and Adams 2013; Misener et al. 2015), and split cuts (Modaresi et al. 2015).

The cut strengthening techniques presented here can be viewed as an alternative approach to the previously mentioned lift-and-project and disjunctive cuts. However, our cut strengthening procedure is more focused on obtaining a tight MILP relaxation, than getting the best improvement for the continuous relaxation. The cuts are generated by selecting a disjunction of the MINLP problem and strengthening an ESH cut over the convex hull of the selected disjunction. Trespalacios and Grossmann (2016) use a somewhat similar idea, where they derive a supporting hyperplane for a nonlinear disjunction by solving a separation problem. Instead of solving a separation problem, we strengthen the ESH cut by deriving the smallest possible right-hand side values to the ESH cut that are still valid for each term of the disjunction. This enables us to effectively use individual right-hand side values for each term of the disjunction, making the cut tight for each disjunct. A similar approach is used by Trespalacios and Grossmann (2015) to construct tighter big-M reformulations of generalized disjunctive programs. We determine right-hand side values of the cuts by solving independent convex NLP problems in the original variable space and do not rely on the convex hull formulation of the disjunctions. By doing so, numerical difficulties associated with the perspective function are avoided and instead of solving a larger (lifted) problem, we solve several smaller independent (parallelizable) problems. This approach also enables us to identify some infeasible integer assignments and to handle numerical tolerances in a straightforward fashion. To the authors’ best knowledge, this is a novel cut strengthening technique for convex MINLP.

The paper is organized as follows. Section 2 gives a short description of the ESH algorithm, along with the necessary assumptions on the MINLP problems. Section 3 presents the theory and techniques used for the cut strengthening, and a cut strengthening algorithm is presented in Sect. 4. Section 5 presents an algorithm for solving convex MINLP problems that combines the ESH algorithm with the cut strengthening techniques. Finally, some numerical results are presented in Sect. 6.

## Background

First, we define the class of problems considered within the paper and state the assumptions needed to guarantee convergence of the ESH algorithm. The disjunctive structure that the cut strengthening technique builds upon is also presented in this section. The second part of this section briefly describes the ESH algorithm, which is later used to generate cuts and forms the basis of the convex MINLP algorithm in Sect. 5.

### Problem statement

The most commonly used, and most practical, definition of a convex MINLP problem, is that all of the nonlinear constraints and objective are given by convex functions (Gupta and Ravindran 1985; Quesada and Grossmann 1992; Westerlund and Petterson 1995; Bonami et al. 2012). Throughout the paper, we use this definition of convexity. Without loss of generality, we only consider convex MINLP problems with the following structure

where \(g_j: {{\mathbb {R}}^{n}}\rightarrow {{\mathbb {R}}}\) are convex continuously differentiable functions. Here, \(I_{{\mathbb {Z}}}\) is a set containing the indices of all the integer variables. To clarify the notation, \(x_i\) referrers to the i-th element of the variable vector \(\mathbf {x}\). The feasible set defined by the nonlinear constraints will be referred to as the nonlinear feasible set, and it is given by

To simplify the notation, we will also introduce a set *L* defined by the linear constraints and a set *Y* given by the variable domains

To ensure convergence of the ESH algorithm, we need to make the following assumptions of problem (MINLP).

### Assumption 1

The linear constraints form a compact set.

### Assumption 2

The continuous relaxation of problem (MINLP) satisfies Slater’s condition (Slater 1950).

For the cut strengthening procedure, we make the following assumption on the problem structure.

### Assumption 3

The MINLP problem contains at least one exclusive selection constraint of binary variables, i.e., \(\exists \ I_D \subset I_{{{\mathbb {Z}}}}:\ x_i \in \left\{ 0, 1\right\} \ \ \forall i \in I_D\), and either one of the constraints

appears in the problem.

For the sake of simplicity and clarity, we will throughout the paper only focus on the exclusive selection constraint (2). The second type of exclusive selection constraint (3), can trivially be converted into the first type by introducing a slack binary variable and can be handled by the same approach.

The exclusive selection constraints arise, for example, from the representation of disjunctive constraints through the so-called *big-M* or *convex hull* formulation (Balas 1979; Raman and Grossmann 1994; Trespalacios and Grossmann 2014). Note that we do not restrict all of the integer variables to be binary variables, nor do we assume the problems to have disjunctive constraints of a specific type. The cut strengthening simply requires that the problem contains at least one exclusive selection constraint, which is used for strengthening the cut. However, the cut strengthening is most powerful in case the problem contains the big-M constraints, resulting in a weak continuous relaxation. Therefore, we focus on problems containing big-M constraints.

For the cut strengthening to be computationally efficient, the number of elements in \(I_D\) should be less than the elements in \(I_{{\mathbb {Z}}}\). Throughout the paper, we also assume that the main challenges in solving problem (MINLP) arise from the integer restrictions. Consequently, we assume that a continuous relaxation of the problem is significantly easier to solve than the MILP relaxations used by OA, ECP, and ESH. This is often the case for convex MINLP problems which is, for example, shown by the numerical result in Muts et al. (2020) and Su et al. (2015).

### The extended supporting hyperplane algorithm

The ESH algorithm was presented by Kronqvist et al. (2016) as a method for solving convex MINLP problems, and it builds upon ideas presented by Veinott Jr (1967). It was proven by Eronen et al. (2017) that the ESH algorithm is directly applicable to nonsmooth MINLP problems with constraints given by pseudoconvex functions. Properties of the ESH algorithm have also been further analyzed by Serrano et al. (2019).

The ESH algorithm constructs a tight polyhedral outer approximation of the nonlinear feasible set *N*, by generating supporting hyperplanes to the set. The polyhedral outer approximation at iteration *k* is given by

where \(\bar{\mathbf {x}}^i\) are points on the boundary of *N* and \(A_i\) contains the indices of all constrains active at \(\bar{\mathbf {x}}^i\). From convexity it directly follows that \(N \subseteq \hat{N_k}\), and \(\hat{N_k}\) is commonly referred to as an outer approximation of *N*.

A new trial solution \(\mathbf {x}^{k+1}\) is obtained by solving the following MILP relaxation

A lower bound on the optimal objective value of problem (MINLP) is given by \(\mathbf {c}^\top \mathbf {x}^{k+1}\), where \(\mathbf {x}^{k+1}\) is an optimal solution to the MILP relaxation.

The trial solutions obtained by solving problem (MILP-r) will all be outside of the nonlinear feasible set *N*, before the very last iteration. Therefore, linearizing the nonlinear constraints at the trial solutions \(\mathbf {x}^{k}\) would, in general, not form supporting hyperplanes to *N* and would result in weaker cuts. To obtain supporting hyperplanes, ESH performs an approximative projection of the trial solution \(\mathbf {x}^{k}\) onto \(N\cap L\). A point in the interior of \(N\cap L\) is needed for the projection, and such a point is obtained by solving the convex continuous problem

For the approximative projection of \(\mathbf {x}^{k}\), we define the one-dimensional function

for \(\lambda \in [0, 1]\). Using a simple root-search algorithm we can obtain a \(\lambda ^k\) such that \(F\left( \lambda ^k\right) = 0\). The approximative projection of \(\mathbf {x}^{k}\) onto \(N\cap L\) is then given by

Now, if the active constraints are linearized at \(\bar{\mathbf {x}}^k\) we obtain the following cuts

which forms supporting hyperplanes to \(N\cap L\). The supporting hyperplanes are then added to the current polyhedral outer approximation to form \({\hat{N}}_{k+1}\), which ensures that \(\bar{\mathbf {x}}^k \notin {\hat{N}}_{k+1}\).

The ESH algorithm repeats the procedure of solving (MILP-r) and improving the outer approximation by generating supporting hyperplanes. To improve the computational performance, the algorithm starts by further relaxing (MILP-r) and solving LP relaxations to quickly generate an outer approximation. For more details and computational enhancements on the ESH algorithm see Lundell et al. (2018).

The cuts generated by the ESH algorithm are as tight as possible with regards to \(N \cap L\). However, there is no guarantee that the algorithm generates supporting hyperplanes to the convex hull of \(N\cap L\cap Y\). Therefore, it can be possible to further strengthen the cuts by considering the integrality restrictions. To illustrate the possible strengthening of the cuts, consider the following example

The example contains the disjunctive constraint that the \((x_1,x_2)\)-variables must be within one of three circles, which is represented by the big-M formulation. The value 29.944 is, in this case, the tightest common value for the big-M coefficients. A stronger problem formulation could simply be obtained by using individual M values for each constraint, which can easily be determined as described in the Appendix. We only use the weaker formulation in order to better highlight differences between the cuts. Figure 1 shows the feasible set of problem (EX1) along with the continuously relaxed feasible set projected down onto the \((x_1,x_2)\)-space.

In the first iteration, the ESH algorithm will generate the following cut

which forms a supporting hyperplane to \(N\cap L\) but not a supporting hyperplane to convex hull of \(N \cap L\cap Y\). From Fig. 1, it is clear that the cut given by Eq. (8) is not as tight as possible when considering the integer properties. In the next section, we present a technique to further tighten the cut by utilizing the disjunctive structures of the MINLP problem.

## Cut strengthening

From the example in the previous section, it can be observed that the ESH cut can be tightened by simply reducing the right-hand side and still remain valid for the integer feasible set, i.e., \(N\cap L \cap Y\). To reduce the right-hand side, we will consider an exclusive selection constraint, see assumption 3, and determine the smallest right-hand side values for each selection. This enables us to strengthen the cut by reducing the right-hand side alone or to further strengthen the cut by assigning individual right-hand side values for each assignment of the exclusive selection constraint.

First, we select an index set \(I_D \left( I_D \subset I_{{\mathbb {Z}}}\right)\) that contains the indices of all the binary variables included in an exclusive selection constraint of the MINLP problem. By using the ESH algorithm we obtain the cut

which forms a tight valid inequality for \(N\cap L\). To tighten cut (9), consider the following disjunctive programming (DP) problem

This DP problem can be solved as a convex NLP through the convex hull formulation (Ceria and Soares 1999; Stubbs and Mehrotra 1999; Lee and Grossmann 2000). Formulating problem (10) as a convex NLP through a convex hull formulation can cause numerical difficulties, such as division by zero and non-smoothness (Sawaya and Grossmann 2007), and the problem will contain \(|I_D|\) copies of the variables. Instead of solving (10) as a single large problem we solve it as smaller individual convex problems, by considering the following alternative formulation of problem (10)

By solving each inner problem of (11) separately we can determine \(z^*\) as the largest \(b_i\). This approach requires \(|I_D|\) independent convex NLP problems to be solved, but computationally it can be more efficient than solving a single problem with \(|I_D|\) copies of the variables. Using \(z^*\) as the new right-hand side value of cut (9), we form the tightened cut

### Proposition 1

*The cut given by Eq*. (12) *forms a valid inequality for* \(N \cap L \cap Y\), *and is at least as tight as the cut given by Eq*. (9).

### Proof

From optimality of problem (10) it directly follows that cut (12) forms a supporting hyperplane to the feasible set of problem (10), which contains \(N\cap L \cap Y\). Since the feasible set of problem (10) is contained within \(N\cap L\), it follows that \(z^* \le \beta\). \(\square\)

Solving (10) as smaller individual convex problems also enables us to further tighten the cut. To further strengthen the cut, we considering each term of the disjunction in problem (10) and form a convex NLP problem for each \(i \in I_D\)

Note that each problem (NLP-i) is a subproblem of problem (11). To simplify the derivation and analysis, we first assume that all \(i \in I_D\) result in a feasible problem (NLP-i). Solving problem (NLP-i) for each \(i \in I_D\) gives the values \(b_i\) that can be used as individual right-hand side values for each integer assignment of the exclusive selection constraint (2). A new strengthened cut is then given by

and the properties of the new cut are presented in the following two theorems.

### Theorem 1

*The cut given by Eq*. (13) *forms a valid inequality for* \(N\cap L\cap Y\).

### Proof

The theorem is easily proven by contradiction. First, assume \(\exists \ \bar{\mathbf {x}} \in N\cap L \cap Y :\)

Due to the exclusive selection constraint, one and only one of the binary variables \(x_{i \in I_D}\) can be nonzero. Let *j* be the index of the nonzero binary variable, and the strict inequality (14) can now be written as

By assumption, \(\bar{\mathbf {x}}\) must satisfy all constraints of problem (NLP-i). This implies that \(b_j\) cannot be an optimal solution to problem (NLP-i), and this leads to a contradiction. \(\square\)

Before analyzing the tightness of the cuts, we first describe our definition of a tighter cut. Here we consider cut (13) to be tighter than cut (12) in the sense that any \(\mathbf {x}\) satisfying Eq. (13) will satisfy Eq. (12), but not vice versa. In integer programming, this tightness relation is commonly referred to as cut (13) strictly dominating cut (12), e.g., see Balas and Margot (2013).

### Theorem 2

*The cut given by Eq*. (13) *is always as tight or tighter than the cut given Eq*. (12).

### Proof

Since \(z^*\) is chosen as the maximum of \({\alpha }^\top \mathbf {x}\) over all integer assignments of the exclusive selection constraint intersected with \(N\cap L\), it follows that \(z^* = max_{i\in I_D} \{b_i\}\). Therefore, each \(b_i\) can be split into two parts \(b_i = z^* -\varDelta _i\), where each \(\varDelta _i\ge 0\). The cut given by Eq. (13) can now be written as

proving that the cut is always as tight as cut (12). Furthermore, if a single \(\varDelta _i >0\), then the cut given by (13) will strictly dominate cut (12). \(\square\)

Earlier we assumed that all \(i \in I_D\) result in a feasible problem (NLP-i), which is not a necessary assumption for the cut strengthening. Finding such infeasible integer assignments enables us to remove the corresponding binary variable, as further described in the following proposition.

### Proposition 2

*If* \(i \in I_D\)*result in an infeasible problem* (NLP-i), *then the binary variable* \(x_i\)*can be eliminated by permanently fixing the variable to zero.*

### Proof

In problem (NLP-i) all variables, except those included in the exclusive selection constraint, are relaxed to continuous variables and they are only restricted by the original constraints. Variable \(x_i\) is fixed to one, which automatically fixes the other variables in the exclusive selection constraint to zero. Therefore, the only case where problem (NLP-i) can be infeasible is when \(x_i=1\) is an infeasible partial integer assignment to the MINLP problem. \(\square\)

To illustrate the difference between the two cuts, we again consider problem (EX1). By applying the cut strengthening technique to the cut given by the ESH algorithm, we can generate the following two cuts

The outer approximations obtained given by the two different cuts are shown in Fig. 2. The figure shows a clear advantage of the second cut, resulting in a significantly tighter linear relaxation of the MINLP problem. However, comparing Figs. 1 and 2 show that both cuts are significantly stronger than the standard ESH cut.

In an outer approximation type algorithm, it is not only important to obtain a tight continuous relaxation, but also to obtain a tight MILP relaxation, i.e., a tight linear relaxation for given integer assignments. The two are obviously related, but it is possible to have a tight MILP relaxation with a weak continuous relaxation. To further illustrate the differences between the two types of cuts, we analyze how the feasible region of the cuts to problem (EX1) varies with the feasible integer assignments. Figure 3 shows the feasible region of the cut given by Eq. (17) for each feasible integer assignment. The figure shows that cut (17) is tight for one of the feasible integer assignments, but not as tight as possible for the other two.

Figure 4 shows the cut given by Eq. (18) forms a supporting hyperplane to the feasible set of each term of the disjunction in problem (EX1), i.e., for each feasible integer assignment the cut is as tight as possible. The example highlights the fact that the individually tightened cuts, i.e., cuts formed by Eq. (13), can give both significantly tighter continuous and MILP relaxations than the cut given by Eq. (12) and the original ESH cut.

In this section, we have presented a framework for strengthening cuts obtained by the ESH algorithm. However, the same approach can also be used to strengthen cuts obtained by a similar algorithm, such as ECP, OA or generalized Benders decomposition. The next section will focus more on the computational aspects, and how to practically utilize the cut strengthening framework within a solver.

## A cut strengthening algorithm

This section focuses on the computational aspects and how to utilize the cut strengthening techniques from the previous section in an algorithm. We present a simple strategy for selecting one out of multiple exclusive selection constraints, and describe some computational enhancements along with a discussion on how to deal with tolerances.

The cut strengthening techniques in the previous section utilizes the exclusive selection constraint (2) to tighten cuts of the type given by Eq. (9). However, MINLP problems can contain multiple exclusive selection constraints, e.g., originating from multiple disjunctive constraints. Given a cut, there is a choice of which exclusive selection constraint and the corresponding variables to choose for the tightening procedure. Ideally one wants to choose the exclusive selection constraint with the binary variables \(x_{i}\) for \(i \in I_D\) such that the coefficients \(b_i\) obtained by solving (NLP-i) are as small as possible. However, such an optimal choice cannot trivially be determined, and instead, we will make the choice based on the variable connections.

Suppose that we have obtained cut (9), which is given by linearizing the nonlinear constraint \(g_j(\mathbf {x})\le 0\). To compare the different exclusive selection constraints, and their corresponding variables \(x_{i}\) for \(i \in I_D\), we check the connections of the variables \(x_{i}\) for \(i \in I_D\) to the constraint \(g_j(\mathbf {x}) \le 0\). Here we consider two types of connections, *direct connections* and *step-one connections*. Variable \(x_{i}\) is directly connected to \(g_j(\mathbf {x}) \le 0\), if the variable is included in the constraint. In a step-one connection, the variable \(x_{i}\) is included in another constraint (linear or nonlinear) that has at least one variable in common with \(g_j(\mathbf {x}) \le 0\). The number of direct connections in an exclusive selection constraint is given by number of variables in \(I_D\) that are directly connected to the nonlinear constraint \(g_j(\mathbf {x}) \le 0\), and similarly for the step-one connections. Here, we use the following heuristic rule for selecting an exclusive selection constraint.

### Rule 1

*Given cut* (9), *select the exclusive selection constraint with the largest number of direct connections to the corresponding nonlinear constraint. If there are no direct connections, chose the one with the largest number of step-one connections. In case of multiple exclusive selection constraints with the same number of connections, chose one of them randomly.*

A feasible solution to the MINLP problem \(\hat{\mathbf {x}}\) can also be utilized within the cut strengthening procedure. This is done by simply including the objective reduction constraint

as a constraint in problem (NLP-i). Including the objective reduction constraint can further reduce the coefficients \(b_i\), resulting in a stronger cuts. Furthermore, including the objective reduction constraint can enforce infeasibility on some partial integer assignments, and cause assignments in problem (NLP-i) to be infeasible. As mentioned earlier, the only way problem (NLP-i) can be infeasible is if the partial assignment, i.e., \(x_i=1 \ i\in I_D,\ x_j=0 \ \forall j\in I_D \setminus i\), is infeasible for the MINLP problem. Finding such infeasibilities is desirable since it allows us to eliminate a variable from the MINLP problem by fixing it to zero.

Including the previously tightened cuts into problem (NLP-i) can also improve performance by tightening the continuous relaxation. Obtaining a tighter continuous relaxation in problem (NLP-i) can further strengthen the cut and infer infeasibilities. In the numerical results presented in Sect. 6, it was noticed that including the tightened cuts and an objective reduction constraint can greatly help in identifying infeasible or non-optimal partial integer assignments. The ability to identify and eliminate these from the search space can result in fewer iterations but can also reduce the complexity of the MILP relaxations, used by algorithms such as ESH, ECP, and OA.

The cut strengthening techniques are summarized as pseudo-code in Algorithm 1. In the algorithm, the two different cuts from the previous section are considered as different strategies. The cut given by Eq. (13) is referred to as a *Multi Tightening* (MT) strategy, since it effectively uses multiple values for the right-hand side. Similarly, the cut given by Eq. (12) is referred to as a *Single Tightening* (ST) strategy.

### Computational comments

When solving an optimization problem to generate a cut, it is important to take the solver tolerances into consideration. The tolerances are especially important when dealing with nonlinear problems, where it is rare that a solver returns an *exact* optimal solution. In the cut strengthening procedure, presented in the previous section, the solver tolerance will only affect the coefficients \(b_i\). If we can ensure that the solution of problem (NLP-i) is within an \(\epsilon\)-tolerance from the true optimal objective value, then the suboptimality can easily be handled by relaxing the cut, i.e., adding \(\epsilon\) to the right-hand side.

As a comparison, some other techniques to obtain strong cuts for convex MINLP problems use the minimum distance (separation) problem to generate cuts (Stubbs and Mehrotra 1999; Bonami et al. 2009; Trespalacios and Grossmann 2016). In these approaches, the minimizer of an NLP subproblem forms the coefficients of both the left- and right-hand side of the cut. For these cuts, it is important to obtain a high optimality accuracy in the variable space, since it affects both the angle and level of the cut. Issues with numerical tolerances can be reduced or effectively eliminated, e.g., by post-processing the cut and optimizing over each term in the disjunction to determine a valid right-hand side, but this comes at a significant computational expense. However, since both the coefficients on the left- and right-hand side are optimized, this approach is not limited to a specific cut but can basically generate any supporting hyperplane to the convex hull of the disjunction. Generating cuts by solving the separation problem can, therefore, result in stronger cuts than the cut strengthening procedure which is limited by the structure of the original cut.

In the cut strengthening procedure, we optimize over each term of a disjunction in problem (10) separately. This allows us to obtain stronger cuts and identify infeasible partial integer assignments, as described in Sect. 3. In an efficient implementation, the individual problems given by (NLP-i) can be solved in parallel since they are completely independent. This approach also has computational advantages, since the convex hull formulation and the perspective function, in particular, comes with numerical challenges. There are formulations to avoid division by zero (Sawaya 2006) and for some types of problems, the convex hull is second-order cone representable, which can be handled more efficiently (Ben-Tal and Nemirovski 2001). However, if some of the partial integer assignments are infeasible it can cause difficulties for solvers since the convex hull of problems (NLP-i) will then have an empty interior even though it is feasible. Such issues can be eliminated by analyzing each term of the disjunction in a pre-processing and eliminating infeasible terms, but this also comes at a significant computational expense.

As previously mentioned, our cut strengthening approach is limited to a specific cut and, therefore, it may result in a weaker cut compared to generating the cut from solving a separation problem. The main advantage of our cut strengthening approach is that the cut is obtained by solving several smaller independent convex problems, compared to solving the larger separation problem. Therefore, the trade-off of our cut strengthening approach is a reduced computational complexity at the expense of a possibly weaker cut.

## Computational setup

To compare the cuts and to show the advantage of the cut strengthening, we have included a numerical study where we compare the ESH algorithm with and without the cut strengthening technique. These are preliminary results and are mainly intended as a proof of concept. To focus on the effects of cut strengthening, we apply them to a basic implementation of the ESH algorithm. As shown by Lundell et al. (2016, 2020) several other techniques can be combined with the algorithm to improve the computational performance, such as early MILP termination and multiple cut generation strategies. Before presenting the results, we will give a more detailed description of the computational setup.

### A Convex MINLP algorithm

To solve the MINLP problems we will use the ESH algorithm, which was briefly presented in Sect. 2. In each iteration, we use the cut strengthening algorithm from Sect. 4 to strengthen the cut generated by the ESH algorithm. It is known that the basic ESH algorithm tends to only generate a single cut per iteration (Kronqvist et al. 2016; Lundell et al. 2017). However, in some iterations the root-search can result in a point where multiple constraints are active, resulting in multiple cuts. Here, we will only strengthen one cut per iteration. If we obtain multiple cuts in an iteration, then we randomly pick one of them for the strengthening procedure. We do not use the LP-preprocessing from (Kronqvist et al. 2016), which simplifies the algorithm and allows us to better focus on the effect of the cut strengthening.

Besides the basic ESH algorithm, we only include two simple primal heuristics that have proven to be effective within this framework (Kronqvist et al. 2016; Lundell et al. 2018). Without any primal heuristics the ESH algorithm will generally not obtain feasible solutions during the solution procedure, making it difficult to terminate based on the optimality gap. Therefore, the primal heuristics is an important enhancement to the ESH algorithm and practically needed within a solver. From the numerical tests, we also noticed that feasible solutions improve the cuts and help to identify non-optimal partial integer assignments. The primal heuristics we use here are checking the alternative solution in the MILP solver’s solution pool, and fixing the integer assignments in the MINLP and solving the resulting convex NLP problem in every fourth iteration. The primal heuristics are summarized as a pseudo-code in Algorithm 2.

For more details on heuristics in combination with the ESH algorithm, see (Lundell et al. 2020). For a summary of different primal heuristics see, for example, (Berthold 2014; D’Ambrosio et al. 2012).

As a termination criterion we use the relative optimality gap defined as

where ub and lb are upper and lower bounds on the optimal objective value of the MINLP problem. Here, ub is given by the best found feasible solution and lb is given by \(\mathbf {c}^\top \mathbf {x}^{k}\), where \(\mathbf {x}^{k}\) is given by problem (MILP-r). We consider the MINLP problem as solved when the relative gap is reduced to \(10^{-3}\), thus proving that the best found solution is within \(0.1\%\) of the global optimum. The method used for solving the MINLP problems is summarized as a pseudo-code in Algorithm 3.

### Implementation and hardware

For the numerical comparison, we use a simple implementation of the ESH algorithm utilizing IPOPT 3.12.9 (Wächter and Biegler 2006) and Gurobi 8.1 (Gurobi 2019) as subsolvers for NLP and MILP subproblems. For reading and parsing the MINLP problems, we use the open-source MATLAB toolbox OPTI Toolbox (Currie and Wilson 2012). In the current implementation, we are not able to run the cut strengthening NLP subproblems in parallel, which could significantly speedup the cut strengthening. However, the computational results in the following section still clearly show an advantage of the cut strengthening, both in terms of total computational time and in number of iterations.

The numerical comparisons are performed on a basic desktop computer with an Intel i7-7700k processor, 16 GB RAM, and Windows 10. For the subsolvers, we use default settings except for allowing Gurobi to run on 8 threads. By running Gurobi on multiple threads, the MILP subproblems are solved faster and this is simply done by changing the Threads-parameter. The root-search, in the approximative projection, is done to a tolerance of \(10^{-16}\) in the \(\lambda\)-variable.

## Numerical results

To test the efficiency of the cut strengthening, we apply the simple implementation of the ESH algorithm, described in Algorithm 3, to a set of test problems. The ESH algorithm forms the baseline for the numerical comparison, and we compare how the cut strengthening techniques affect the number of iterations and solution times. As already mentioned, the results are mainly intended as a proof of concept to show the impact of the cut strengthening. By using techniques such as early stopping (Lundell et al. 2018) and running the cut tightening NLP problems in parallel it would be possible to significantly reduce the solution times.

For the numerical test we have chosen convex MINLP instances from MINLPLib (MINLPLib 2020) containing at least one exclusive selection constraint. The cut strengthening is mainly intended to strengthen the linear approximation of the nonlinear constraints, and it is expected to be most beneficial for problems containing the big-M formulation of disjunctions containing nonlinear constraints. The disjunctions are identified through the exclusive selection constraints, and the cuts are strengthened through a tighter representation of the disjunctions. If nonlinear disjunctions are represented by the convex hull formulation, our approach will not necessarily be able to tighten the relaxation. For example, if a nonlinear disjunction is represented by the convex hull, then the ESH algorithm can generate supporting hyperplanes to the convex hull of the disjunction and the ST-strategy will not be able to change such cuts. The MT-strategy could still give a tighter approximation for integer feasible solutions, as it may cut off parts of the convex hull for some integer values as shown in Fig. 4. Since the cut strengthening is an expensive operation, it is better suited for problems with the big-M formulation as the impact will be more significant and the subproblems are smaller. Therefore, we focus on problems where disjunctions, with either linear or nonlinear constraints, are represented by the big-M formulation. The problems we consider from MINLPLib are different versions of the problems *clay, flay, slay, sssd*, and *tls*. These problems represent optimization tasks such as trimloss problems (Harjunkoski et al. 1998), optimal placement tasks (Sawaya 2006) and service systems design (Elhedhli 2006). We also consider a problem called *stockcycle* (Silver and Moon 1999), which is known to be difficult to solve without any reformulations (Kronqvist et al. 2018c). Furthermore, we also consider a class of test problems called *p_ball*, that are described in the Appendix. The *p_ball* instances contain several relatively large nonlinear disjunctions, and are designed to be challenging due to both the nonlinearity and the combinatorial aspects. We use a 2 h time limit for all the problems except for *stockcycle*, where we use a time limit of 96 h.

The results are presented in Table 1, showing both the number of iterations and the time needed to solve each problem. The table shows that both cut strengthening techniques can significantly reduce the number of iterations needed to solve the problems. However, the table shows a clear advantage of the multi tightening (MT) strategy. This result aligns well with the theory since cut (13) used in the MT strategy can dominate the cuts used by the single tightening (ST) strategy. On average, the ST strategy reduces the number of iterations by a factor of 1.5, and the MT strategy gives a further reduction with a factor of 2.9 on average. Both cut strengthening strategies give a significant reduction in solution times, but the MT strategy has a clear advantage and is faster by a factor of 2 compared to the ST strategy. The performance in terms of speed for the strategies is illustrated in Fig. 5, which shows the performance profiles of the different strategies. From the figure, it can be observed that MT strategy gives a great advantage for the more challenging problems.

As shown in Table 1, the cut strengthening is especially powerful for the *clay* and *p_ball* problems. These problems contain nonlinear disjunctions that are represented by the big-M formulations, giving weak continuous relaxations that can be efficiently strengthened by the cut strengthening technique. For the *p_ball* problems, the MT cut strengthening reduces the number of iterations by a factor of 11.7 on average. Without the cut strengthening the larger *p_ball* problems are practically intractable with the ESH algorithm, and the optimality gap remained large after 2 h.

As previously mentioned, the cut tightening comes at a computational cost of solving convex NLP subproblems. For example, problem *p_ball_40b_5p_4d* contains nonlinear disjunctions of size 40, which results in 40 subproblems for the cut tightening per iteration. Solving these subproblems accumulates to about 35% of the total solution time. However, this is well compensated for by the great reduction in the number of iterations.

It is worth mentioning that the cut strengthening techniques do not necessarily result in computationally more demanding iterations. For example, the average iteration time for *slay10m* is 10.6 seconds with the ESH strategy and less than 2 seconds with both the ST and MT strategies. There are two reasons behind the significantly faster iterations. First, the strengthened cuts can result in a tighter continuous relaxation, making the MILP relaxations easier to solve. But more importantly, the cut strengthening procedure can sometimes identify infeasible or non-optimal integer assignments during the solution procedure, see Sect. 3 for details. For *slay10m*, the cut strengthening is able to fix 53 of the binary variables to zero. Similarly, the cut strengthening eliminates 299 of the 432 binary variables in stockcycle. By further studying these problems, we found that the binary variables fixed by the cut tightening cannot trivially be removed, e.g., by performing LP-based bounds tightening. Some of the integer assignments immediately resulted in problem (NLP-i) to be infeasible in the cut tightening, and some became infeasible due to bounds on the objective and accumulation of strengthened cuts. The ability to identify the infeasible or non-optimal integer assignments can greatly reduce the complexity of the MINLP problems and comes as a desirable side effect of the cut tightening.

MINLPLib also contains a large number of problems called *syn* and *rsyn* (Türkay and Grossmann 1996; Sawaya 2006). These problems do have a disjunctive structure, although mainly involving linear constraints. These problems are all easy to solve, and on average they require less than 10 iterations and 3 seconds with the ESH algorithm. There are in total 24 *rsyn* and 24 *syn* problems with the big-M formulation. For these problems, the cut strengthening did not provide any significant advantages. The average times and number of iterations for these two problem types are shown in Table 2.

For the *rsyn* and *syn* instances the cut tightening procedure has little effect on the cuts, and does not result in fewer iterations. In these problems the nonlinear constraints only contain three variables, and there is only a single nonlinear variable in each constraint. It is possible that these constraints are tight to begin with, which would explain why the strengthening does not have much effect for these specific problems.

The cut strengthening seems to be most efficient for problems that contain disjunctions with nonlinear constraints, e.g., *clay* and *p_ball* problems. Some aspects of why the multi tightening strategy works particularly well for these problems are described in the next section. For problems with nonlinear disjunctions, the choice of which exclusive selection constraint to perform the strengthening on is also straight forward since binary variables will be present in the nonlinear constraints. The cut strengthening also performed well on the problems *slay*, *sssd*, and *stockcyckle*, where there are only disjunctions with linear constraints.

### Comparing strong problem formulations and cut strengthening

These results show that the strengthening procedure can give a great advantage for problems where disjunctions are represented by big-M constraints. To further analyze the cut strengthening procedure, we compare the cut strengthening procedure with applying the basic ESH algorithm on the same MINLP instances in a convex hull form, where all or some disjunctions are represented by the convex hull formulation. For this test, we use all problems from the previous section that are available in both a big-M and convex hull form. The results are presented in Table 3. Here we only use the multi strengthening technique, since it results in stronger cuts than the single tightening at the same computational cost.

For nonlinear disjunctions represented by a convex hull formulation, the ESH algorithm can generate supporting hyperplanes to the convex hull of the disjunction. Therefore, applying the ESH algorithm to MINLP instances where nonlinear disjunctions are represented by the convex hull can result in significantly tighter cuts compared to cuts obtained from big-M constraints. This can be seen from the results in Table 3, which shows that the ESH algorithm requires fewer iterations for most of the problems in the convex hull form. The ESH algorithm is still faster on some of the problems in big-M form, which is most likely due to the smaller subproblems.

It is important to notice that the cut strengthening procedure will not necessarily result in similar cuts as applying the ESH algorithm to the convex hull formulation of the problem. This is well illustrated by problem (EX1), where the single tightening strategy does not result in a supporting hyperplane to the convex hull of the disjunction as illustrated in Fig. 2. The multi tightening strategy forms a supporting hyperplane to the convex hull of the disjunction, but it still behaves differently compared to a cut obtained by applying the ESH algorithm to the convex hull form of the problem. Figure 4 shows that the multi tightened cut not only forms a supporting hyperplane to the convex hull of the disjunction, but for each feasible integer assignment it also forms a supporting hyperplane to the corresponding term of the disjunction. For problem (EX1), a single multi tightened cut effectively acts as a supporting hyperplane to three different nonlinear constraints for each feasible integer assignments. The multi tightened cuts behave similarly for the *p_ball* instances, where each disjunction corresponds to assigning a point to one of the balls. For a feasible integer assignment, a cut obtained by multi tightening will then act as a supporting hyperplane to each ball for one of the points. For example, for the problem *p_ball_40b_5p_3d* a multi tightened cut effectively behaves as a tight cut for 40 different nonlinear constraints. This behaviour can make the multi tightened cuts especially powerful for problems with nonlinear disjunctions, which is also shown by the results in Table 3.

Only the *p_ball* and *clay* instances contain nonlinear disjunctions and for most of these problems the multi tightening strategy significantly reduces both solution times and number of iterations. For problems with only linear disjunctions, the multi tightening strategy does not necessarily give the same advantage. However, the multi tightening strategy also performed well on the test problems with only linear disjunctions. On average the multi tightening strategy reduces the number of iterations by a factor of 7.2 compared to the ESH algorithm with the big-M formulation and by a factor of 1.5 compared to ESH algorithm with the convex hull formulation of the problems. In terms of total solution time, the multi tightening strategy reduces the total solution time by more than a factor of 3 on average compared to the other two approaches.

## Conclusions

In this paper, we have presented a new framework for strengthening cuts to obtain tighter outer approximations for convex MINLP. The cut strengthening is based on analyzing disjunctive structures in the MINLP problem, and either strengthen the cut for the entire disjunction or separately for each term of the disjunction. We have proven that the strengthening results in valid cuts that can dominate the original cut. The numerical results show that the strengthening can greatly reduce the number of iterations and time needed to solve convex MINLP problems. We have focused on strengthening cuts derived from the ESH algorithm, but the same techniques can just as well be used to strengthen cuts obtained by OA, ECP or generalized Benders decomposition.

## References

Achterberg T, Wunderling R (2013) Mixed integer programming: Analyzing 12 years of progress. In: Facets of combinatorial optimization, Springer, Berlin, pp 449–481

Atamtürk A, Narayanan V (2010) Conic mixed-integer rounding cuts. Math Program 122(1):1–20

Balas E (1979) Disjunctive programming. In: Annals of discrete mathematics. Elsevier, Amsterdam, vol 5, pp 3–51

Balas E, Margot F (2013) Generalized intersection cuts and a new cut generating paradigm. Math Program 137(1–2):19–35

Balas E, Ceria S, Cornuéjols G (1993) A lift-and-project cutting plane algorithm for mixed 0–1 programs. Math Program 58(1–3):295–324

Ben-Tal A, Nemirovski A (2001) Lectures on modern convex optimization: analysis, algorithms, and engineering applications, vol 2. SIAM

Bernal DE, Vigerske S, Trespalacios F, Grossmann IE (2020) Improving the performance of DICOPT in convex MINLP problems using a feasibility pump. Optim Methods Softw 35(1):171–190

Berthold T (2014) Heuristic algorithms in global MINLP solvers. PhD thesis, Technische Universität Berlin

Bienstock D (1996) Computational study of a family of mixed-integer quadratic programming problems. Math Program 74(2):121–140

Bonami P (2011) Lift-and-project cuts for mixed integer convex programs. In: International conference on integer programming and combinatorial optimization. Springer, Berlin, pp 52–64

Bonami P, Gonçalves JP (2012) Heuristics for convex mixed integer nonlinear programs. Comput Optim Appl 51(2):729–747

Bonami P, Lejeune MA (2009) An exact solution approach for portfolio optimization problems under stochastic and integer constraints. Oper Res 57(3):650–670

Bonami P, Biegler LT, Conn AR, Cornuéjols G, Grossmann IE, Laird CD, Lee J, Lodi A, Margot F, Sawaya N, Wächter A (2008) An algorithmic framework for convex mixed integer nonlinear programs. Discrete Optim 5(2):186–204

Bonami P, Cornuéjols G, Lodi A, Margot F (2009) A feasibility pump for mixed integer nonlinear programs. Math Program 119(2):331–352

Bonami P, Kilinç M, Linderoth J (2012) Algorithms and software for convex mixed integer nonlinear programs. In: Mixed integer nonlinear programming, Springer, Berlin, pp 1–39

Boukouvala F, Misener R, Floudas CA (2016) Global optimization advances in mixed-integer nonlinear programming, MINLP, and constrained derivative-free optimization. CDFO. Euro J Oper Res 252(3):701–727

Castillo I, Westerlund J, Emet S, Westerlund T (2005) Optimization of block layout design problems with unequal areas: a comparison of MILP and MINLP optimization methods. Comput Chem Eng 30(1):54–69

Ceria S, Soares J (1999) Convex programming for disjunctive convex optimization. Math Program 86(3):595–614

Currie J, Wilson DI (2012) OPTI: Lowering the Barrier Between Open Source Optimizers and the Industrial MATLAB User. In: Sahinidis N, Pinto J (eds) Foundations of computer-aided process operations, Savannah. Georgia

D’Ambrosio C, Frangioni A, Liberti L, Lodi A (2012) A storm of feasibility pumps for nonconvex MINLP. Math Program 136(2):375–402

Duran M, Grossmann I (1986a) A mixed-integer nonlinear programming algorithm for process systems synthesis. AIChE J 32(4):592–606

Duran MA, Grossmann IE (1986b) An outer-approximation algorithm for a class of mixed-integer nonlinear programs. Math Program 36(3):307–339

Duran MA, Grossmann IE (1986c) Simultaneous optimization and heat integration of chemical processes. AIChE J 32(1):123–138

Durán-Peña MA (1984) A mixed-integer nonlinear programming approach for the systematic synthesis of engineering systems. PhD thesis, Carnegie-Mellon University

Elhedhli S (2006) Service system design with immobile servers, stochastic demand, and congestion. Manuf Serv Oper Manag 8(1):92–97

Eronen VP, Kronqvist J, Westerlund T, Mäkelä MM, Karmitsa N (2017) Method for solving generalized convex nonsmooth mixed-integer nonlinear programming problems. J Global Optim 69(2):443–459

Fletcher R, Leyffer S (1994) Solving mixed integer nonlinear programs by outer approximation. Math Program 66(1):327–349

Frangioni A, Gentile C (2006) Perspective cuts for a class of convex 0–1 mixed integer programs. Math Program 106(2):225–236

Geiler B, Morsi A, Schewe L, Schmidt M (2015) Solving power-constrained gas transportation problems using an MIP-based alternating direction method. Comput Chem Eng 82:303–317

Geoffrion AM (1972) Generalized Benders decomposition. J Optim Theory Appl 10(4):237–260

Gomory R (1960) An algorithm for the mixed integer problem. Technical report, RAND Corp. Santa Monica, CA

Grossmann IE, Viswanathan J, Vecchietti A, Raman R, Kalvelagen E et al. (2002) Gams/dicopt: a discrete continuous optimization package. GAMS Corporation Inc, Washington

Gupta OK, Ravindran A (1985) Branch and bound experiments in convex nonlinear integer programming. Manag Sci 31(12):1533–1546

Gurobi (2019) Gurobi optimizer reference manual. Gurobi Optimization, LLC. https://www.gurobi.com/documentation/8.1/refman/index.html

Harjunkoski I, Westerlund T, Pörn R, Skrifvars H (1998) Different transformations for solving non-convex trim-loss problems by MINLP. Eur J Oper Res 105(3):594–603

Hijazi H, Bonami P, Ouorou A (2013) An outer-inner approximation for separable mixed-integer nonlinear programs. INFORMS J Comput 26(1):31–44

Kılınç MR, Linderoth J, Luedtke J (2017) Lift-and-project cuts for convex mixed integer nonlinear programs. Math Program Comput 9(4):499–526

Kröger O, Coffrin C, Hijazi H, Nagarajan H (2018) Juniper: an open-source nonlinear branch-and-bound solver in Julia. arXiv preprint arXiv:1804.07332

Kronqvist J, Lundell A, Westerlund T (2016) The extended supporting hyperplane algorithm for convex mixed-integer nonlinear programming. J Global Optim 64(2):249–272

Kronqvist J, Bernal D, Lundell A, Westerlund T (2018a) A center-cut algorithm for quickly obtaining feasible solutions and solving convex MINLP problems. Comput Chem Eng 122:105–113

Kronqvist J, Bernal DE, Grossmann IE (2018b) Using regularization and second order information in outer approximation for convex MINLP. Math Program. https://doi.org/10.1007/s10107-018-1356-3

Kronqvist J, Lundell A, Westerlund T (2018c) Reformulations for utilizing separability when solving convex MINLP problems. J Global Optim 71:571–592

Kronqvist J, Bernal DE, Lundell A, Grossmann IE (2019) A review and comparison of solvers for convex MINLP. Optim Eng 20(2):397–455

Lastusilta T (2011) GAMS MINLP solver comparisons and some improvements to the AlphaECP algorithm. PhD thesis. Åbo Akademi University

Lee S, Grossmann IE (2000) New algorithms for nonlinear generalized disjunctive programming. Comput Chem Eng 24(9–10):2125–2141

Linderoth JT, Lodi A (2011) MILP Software. https://doi.org/10.1002/9780470400531.eorms0524

Lodi A, Tanneau M, Vielma JP (2019) Disjunctive cuts for mixed-integer conic optimization. arXiv preprint arXiv:1912.03166

Lundell A, Westerlund T (2018) Solving global optimization problems using reformulations and signomial transformations. Comput Chem Eng 116:122–134

Lundell A, Kronqvist J, Westerlund T (2016) Improvements to the supporting hyperplane optimization toolkit solver for convex MINLP. In: XIII global optimization workshop GOW16, vol 16, pp 101–104

Lundell A, Kronqvist J, Westerlund T (2017) SHOT—a global solver for convex MINLP in Wolfram Mathematica. In: Computer aided chemical engineering, vol 40, Elsevier, Amsterdam, pp 2137–2142

Lundell A, Kronqvist J, Westerlund T (2020) The supporting hyperplane optimization toolkit—a polyhedral outer approximation based convex MINLP solver utilizing a single branching tree approach. Optimization (preprint, online). http://www.optimization-online.org/DB_HTML/2018/06/6680.html

Mahajan A, Leyffer S, Linderoth J, Luedtke J, Munson T (2017) Minotaur: a mixed-integer nonlinear optimization toolkit. Optimization (preprint, online). http://www.optimization-online.org/DB_FILE/2017/10/6275.pdf

Melo W, Fampa M, Raupp F (2020) An overview of MINLP algorithms and their implementation in Muriqui Optimizer. Ann Oper Res 286(1):217–241

MINLPLib (2020) Mixed-integer nonlinear programming library. http://www.minlplib.org/. Accessed 01 Jan 2020

Misener R, Floudas CA (2009) Advances for the pooling problem: modeling, global optimization, and computational studies. Appl Comput Math 8(1):3–22

Misener R, Smadbeck JB, Floudas CA (2015) Dynamically generated cutting planes for mixed-integer quadratically constrained quadratic programs and their incorporation into GloMIQO 2. Optim Methods Softw 30(1):215–249

Modaresi S, Kılınç MR, Vielma JP (2015) Split cuts and extended formulations for mixed integer conic quadratic programming. Oper Res Lett 43(1):10–15

Muts P, Nowak I, Hendrix EM (2020) The decomposition-based outer approximation algorithm for convex mixed-integer nonlinear programming. J Global Optim 75:77–96

Nowak I, Breitfeld N, Hendrix EM, Njacheun-Njanzoua G (2018) Decomposition-based inner-and outer-refinement algorithms for global optimization. J Global Optim 72(2):305–321

Quesada I, Grossmann IE (1992) An LP/NLP based branch and bound algorithm for convex MINLP optimization problems. Comput Chem Eng 16(10–11):937–947

Raman R, Grossmann IE (1994) Modelling and computational techniques for logic based integer programming. Comput Chem Eng 18(7):563–578

Sawaya N (2006) Reformulations, relaxations and cutting planes for generalized disjunctive programming. PhD thesis, Carnegie Mellon University

Sawaya NW, Grossmann IE (2007) Computational implementation of non-linear convex hull reformulation. Comput Chem Eng 31(7):856–866

Serra T (2020) Reformulating the disjunctive cut generating linear program. Ann Oper Res. https://doi.org/10.1007/s10479-020-03709-2

Serrano F, Schwarz R, Gleixner A (2019) On the relation between the extended supporting hyperplane algorithm and Kelley’s cutting plane algorithm. arXiv preprint arXiv:1905.08157

Sherali HD, Adams WP (2013) A reformulation-linearization technique for solving discrete and continuous nonconvex problems, vol 31. Springer, Berlin

Silver E, Moon I (1999) A fast heuristic for minimising total average cycle stock subject to practical constraints. J Oper Res Soc 50(8):789–796

Slater M (1950) Lagrange multipliers revisited. Cowles Foundation for Research in Economics, Yale University, Technical report

Stubbs RA, Mehrotra S (1999) A branch-and-cut method for 0–1 mixed convex programming. Math Program 86(3):515–532

Su L, Tang L, Grossmann IE (2015) Computational strategies for improved minlp algorithms. Comput Chem Eng 75:40–48

Su L, Tang L, Bernal DE, Grossmann IE (2018) Improved quadratic cuts for convex mixed-integer nonlinear programs. Comput Chem Eng 109:77–95

Trespalacios F, Grossmann IE (2014) Review of mixed-integer nonlinear and generalized disjunctive programming methods. Chem Ing Tech 86(7):991–1012

Trespalacios F, Grossmann IE (2015) Improved Big-M reformulation for generalized disjunctive programs. Comput Chem Eng 76:98–103

Trespalacios F, Grossmann IE (2016) Cutting plane algorithm for convex generalized disjunctive programs. INFORMS J Comput 28(2):209–222

Türkay M, Grossmann IE (1996) Logic-based MINLP algorithms for the optimal synthesis of process networks. Comput Chem Eng 20(8):959–978

Veinott AF Jr (1967) The supporting hyperplane method for unimodal programming. Oper Res 15(1):147–152

Wächter A, Biegler LT (2006) On the implementation of an interior-point filter line-search algorithm for large-scale nonlinear programming. Math Program 106(1):25–57

Westerlund T, Petterson F (1995) An extended cutting plane method for solving convex MINLP problems. Comput Chem Eng 19:131–136

Westerlund T, Pörn R (2002) Solving pseudo-convex mixed integer optimization problems by cutting plane techniques. Optim Eng 3(3):253–280

Zhu Y, Kuno T (2006) A disjunctive cutting-plane-based branch-and-cut algorithm for 0–1 mixed-integer convex nonlinear programs. Ind Eng Chem Res 45(1):187–196

## Acknowledgements

The work was funded by a Newton International Fellowship by the Royal Society (NIF\(\backslash\) R1\(\backslash\) 182194) to JK, a grant by the Swedish Cultural Foundation in Finland to JK, and by an Engineering and Physical Sciences Research Council Research Fellowship to RM (Grant No. EP/P016871/1).

## Author information

### Affiliations

### Corresponding author

## Additional information

### Publisher's Note

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

## Appendix: New nonlinear disjunctive test problems

### Appendix: New nonlinear disjunctive test problems

To further test the cut strengthening for problems with different sized disjunctions containing nonlinearities of varying difficulty, we have generated 12 new test problems. The underlying optimization task is simple, select *n*-points in *m*-dimensional balls, such that the \(\ell _1\)-distance between all points is minimized. Only one point can be assigned to each ball, and in total there are *l* balls with radius one. The problem has a clear disjunctive programming structure, where the disjunctions arise from the assignment of each point to one of the balls. In total we get *n* disjunctions of size *l*, i.e., one disjunction per point and one disjunctive term per ball.

Even if this optimization task can be represented as a binary quadratic problem, it is a challenging problem for OA-type algorithms. Without any reformulations, OA-type algorithms will require a large number of iterations due to the difficulties of accurately approximating an *n*-dimensional ball with hyperplanes (Hijazi et al. 2013). Higher-dimensional balls render the outer approximation task more difficult, and the number of nonlinear constraints is given by the number of balls times the number of points. There is a clear combinatorial structure to the problem, and the complexity increases with the number of points and balls as the number of possible discrete configurations drastically increases. The seemingly simple optimization problem is, thus, challenging both due to the combinatorial nature and the nonlinearity.

Before presenting the MINLP formulation, we briefly describe the notation and some details of the problem formulation. Here, \(\mathbf{c} ^i\in {{\mathbb {R}}}^m\) denotes the center of ball *i* and \(c^i_1\) refers to the first coordinate of the center. Similarly, \(\mathbf{p} ^i\in {{\mathbb {R}}}^m\) refers to point *i* and \(p^i_1\) is the first coordinate of the point. To simplify the notation, we introduce the sets \(D = \{1, 2, \ldots , m\}\), \(P = \{1, 2, \ldots , n\}\), \(P^i = \{i+1, i+2, \ldots , n\}\), and \(B = \{1, 2, \ldots , l\}\). The \(\ell _1\)-distance can be represented by linear constraints by introducing auxiliary variables \(\mathbf{d} ^{i,j} \in {{\mathbb {R}}}^m\). As before, \(d^{i,j}_k\) refers to the *k*-th component of the vector \(\mathbf{d} ^{i,j}\). To act as the absolute value, we use the following constraints

and the distance between the points *i* and *j* is now given by \(\sum _{k=1}^m d^{i,j}_k\). For the test problems, we randomly chose each coordinate of the balls’ centers between 0 and 10, which also limits each variable \(d^{i,j}_k\) to the interval [0, 10]. We use a binary variable \(b_{i,r}\) for selecting if point *i* is assigned to ball *r*. There are several identical solutions to these optimization problems due to symmetries, e.g., you can switch places of the first and second point to obtain another equally good solution. To eliminate some of the symmetrical solutions we include an ordering of the points along the first coordinate. The ordering is enforced by including the constraints that the first point must be closer to the origin along the first coordinate than the second point, and similarly for the following points. Using the big-M formulation the problem can be written as

where \(M_r\) are sufficiently large constants. For these problems the smallest valid \(M_r\) is simply given by

Here, \(M_r\) are based on the largest squared Euclidean distance between the center of a ball and the point furthest away in any other ball. This gives the smallest valid *M* constants, resulting in a tight Big-M formulation. It could be possible to obtain a stronger formulation, e.g., by eliminating furhter symmetries or by the techniques presented by Trespalacios and Grossmann (2015). However, the goal here is not to derive an optimal problem formulation, but simply to generate a few test problems of different size and difficulty.

We have generated 12 random test instances, where the centers of the unit balls are chosen randomly. The test problems are of different size, and the main attributes are summarized in Table (4). The problems range in size from 50–210 binary variables and 30–85 continuous variables.

It is also possible to represent the assignment of points to circles with the convex hull formulation to obtain a tighter continuous relaxation. For each point \(i \in P\), we need to make *l* copies of the variables \(\mathbf{p} ^i\), and we get the new variables \({\nu }^\mathbf{p ^i}_r \in {{\mathbb {R}}}^m\). It would be possible to represent the convex hull by second-order cones, but to fit within the framework of this paper we use the formulation presented by Sawaya and Grossmann (2007). The problem can then be written as

In the numerical tests we use \(\epsilon =10^{-9}\) which was stable for the subsolvers. The main properties of the test problems with the convex hull formulation are summarized in Table 5. The problems range in size from 50–210 binary variables and 130–860 continuous variables.

Numerical results are presented in Sect. 6, which show that the test problems are challenging for the ESH algorithm with both problem formulations. Finally, all the test problems can be downloaded from https://github.com/jkronqvi/points_in_circles.

## Rights and permissions

**Open Access** This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.

## About this article

### Cite this article

Kronqvist, J., Misener, R. A disjunctive cut strengthening technique for convex MINLP.
*Optim Eng* (2020). https://doi.org/10.1007/s11081-020-09551-6

Received:

Revised:

Accepted:

Published:

### Keywords

- Disjunctive cuts
- Convex MINLP
- Cut strengthening
- Extended supporting hyperplane algorithm