A computational study of perspective cuts

The benefits of cutting planes based on the perspective function are well known for many specific classes of mixed-integer nonlinear programs with on/off structures. However, we are not aware of any empirical studies that evaluate their applicability and computational impact over large, heterogeneous test sets in general-purpose solvers. This paper provides a detailed computational study of perspective cuts within a linear programming based branch-and-cut solver for general mixed-integer nonlinear programs. Within this study, we extend the applicability of perspective cuts from convex to nonconvex nonlinearities. This generalization is achieved by applying a perspective strengthening to valid linear inequalities which separate solutions of linear relaxations. The resulting method can be applied to any constraint where all variables appearing in nonlinear terms are semi-continuous and depend on at least one common indicator variable. Our computational experiments show that adding perspective cuts for convex constraints yields a consistent improvement of performance, and adding perspective cuts for nonconvex constraints reduces branch-and-bound tree sizes and strengthens the root node relaxation, but has no significant impact on the overall mean time.


Introduction
Consider a mixed-integer nonlinear program (MINLP) with semi-continuous variables: min c, px, y, zq s.t.gpx, y, zq ď 0, (1b) py j ´y0 j qz k ď y j ´y0 j ď py j ´y0 j qz k , @j P S k , @k P I, x P R n , y P R p , z P t0, 1u q .(1d) Here, c, px, y, zq is the linear objective function given by a scalar product of a constant vector c P R n`p`q and the vectors of continuous variables x, semicontinuous variables y and binary variables z.Constraints (1b) are given by inequalities gpx, y, zq ď 0, where g : R n ˆRp ˆr0, 1s q Ñ R m is a vector function and some of its elements g i are nonlinear.The set S k Ď t1, . . ., pu shall contain the indices of semi-continuous variables controlled by the indicator variable z k , and I Ď t1, . . ., qu is the set of indices of all indicator variables.Constraints (1c) ensure that for each j P S k , the value of y j belongs to the domain ry j , y j s when the indicator variable z k is equal to 1 and has a fixed value y 0 j when z k is equal to 0. Semi-continuous variables are typically used to model "on" and "off" states of a process and can be found in such problems as optimal line switching in electrical networks [7], blending [24] and production planning [3], to name but a few.
In order to simplify the notation, in the rest of the paper the subscript k will be omitted and we will be referring to a vector of semi-continuous variables y P R p controlled by the indicator variable z P t0, 1u.The semi-continuity relation is then defined by the inequality py ´y0 qz ď y ´y0 ď py ´y0 qz.
Without loss of generality, we consider constraints of the form gpx, yq " f pyq ´x ď 0 for some P t1, . . ., nu.The continuous variable x represents the linear nonsemi-continuous part and the same arguments as presented in this paper can be directly adapted for a more general linear part.When z " 0, function f is reduced to a fixed value f py 0 q.A common example of such constraints are on/off constraints which become redundant when the corresponding indicator variable is set to 0. Many state-of-the-art algorithms for the solution of MINLP (1) make use of nonlinear and linear programming relaxations where the condition z P t0, 1u is replaced with z P r0, 1s.However, for a constraint of the form (2), simply dropping the integrality condition generally does not produce the tightest possible continuous relaxation.The reason for this is that the dependence of the bounds on y on the indicator variable z is not exploited by a straightforward continuous relaxation.Consequently, the same applies for the linearization of Constraint (2) via gradient cuts [16], that is, inequalities f p ŷq ` ∇f p ŷq, y ´ŷ ď x , (3) where ŷ is the point at which f is linearized.
The strongest continuous relaxation of the set described by Constraint (2), given that y is semi-continuous, can be achieved by applying the perspective reformulation [9].Linearizing this reformulation provides valid linear inequalities known as perspective cuts.
In this paper we present a computational study of perspective cuts within SCIP [12], a general-purpose solver that implements an LP-based branch-andcut algorithm to solve mixed-integer nonlinear programs to global optimality.Section 2 provides the theoretical background for this study and a review of applications that can be found in existing literature.In Section 3, we describe our approach to creating perspective cuts and show that for convex instances, it is equivalent to linearizing the perspective formulation via gradient cuts.Section 4 gives an outline of our implementation of perspective cuts in SCIP, which includes detection of suitable structures and separation and strengthening of perspective cuts.Finally, in Section 5 the results of computational experiments on instances from MINLPLib1 [4] are presented.

Perspective Formulations for Convex Nonlinearities
This section gives a review of the existing literature on theoretical and computational results related to perspective formulations for convex nonlinearities.

Theoretical background
Let F denote the feasible region defined by Constraint (2) and the semi-continuity constraints (1c) for an indicator z.F can be written as a union of two sets F 0 and F 1 corresponding to values 0 and 1 of z, respectively: The tightest possible convex relaxation of F is its convex hull.Ceria and Soares [5] studied convex hull formulations for unions of convex sets and their applications to disjunctive programming.Stubbs and Mehrotra [21] described the convex hull of the feasible set of a convex 0-1 program and developed a procedure for generating cutting planes.Grossmann and Lee [13] extended the convex hull results to generalized disjunctive programs (GDPs).Similarly to disjunctive programming, feasible sets of GDPs are given as unions of convex sets, but more general logical relations are also allowed.These works used the perspective function, which is defined as follows: Definition 1. [18] For a given convex function f : R p Ñ R, its perspective function f : R n`1 Ñ pR Y t`8uq is defined as: where y P R p , z P R.
These early results are applicable to convex sets with few non-restrictive conditions and utilize an extended variable space.Frangioni and Gentile [9] proposed a reformulation in the original space for a special case.Considering a semi-continuous vector y, an indicator variable z, and a convex function f depending only on y such that y 0 " p0, . . ., 0q and f p0q " 0, they capture the disjunctive structure by defining a new nonconvex function f d : The function f d is directly related to the set F : the latter can be described as the set of all points px , y, zq such that f d py, zq is finite and f d py, zq ď x .
Frangioni and Gentile describe the convex envelope of f d : In a related work, Günlük and Linderoth [14] show that the convex hull of F is given by convpF q " tpx , y, zq | cof d py, zq ď x , py ´y0 qz ď y ´y0 ď py ´y0 qz, z P r0, 1su.
Therefore, replacing f with cof d in Constraint ( 2) results in a reformulation with the tightest possible continuous relaxation: the perspective reformulation.This is a valid reformulation since f " cof d for z P t0, 1u.  Figure 1 shows an example of a disjunctive set and compares its continuous relaxations.The disjunctive set (shown in Figure 1a) consists of the ray tpx , y, zq | x ě 0, y " 0, z " 0u and the convex set tpx , y, zq | x ě f pyq, z " 1u, where f pyq " y 2 .The convex hull, shown in Figure 1b, is the closure of the set of all points above the dark gray surface defined by x " y 2 {z, z P p0, 1s.This equation is obtained by applying the perspective operator to f : f py, zq " zf py{zq " y 2 {z.For comparison, the boundary of the straightforward continuous relaxation given by x " y 2 , z P r0, 1s, is shown in Figure 1b in light gray color.
Due to the division by z in the perspective function, the perspective reformulation ( 6) is non-differentiable at z " 0. In some special cases, formulation (6) can be written as a second-order cone (SOC) constraint [22,1,14,10].In particular, this is possible when Constraint (2) itself is SOC-representable.
Frangioni and Gentile [11,8] introduced projection approaches for additively separable closed convex functions.In the projected perspective reformulation (P 2 R) [11], the perspective function is projected into the space of continuous variables and rewritten as a piecewise-convex function.This technique avoids the numerical issues associated with the perspective functions while yielding strong bounds, but at the cost of using piecewise-continuous functions which cannot be directly passed to off-the-shelf solvers.The approximated projected perspective reformulation (AP 2 R) method [8] lifts the P 2 R formulation back into the original space by reintroducing the indicator variables.AP 2 R can be solved by general-purpose solvers and, if y 0 ď y, has the same number of variables and constraints as the original problem.The bound provided by AP 2 R is, however, generally weaker than the one from P 2 R.
Alternatively, the perspective reformulation (6) can be represented by an infinite number of linear outer approximations which are then dynamically separated.Suppose that we have a point px , ŷ, ẑq such that ẑ P p0, 1q and x ă f p ŷ, ẑq.By performing first-order analysis of the convex envelope cof d , Frangioni and Gentile [9] derive cuts that separate px , ŷ, ẑq from the convex hull of F , referred to as perspective cuts: ∇f py ˚q, y `pf py ˚q ´ ∇f py ˚q, y ˚ q z ď x , (7) where y ˚" ŷ{ẑ.
It is easy to adjust the perspective reformulation and the inequalities (7) for the case of nonzero y 0 and f py 0 q: ∇f py ˚q, y ´y0 `pf py ˚q ´f py 0 q ´ ∇f py ˚q, y ˚´y 0 qz `f py 0 q ď x , (8) where y ˚" p ŷ ´y0 q{ẑ `y0 .We refer to (8) as the perspective cut at y ˚.

Existing applications and computational results
Perspective cuts and reformulations were tested on several applications which contain convex functions of semi-continuous variables.
Frangioni and Gentile [9] applied perspective cuts (8) to the thermal unit commitment problem.In order to avoid the technical difficulties of incorporating perspective cuts into a general-purpose solver, the authors implemented their own NLP-based branch-and-cut algorithm.Perspective cuts are applied to the objective function via a specialized separation procedure, which replaces a univariate term with its perspective linearization if the perspective linearization is tighter at the current relaxation solution.The linearization is represented by an auxiliary variable, and as more perspective cuts are added for the term, the variable is set to be equal to the maximum of all linearizations.Perspective cuts were shown to have a considerable impact on the performance.The geometric mean of the running time of the best performing setting was smaller than that for the algorithm with the straightforward continuous relaxation by a factor of 60.
Perspective reformulations were studied by Günlük and Linderoth [14,15].Their key observation is that for some problems, the perspective reformulation can be written with the use of second-order cone constraints.The applications studied in this paper are: • Separable quadratic uncapacitated facility location on a testset consisting of 16 instances.With the perspective reformulation, 50% more instances are solved within the time limit of 8 hours and on the instances that are solved with both formulations, the perspective formulation is faster by a factor of 8 when comparing the geometric mean.
• Network design with congestion constraints on a testset consisting of 35 instances.The perspective formulation is solved for 29 instances within the time limit of 4 hours, as opposed to only 2 instances with the standard formulation.
• Mean-variance optimization (portfolio optimization) on a testset consisting of 20 instances.Although none of the instances are solved within the time limit of 10,000 CPU seconds, perspective reformulation significantly improves the gap.For example, the final gap between the best found lower and upper bounds is reduced from 185.1% with the standard formulation to 4.2% with the perspective reformulation on instances of smaller size, and from 490.0% to 5.9% on instances of larger size.
Atamtürk and Gómez [2] applied the perspective-based conic reformulation to the image segmentation problem, testing it on 4 instances of different sizes.On the one instance that was solved within a time limit of 1 hour, the running time was reduced by a factor of 18 when compared to the standard formulation.On the three remaining instances, using the perspective formulation resulted in a 45-55% decrease of the remaining gap at time limit.
Aktürk et al. [1] presented a perspective-based conic reformulation of the machine-job assignment problem with controllable processing times.The tests were conducted on 180 randomly generated instances of varying sizes with quadratic and cubic objectives.For problems with a quadratic objective, 91% of the 90 instances were solved when using the strengthened conic formulation, whereas at most 36% of instances were solved when using non-perspective formulations.For problems with a cubic objective, 88% of the 90 instances were solved with the perspective formulation and at most 27% were solved with nonperspective formulations.
A comparison between SOC-based perspective formulations and perspective cutting planes was performed by Frangioni and Gentile [10].Using the CPLEX-11 solver, they test the two approaches on two sets of mixed-integer quadratic problems, namely, the Markowitz mean-variance model and the unit commitment problem.The difference between the two formulations is particularly significant with the setup used in the paper [10] since by default, CPLEX obtains dual bounds by solving nonlinear relaxations.The results favor the cutting planes approach, with the difference being larger for the Markowitz meanvariance problem.The authors observe that the advantage of perspective cuts stems mostly from efficient reoptimization of linear programs.They add that the perspective conic reformulation is more competitive for problems that are larger, more nonlinear (i.e., have more nonlinear constraints or non-quadratic nonlinear constraints) or have richer structure.
Frangioni and Gentile [11,8] tested the projected perspective reformulation (P 2 R) and the approximated perspective projected reformulation (AP 2 R) on sensor placement, nonlinear network design, mean-variance portfolio and unit commitment problems.P 2 R was implemented as part of a specialized branchand-bound algorithm and AP 2 R was solved directly with CPLEX 12.Both approaches were compared to perspective cuts implemented as a callback in CPLEX.Computational results show that P 2 R is the best performing method for problems that have a well-suited structure and require little or no branching.For problems with more complex structures, AP 2 R is competitive with the perspective cut approach.When there are constraints linking indicator variables and few linear approximations provide a good estimate of the original nonlinear function, perspective cuts tend to be the best performing method.
Salgado et al. [19] studied the alternating current optimal power flow problem with activation/deactivation of generators (ACOPFG) using 8 test instances.They tested two perspective-based reformulations of the objective function.The first uses four perspective cuts of the form (8); the other is obtained by applying AP 2 R [8].Although the results of enhancing the standard ACOPFG model with perspective reformulations are inconclusive, an outer approximation [20] of the problem significantly benefits from both perspective cuts and AP 2 R. The perspective cuts approach performs best, solving one more instance than the standard formulation within the time limit of 1 hour and taking less than 4 seconds on all the remaining instances, whereas the standard formulation requires over 1000 seconds on most instances.

Generalized perspective cuts
If f is non-convex, neither the gradient cuts (3) nor the perspective cuts ( 8) are guaranteed to be valid.However, the perspective reformulation can be applied to a convex underestimator of f , from which the perspective cuts (8) can be derived.Alternatively, any linear inequality φpyq ď x that is valid for the 'on' set F 1 can be adjusted for the 'off' set F 0 .
In the following, we propose a cut extension procedure that ensures that the generated inequality is equivalent to φpyq ď x when the indicator is equal to 1 and holds with equality at the point px , y, zq " pf py 0 q, y 0 , 0q.
Theorem 1 (Generalized perspective cuts).Consider a vector of semi-continuous variables y P R p with an indicator z P t0, 1u, such that y " y 0 if z " 0, and a linear inequality φpyq ď x that is valid for the set F 1 " tpx , y, zq | x ě f pyq, y P ry, ys, z " 1u.
Then the linear inequality φpy, zq ď x is valid for the set F 0 Y F 1 , where Proof.It is sufficient to check the validity for each possible value of z P t0, 1u.By substituting z " 1 and z " 0 in φpy, zq, we immediately obtain 1. φpy, 1q " φpyq @y P R p and 2. φpy 0 , 0q " f py 0 q, respectively.Therefore, φpy, zq ď x is a valid inequality.
If the cut φpyq ď x is already valid for F 0 , then the described above adjustment always produces a cut that is at least as strong as the original cut.Since φpyq ď x is in this case implied by f pyq ď x for px , yq P F 0 , we have φpy 0 q ď f py 0 q.Hence the coefficient of p1 ´zq in φpy, zq is nonnegative and φpy, zq ě φpyq, @z P r0, 1s, @y P R p .
If additionally φpy 0 q ă f py 0 q, i.e., the original cut is not tight at y 0 , then the new cut is also stronger.Otherwise, if φpyq ď x does not hold for F 0 (that is, if φpy 0 q ą f py 0 q), then the adjustment is necessary to obtain a cut that is valid for This cut extension procedure has two main advantages: 1.It does not depend on the convexity of f and requires no assumptions on the cut except for its validity for F 1 .
2. In the case where y 0 R ry, ys, variable bounds for F 1 are tighter than those for F 0 Y F 1 .This is useful for non-convex constraints since the tightness of their relaxations depends on variable bounds, and therefore cuts constructed for y P ry, ys will generally be stronger than those for y P rminty 0 , yu, maxty 0 , yus.
When the cut strengthening is applied to the convex setting, the result is equivalent to the well-known perspective cuts: Theorem 2 (Alternative derivation of perspective cuts).Suppose that f : R p Ñ R is convex and px , ŷ, ẑq R convpF q as defined in Section 2.1.Consider the gradient cut (3) at point y ˚" p ŷ ´y0 q{ẑ `y0 for Constraint (2): φpyq " f py ˚q ` ∇f py ˚q, y ´y˚ ď x .
Let φpy, zq be the linear function obtained from φpyq by following the strengthening procedure in Theorem 1. Then φpy, zq is written as follows: φpy, zq " ∇f py ˚q, y ´y0 `pf py ˚q ´f py 0 q ´ ∇f py ˚q, y ˚´y 0 qz `f py 0 q and the cut φpy, zq ď x is equivalent to the perspective cut (8) at point p ŷ, ẑq.
Proof.The coefficient of p1 ´zq in φpy, zq is α " f py 0 q ´φpy 0 q " f py 0 q ´f py ˚q ´ ∇f py ˚q, y 0 ´y˚ .Adding αp1 ´zq to the left hand side of the gradient cut produces the perspective cut (8): φpy, zq " φpyq `αp1 ´zq " ∇f py ˚q, y ´y0 `pf py ˚q ´f py 0 q ´ ∇f py ˚q, y ˚´y 0 qz `f py 0 q.
To paraphrase, for a convex function f the perspective cut at a solution px , ŷ, ẑq of the LP relaxation can equivalently be obtained by first generating a gradient cut for f at the modified point y ˚and then applying the strengthening procedure from Theorem 1.Let us consider an example to illustrate the cut extension method.
Example 1.Consider a constraint f pyq " ´y3 `y ď x .The boundary of the feasible region is shown in Figure 2 by the dark gray nonlinear surface, and the feasible points are located above it.Let 0.5z ď y ď z, where y is a scalar, semi-continuous variable modeled using the binary variable z P t0, 1u.First we find an underestimator of f pyq valid for z " 1.In this case, y is constrained to belong to the interval r0.5, 1s.Since f pyq is concave on r0.5, 1s, the underestimator is the secant through points p0.5, f p0.5qq and p1, f p1qq: The cut f sec ď x (shown in Figure 2a) is not valid for the whole feasible set.In particular, a feasible point py, z, x q " p0, 0, 0q violates the cut: f sec p0, 0q " 0.75 ą 0 " x .Now we extend the cut so that to ensure validity at z " 0. By Theorem 1, the new cut is written as: f sec " f sec `pf py 0 q ´f sec py 0 qqp1 ´zq " ´0.75y `0.75z.This cut, shown in Figure 2b, is valid for the whole feasible set given by the cubic constraint and the semi-continuity condition.

Implementation of perspective cuts
An effective implementation of perspective cuts within a general-purpose solver requires providing methods for detecting suitable structures in a general problem and generating the cuts during the solution process.In the following, we describe our implementation within SCIP, but many considerations discussed here will be applicable to MINLP solvers in general.

Organization of nonlinear constraints in SCIP
SCIP builds a relaxation for the MINLP (1) by means of an extended formulation, where auxiliary variables w are introduced for the subexpressions that constitute the constraint functions gpx, y, zq.Without loss of generality, we can assume that (1b) has been replaced by a new system where w l and w u denote global lower and upper bounds on w.
The handling of nonlinear constraints in the version of SCIP used for this work is performed by modules called "nonlinearity handlers".Each nonlinearity handler works on a specific structure (e.g.quadratic, convex, etc.) and provides callback methods.For the purposes of this paper, three types of callbacks are relevant: • Detection callbacks receive an expression and determine whether it is suitable for the nonlinearity handler.
• Estimation callbacks provide linear under-and overestimators given an expression and a point at which to linearize it.
• Enforcement callbacks enforce a given violated constraint by adding cutting planes, tightening bounds, detecting infeasibility, etc.
Our addition of generalized perspective cuts is implemented via a specialized perspective nonlinearity handler.

Structure detection
The detection algorithm identifies constraints of the form (9), where h i is nonlinear and at least one other nonlinearity handler provides an estimation callback for it.All variables that h i depends on must be semi-continuous with at least one common indicator variable.If several binary variables satisfying this condition are found, all such variables are stored for use in cut generation.
A special case is that of h i being a sum.Here, only the variables appearing in nonlinear terms of the sum are required to be semi-continuous.
To determine whether a variable y j is semi-continuous, the detection callback of the perspective nonlinearity handler searches for pairs of implied bounds on y j with the same indicator z k : If β puq " β p q , then y j is a semi-continuous variable and y 0 j " β puq , y j " α p q `βp q and y j " α puq `βpuq .This information can be obtained either directly from linear constraints in y j and z k , or by finding implicit relations between y j and z k .Such relations can be detected by probing, which fixes z k to its possible values and propagates all constraints in the problem, thus detecting implications of z k " 0 and z k " 1. SCIP stores the implied bounds in a globally available data structure.
In addition, the perspective nonlinearity handler detects semi-continuous auxiliary variables, that is, variables w i that were introduced to express the extended formulation (9).Given h i py, w 1 , . . ., w i´1 q ¿ w i , where y, w 1 , . . ., w i´1 are semi-continuous variables depending on the same indicator z k , the auxiliary variable w i is semi-continuous with w 0 i " h i py 0 , w 0 1 , . . ., w 0 i´1 q and rw i , w i s " h i pry 0 , y 0 s, rw 1 , w 1 s, . . ., rw i´1 , w i´1 sq computed by interval arithmetics.
According to Theorem 1, the constraint must have the form where all variables y, w 1 , . . ., w i´1 are semi-continuous with respect to the same indicator z k .In our implementation we allow a more general form: h i px, y, w 1 , . . ., w i´1 , zq " h sc i,k py, w 1 , . . ., w r q (10) where the variables are assumed to be sorted so that semi-continuous auxiliary variables w 1 , . . ., w r come before the non-semi-continuous auxiliary variables w r`1 , . . ., w i´1 and the auxiliary variable w i representing h i .Thus, for each suitable indicator z k the function h i is split up into the semi-continuous part h sc i,k , which can depend only on variables that are semicontinuous with respect to indicator z k , and a non-semi-continuous part h nsc i,k , which depends on non-semi-continuous variables.The non-semi-continuous part must be linear.If the sum has a constant term, the constant is considered to be part of h sc i,k .

Separation and strengthening of generalized perspective cuts
During the cut generation loop, generalized perspective cuts as in Theorem 1 are constructed for constraints of the form (10).
In the following, let v denote the vector of all problem variables: v " px, y, w, zq, and let F 1 i,k and F 0 i,k be the sets of points satisfying a constraint of the form (10) for a given i P t1, . . ., m 1 u together with implied variable bounds for z k " 1 and z k " 0, respectively.For simplicity, we fix the inequality sign and consider "less than or equal to" constraints: . ., w i´1 , zq ď w i , y P ry, ys, w P rw, ws, z k " 1u, F 0 i "tv | h i px, y, w 1 , . . ., w i´1 , zq ď w i , y " y 0 , w " w 0 , z k " 0u.
Suppose that the point v violates the nonlinear constraint: If h i is nonconvex and its estimators depend on variable bounds, the enforcement callback first performs probing for z k " 1 in order to tighten the implied bounds ry, ys and rw j , w j s for j ď r.Estimation callbacks of non-perspective nonlinearity handlers are called in order to find valid cuts that separate v from F 1 i,k , which are then modified according to Theorem 1.For a constraint of the generalized form h i " h sc i,k hnsc i,k ď w i , which is described in Section 4.2, an estimation callback will provide an underestimator of h i : `hnsc i,k .This underestimator consists of an underestimator of the semi-continuous part h sc i,k and the non-semi-continuous part h nsc i,k , which remains unchanged since it is already linear and shares none of the variables with the semi-continuous part.The extension procedure from Theorem 1 is applied only to h sc i,k to obtain hsc i,k .Since h sc i,k depends only on semi-continuous variables, similar arguments to Section 3 hold for feasibility and tightness of the strengthened underestimator hsc i,k .The strengthened underestimator of h i is then written as hi,k " hsc i,k If v violates the cut hi,k ď w i , the cut is passed to the SCIP core where it will be considered for addition to the LP relaxation.Let us consider an example of generalized perspective cut separation by extending Example 1.

Example 2. The extended formulation of the constraint from Example 1 is written as:
hpx l , yq " ´y3 `y ´xl ď w ď 0.
The semi-continuous part of h is h sc pyq " ´y3 `y, and the non-semicontinuous part is h nsc px l q " ´xl .The perspective underestimator of h is hpx l , y, zq " ´0.75y `0.75z ´xl and the perspective cut is written as follows: ´0.75y `0.75z ´xl ď w.
Suppose that the point to be separated is px l , ŷ, ẑ, ŵq " p0, 0.4, 0.7, 0q.Substituting the variables with their values at this point in the perspective cut, we get a violated inequality 0.225 ď 0. Therefore the cut is violated and will be considered for addition to the LP relaxation.

Computational results
This section presents the results of computational experiments.A development version of SCIP (githash f0ee1d793d) was used, together with the linear solver SoPlex 5.0.1.3[12] and the nonlinear solver Ipopt 3.12.13[23].All the experiments were run on a cluster of 3.60GHz Intel Xeon E5-2680 processors with 64 GB memory per node.The time limit was set to one hour and the optimality gap limit to 0.01%.
Throughout the section, we analyze the following settings, each defined by the types of constraints for which perspective cuts are added: • Off : perspective cuts are disabled; • Convex: perspective cuts are enabled only for convex constraints; • Full: perspective cuts are enabled for both convex and nonconvex constraints.

Detection of suitable structures
Out of the 1703 instances of MINLPLib, suitable constraints of the extended form (10) were detected for 186 instances.Table 1 shows the numbers of instances where at least one such constraint was detected, when counting: all instances, instances where detection succeeded for convex constraints only, instances where detection succeeded both for convex and nonconvex constraints and instances where detection succeeded for nonconvex constraints only.Only those instances were counted for Table 1 where suitable constraints were detected in the main problem.Additionally, sometimes a constraint can only be detected by the perspective nonlinearity handler in a subproblem.A typical example of this is a heuristic creating a subproblem to represent a restricted version of the main problem.This often involves fixing some variables or modifying bounds, which can result in new semi-continuous variables and thus new suitable constraints.In our test set there are 3 instances where suitable constraints were found only in subproblems.However, subproblem detections are not guaranteed to have an impact on performance.Because of this, subproblem detections are not counted in Table 1.

Overall performance impact
This subsection evaluates the overall impact of perspective cuts on the performance of SCIP.Its purpose is to give an overview of how the three major settings compare against each other before moving onto more detailed comparisons in the next subsection.
In order to robustify our results against the effects of performance variability [17], four different permutations of the order of variables and constraints were applied to each of the 186 instances, for which suitable structures were detected.Each permutation is treated as a separate instance, and together with the instances without any permutation they comprise a test set of 930 instances.In our analysis, we exclude instances where one of the solver settings encountered numerical troubles or where the numerical results of the different solver settings are inconsistent.Table 2 provides an overview of the number of instances solved to global optimality by each setting.The row Limit contains the count of instances where the time limit was reached.The row Fails reports the number of instances where numerical troubles were encountered.The largest number of instances solved with a given setting was 764, yielded by setting Convex, which had both the smallest number of numerical fails and time outs.It is followed by Full, which solved 759 instances.The setting Off solved the least number of instances overall.
Table 3 shows the shifted geometric mean of the running time in seconds (with a shift of 1 second) and the shifted geometric mean of the number of branch-and-bound nodes (with a shift of 100 nodes).All numbers in the table are computed for the subset of 672 affected instances: all instances where at least two of the three settings yielded a different solving path (judged by a different number of linear programming iterations), where the solver failed with none of the settings, and solved the instance to optimality with at least one setting.
From Table 3 one can see that a significant improvement is achieved when enabling perspective cuts for convex constraints.The results with the settings Convex and Full, however, are almost identical.

Detailed comparisons
In this subsection we provide a more detailed analysis of the performance results by comparing pairs of settings, in order to evaluate the impact of each major feature more thoroughly.
First, we present the numbers of relevant and affected instances in Table 4.It has the following rows: • Relevant: the number of instances where more expressions are detected with the second setting than with the first setting; • Affected: the number of instances which were solved with at least one of the two settings, where the number of linear programming iterations differs between the two settings and the solver failed with none of the two settings.
From Table 4 we can see that while nonconvex structures can be found on more than half of the test set, applying generalized perspective cuts to nonconvex functions affects the solving path less often than applying perspective cuts to convex functions.Table 5 summarizes the effect of perspective cuts on the dual bound at the end of the root node.It reports the numbers of instances of the subset Relevant where the dual bound was better with the corresponding setting by a percentage that is specified in the first column, as well as the numbers of instances where the dual bound change was less than 5%.A significant difference in root node dual bound can be observed only for a relatively small number of instances.The comparison between Off and Convex is consistent with the results in the above tables, with Convex improving more bounds than Off.The comparison between Convex and Full deserves a closer look.When inspecting medium dual bound changes (5-50%), Convex yields a better bound than Full slightly more often than the other way round.However, when considering only large improvements (ą 50%), we observe that those were always due to setting Full.From this we conclude that, overall, enabling perspective cuts for nonconvex constraints improves the quality of dual bounds in the root node.Table 6 compares the running time when considering pairs of settings and the corresponding subsets of affected instances.It has the following rows: • Time: shifted geometric mean of the running time in seconds (with a shift of 1 second); • Relative time: shifted geometric mean of the running time relative to the first of the two settings; • Faster: the number of instances where SCIP was faster with the given setting than with the other setting by at least 25%.
In order to analyze the impact on subsets of increasingly hard instances, these rows repeat for three subsets of instances given by time brackets rt, 3600s, which contain the instances that were solved to optimality with both settings and took at least t seconds by at least one setting.The results shown in Table 6 strongly confirm that enabling perspective cuts for convex constraints decreases the mean running time.This effect becomes more pronounced as the difficulty of the instances increases.On instances that took at least 100 seconds to solve, setting Convex was faster almost by a factor of 3. The additional activation of perspective cuts for nonconvex constraints, however, rather had a detrimental effect on performance, especially as instances become more difficult.This is despite the fact that there are more speedups than slow-downs when switching from setting Convex to setting Full, as seen from the rows Faster.Hence, the increase in the mean time is due to significant slow-downs on a few challenging instances.However, these observed slow-downs should not be overestimated since the size of the subsets r100, 3600s and r1000, 3600s are comparatively small.
A comparison of branch-and-bound tree sizes is given in Table 7. Again, a consistent improvement is observed when enabling perspective cuts for convex expressions.This improvement becomes more pronounced as the instances become more challenging.Here we also observe an overall improvement when enabling perspective cuts for nonconvex constraints.However, on the harder subsets r100, 3600s and r1000, 3600s, Convex still remains the best setting.Figures 3 and 4 show performance profiles [6] for running time and number of nodes with settings Off and Convex and settings Convex and Full, respectively.Let t i,s denote the running time for instance i with setting s.The virtual best setting used for the running time performance profiles, denoted by index vb, is defined as a setting whose running time for each instance is equal to the minimum of the running times with the two settings that are being compared: t i,vb " min s tt i,s u.The horizontal axis represents the maximum allowed ratios to the time with the virtual best setting, denoted by τ .The vertical axis represents the fraction of instances solved within the maximum allowed fraction of time of the virtual best, denoted as p s pτ q: p s pτ q " number of instances i s.t.: t i,s ď τ ¨ti,vb total number of instances .
Performance profiles for the number of nodes in the branch-and-bound tree are constructed similarly, the only difference being that t .,. is replaced everywhere with n .,. , which represents the number of nodes per instance and setting.
From Figure 3 we see that setting Convex dominates setting Off.With Convex, over 55% of instances are solved faster or as fast as with setting Off.It is able to solve around 80% of instances within a factor of 4 of the best time, and the curve approaches approximately 82% in the limit, i.e., Convex is able to solve around 82% of the instances.The respective numbers for Off lie at around 10% lower than those for Convex.A very similar picture is observed for the number of nodes.According to Figure 4, the setting Full is roughly on par with Convex in terms of running time if the ratio we are interested in is below 3.As the ratio increases, Convex becomes the better setting, which reflects the fact that it solves slightly more instances than Full.When looking at the number of nodes, Full yields the best result for around 74% of instances, as opposed to around 70% yielded by Convex.For ratios above 16, Convex is better than Full, which, again, is due to it solving more instances.

Feature evaluation: bound tightening
As explained in Section 4.3, if the constraint is nonconvex and its relaxation depends on variable bounds, then the indicator variable is first set to 1 and bound tightening is performed.A cut is then computed for this possibly tighter set F 1 i and strengthened according to Theorem 1.In this subsection we evaluate the usefulness of this feature.
To this end, we introduce the setting Full-noBT.It is equivalent to Full except that the bound tightening feature is disabled.When bound tightening is disabled, two more instances are solved due to one less fail and one less time out.Enabling it, on the other hand, leads to large (ą 50%) root node dual bounds improvements on 25 out of 68 affected instances and a comparable weakening of root node dual bounds only on 4 instances.Enabling bound tightening also yields a small decrease in the mean time (2.2%) and a moderate decrease in the number of nodes (10%).According to these results, the two settings are very close in performance, Full-noBT being the slightly more reliable setting and Full yielding smaller branch-and-bound trees and slightly better solving times.The curves are very close since there are few affected instances.The setting Full performed slightly better than Full-noBT both in terms of running times and tree sizes, and the two settings are nearly identical in the limit.

Conclusion
In this paper we introduced a general method to construct perspective cuts not only for convex constraints as previously proposed in the literature, but also for nonconvex constraints, for which linear underestimators are readily available.We conducted a computational study of perspective cuts for convex and nonconvex constraints.Relevant structures were detected in about 10% of MINLPLib instances.The computational results indicate that adding perspective cuts for convex constraints reduces the mean running times and tree sizes by over 20%.Adding perspective cuts for nonconvex constraints can be detrimental to performance on challenging instances and can lead to an increased amount of numerical issues, which is reflected in a small decrease in the number of solved instances.Despite this, perspective cuts for nonconvex constraints reduce the geometric mean of the number of nodes of the branch-and-bound tree by 5% and improve dual bounds at the root node.
These results indicate that perspective cuts improve performance of general-purpose solvers.However, in order to efficiently utilize perspective cuts for nonconvex structures, careful implementation and tuning is necessary.
One direction for future work is developing more sophisticated detection algorithms.Some problems contain constraints that do not satisfy the requirements in our current implementation, but with more careful analysis of the problem structure can be revealed to be suitable for applying perspective cuts.Another direction for future research is generalizing the cut strengthening method to on/off variables whose "off" domain is a non-singleton interval, as well as to more general types of on/off sets.Unlike the case considered in this paper, there is no single best choice of how to strengthen a given valid cut in such a setting.Moreover, increased complexity of the set makes developing a computationally efficient cut strengthening method a more challenging task.
(a) the mixed-integer set (b) the continuous relaxations

Figure 1 :
Figure 1: Example of a disjunctive set and its convex hull (a) original cut valid for z " 1, y P r0.5, 1s (b) generalized perspective cut

Figure 2 :
Figure 2: Example of cut extension

Figure 3 :
Figure 3: Performance profiles comparing Off and Convex

Figure 4 :
Figure 4: Performance profiles comparing Convex and Full

Figure 5 :
Figure 5: Performance profiles comparing Full-noBT and Full

Table 1 :
Detection results

Table 2 :
Overview of solved instances

Table 3 :
Overall results on the subset of 672 affected instances

Table 4 :
Relevant and affected instances

Table 5 :
Root node dual bound differences

Table 6 :
Time on subsets of affected instances

Table 7 :
Number of nodes on subsets of affected instances

Table 8 :
Table 8 compares settings Full-noBT and Full for the 68 affected instances.Comparison between Full-noBT and Full