AlphaECP

# Introduction

AlphaECP is a Mixed-Integer Non-Linear Programming (MINLP) solver based on the extended cutting plane (ECP) method. The solver can be applied to general MINLP problems and it can ensure global optimal solutions for pseudo-convex MINLP problems.

The ECP method is an extension of Kelley's cutting plane method, which was originally given for convex NLP problems [139] . The method only requires the solution of a MIP sub-problem in each iteration. The MIP sub-problems can be solved to optimality, to feasibility, or only to an integer relaxed solution in intermediate iterations. This makes the ECP algorithm efficient and easy to implement. Further information about the underlying algorithm can be found in [257] and [196, 230, 256, 258] .

Further developments of the GAMS/AlphaECP algorithm have introduced additional functionality. A NLP solver can now be called at MIP solutions. This improves AlphaECP's ability to find feasible and accurate solutions, especially for MINLP problems which mainly contain continuous variables. Furthermore, a heuristic that reselects cutting planes during the iteration procedure can be used to improve the capability of solving non-convex problems.

## Licensing and software requirements

Users need to have a GAMS/AlphaECP license in order to use GAMS/AlphaECP. In addition, a licensed MIP solver is required for solving the mixed integer sub-problem, and a licensed NLP solver is required if the NLP option is used.

## Running AlphaECP

AlphaECP solves MINLP models. If AlphaECP is not specified as the default solver for these models it can be invoked by issuing the following command before the solve statement:

option minlp=alphaecp, miqcp=alphaecp;


In principle AlphaECP can also handle NLP models, but it is more suitable for MINLP problems. However, when combined with an NLP solver it can find solutions the NLP solver cannot find by itself. In this case it acts as a good starting point generator. If you want to solve NLPs with AlphaECP you need to trick the GAMS system by solving your NLP as an MINLP:

solve mynlpmodel minimizing obj using minlp;


Constraint violations are reported throughout the progress of AlphaECP and at the end of the algorithm. The violation is reported for the non-linear constraints only. The violation of the linear constraints is subject to the feasibility tolerance of the MIP/NLP solver.

# GAMS/AlphaECP Output

The log output below is obtained for the MINLP model fuel.gms from the GAMS model library:

------------------------------------------------------------------------------
Welcome to Alpha-ECP v2.10.06
MINLP Problem Solver using the Extended Cutting Plane Approach.
Method development - T.Westerlund, Abo Akademi University, FIN
Algorithm implementation - T.Lastusilta, Abo Akademi University, FIN
Westerlund Tapio and Poern Ray (2002). Optimization & Engineering, 3, 253-280
-------------------------------------------------------------------------------
Minimization problem: "fuel.gms"
The GAMS-model has in total 39 elements of which 15% are non-linear(NL)
included in 16 constraints of which 25% are NL
The NL constraint signs: =E=(3), =G=(1), =L=(0)
The number of variables in NL elements are 6 from a total of 16
variables: Continuous(13), Binary(3), Integer(0)
-------------------------------------------------------------------------------
Using following settings
AlphaECP option file                                    optfile=0
Time limit for AlphaECP (in seconds)                    reslim=1000
Solver trace file                                       solvetrace=(Inactive)
Cutting plane strategy (0-3)                            CUTdelcrit=3
Cut generation pace                                     CUTnrcuts=0
Updating multiplier if MIP is infeasible                ECPbeta=1.3
Write encountered solutions to gdx files                ECPdumpsol=0
Updating multiplier when verifying solution             ECPgamma=2
Maximum number of AlphaECP iterations                   ECPiterlim=-1
Level of AlphaECP output to statusfile (0-4)            ECPloglevel=0
Master strategy (0=User 1=Convex)                       ECPmaster=0
User specified start-point (0-3)                        ECPstart=3
Return solution (1.MIP/2.NLP/...)                       ECPretsol=2
AlphaECP strategy (1-5)                                 ECPstrategy=2
Upper limit of considered MIP solutions per MIP call    MIPnrsols=50
Relative MIP gap in intermediate sub-problems (0->1.0)  MIPoptcr=1.00
Initial MIPoptcr interval before MIPoptcr reduction     MIPoptcrlim=200
Strategy for multiple MIP solutions                     MIPsolstrat=1
MIP solver for sub-problems and . option file number    MIPsolver=cplex.0
NLP strategy. Inactive:0 Active strategy:1-5            NLPcall=5
NLP solver call at next (incremental) iteration         NLPcalliter=0
NLP time limit per call (in seconds or auto=0)          NLPreslim=30
NLP solver for sub-problems and . option file number    NLPsolver=conopt.0
Constraint tolerance                                    TOLepsg=0.001
Distance tolerance for a new linearization              TOLepsz=0.1
Infinity bound (MIP variable bound)                     TOLinfbnd=1e+010
-------------------------------------------------------------------------------
Itera  Stepcode, Number  Point Alpha OPT Movement Viol  Maximum   MIPobjval
tion   Problems  of Cuts usage Upd.  CR  Norm     Cons  Violation
Start-point: NL constraint (1) infeasibile
0      H         0       0     0     1   0        4     1.8E+003  NA
1      SAFGI     1       1     1     1   9.3E+003 0     -0        8566.12
1      FOUND SOLUTION:   8566.12      (NLP) in 1 sec.

2      SAFH      1       1     0     1   6.6E+003 4     1.8E+003  4844.02
3      SAFH      3       2     0     1   8.4E+003 3     1.8E+003  7031.72
4      SAFH      4       3     0     1   1E+003   2     1.8E+003  10157
5      SAH       5       4     0     1   0        1     7E+002    11925
6      SAH       6       5     0     1   1.1E+003 2     3.5E+002  11925
7      SAH       8       6     0     1   1.9E+003 2     5.3E+002  11925
8      SAH       9       7     0     1   8.8E+002 3     2.6E+002  11925
9      SAH       12      8     0     1   8.8E+002 3     1.3E+002  11925
10     SAH       15      9     0     1   4.4E+002 3     66        11925
...
92     AIJ       101     66    0     0   0        0     0.00067   11925
92               Pointusage    44/66     Cutusage   111/172   (    0,82   )
93     AH        111     44    0     0   1.4E+003 3     76        9926.15
94     AI        113     45    7     0   1.4E+003 0     0.00067   11925
95     AH        113     45    0     0   5.3E+002 2     58        10898
...
104    AI        117     48    1     0   0        0     0.00067   11925
105    AIJ       117     48    0     0   0        0     0.00067   11925
AlphaECP: Iteration procedure terminated normally
-------------------------------------------------------------------------------
Problem                   : fuel.gms
Solver Status             : Normal Completion
Model Status              : Locally Optimal
Exit comment              : No Issues
Final solution            : NLP
Objective value           : 8566.1189616876654
Max constraint (1)        : -0
Alternative solution      : MIP
Alt. objective value      : 8566.1189616876654
Max constraint (1)        : -0
Time used (seconds)       : 0.97
Time limit (seconds)      : 1000
Iterations used           : 105
Iteration limit           : -1
Function evaluations      : 484
Domain violations         : 0
Alphamax bound violations : 0
ECP time usage            : 3.2 %
NLP time usage            : 3.2 %
MIP time usage            : 93.6 %
Optimal/total MIPs        : 24/105
NLP solver calls          : 8
-------------------------------------------------------------------------------

In every iteration, information about the MIP problem and modifications to it is given in 10 columns. Here is a description of the different columns:

Iteration: Iteration identifier.

Stepcode, Problems: Letter for what actions were taken in this iteration, i.e. MIP problem modifications before the next iteration.

A: MIP solver feasible.

B: MIP solver feasible after moving cutting planes, i.e. alpha update.

C: MIP solver feasible after moving cutting planes close to their generation point. The movement is done to make it easier to satisfy nonlinear equality constraints.

D: Line search was successful (in ECPstrategy 3).

E: Line search failed (in ECPstrategy 3).

F: A NLP solver was called.

G: Found a MINLP solution.

H: Added linearization(s) to the next MIP problem.

I: Updated alpha values and possibly added linearizations.

J: All cutting planes are valid underestimators for the pseudo-convex constraints, except for the nonlinear objective function constraint.

K: The nonlinear objective function constraint value and MIP solution value differ more than $$\epsilon_f$$. A linearization was done to reduce the difference (in ECPstrategy 3).

L: Removed all temporal linearizations.

M: Domain violation(s), some of the constraint could not be evaluated.

N: Some cutting plane(s) could not be generated because of gradient problems.

O: No cutting planes could be generated.

P: Reselecting cuts because cutting planes are repeatedly moved close to their generation point.

R: Failed to add temporal linearization(s).

S: MIP solver strategy to find encountered solutions selected.

T: MIP solver strategy to require MIPnrsols solutions selected.

U: MIP solver strategy to require MIPnrsols solutions with a MIPoptcr <= 0.2 selected.

Number of Cuts: The number of cutting planes the solved MIP problem had.

Point usage: Number of points used to generate the cuts in the solved MIP problem.

Alpha Upd.: The number of times the alpha values has been increased.

OPTCR: Requirement of the relative distance to the relaxed MIP solution for the current MIP solution.

Movement Norm: The Euclidean norm of the current and previous MIP solution.

Viol Cons: Number of unsatisfied (violating) nonlinear constraints.

Maximum Violation: The most violating nonlinear constraint value.

MIPobjval/NLobjval: MIP or nonlinear objective variable value depending on ECPstrategy setting.

The cut reselection heuristic is called in the following cases:

1. If the MIP solver would otherwise return infeasible.
2. When the violation is not reducing, but the cutting planes are repeatedly moved close to their generation point.
3. When the violation is not reducing and domain violations are repeatedly encountered.

The heuristic reselects cutting planes in different ways, but always ensures that the same point cannot be found twice.

                 Pointusage     6/90     Cutusage    15/341   (    0,135  )


Pointusage informs how many points of all usable points have been used to generate the cutting planes. Cutusage tells how many cuts of all usable cuts have been used. The first number in ( 0,135 ) tells how many cuts is required by the user, see CUTnrcuts and the second number gives the sum of added and removed cuts, i.e. a measure of how much the MIP problem has been modified. AlphaECP may fix some cuts and remove points and cuts during the cut reselection procedure in order to save memory.

At the end of each solve AlphaECP gives a summary which includes Problem, Solver Status, Model Status, etc. Note the following lines:

• Exit comment may give further information than solverstatus on why the solution procedure stopped.
• Domain violations (function evaluation failed) or Gradients unusable (all gradients < TOLgrad) might be caused by poor variable bounds.
• Alphamax bound violations inform the user how many times an alphamax value was calculated to be $$> 10^{154}$$ and was reset to $$10^{154}$$.

To instruct AlphaECP to read an option file you may use ModelName.OptFile = 1. The name of the option file is in this case alphaecp.opt. For further information, see The Solver Options File. AlphaECP supports the GAMS parameter reslim, however, other GAMS parameters are passed on to the sub-solvers. Furthermore, you may also pass additional sub-solver specific options to the sub-solvers. For example, if you want to use all available threads and sub-solver CPLEX in opportunistic parallel search mode, then you may specify this in a GAMS model, in a similar way, as follows:

Model m / all /;
m.optfile=1;
$echo MIPsolver cplex.1 > alphaecp.opt$echo parallelmode -1 > cplex.opt
Solve m using MINLP minimizing objvar;


The following information is worth noting when you are interested in AlphaECP options. A linearization of a nonlinear constraint is called a cutting plane or cut. Here a point refers to the variable levels. Global optimality can be guaranteed for pseudo-convex problems. However, if the objective variable is in a nonlinear constraint and pseudo-convex, then ECPstrategy >= 3 needs to be used to guarantee global optimality (because one non-linear equality constraint makes a problem non-pseudo-convex, and hence also non-convex). The basic options might significantly impact the solution procedure, and the best values are likely to be problem specific. The user is therefore encouraged to try different values for the basic options.

# Summary of AlphaECP Options

## Basic options

Option Description Default
CUTnrcuts Cut generation pace 0
ECPmaster Master strategy (0=User 1=Convex) 0
MIPnrsols Upper limit of considered MIP solutions per MIP call 50
MIPsolstrat MIP solution collection strategy 1
MIPsolver MIP solver for sub-problems and . option file number GAMS MIP solver
NLPsolver NLP solver for sub-problems and . option file number GAMS NLP solver
reslim Time limit for AlphaECP (in seconds) GAMS reslim

## Algorithmic options for advanced users

Option Description Default
CUTdelcrit Cutting plane strategy 3
ECPbeta Updating multiplier if MIP is infeasible 1.3
ECPdumpsol Write encountered solutions to gdx files 0
ECPgamma Updating multiplier when verifying solution 2.0
ECPiterlim Maximum number of AlphaECP iterations -1
ECPloglevel Level of AlphaECP output to statusfile 0
ECPpcostrategy Pseudo-convex objective function strategy 3
ECPretsol Return solution (1.MIP/2.NLP/3.QUALITY/4.PERFORMANCE) 2
ECPstart User specified start-point 3
ECPstrategy AlphaECP strategy 2
solvelink Solvelink for NLP and MIP sub-solver 5
solvetrace Filename of solvetrace file
solvetracetime Time interval when a trace record is written 1
TOLepsf Pseudo-convex objective function termination tolerance 1e-3
TOLepsg Constraint tolerance 1e-3
TOLepsz Distance tolerance for a new linearization 1e-1
TOLgrad Gradient tolerance 1e-6
TOLinfbnd Infinity bound (MIP variable bound) 1e10

## MIP Solver related options

Option Description Default
MIPloglevel Level of MIP solver output 0
MIPoptcr Relative MIP gap in intermediate sub-problems 1.0
MIPoptcrlim Initial MIPoptcr interval before MIPoptcr reduction 200

## NLP Solver related options

Option Description Default
NLPcall NLP strategy 5
NLPcalliter NLP solver call at next (incremental) iteration 0
NLPlimsameint NLP call after a number of recurring integer solutions 5
NLPloglevel Level of NLP solver output 0
NLPreslim NLP time limit per call 0

# Detailed Descriptions of AlphaECP Options

CUTdelcrit (integer): Cutting plane strategy

Default: 3

value meaning
0 Do not remove any valid cuts.
1 As 0 and allow temporary cuts at semirandom points if normal cuts can not be made.
2 Allow temporary cuts and cut reselection, and use memory to save points and cuts.
3 As 2 and call the reselection heuristic before termination to improve the solution.

CUTnrcuts (real): Cut generation pace

The number of linearizations that are generated during an iteration can be chosen by AlphaECP, proportional to the number of violating constraints, or can be determined by a fixed amount. Furthermore, the cut reselection CUTdelcrit >=2 adds cuts to the problem so that the requested cut generation pace is taken into consideration.

Default: 0

value meaning
0 Let AlphaECP decide.
0<n<1 Number of linearizations = n* the number of linearizations that is possible to generate.
>1 Specifies the number of linearizations to generate.

ECPbeta (real): Updating multiplier if MIP is infeasible

In case of an infeasible MIP solution, the invalid cuts are updated with the ECPbeta multiplier.

Range: [1.001, ∞]

Default: 1.3

ECPdumpsol (integer): Write encountered solutions to gdx files

Default: 0

value meaning
0 No.
1 Solutions that the NLP solver found.
2 Solutions that the NLP or MIP solver found.

ECPgamma (real): Updating multiplier when verifying solution

If a MINLP solution is obtained but some cuts are not valid underestimators they are updated with the ECPgamma multiplier in order to make them into valid underestimators.

Range: [1.001, ∞]

Default: 2.0

ECPiterlim (integer): Maximum number of AlphaECP iterations

This is the maximum number of iterations given to AlphaECP to perform the optimization. Value -1 deactivates the AlphaECP iteration limit.

Default: -1

value meaning
-1 No limit.
>=0 Specifies an iteration limit.

ECPloglevel (integer): Level of AlphaECP output to statusfile

Default: 0

value meaning
0 No additional output to statusfile.
1 Report solutions.
Report all encountered solutions with their corresponding variable levels.
2 Report main actions at iteration level
(available for minimization problems).
3 Report main actions at linearization level
(available for minimization problems).
4 Full reporting.
Report the main actions taken, the linearizations, function values, and solution points for every iteration and line search details (available for minimization problems).

ECPmaster (integer): Master strategy (0=User 1=Convex)

The master strategy sets some options in order to solve a model with specific characteristics more efficiently. The affected options are noted in the log output. The set options takes precedence over the value set by the user for the affected options.

Default: 0

value meaning
0 Use only user defined options.
1 The model is convex. Set option ECPstrategy and CUTdelcrit.

ECPpcostrategy (integer): Pseudo-convex objective function strategy

Default: 3

value meaning
1 Remove support.
Remove old support planes when a new pseudo-convex problem is formed.
2 Replace support.
Replace old support planes with linearizations of the reduction constraint when a new pseudo-convex problem is formed.
3 Remove support and line search.
Remove old support planes when a new pseudo-convex problem is formed and perform a line search when it is possible.
4 Replace support and line search.
Replace old support planes with linearizations of the reduction constraint when a new pseudo-convex problem is formed and perform a line search when it is possible.

ECPretsol (integer): Return solution (1.MIP/2.NLP/3.QUALITY/4.PERFORMANCE)

The reported solution can be extracted from either the MIP or NLP solver result. If the MIP solution is returned only the primal values are available.

Default: 2

value meaning
1 Choose MIP solution if it is available.
2 Choose NLP solution if it is available.
3 Choose the solution with the best tolerance.
4 Choose the solution with the best objective value.

ECPstart (integer): User specified start-point

Define which variable levels are used when the optimization is started.

Default: 3

value meaning
0 Do not use a start-point; start the algorithm by solving the linear part (MIP) of the problem.
1 Use the user specified startpoint, but adjust the variable levels with a small value.
2 Use the exact start-point set by the user.
3 Use the exact start-point if linearly feasible; else adjust variable levels with a small value.

ECPstrategy (integer): AlphaECP strategy

Default: 2

value meaning
1 Convex strategy.
Ensures global optimality for problems with convex objective function and convex constraints.
2 Pseudo-convex constraints.
Ensures global optimality for problems with convex objective function and pseudo-convex constraints.
3 Pseudo-convex objective.
Ensures global optimality for problems with pseudo-convex objective function and pseudo-convex constraints. The reformulation of a non-linear objective function into a constraint must be done in a specific way. The requirement is that the objective variable must be in a linear part of the non-linear function. Assuming that the minimized or maximized variable is called objvar, the reformulation can be done as follows: (objective function expression) - objvar =E= 0. Furthermore, this strategy can effectively use a feasible start-point.
4 Pseudo-convex objective, but first complete with ECPstrategy 2.
(Only the necessary linearizations are removed when the ECPstrategy is changed.)
5 Pseudo-convex objective, but find the first solution with ECPstrategy 2.
(Only the necessary linearizations are removed when the ECPstrategy is changed.)

MIPloglevel (boolean): Level of MIP solver output

By default the detailed log of the MIP solver is suppressed in the AlphaECP log stream. If this option is turned on and the GAMS LogOption is set to 1 or 3, the MIP log will be merged into the AlphaECP log.

Default: 0

value meaning
0 No output.
1 MIP solver log goes to GAMS log.

MIPnrsols (integer): Upper limit of considered MIP solutions per MIP call

When the MIP solver returns several solutions the most suitable solution is chosen. Many times the solutions from the MIP solver are similar and a larger number might help to find a feasible MINLP solution if the constraints are almost satisfied. See MIPsolstrat to change the solution collection strategy.

Range: {1, ..., ∞}

Default: 50

MIPoptcr (real): Relative MIP gap in intermediate sub-problems

The relative stopping tolerance sent to the MIP solver for intermediate MIP problems. Note that the MIPoptcr value is decreased automatically to zero during the optimization.

Range: [0, 1]

Default: 1.0

MIPoptcrlim (integer): Initial MIPoptcr interval before MIPoptcr reduction

The MIPoptcr parameter is reduced in steps: From 1 to 0.5 to 0.3 to 0.2 to 0.1 to 0.0. The first reduction is at iteration MIPoptcrlim. MIPoptcrlim defines a step reduction at specific iterations (next reduction at iteration = the iteration number for this reduction multiplied by two). Note that a step reduction can also be caused by other reasons. If MIPoptcrlim is 200 then MIPoptcr is reduced at the following iterations: 200, 400, 800, etc.

Range: {1, ..., ∞}

Default: 200

MIPsolstrat (integer): MIP solution collection strategy

Default: 1

value meaning
0 Instruct MIP solver to return only one solution.
1 Instruct MIP solver to return any solutions encountered during MIP procedure.
2 Instruct MIP solver to search for solutions to obtain requested number MIPnrsols solutions.
3 As 2, but also require the solutions to fulfill MIPoptcr >= 0.2.
4 Let AlphaECP decide.

MIPsolver (string): MIP solver for sub-problems and . option file number

solver[.n] Solver is the name of the GAMS MIP solver and n is the integer corresponding to optfile. The option file is appended to the option file, that is written by AlphaECP. Hence, the specified options take precedence over the options set by AlphaECP. If .n is missing, the optfile is treated as zero i.e. the MIP solver will not look for a options file specified by the user. This option can be used to overwrite the default that uses the MIP solver specified with an Option NLP = solver; statement or the default GAMS solver for NLP.

Default: GAMS MIP solver

NLPcall (integer): NLP strategy

Determine when the NLP solver is called.

Default: 5

value meaning
0 No output.
1 Call the NLP solver at end of AlphaECP algorithm.
2 As 1 and when a better solution is found.
3 As 2 and when the same integer solution is encountered NLPlimsameint times.
4 Let AlphaECP decide.
5 Let AlphaECP decide and add noise to the variable levels before call.

NLPcalliter (integer): NLP solver call at next (incremental) iteration

Specify an iteration interval for the NLP solver calls.

Default: 0

NLPlimsameint (integer): NLP call after a number of recurring integer solutions

If the same integer solution is encountered NLPlimsameint times in a row then the NLP solver is called. The counter is reset after the NLP solver is called.

Range: {1, ..., ∞}

Default: 5

NLPloglevel (boolean): Level of NLP solver output

By default the detailed log of the NLP solver is suppressed in the AlphaECP log stream. If this option is turned on and the GAMS LogOption is set to 1 or 3, the NLP log will be merged into the AlphaECP log.

Default: 0

value meaning
0 No output.
1 NLP solver log goes to GAMS log.

NLPreslim (real): NLP time limit per call

The time limit (in seconds) given to the chosen NLP solver at each NLP solver call. Setting this option to 0 calculates a time limit which is relative to the problem size.

Default: 0

NLPsolver (string): NLP solver for sub-problems and . option file number

solver[.n] Solver is the name of the GAMS NLP solver that should be used in the root node, and n is the integer corresponding to optfile. If .n is missing, the optfile is treated as zero, i.e., the NLP solver will not look for an options file. This option can be used to overwrite the default that uses the NLP solver specified with an Option NLP = solver; statement or the default GAMS solver for NLP.

Default: GAMS NLP solver

reslim (real): Time limit for AlphaECP (in seconds)

Default: GAMS reslim

Default: 5

value meaning
1 Call NLP and MIP solver via script.
2 Call NLP and MIP solver via module.
5 Call NLP and MIP solver in memory.

solvetrace (string): Filename of solvetrace file

solvetracetime (real): Time interval when a trace record is written

Default: 1

TOLepsf (real): Pseudo-convex objective function termination tolerance

Maximum allowed absolute difference between the nonlinear and the MIP objective function value (used only in ECPstrategy 3).

Range: [1e-20, 1]

Default: 1e-3

TOLepsg (real): Constraint tolerance

The nonlinear constraint tolerance defines the maximum value that a nonlinear constraint may violate. For example, a constraint required to be zero may hold a value +/- TOLepsg at a solution.

Range: [1e-20, 1]

Default: 1e-3

TOLepsz (real): Distance tolerance for a new linearization

The maximum perpendicular distance between a valid cutting plane and its generation point (MIP solution).

Range: [1e-20, 1]

Default: 1e-1

The absolute value of a gradient's partial derivative must be above TOLgrad value in order for it to be considered nonzero.

Range: [1e-20, 1]

Default: 1e-6

TOLinfbnd (real): Infinity bound (MIP variable bound)

All variables must have a positive and a negative finite bound in order to ensure a bounded MIP problem. The finite bound value TOLinfbnd will be applied to single or double unbounded variables.

Default: 1e10

# FAQ

• What are good settings to solve a convex problem?

Use ECPmaster 1.

• What are good settings if the solution speed is essential?

Try ECPstrategy 1 and CUTdelcrit 1 to see if using multiple threads for the MIP solver improves the solution speed. However, there is considerable chance that a feasible solution for a non-convex problem with nonlinear equality constraints cannot be found.

• What are good settings when the solution quality is essential?

Use NLPcalliter 1 and MIPsolstrat 4 or 3, and also try different values, for CUTnrcuts option, for example 0.1.

• The objective function is non-linear, should the default ECPstrategy be used?

If the objective function constraint can be written in the required form of ECPstrategy 3 then this strategy may find a better solution. If the constraints and the objective function are pseudo-convex the global optimal solution will be found.