Patent Publication Number: US-7593834-B2

Title: Exclusion of regions method for multi-objective optimization

Description:
CROSS-RELATED APPLICATIONS 
     This application claims priority from Provisional Patent Application Ser. No. 60/567,627 filed Apr. 30, 2004. 
    
    
     BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to the field of multi-objective optimization methods, and especially to methods of solving large-scale design optimization tasks. 
     2. Description of the Prior Art 
     Optimization methods started with Newton&#39;s method, which was described by Isaac Newton in “De Analysi Per Aequationes Numero Terminorum Infinitas,” written in 1669. Since then a lot of methods for optimization of functions have been developed and applied for solving a variety of technical and scientific problems. Modern applied mathematics includes a large collection of optimization methods created over three centuries. An important group of such methods is based on using 1 st  and 2 nd  order derivatives of objective function [5, 6, 7] (Newton-Ralphson, Steepest descent, Conjugate gradient, Sequential quadratic programming, et cetera). 
     Italian economist Vilfredo Pareto introduced the concept of Pareto optimality in 1906 (see related definitions and multi-objective optimization problem formulation in p.A.1.) The concept has broad applications in economics and engineering. The Pareto optimality concept became the starting point for a new discipline of multi-objective optimization, which is intended to find trade-offs for several contradicting objectives. For instance, survivability and cost are contradicting objectives in ship design. If survivability is improved then cost may become too high. If the cost is decreased then survivability may become worse. It is important to find a reasonable trade-off for these two objectives, which determines the practical value of the multi-objective optimization concept. 
     The general multi-objective optimization problem is posed as follows [1]:
 
Minimize X   : F ( X )=[ F   1 ( X ), F   2 ( X ), . . . , F   m ( X )] T   (1)
 
subject:  q   j ( X )≦0 ; j =1,2 , . . . k 
 
     Here is a particular sample of a small optimization task with two independent variables and two objective functions:
 
Minimize:  F 1=1−exp[−( x 1−1/√{square root over (2)}) 2 −( x 2−1/√{square root over (2)}) 2 ];  (2)
 
Minimize:  F 2=1−exp[−( x 1−1/√{square root over (2)}) 2 −( x 2−1/√{square root over (2)}) 2 ];
 
−4 ≦x 1, x 2≦4;
 
     Dimension of multi-objective optimization tasks can be very different from two-dimensional tasks like the task (2) to large-scale tasks with dozens of objective functions and thousands of independent variables typical for aerospace, automotive industries, ship design, et cetera. Today it is impossible to design an airplane, automobile, or ship without intensive use of multi-objective optimization algorithms. This determines market demand and practical value of efficient multi-objective optimization algorithms. 
     There are no numerical methods developed for solving multi-objective optimization tasks. So, first attempts to solve such tasks were based on using well developed for the moment gradient-based optimization methods. In order to use those single-objective methods for multi-objective optimization a scalarization technique has been developed, which allowed substitution of multiple objective functions by a weighted exponential sum of those functions. The following is the simplest and the most common form of scalarization for the optimization problem (3): 
     
       
         
           
             
               
                 
                   
                     U 
                     = 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         m 
                       
                       ⁢ 
                       
                         
                           
                             w 
                             i 
                           
                           ⁡ 
                           
                             [ 
                             
                               
                                 F 
                                 i 
                               
                               ⁡ 
                               
                                 ( 
                                 x 
                                 ) 
                               
                             
                             ] 
                           
                         
                         p 
                       
                     
                   
                   ; 
                   
                     
                       
                         F 
                         i 
                       
                       ⁡ 
                       
                         ( 
                         x 
                         ) 
                       
                     
                     &gt; 
                     0 
                   
                   ; 
                   
                     ∀ 
                     i 
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
     In the early 1970&#39;s John Holland invented Genetic Algorithms (GAs). A genetic algorithm is a heuristic used to find approximate solutions to difficult-to-solve problems through application of the principles of evolutionary biology to optimization theory and other fields of computer science. Genetic algorithms use biologically derived techniques such as inheritance, mutation, natural selection, and crossover. GAs differs from conventional optimization algorithms in several fundamental respects. They do not use derivative or gradient information, but instead rely on the observed performance of evaluated solutions, and the transition rules are probabilistic rather than deterministic. 
     Thus, there are two groups of known multi-objective optimization methods: scalarization methods and multi-objective genetic algorithms. 
     1. Scalarization methods use a global criterion to combine multiple objective functions mathematically. These methods require solving a sequence of single-objective problems. The most common method of the group is weighted sum method. The method has several serious problems: 
     a. Use of gradients for determination of direction for the next step works perfectly when a single objective function is optimized. But utilizing the same technique for a weighted sum of multiple objective functions does not allow controlling values of individual objective functions during the optimization process. It creates serious problems finding evenly distributed Pareto optimal points:
         It is impossible to obtain points on non-convex portions of the Pareto optimal set in the objective function space [1]. This is important because the best trade-off solution can be lost there. See  FIG. 1   a  with Pareto-optimal points found by a gradient-based method for a task with non-convex Pareto frontier. All found Pareto points are concentrated in the areas of best and worse objective functions&#39; values. Non-convex part of the Pareto frontier is empty;   Uniform distribution of Pareto optimal points cannot be guaranteed even if the weights are varying consistently and continuously. It means that Pareto set will be incomplete and inaccurate [2]. This leads to the situation when the best optimal design solution is missed;       

     b. Methods are based upon usage of a priori articulation of preferences for determining weights in the weighted sum. However, a satisfactory a priori selection of weights does not necessarily guarantee that the final solution will be acceptable; 
     c. Mixed discrete and continuous problems cannot be solved by derivative based optimization methods. Any real life design problem naturally has discrete or integer design parameters. Substitution of discrete parameters by continuous ones compromises accuracy of the optimization result significantly. 
     2. Multi-objective Genetic Algorithms combine the use of random numbers and information from previous iterations to evaluate and improve a population of points rather than a single point at a time. GAs are based on heuristic strategies not related to the nature of multi-objective optimization. As a result, GAs are: 
     a. Computationally extremely intensive and resource consuming; 
     b. Do not provide adequate accuracy. See  FIG. 1   c  with Pareto-optimal points found by one of Genetic Algorithms. The algorithm was not able to find points located closer to the true solution, which is the diagonal of the x1-x2 diagram; 
     c. Do not provide an objective measure to evaluate divergence of found solutions from true Pareto frontier; 
     d. The objective of GAs is to find the optimal solution to a problem. However, because GAs are heuristics, the solution found is not always guaranteed to be the optimal solution. See a sample on  FIG. 1   c.    
     Traditional gradient-based optimization methods are designed to solve single-objective optimization tasks. Absence of numerical methods designed specifically for multi-objective optimization, forced engineers to invent an artificial scalarization technique, which allows considering multi-objective optimization tasks as single-objective ones, and using gradient-based methods. 
     For the same reason, engineers started utilizing heuristic GAs for multi-objective optimization. Both approaches are not designed to solve multi-objective optimization tasks and do not have appropriate mathematical foundation, and as result have above listed disadvantages. 
     Our invention offers new a type of numerical analysis specifically targeted to solve multi-objective optimization tasks. It is based on mathematically proven results (see Appendix A) and intended to overcome disadvantages of existent approaches. 
     1. Andersson J., “A Survey of Multi-objective Optimization in Engineering Design,” Fluid and Mechanical Engineering Systems, Linköping University, Sweden, LiTH-IKP-R1097. 
     2. Marler, R. T., and Arora, J. S. (2004), “Survey of Multi-objective Optimization Methods for Engineering”, Structural and Multidisciplinary Optimization, 26, 6, 369-395. 
     3. Pareto, V. 1906: Manuale di Economica Politica, Societa Editrice Libraria. Milan; translated into English by A. S. Schwier as Manual of Political Economy. Edited by A. S. Schwier and A. N. Page, 1971. New York: A. M. Kelley. 
     4. Holland, J. H. (1975). Adaptation in Natural and Artificial Systems. University of Michigan Press: Ann Arbor, Mich. 
     5. Vanderplaats, G. N., Numerical Optimization Techniques for Engineering Design, McGraw-Hill Book Co., 1984. 
     6. Haftka, R. T., and Gurdal, Z., Elements of Structural Optimization, Kluwer Academic Publishers, 1992. 
     7. Walsh, G. R., Methods of Optimization, John Wiley, 1975. 
     SUMMARY OF THE INVENTION 
     The Exclusion of Regions Method (TERM) for multi-objective optimization of objective functions considered in a multi-dimensional domain is provided. The principal approach is to decompose the domain into a set of sub-regions, and apply a special criterion to each sub-region to determine if it does not contain Pareto-points. Non-prospective sub-regions are filtered out, while prospective ones are used for generating points-candidates, and they are improved by a procedure until a pre-assigned accuracy is achieved. 
     In accordance with the present invention, a multi-objective optimization system and method are provided that substantially eliminate or reduce disadvantages of previously developed multi-objective optimization tools. 
     Accordingly, this invention provides a numerical method of multi-objective optimization for objective functions considered in a multidimensional domain. The method includes two stages: decomposition and improvement. Decomposition is targeted to filter out the sub-regions not containing any solutions, and find in such a way prospective sub-regions for further search. On the improvement stage points-candidates are generated in the prospective sub-regions, and improved by a special iterative procedure until pre-assigned accuracy has been achieved. In this way unnecessary searching in wrong sub-regions is avoided and computational time is reduced. An important feature of the numerical method is ability to find sub-regions containing true Pareto points at the end of calculations. The size of such sub-regions is determined by the pre-assigned accuracy. If higher accuracy is required then found sub-regions are smaller and found solutions are closer to the true Pareto frontier. 
     Another object of invention is a set of criteria allowing one to determine whether a sub-region does not contain Pareto solutions, and excluding it from further consideration. 
     Other objects of invention are Decomposition and Simplex Improvement algorithms allowing one to find solutions with pre-assigned accuracy. These two improvement algorithms are pure search algorithms. 
     TERM algorithm in conjunction with Decomposition and Simplex Improvement algorithms allow finding Pareto optimal points with pre-assigned accuracy. It does not have any problems in finding non-convex parts of Pareto frontier (see  FIG. 1   d .) TERM also supports working with mixed independent variables. See  FIG. 2  that illustrates a solution for the following problem with mixture of continuous and discrete design variables:
 
Maximize:  F 1=3−(1 +x 3)*cos( x 1*3.14/2)*cos( x 2*3.14/2);  (4)
 
Maximize:  F 2=3−(1 +x 3)*cos( x 1*3.14/2)*sin( x 2*3.14/2);
 
Maximize:  F 3=3−(1 +x 3)*cos( x 1*3.14/2)*sin( x 1*3.14/2);
 
0 ≦x 1,  x 2≦1 ; x 3∈{0.1,0.3,0.5,0.7,0.9};
 
     Another object of invention is Concurrent Gradients Method (CGM) for multi-objective optimization. CGM is based on gradient values, and can be used as an improvement algorithm in conjunction with the TERM algorithm, and as an independent algorithm of multi-objective optimization as well. 
     CGM is a generalization of the gradient-based approach for multi-objective optimization. Basically, it works as any gradient-based algorithm, but on each step CGM determines the area of simultaneous objective functions improvement and a direction for the next step in this area. The area is determined in a simple way based on gradients for each objective function calculated on current point. This introduces new a type of numerical analysis in the multi-objective optimization theory, and allows developing extremely efficient optimization algorithms without using the scalarization technique or any kind of heuristic. 
     According to CGM, a step cannot be done in a direction that improves some objective functions and makes other ones worse. No objective function gets worse on the next step. This is the main difference and a big advantage compared with traditional gradient-based algorithms, which ignore current value of each objective function, and improve just their weighted sum. This allows significant reduction in the iterations number until an optimal point will be found, and improves quality of results. See  FIG. 1   c  with Pareto-optimal points found by CGM method. The points are evenly spread and cover the entire Pareto frontier, which confirms high quality and accuracy of the solution. 
     Evaluation of computational efficiency has been performed for the CGM algorithm. On average, CGM has approximately the same efficiency as traditional gradient-based optimization algorithms. For some tasks CGM is 2-5 times faster than traditional algorithms. For other tasks CGM is 2-5 times slower. Efficiency of the CGM algorithm has been evaluated also for large-scale optimization tasks with 1000-2000 independent variables, and it was 1.5-4 times faster than traditional gradient-based optimization methods on a few considered tasks. 
     As mentioned earlier, CGM is a gradient-based method, which allows using so-called Response Surface Method (RSM) that is widely used in conjunction with traditional gradient-based algorithms. RSM builds local approximations of objective functions and uses them for calculating of gradients and even making a few steps without evaluation of the objective functions. This allows reducing the number of objective functions evaluations hundreds and thousands times, and makes CGM capable of solving the most challenging optimization tasks in aerospace, automotive, et cetera industries. CGM+RSM is at least as efficient as the fastest traditional gradient-based algorithms using the same RSM technique, and in many cases it is even more computationally efficient. 
     Employing the RSM technique gives CGM a huge advantage in computational efficiency compared with GAs because GAs do not use gradients, and as result, are not able to use the RSM technique. It means that CGM+RSM is hundreds and thousands times faster compared to GAs. 
     CGM is at the start point of its development while traditional gradient-based optimization algorithms have a long history of continuous efforts to improve their computational efficiency. We believe that CGM will become the fastest multi-objective optimization algorithm in the short term, and the number one choice for the most challenging design optimization tasks in aerospace, automotive, ship design, et cetera industries. 
     Another object of invention is a hybrid of multi-objective and single-objective optimization. On the first stage it uses the TERM algorithm for determination of initial points. Each found initial point has own sub-region around it, which includes true Pareto optimal solutions localized in such a way with pre-assigned accuracy (see mathematical proof in the Appendix A.) On the second stage it starts a gradient-based single-objective optimization algorithm from each initial point and performs a search inside of its small sub-region.  FIG. 1   a  illustrates inability of gradient-based algorithms relying on scalarization technique to find non-convex parts of Pareto frontier, while  FIG. 1   b  shows the correct results found by the hybrid algorithm. 
     The inventors hereof have developed The Exclusion of Regions Method (TERM) and Concurrent Gradients Method (CGM) for multi-objective optimization. TERM and CGM provide all above features. 
     Still further objects and advantages will become apparent from a consideration of the ensuing description and accompanying drawings. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The aforementioned objects and advantages of the present invention, as well as additional objects and advantages thereof, will be more fully understood hereinafter as a result of a detailed description of a preferred embodiment when taken in conjunction with the following drawings in which: 
         FIG. 1   a  illustrates the inability of gradient methods relying on a scalarization technique to find points of a non-convex part of Pareto front for the task (2); 
         FIG. 1   b  shows the solution found by a hybrid method, which determined initial points by TERM algorithm and then improves them by a traditional gradient method; 
         FIG. 1   c  shows the solution found by an evolutionary algorithm named Fair Evolutionary Multi-Objective Optimizer (FEMO.) FEMO is not able to improve accuracy of the solution; 
         FIG. 1   d  shows an accurate solution found by Concurrent Gradients method; Simplex Improvement algorithm and Decomposition Improvement algorithm give similar pictures, but require more significant computational time, 
         FIG. 2 , comprising  FIGS. 2   a  and  2   b , illustrates a solution found by the TERM algorithm for the multi-objective optimization task (4) with a mixture of continuous and discrete independent variables; 
         FIG. 3  is a flow diagram of the general schema of TERM algorithm; 
         FIG. 4  is a flow diagram of a general schema of region decomposition; 
         FIG. 5  is a flow diagram of a schema of region decomposition into a set of sub-regions; 
         FIG. 6   a  is a graph showing the creation of a core region in the decomposition process; 
         FIG. 6   b  is a graph illustrating decomposition on the variable x 1 ; 
         FIG. 6   c  is a graph illustrating decomposition on the variable x 2 ; 
         FIG. 7  is a flow chart of filtration non-Pareto points from the pool of points-candidates; 
         FIG. 8  is a flow chart of determination if one point is worse than another; 
         FIG. 9  is a flow chart of improvement via decomposition algorithm; 
         FIG. 10   a  is a graph, which illustrates intersection of current core sub-region with the area of true Pareto optimal solutions P; 
         FIG. 10   b  is a graph, which shows a set of “red” sub-regions R 2 , R 4 , R 7 , and R 8  those intersecting the area P of true Pareto optimal solutions. The sub-regions are created via Decomposition Improvement algorithm; 
         FIG. 11  is a flowchart of the general schema of core point improvement via the Simplex Improvement method; 
         FIG. 12  is a flow chart of recursive finding of an improved point-candidate via Simplex method; 
         FIG. 13  is a graph, which illustrates the schema of evaluated points via Simplex improvement algorithm on the one iteration; 
         FIG. 14   a  is a graph, which illustrates found “red” sub-regions intersecting true Pareto-frontier; each sub-region has a point-candidate inside; 
         FIG. 14   b  is a graph, which illustrates optimization by a traditional gradient-based method starting from a point-candidate, and finding a solution in the true Pareto-frontier area; 
         FIG. 15   a  is a graph, which illustrates determination the area of improved values A 1  for first objective function; 
         FIG. 15   b  is a graph, which illustrates determination the area of improved values A 2  for second objective function; 
         FIG. 15   c  is a graph, which illustrates determination the area of simultaneous objective functions improvement A SI  for both first and second objective functions; 
         FIG. 15   d  is a graph, which illustrates finding points Xg 1  and Xg 2  as intersections of gradients G 1  and G 2  with unit sphere (unit circle in the sample); 
         FIG. 15   e  is a graph, which illustrates determination of the direction of simultaneous improvement for all objective functions; 
         FIG. 15   f  is a graph, which illustrates determination of new point-candidate X′={x* 1 ,x* 2 } as intersection of the vector G i  with boundary of the core sub-region; 
         FIG. 16  is a flowchart, which shows the schema of point improvement by Concurrent Gradients method; (See details on  FIG. 17 ); 
         FIG. 17  is a flowchart for creating a new core point-candidate by Concurrent Gradients method; and 
         FIG. 18  is a general flowchart of the Concurrent Gradients algorithm (See details on  FIGS. 16-17 ). 
     
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     General Description of the Exclusion of Regions Method 
     The Exclusion of Regions Method (TERM) for multi-objective optimization consists of two main steps: decomposition to find prospective initial regions, and improvement of the points taken in initial regions. Decomposition algorithm finds in design space a set of so-called “red” n-dimensional sub-regions that are likely to contain Pareto points. Then on the improvement stage a point from each “red” sub-region is improved by special iterative procedure until pre-assigned approximation tolerance δ is achieved. Obtained set of points is filtered and output (see  FIG. 3 ). 
     Let us consider the decomposition algorithm in details. 
     1. First “red” sub-region is equal to the domain that is determined by user in the task formulation. It can be described by the following inequalities:
 
 x   l     i     ≦x   i   ≦x   u     i   , where  i= 1 , . . . ,n.   (5)
 
     2. Then Lipschitz constants are calculated for the base “red” region. 
     3. Lipschitz constants and current objective functions tolerances δ i  are used for creating core sub-regions. The base core sub-region with core point X 0 ={x 1 , . . . ,x n } has the following bounds:
 
 x   l     i     0   ≦x   i   ≦x   u     i     0 ,  (6)
         where i=1, . . . ,n, x l     i   ≦x l     i     0  and x u     i     0 ≦x u     i   .       

     4. The base core sub-region is utilized for decomposing base region into a set of sub-regions of 2 nd  order. Each sub-region of 2 nd  order has own core region and is decomposed to set of 3 rd  order, et cetera. The sub-region not decomposed if its own core region size is equal to the region size. 
     5. The set of created sub-regions is divided into two categories: “blue” and “red”. 
     6. The set of “blue” sub-regions is excluded from further consideration. 
     7. An initial point is selected in each “red” sub-region. 
     8. Each selected initial point is improved by an improvement method. 
     9. The points obtained after improvement process are compared with respect to pre-assigned accuracy coefficients in order to filter out non-Pareto points. 
     10. The rest of points are declared as approximate Pareto points, or multi-objective optimization results. 
     11. Current values of objective functions tolerances δ i  are decreased. Continue from step 3 if further optimization is needed. 
     12. Output optimization results. 
     Decomposition 
     Decomposition is targeted to decompose the design space into a set of sub-regions, recognize and filter out the sub-regions not containing any solutions, and find in such a way prospective sub-regions for further search. 
     Major part of the decomposition algorithm is creating core region according to current tolerance coefficients, which are calculated using Lipschitz constants. Let us consider in detail the evaluation of Lipschitz constants, tolerance coefficients, and partial derivatives at an arbitrary point and at a core point. 
     Evaluation of partial derivatives at the point X 0 ={x 1   0 , . . . ,x n   0 } for objective functions F 1 , . . . ,F m : 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           ∂ 
                           
                             F 
                             j 
                           
                         
                         
                           ∂ 
                           
                             x 
                             i 
                           
                         
                       
                       = 
                       
                         
                           
                             
                               F 
                               j 
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   
                                     x 
                                     i 
                                     0 
                                   
                                   + 
                                   
                                     Δ 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       x 
                                       i 
                                     
                                   
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   n 
                                   0 
                                 
                               
                               ) 
                             
                           
                           - 
                           
                             
                               F 
                               j 
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   n 
                                   0 
                                 
                               
                               ) 
                             
                           
                         
                         
                           Δ 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             x 
                             i 
                           
                         
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     where 
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     
                       i 
                       = 
                       
                         1 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         … 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         n 
                       
                     
                     , 
                     
                       j 
                       = 
                       
                         1 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         … 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         m 
                       
                     
                     , 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         Δ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           x 
                           i 
                         
                       
                       = 
                       
                         
                           
                             x 
                             ui 
                           
                           - 
                           
                             x 
                             li 
                           
                         
                         K 
                       
                     
                     , 
                     
                       K 
                       -&gt; 
                       
                         ∞ 
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
     Current objective functions tolerances are calculated based on objective functions values on N arbitrary points:
 
Δ F   j =|(max  F   j ( x   1   k   , . . . ,x   n   k )−min  F   j ( x   1   k   , . . . ,x   n   k ))·δ i |,  (8)
         Where k=1 . . . N, j=1 . . . m,   δ i  is current approximation tolerance.       

     Current objective functions tolerances ΔF j  are used to create a core region for the core point X 0 ={x 1   0 , . . . ,x n   0 }:
 
 x   l     i     0 =max{ x   i   0   −hx   i   , x   l     i   },
 
 x   u     i     0 =min{ x   i   0   +hx   i   , x   u     i   },
 
     
       
         
           
             
               
                 
                   
                     
                       Where 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       i 
                     
                     = 
                     
                       1 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       n 
                     
                   
                   , 
                   
                     
                       hx 
                       i 
                     
                     = 
                     
                        
                       
                         
                           min 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           Δ 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             F 
                             j 
                           
                         
                         
                           
                             Cz 
                             · 
                             max 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               ∂ 
                               
                                 F 
                                 j 
                               
                             
                             
                               ∂ 
                               
                                 x 
                                 i 
                               
                             
                           
                         
                       
                        
                     
                   
                   , 
                   
                     j 
                     = 
                     
                       1 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       m 
                     
                   
                   , 
                   
                     
 
                   
                   ⁢ 
                   
                     Cz 
                     ≤ 
                     
                       1 
                       - 
                       
                         Safety 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           factor 
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
       FIG. 4  illustrates a general schema of region decomposition after determining the core region bounds. The main decomposition algorithm uses a recursive procedure to decompose a region into a set of sub-regions (see  FIG. 5  for details). 
     For better understanding of the decomposition algorithm a sample of an optimization task with two independent variables x 1  and x 2  is illustrated in  FIG. 6 : creating a core region ( FIG. 6   a ), and also decomposing of sub-regions along the variables x 1  ( FIG. 6   b ) and x 2  ( FIG. 6   c ). 
       FIG. 6  illustrates a single iteration of recursive decomposition process. Five sub-regions have been decomposed during the iteration:
     1 sub-region: x l     1   ≦x 1 ≦x l     1     0 , x l     2   ≦x 2 ≦x u     2   ;   2 sub-region: x u     1     0 ≦x 1 ≦x u     1   , x l     2   ≦x 2 ≦x u     2   ;   3 sub-region: x l     1     0 ≦x 1 ≦x u     1     0 , x l     2   ≦x 2 ≦x l     2     0 ;   4 sub-region: x l     1     0 ≦x 1 ≦x u     1     0 , x u     2     0 ≦x 2 ≦x u     2   ;   5 sub-region: x l     1     0 ≦x 1 ≦x u     1     0 , x l     2     0 ≦x 2 ≦x u     2     0 .   
     In the next step of decomposition, sub-region 5 will not be decomposed further because the core region covers the entire sub-region 5. For all other sub-regions it is necessary to:
         Take an arbitrary core point;   Create a core region in the current sub-region;   Repeat all steps of the decomposition process described above.
 
Filtration of Sub-Regions and Points-Candidates
       

     The filtration procedure is intended to separate “blue” and “red” sub-regions. 
     According to the criteria 1)-3) (see Numerical Solution with Pre-assigned Accuracy, section A.1), “blue” sub-regions do not contain any solutions, and they are excluded from further consideration. Each “red” sub-region will be processed by an improvement algorithm, and a point-candidate will be found in the sub-region. 
     Size of each sub-region is limited by current objective functions tolerance ΔF j , j=1 . . . m. It allows use of ΔF j  for comparing core points against each other, which simplifies the sub-region filtration procedure. 
     Let us consider filtration of points-candidates. It is performed as a comparison of each point-candidate against all other points. If one of compared points is substantially worse than another one, then it is excluded from the set of points-candidates (see the flowchart on  FIG. 7 ). 
     Point X 1 ={x 1   1 , . . . , x n   1 } is worse than the point X 2 ={x 1   2 , . . . , x n   2 } if condition (10) is satisfied:
 
 F   j ( x   1   1   , . . . x   n   1 )−Δ F   j   &gt;F   j ( x   1   2   , . . . x   n   2 ),  j =1  . . . m.   (10)
 
     Condition (10) assumes that all objective functions are minimized.  FIG. 6  illustrates the flowchart of the algorithm that determines which of two points is worse. 
     Thus, if point X k ={x 1   k , . . . ,x n   k } is worse than any point X l ={x 1   l , . . . ,x n   l }, where l=0,1, . . . ,k−1,k+1, . . . N, then point is considered as “blue” one, and excluded with its sub-region from further consideration (see  FIG. 7 .) 
     Improvement of a Point-Candidate 
     On the improvement stage points-candidates are generated in the prospective sub-regions, and improved by an iterative procedure until pre-assigned accuracy has been achieved. 
     The procedure of point-candidate improvement is applied to each “red” sub-region found via decomposition. An arbitrary point taken from a “red” sub-region can be used as initial point for the improvement procedure (see Appendix A.) But the center of a sub-region is a preferable choice because it simplifies calculation of gradients. Different improvement methods can be used for improvement of a point-candidate. 
     A common part of each improvement algorithm is the comparison of the current point and a new evaluated point, which is necessary to decide if a better point can be found. The comparison procedure can use different conditions to recognize if the new point is better than current one:
         New point improves at least one objective function and is not worse in any other objective functions;   New point improves all objective functions except one, which does not get worse;   New point improves all objective functions simultaneously.       

     Let us consider a few improvement methods in detail. 
     Search Methods for Improvement a Point-Candidate 
     A variety of known search algorithms can be used for improvement of points-candidates taken in “red” sub-regions. One of such methods is the decomposition method described above. The following is a detailed description of the Decomposition Improvement algorithm. 
     Let us consider the following task: 
     Find improved point set SX′ in the region R with core point X 0  and bounds x l     i     0 ≦x i   0 ≦x u     i     0 , i=1, . . . ,n. 
     Tolerances Δx i =x u     i   −x l     i    are calculated for all independent variables for pre-assigned approximation tolerance δ. 
     Decomposition Improvement algorithm is applied with pre-assigned approximation tolerance δ to each “red” sub-region that is created on the decomposition stage of TERM algorithm (see “Decomposition” section.) It includes the following sequence of operations (see  FIG. 7 ):
         1. Initial region R with boundaries x l     i     0 ≦x i   0 ≦x u     i     0  is decomposed into a set of sub-regions R j ; each sub-region is created with respect to the tolerance coefficients;   2. Filtration procedure filters out all “blue” sub-regions (see “Filtration of Sub-Regions and Points-Candidates” section.) As result, a set of “red” sub-regions is found;   3. Core point (or any other points from “red” sub-region) of each “red” sub-region is declared as improved point; this is the result of improvement via decomposition algorithm.       

       FIG. 10  illustrates the process of a point-candidate improvement via the decomposition algorithm for a task with two independent variables. As a result of decomposition, region R (see  FIG. 10   a ) is decomposed into a set of sub-regions R 1 , . . . ,R 8  (see  FIG. 10   b .) Then filtration procedure is applied, and sub-regions R 2 ,R 4 ,R 7 ,R 8  are recognized as “red” ones. Core point (but it can be any other points taken in the sub-region) of each “red” sub-region is declared as improved point-candidate: X* (2) ,X* (4) ,X* (7) ,X* (8) . So, we have the following set of improved points:
   SX′={X*   (2)   ,X*   (4)   ,X*   (7)   ,X*   (8) }. 
     If only one improved point is required then any of found points can be taken as a solution. 
     Simplex Improvement method also can be used for improvement of a point-candidate. Its major idea is to find a point on the core region boundary that improves at least one objective function without worsening other objective functions. 
     Simplex Improvement method can be performed in the following way (see  FIG. 11 ):
         1. Create a core sub-region x l     i     0 ≦x i   0 ≦x u     i     0 , i=1, . . . ,n for current core point X 0 .   2. Take three values for each independent variable x i : x i   1 =x i   0 , x i   2 =x l     i     0  and x 1   3 =x u     i     0 .   3. Create all combinations of those values and calculate optimized objective functions on all the points: X* k , k=1, . . . ,3 n −1 (see  FIG. 12 )   4. Compare calculated objective functions values with their values on the core point X 0 . If core point X 0  is worse than new point X* k  then X* k  is declared as new core point. Go to step 1.   5. Point X* is declared as the solution (improved point.)       

       FIG. 13  illustrates an iteration of a point-candidate improvement process via Simplex Improvement algorithm. A task with two independent variables is illustrated. Objective functions are evaluated on the points {X* 1 ,X* 2 ,X* 3 ,X* 4 ,X* 5 ,X* 6 ,X* 7 ,X* 8 }; point X* 2  selected as a new point-candidate, because point X 0  is worse than X* 2 . 
     Gradient-Based Optimization Methods for Improvement a Point Candidate 
     Traditional single-objective optimization methods based on scalarization technique also can be used for improvement of point-candidates. 
     There is a unique advantage of TERM algorithm, which allows further development of the approach. As follows from the description of TERM numerical method, and especially from the section Numerical Solution with Pre-Assigned Accuracy (see Appendix A, section A.1), a sub-region surrounding an initial point contains a part of Pareto frontier approximated with pre-assigned accuracy (see  FIG. 13   a .) So, it is not necessary to use the entire design space  X  for the gradient-based optimization. The search space should be limited by the boundaries of the sub-region R i  for the initial point x i , i=1, . . . ,n (see  FIG. 13   b ). 
       FIG. 14  illustrates two stages of multi-objective optimization performed in this way: 
       14   a —Start TERM algorithm and find required number of initial points and their sub-regions with pre-assigned accuracy; the size of sub-regions surrounding each initial point determined by the pre-assigned accuracy; each sub-region includes an approximation of Pareto points determined by the pre-assigned accuracy; 
       14   b —After initial point has been obtained, gradient-based optimization is started. It stops after an optimal point has been found inside of the sub-region. Each initial point is processed similarly one by one. 
     Combination of inventive TERM algorithm with traditional gradient-based optimization methods is a hybrid algorithm that utilizes TERM&#39;s ability to find good initial points, and improves the points via computationally efficient gradient-based methods. Such a hybrid algorithm allows avoiding weak sides of traditional gradient-based methods relying on scalarization technique: inability to find initial points, and difficulties in finding Pareto points. 
     Concurrent Gradients Method for Improvement a Point Candidate 
     This method determines the area of simultaneous objective functions improvement in the core sub-region, and finds a point in the area that improves the objective functions. 
     Let us consider the following task: 
     max F j (X), j=1, . . . ,m for core point X 0  and bounds: 
     
         
         x l     i     0 ≦x i   0 ≦x u     i     0  created around the core point X 0  with respect to objective functions tolerances ΔF j ; 
         G j , j=1, . . . ,m are gradients for objective functions F j  That show the improvement direction for corresponded objective functions. 
       
    
     Gradients of all objective functions need to be evaluated at the core point: 
     
       
         
           
             
               
                 G 
                 j 
               
               ⁡ 
               
                 ( 
                 X 
                 ) 
               
             
             , 
             
               j 
               = 
               1 
             
             , 
             … 
             ⁢ 
             
                 
             
             , 
             m 
             , 
             
               
                 where 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   
                     G 
                     j 
                   
                   ⁡ 
                   
                     ( 
                     X 
                     ) 
                   
                 
               
               = 
               
                 
                   { 
                   
                     
                       
                         ∂ 
                         
                           F 
                           j 
                         
                       
                       
                         ∂ 
                         
                           x 
                           1 
                         
                       
                     
                     , 
                     … 
                     ⁢ 
                     
                         
                     
                     , 
                     
                       
                         ∂ 
                         
                           F 
                           j 
                         
                       
                       
                         ∂ 
                         
                           x 
                           n 
                         
                       
                     
                   
                   } 
                 
                 . 
               
             
           
         
       
     
     Each gradient shows the direction where corresponding objective function is getting better (maximized in our sample.) Let us consider a flat L j (X) perpendicular to the corresponded gradient G j ={g 1   j , . . . , g n   j } in the core point x 0 . The flat splits current sub-region into two parts: area A j  where objective function F j (X) is getting better, and area B j  where F j (X) is getting worse. In reality a surface splits the sub-region into A j  and B j  areas. So, we assume that the sub-region is small enough to use the flat L j (X) as an approximation of the surface. 
     Let us formulate an equation of the flat that is perpendicular to the gradient vector G j ; we assume that X 0  is the origin of coordinates:
 
 L   j ( X )= g   1   j   ·x   1   +g   2   j   ·x   2   + . . . +g   n   j   ·x   n 
 
     All points that satisfy the condition L j (X)&lt;0 decrease the value of objective function F j (X). On another side of the flat all points satisfy the condition L j (X)&gt;0, and they increase the value of objective function F j (X). 
     Correspondingly, all points satisfying the system of inequalities (11) increase values of all objective functions simultaneously: 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             
                               
                                 
                                   L 
                                   1 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   X 
                                   ) 
                                 
                               
                               &gt; 
                               0 
                             
                           
                         
                         
                           
                             
                               
                                 
                                   L 
                                   2 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   X 
                                   ) 
                                 
                               
                               &gt; 
                               0 
                             
                           
                         
                         
                           
                             ⋯ 
                           
                         
                         
                           
                             
                               
                                 
                                   L 
                                   m 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   X 
                                   ) 
                                 
                               
                               &gt; 
                               0 
                             
                           
                         
                       
                       } 
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     or 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         
                           
                             
                               
                                 
                                   g 
                                   1 
                                   1 
                                 
                                 · 
                                 
                                   x 
                                   1 
                                 
                               
                               + 
                               
                                 
                                   g 
                                   2 
                                   1 
                                 
                                 · 
                                 
                                   x 
                                   2 
                                 
                               
                               + 
                               … 
                               + 
                               
                                 
                                   g 
                                   n 
                                   1 
                                 
                                 · 
                                 
                                   x 
                                   n 
                                 
                               
                             
                             &gt; 
                             0 
                           
                         
                       
                       
                         
                           
                             
                               
                                 
                                   g 
                                   1 
                                   2 
                                 
                                 · 
                                 
                                   x 
                                   1 
                                 
                               
                               + 
                               
                                 
                                   g 
                                   2 
                                   2 
                                 
                                 · 
                                 
                                   x 
                                   2 
                                 
                               
                               + 
                               … 
                               + 
                               
                                 
                                   g 
                                   n 
                                   2 
                                 
                                 · 
                                 
                                   x 
                                   n 
                                 
                               
                             
                             &gt; 
                             0 
                           
                         
                       
                       
                         
                           ⋯ 
                         
                       
                       
                         
                           
                             
                               
                                 
                                   g 
                                   1 
                                   m 
                                 
                                 · 
                                 
                                   x 
                                   1 
                                 
                               
                               + 
                               
                                 
                                   g 
                                   2 
                                   m 
                                 
                                 · 
                                 
                                   x 
                                   2 
                                 
                               
                               + 
                               … 
                               + 
                               
                                 
                                   g 
                                   n 
                                   m 
                                 
                                 · 
                                 
                                   x 
                                   n 
                                 
                               
                             
                             &gt; 
                             0 
                           
                         
                       
                     
                   
                   } 
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
     This is the key point of the Concurrent Gradients method. The system of inequalities (11) determines the area of simultaneous improvement of all objective functions A SI . Now we need to find a point X′∈A SI  satisfying conditions (11), and the core point X 0  will be improved with respect to all objective functions. 
     Let us consider a graphical interpretation of the method for the simplest multi-objective optimization task with two independent variables and two objective functions that need to be maximized. Our goal is to:
         determine the area of simultaneous improvement for both objective functions;   determine the direction of next step in the optimization process;   determine the length of the step.       

     In this way we will find next point X′={x* 1 , . . . , x* n }, which is a solution of the system of inequalities (11). 
       FIG. 15  illustrates i th  iteration of the improvement process for a sample task with two independent variables and two maximized objective functions. The variables on the  FIG. 15  have the following meaning:
     {x 1   0 ,x 2   0 } is a core point X 0 , which needs to be improved on the i th  iteration;   x l     1     0 ≦x 1 ≦x u     1     0 ,x l     2     0 ≦x 2 ≦x u     2     0 —boundaries of the core sub-region created around the core point X 0 ; the size of the sub-region is determined by objective functions tolerances ΔF 1 , ΔF 2 ;   G 1  and G 2  are gradients of objective functions F 1  and F 2  those indicate the direction of maximization for each objective function; if objective functions F 1  and F 2  need to be minimized then opposite vectors −G 1  and −G 2  can be used to determine the direction of minimization for each objective function;   Xg 1   Xg 2 —intersection points of gradients G 1  and G 2  with unit sphere (unit circle for our 2-dimensional sample) with the center in the point X 0 ;   G* is the vector, which indicates the direction of simultaneous improvement of all objective functions;   A 1  is the area of points improving the objective function F 1 ;   A 2  is the area of points improving the objective function F 2 ;   A SI  is the area of points improving both objective functions F 1  and F 2  simultaneously;   A SI =A 1 ∩A 2 ;   X′={x* 1 ,x* 2 }∈A SI  is new point candidate, which improves all the objective functions simultaneously.   
     Finding a new point-candidate on the i th  iteration can be performed in the following way: 
       FIG. 15   a  illustrates the following: calculate the gradient G 1  on the point X 0  for the objective function F 1 ; create a flat L 1  that is perpendicular to the gradient G 1 ; flat L 1  is the boundary between area A 1  of the points improving the objective function F 1 , and area B 1  of the points where the objective function F 1  gets worse; 
       FIG. 15   b  illustrates similar determination of area A 2  where function F 2  gets better; 
       FIG. 15   c  illustrates that area of simultaneous improvement for both objective functions F 1  and F 2  is equal to intersection of areas A 1  and A 2 : A SI =A 1 ∩A 2 ; 
       FIG. 15   d  illustrates finding points Xg 1  and Xg 2  as intersections of gradients G 1  and G 2  with unit sphere (unit circle in the sample); 
       FIG. 15   e  illustrates determination of the direction of simultaneous improvement for all objective functions; such direction can be calculated as a vector G*={g 1 ,g 2 }, where g 1 ,g 2  is arithmetic mean of maximal and minimal coordinates of points 
     
       
         
           
             
               
                 
                   Xg 
                   1 
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 and 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   Xg 
                   2 
                 
                 ⁢ 
                 
                   : 
                 
                 ⁢ 
                 
                   g 
                   1 
                 
               
               = 
               
                 
                   
                     max 
                     ⁡ 
                     
                       ( 
                       
                         
                           xg 
                           1 
                           1 
                         
                         , 
                         
                           xg 
                           2 
                           1 
                         
                       
                       ) 
                     
                   
                   - 
                   
                     min 
                     ⁡ 
                     
                       ( 
                       
                         
                           xg 
                           1 
                           1 
                         
                         , 
                         
                           xg 
                           2 
                           1 
                         
                       
                       ) 
                     
                   
                 
                 2 
               
             
             , 
           
         
       
     
     
       
         
           
             
               g 
               2 
             
             = 
             
               
                 
                   
                     max 
                     ⁡ 
                     
                       ( 
                       
                         
                           xg 
                           1 
                           2 
                         
                         , 
                         
                           xg 
                           2 
                           2 
                         
                       
                       ) 
                     
                   
                   - 
                   
                     min 
                     ⁡ 
                     
                       ( 
                       
                         
                           xg 
                           1 
                           2 
                         
                         , 
                         
                           xg 
                           2 
                           2 
                         
                       
                       ) 
                     
                   
                 
                 2 
               
               . 
             
           
         
       
     
       FIG. 15   f  illustrates determination of new point-candidate X′={x* 1 ,x* 2 } as intersection of the vector G* with boundary of the core sub-region. 
     In general case for n independent variables and m minimized objective functions new point-candidate can be found by the Concurrent Gradients method (see  FIG. 16  and  FIG. 17 ) in the following way (if an objective function F j  needs to be maximized then −F j  can be minimized):
         1. Create a core sub-region with the center in the initial point X 0 . The size of the core sub-region is determined by tolerances ΔF j , j=1, . . . ,m. Created core sub-region has the following boundaries: x l     i     0 ≦x i ≦x u     i     0 , i=1, . . . ,n.   2. Calculate gradients for all objective functions in the initial point X 0 :       

     
       
         
           
             
               
                 ∇ 
                 
                   
                     F 
                     j 
                   
                   ⁡ 
                   
                     ( 
                     X 
                     ) 
                   
                 
               
               = 
               
                 { 
                 
                   
                     
                       ∂ 
                       
                         F 
                         j 
                       
                     
                     
                       
                         ∂ 
                         
                           x 
                           1 
                         
                       
                       ⁢ 
                       
                           
                       
                     
                   
                   , 
                   … 
                   ⁢ 
                   
                       
                   
                   , 
                   
                     
                       ∂ 
                       
                         F 
                         j 
                       
                     
                     
                       ∂ 
                       
                         x 
                         n 
                       
                     
                   
                 
                 } 
               
             
             , 
             
               j 
               = 
               1 
             
             , 
             … 
             ⁢ 
             
                 
             
             , 
             
               m 
               . 
             
           
         
       
         
         
           
             3. Calculate vectors that indicate direction of improvement for corresponded objective functions: for maximized objective functions G j (X)=∇F j (X); for minimized objective functions G j (X)=−∇F j (X). 
             4. Calculate intersection points Xg j  of vectors G j  with surface of the unit sphere, where Xg j ={xg 1 , . . . ,xg n }, j=1, . . . ,m. 
             5. Calculate vector 
           
         
       
    
     
       
         
           
             
               
                 G 
                 * 
               
               = 
               
                 { 
                 
                   
                     g 
                     1 
                   
                   , 
                   … 
                   ⁢ 
                   
                       
                   
                   , 
                   
                     g 
                     n 
                   
                 
                 } 
               
             
             , 
             
               
                 where 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   g 
                   i 
                 
               
               = 
               
                 
                   
                     
                       
                         max 
                         
                           
                             j 
                             = 
                             1 
                           
                           , 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           , 
                           m 
                         
                       
                       ⁢ 
                       
                         ( 
                         
                           xg 
                           i 
                           j 
                         
                         ) 
                       
                     
                     - 
                     
                       
                         min 
                         
                           
                             j 
                             = 
                             1 
                           
                           , 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           , 
                           m 
                         
                       
                       ⁢ 
                       
                         ( 
                         
                           xg 
                           i 
                           j 
                         
                         ) 
                       
                     
                   
                   2 
                 
                 . 
               
             
           
         
       
         
         
           
             6. Find new point-candidate X′ as intersection of the vector G* and boundaries of the core sub-region. 
             7. If point X′ is better than initial point X 0  then declare point X′ as new initial point: X 0 =X′, and continue improvement process; go to step 1; 
             8. Point X 0  is declared as improved point-candidate; improvement process is completed. 
           
         
       
    
     Gradients ∇F j (X), j=1, . . . ,m necessary on the step 2, can be calculated by variety of known ways: via numerical methods, automatic differentiation, Response Surface method, based on local approximations of objective functions. 
     While we believe the vector 
               g   i     =           max       j   =   1     ,           ⁢   …   ⁢           ,   m       ⁢     (     xg   i   j     )       -       min       j   =   1     ,           ⁢   …   ⁢           ,   m       ⁢     (     xg   i   j     )         2           
belongs to the area A SI  for tasks of any dimension and any number of objective functions, we don&#39;t wish to be bound by this. So, here are alternative ways to find points in the area A SI .
 
     Area of simultaneous objective functions improvement A SI  can be found as solution of inequalities system. Each inequality is determined by the flat surface that is perpendicular to the corresponded gradient (see  FIGS. 15   a - 15   c ). 
     There are a variety of ways to determine points X′∈A SI . Any method of numerical or analytical solution to a system of inequalities can be utilized for that. The simplest approach is the Monte Carlo method, which generates a uniformly distributed sequence of points in the core sub-region, and filters out from the points those do not satisfy the system of inequalities. 
     One possible approach applies Cluster Analysis to the points of intersection of the gradients of objective functions and the unit sphere that is created with the center in the current point. This approach can be effective in the case of a large number of objective functions. Cluster Analysis reduces the number of objective functions to the number of found clusters, which simplifies finding the next step direction and new points in the area of simultaneous objective functions improvement A SI . 
     Proper selection of the next step direction in the area of simultaneous objective functions improvement A SI  is an important element of the CGM algorithm. A priori preferences can be determined as weights for the objective functions. 
     If all objective functions have equal weight then the middle of the A SI  area should be taken as the direction of the next step. In this case all objective functions have equal chances to be improved during the optimization process. 
     If some of objective functions have higher weight compared with others then preferable step direction should be closer to the direction of the gradients corresponded to higher weighted objective functions. In this case high weighted objective functions are improved more, and the optimization result reflects a priori preferences. 
     Concurrent Gradients Method for Solving General Multi-Objective Optimization Problem 
     Above section describes how CGM can be used as a part of TERM algorithm for improvement of core points found on the decomposition stage, but CGM can be used also as an independent method of multi-objective optimization. 
     CGM is a generalization of gradient-based approach for multi-objective optimization. 
     Let us compare sequence of steps typical for traditional gradient-based optimization method with CGM. 
     Traditional gradient-based optimization algorithm works in the following way:
         Starts from a given initial point;   Evaluates gradient of the objective function in current point;   Determines the direction for the next step:
           Takes the direction indicated by the evaluated gradient as the direction for the next step;   
           Determines optimal size of the step;   Makes a step in the direction indicated by the gradient.       

     Traditional gradient-based optimization algorithms optimize only one objective function, and the gradient perfectly determines the direction of the objective function improvement, as it shown on  FIG. 15   a.    
     CGM works as any gradient-based algorithm. But it has multiple objectives to optimize, and it determines the direction for the next step in such a way that all objective functions will be improved simultaneously. CGM works in the following way:
         Starts from a given initial point;   Evaluates gradients of all objective functions in current point;   Determines the direction for the next step:
           Determines the area of simultaneous improvement A SI  for all objective functions; A SI  is found based on evaluated gradients (see  FIGS. 15   a - 15   c ),   Determines a vector G that indicates the direction of the next step inside the A SI  area (see  FIGS. 15   d - 15   f );   
           Determines optimal size of the step;   Makes the step in the determined direction inside of the A SI  area.       

     Invented technique based on determination of the area of simultaneous improvement for all objective functions introduces new type of numerical analysis in multi-objective optimization theory, and allows developing extremely efficient optimization algorithms without using the scalarization technique or any kind of heuristic. CGM is first multi-objective optimization algorithm which successfully solves multi-objective optimization tasks with hundreds and thousands of independent variables. 
     According to CGM, a step cannot be done in a direction that improves some objective functions and makes other ones worse. No objective function gets worse on the next step, which allows significantly reduction in the number of iterations until the optimal point is found, and improvement in quality of results. This is the main difference in comparison with traditional gradient-based algorithms. Those improve a weighted sum of objective functions and ignore current value of each of them. 
     Traditional single-objective gradient-based optimization technology has many methods to improve convergence and computational efficiency of optimization process. CGM works in the same way as traditional algorithms except the determination of search direction. Such similarity allows reusing existing techniques. For instance, optimum step-length can be determined exactly as it is done in the steepest-descent algorithm [5]. Another important technique to reuse is response surface method (RSM.) RSM creates local approximation of objective functions, and uses them for calculation of gradients. This technique is especially effective for large-scale optimization tasks with thousands of independent variables because it reduces the number of objective functions evaluations thousands of times. 
     There is another attractive opportunity to convert most of known gradient-based single-objective optimization algorithms into multi-objective optimization algorithms by changing the search direction determination to the inventive method. 
     Such an opportunity allows CGM to successfully compete in computational efficiency with the fastest optimization algorithms. Ability to solve multi-objective optimization tasks so fast makes CGM a preferable choice algorithm for the most challenging tasks in design optimization industry. 
     While the present invention has been described in connection with the illustrated embodiments, it will be appreciated and understood that modifications may be made without departing from the true spirit and scope of the invention which is limited only by the appended claims and their equivalents. 
     Appendix A. Numerical Method TERM for Multi-Objective Optimization 
     A.1. Definition of a Multi-Objective Optimization Problem 
     The multi-objective optimization problem is formulated as follows:
 
Minimize:  F ( X )={ F   1 ( X ), F   2 ( X ), . . . , F   m ( X )},  m≧ 2  (A.1.1)
 
 X  is subject to  q   j ( X )≦0, (1 ≦j≦p ),  (A.1.2)
 
 x   l     i     ≦x   i   ≦x   u     i   , (1 ≦i≦n).   (A.1.3)
 
     Where m is a number of objective functions and p is a number of inequality constraints. 
     X={x 1 , . . . ,x n }∈  X ⊂E n  is a vector of design variables (also called decision variables), where n is a number of independent variables. 
     F(X)∈E n  is a vector of objective functions F i (X): E n →E 1 . 
     Functions F i (X), i=1, . . . ,m, and q j (X), j=1, . . . ,p satisfy Lipschitz condition. 
     The feasible design space D (often called the feasible decision space or constraint set) is defined as the set {X|q j (X)≦0,j=1, . . . ,p} The feasible criterion space Z (also called the feasible cost space or the attainable set) is defined as the set {F(X)|X∈  X }). 
     Definition 1. Pareto Optimal: a feasible point, X*∈  X , is Pareto optimal, if there is no other feasible point X∈  X , which satisfies the following conditions:
 
 F ( X )≦ F ( X *), with at least one  F   i ( X )&lt; F   i ( X *)  (A.1.4)
 
     All Pareto optimal points are denoted by P, and are the solution to the Multi-objective problem formulated in Eqs. A.1.1-A.1.3. Pareto points P lie on the boundary of the feasible criterion space Z. 
     Extended Definition of a Multi-Objective Optimization Problem 
     Let us call point X∈  X  an approximately feasible point if it satisfies the following system of inequality constraints:
 
 q   j ( X )≦Δ q   j   ,j =1 , . . . ,p,   (A.1.5)
 
where Δq j &gt;0 are accuracy coefficients for the condition defined in Eq. A.1.2.
 
     Obviously, any feasible point is approximately feasible. 
     Definition 2. Approximately Pareto Optimal: an approximately feasible point, X*∈  X , is approximately Pareto optimal, if there is none other such an approximately feasible point, X∈  X , that satisfies conditions from Eq. A.1.4. 
     All approximately Pareto optimal points are denoted by S AO , and represent the solution to the extended problem of Multi-Objective Optimization. However, S AO  in general is an infinite set, and finding it could be a daunting task. So, let us reduce the problem to finding a finite sub-set of S AO , which approximates it in a certain sense. Let us call this set an Approximating Set S A . 
     Pre-Assigned Approximation Accuracy: Let us associate each design variable x i , objective function F i (X), and constraint q i (X) with a positive number, which will be called “pre-assigned approximation accuracy,” and be denoted by δx i , δF i , and δq i  respectively. Let us also denote F i (X*) by F i *, and q i (X*) by q i *, X*∈  X . 
     Definition 3. Vicinity of a point: Set of points satisfying conditions (1.6) is called vicinity of the point, and denoted by V if:
 
| x   i   *−x   i   |&lt;δx   i   , i =1 , . . . ,n; 
 
| F   j   *−F   j   |&lt;δF   j   , j =1 , . . . ,m; 
 
| q   k   *−q   k   |&lt;δq   k   , k =1 , . . . ,p.   (A.1.6)
 
     Point X* approximates any other point X∈V with the pre-assigned accuracy. 
     Improvement Tolerance: Let us associate each objective function F i (X) with a positive number ΔF i  named “improvement tolerance”. Then consider two points X a ∈  X  and X b ∈  X , where X a  is an approximately feasible point. We can say that point X a  substantially improves the point X b  if the following condition is satisfied:
 
 F   i ( X   a )+Δ F   i   &lt;F   i ( X   b ),  i =1 , . . . ,m.   (A.1.7)
 
     In this case we can also say that the objective function F i  is improved by more than ΔF i  upon transfer from point X a  to the point X b . 
     Numerical Solution with Pre-Assigned Accuracy: The numerical solution of the Multi-Objective Conditional Optimization problem with the pre-assigned approximation accuracy and improvement tolerance consists of the construction of the approximating set of points S A  in the given region X, i.e., the finite set of points, which possess the following attributes:
         1. There is at least one point from S A  corresponding to any point from S AO  within the vicinity determined by the pre-assigned approximation accuracy. In other words, any point from S AO  is approximated by a certain point from S A ;   2. The conditions of permissibility at any point from S A  are not disturbed by more than 2 “improvement tolerances”, i.e.,
 
 F   i ( X )&lt;2 ·ΔF   i   , i =1 , . . . ,m;   (A.1.8)
   3. None of the points, which belong to S A , can be substantially improved by any approximately feasible point X∈  X . Here by substantial improvement is implied an improvement by all objective functions F i  by more than 2·ΔF i .
 
A.2. Description of the Basic Procedures of the Numerical Solution
 
Basic Analysis Procedure in the Assigned Region
       

     Let us for brevity refer to a multidimensional parallelepiped in the design space X as a rectangular region or sub-region. 
     The basic analysis procedure in the assigned region could be used to find a numerical solution of multi-objective optimization problem with pre-assigned accuracy of approximation and improvement tolerance. 
     This procedure, referred as a basic analysis hence forth, consists of decomposing the assigned rectangular region into rectangular sub-regions of two types, which we will call “blue” and “red”. “Blue” sub-regions do not have any Pareto optimal points. “Red” sub-regions contain solutions of the optimization task. So, a set of “red” sub-regions serves as a result of the analysis process. Each red sub-region contains a determined point, which represents the sub-region, and will be called “green point”. 
     This process is close to the values of chosen improvement tolerances with a trade-off between processing speed and the accuracy of the results. In order to get a “big picture” with not very representative S A , a loose improvement tolerance could be used, which will lead to generation of less green points faster. On the other hand, if the improvement tolerance is too strict, there will be impractically too many green points generated during slow and thorough calculations. 
     General Schema 
     The procedure of analysis is recursive: the analysis of the given region, which represents the region of the 1 st  generation, leads to the analogous analysis of its sub-regions (regions of 2 nd  generation), each of them in turn leads to the analysis of the regions of the 3 rd  generation, and et cetera. 
     Let us denote an arbitrary point within the given region, which we will consider as the current region of the 1 st  generation, as a core point, and rectangular vicinity surrounding this point as the core sub-region of the current region. 
     Core sub-region can consist of points, which do not belong to the set of approximately Pareto optimal points S AO . In this case we will consider it as “blue”, while otherwise as “red”. 
     Let us set aside any painted in ether color core sub-region from its generating current region of the 1 st  generation. Then the remaining part can be decomposed into the rectangular regions of the 2 nd  generation. Each of these sub-regions is made “current” and undergoes the same procedure subsequently: a) selection of a core point; b) generation of a core sub-region; c) decomposing the sub-region into the sub-regions of the 3 rd  generation. This process is virtually infinite, but core sub-regions have finite dimensions, and the decomposing is only possible if the current region does not completely overlap with the core sub-region generated by it. 
     At the end of the process the given region of the 1 st  generation is decomposed into the “blue” and “red” core sub-regions of the 1 st , 2 nd , et cetera generations. 
     Simultaneously with the process of decomposing the given region, another procedure takes place. This other procedure generates an intermediate set of points S I . Towards the end of both processes S I  becomes the “approximating set” S A . 
     Generation of a Sub-Region with Bounded Variation of Objective Function R B    
     Suppose that all objective and feasibility functions (F i (X), i=1, . . . ,m, and q j (X), j=1, . . . ,p) satisfy Lipschitz condition in the given region, which can be formulated as follows: 
     For any objective function F(X) there exist such constants L 1 ,L 2 , . . . ,L n , that for any “i” and for any two points X (1) ,X (2) ∈  X , which differ just by i-th projection, the following inequalities are satisfied:
 
| F ( X   (1) )− F ( X   (2) )|≦ L   i   ·|x   i   (1)   −x   i   (2)   |, i =1 , . . . ,n.   (A.2.1)
 
     In other words, it is assumed that a vector of the constants (L 1 ,L 2 , . . . ,L n ) is known for each objective function. Finding this vector is a separate problem that will be discussed later. 
     Now, consider any point X 0 ∈  X  and generate its surrounding rectangle in the design space  X , in which the values of objective function F(X) differ from F(X 0 ) by less than pre-set value dif, i.e.,
 
| F ( X )− F ( X   0 )|&lt; dif , where  dif  is an arbitrary positive number  (A.2.2)
 
So,
 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                            
                           
                             
                               F 
                               ⁡ 
                               
                                 ( 
                                 X 
                                 ) 
                               
                             
                             - 
                             
                               F 
                               ⁡ 
                               
                                 ( 
                                 
                                   X 
                                   0 
                                 
                                 ) 
                               
                             
                           
                            
                         
                         = 
                           
                         ⁢ 
                         
                            
                           
                             
                               F 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                   
                                   , 
                                   
                                     x 
                                     2 
                                   
                                   , 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   , 
                                   
                                     x 
                                     n 
                                   
                                 
                                 ) 
                               
                             
                             - 
                             
                               F 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                     0 
                                   
                                   , 
                                   
                                     x 
                                     2 
                                     0 
                                   
                                   , 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   , 
                                   
                                     x 
                                     n 
                                     0 
                                   
                                 
                                 ) 
                               
                             
                           
                            
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                         ⁢ 
                         
                            
                           
                             
                               F 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                   
                                   , 
                                   
                                     x 
                                     2 
                                   
                                   , 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   , 
                                   
                                     x 
                                     n 
                                   
                                 
                                 ) 
                               
                             
                             - 
                             
                               F 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                     0 
                                   
                                   , 
                                   
                                     x 
                                     2 
                                   
                                   , 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   , 
                                   
                                     x 
                                     n 
                                   
                                 
                                 ) 
                               
                             
                             + 
                           
                         
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           
                             F 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   2 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   n 
                                 
                               
                               ) 
                             
                           
                           - 
                           
                             F 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   2 
                                   0 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   n 
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           
                             F 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   2 
                                   0 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   n 
                                 
                               
                               ) 
                             
                           
                           - 
                           … 
                           ⁢ 
                           
                               
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           
                             F 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   2 
                                   0 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   n 
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           
                             F 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   2 
                                   0 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   n 
                                 
                               
                               ) 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                         
                             
                           ⁢ 
                           
                             F 
                             ⁢ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   2 
                                   0 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   n 
                                   0 
                                 
                               
                               ) 
                             
                           
                            
                         
                         ≤ 
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           
                              
                             
                               
                                 F 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       x 
                                       1 
                                     
                                     , 
                                     
                                       x 
                                       2 
                                     
                                     , 
                                     … 
                                     ⁢ 
                                     
                                         
                                     
                                     , 
                                     
                                       x 
                                       n 
                                     
                                   
                                   ) 
                                 
                               
                               - 
                               
                                 F 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       x 
                                       1 
                                       0 
                                     
                                     , 
                                     
                                       x 
                                       2 
                                     
                                     , 
                                     
                                       … 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       
                                         x 
                                         n 
                                       
                                     
                                   
                                   ) 
                                 
                               
                             
                              
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                            
                           
                             
                               F 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                     0 
                                   
                                   , 
                                   
                                     x 
                                     2 
                                   
                                   , 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   , 
                                   
                                     x 
                                     n 
                                   
                                 
                                 ) 
                               
                             
                             - 
                           
                         
                       
                     
                   
                   
                     
                       
                         
                             
                           ⁢ 
                           
                             F 
                             ⁢ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   2 
                                   0 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   n 
                                 
                               
                               ) 
                             
                           
                            
                         
                         + 
                         … 
                         ⁢ 
                         
                             
                         
                         + 
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                            
                           
                             
                               F 
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     x 
                                     1 
                                     0 
                                   
                                   , 
                                   
                                     x 
                                     2 
                                     0 
                                   
                                   , 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   , 
                                   
                                     x 
                                     
                                       n 
                                       - 
                                       1 
                                     
                                     0 
                                   
                                   , 
                                   
                                     x 
                                     n 
                                   
                                 
                                 ) 
                               
                             
                             - 
                           
                         
                       
                     
                   
                   
                     
                       
                         
                             
                           ⁢ 
                           
                             F 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   x 
                                   1 
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   2 
                                   0 
                                 
                                 , 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 , 
                                 
                                   x 
                                   
                                     n 
                                     - 
                                     1 
                                   
                                   0 
                                 
                                 , 
                                 
                                   x 
                                   n 
                                   0 
                                 
                               
                               ) 
                             
                           
                            
                         
                         ≤ 
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           
                             
                               L 
                               1 
                             
                             · 
                             
                                
                               
                                 
                                   x 
                                   1 
                                 
                                 - 
                                 
                                   x 
                                   1 
                                   0 
                                 
                               
                                
                             
                           
                           + 
                           
                             
                               L 
                               2 
                             
                             · 
                             
                                
                               
                                 
                                   x 
                                   2 
                                 
                                 - 
                                 
                                   x 
                                   2 
                                   0 
                                 
                               
                                
                             
                           
                           + 
                           … 
                           ⁢ 
                           
                               
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                         ⁢ 
                         
                           
                             L 
                             n 
                           
                           · 
                           
                              
                             
                               
                                 x 
                                 n 
                               
                               - 
                               
                                 x 
                                 n 
                                 0 
                               
                             
                              
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     A 
                     ⁢ 
                     .2 
                     ⁢ 
                     .3 
                   
                   ) 
                 
               
             
           
         
       
     
     There are several ways to determine the above-mentioned rectangle. Here we use the simplest, but not the most efficient method. 
     Any point x of this rectangle must be located within the boundaries of the given region, and in addition the following conditions should be satisfied for those i for which L i &gt;0:
 
| x   i   −x   i   0   |&lt;dif /( k·L   i ), where  k  is a number of nontrivial  L   i  ( k≦n )  (A.2.4)
 
     From Eqs. A.2.3 and A.2.4 it follows that the conditions in Eq. A.2.2 are satisfied and that the desired rectangle (region with bounded variation of the objective function R B ) is the intersection of rectangle defined by Eq. A.2.4 and the assigned region. 
     Let us take again any point X 0 ∈  X  and certain value F l , that
 
 F   l   &lt;F ( X   0 )  (A.2.5)
 
     Assume that dif=F(X 0 )−F l −ε, where ε is an arbitrarily small positive value. Then it is possible to generate such a region with bounded variation of the objective function F(X) in the design space  X , that the following condition is satisfied:
 
 F   l   &lt;F ( X )  (A.2.6)
 
     Expansion of a Region with Bounded Variation of Objective Function: Let us assume that in the assigned region X, objective function F is increasing (decreasing) monotonically with respect to any of the varied parameters (for certainty let it be x 1 ). Then it is possible to extend the region with bounded variation of the objective function, by moving aside its upper (lower) boundary corresponding to x 1  towards the appropriate boundary of the assigned region X. In this case condition from Eq. A.2.6 is still satisfied. 
     Use of a Local Lipschitz Condition: Evidently, there is a need to generate a region with bounded variation of objective function inside of the current region. In this case it is more appropriate to use Lipschitz constants L i , which is local to the current region, instead of global ones related to the entire given region X. This assumption does not invalidate anything said in the above section, but limits the region from X to the current one. Let us also note, that local L i  can be considerably less than global one, which makes it possible to increase R B  and improve the efficiency of the computations. 
     A.3. The “Blue” Base Sub-Region 
     Possible Cases: A core point X 0 ∈  X  is said to be significantly improved by the certain approximately feasible point X a ∈  X , if the following conditions are satisfied:
 
 F   i ( X   a )&lt; F   i ( X   0 )−Δ F   i   , i =1 , . . . ,m.   (A.3.1)
 
     The feasibility condition q j ≦0 is also said to be substantially disturbed at point X 0 , if
 
 q   j ( X   0 )&gt;2 ·Δq   j   , j =1 , . . . ,p.   (A.3.2)
 
     If at least one of these cases occurs, it is possible to build core “blue” sub-region. Let us examine both these cases in more details. 
     Creating a “Blue” Core Sub-Region of the 1 st  Type: Suppose, one of the conditions of feasibility, for certainty let it be the 1st condition, is substantially disturbed at the core point:
 
 q   1 ( X   0 )&gt;2 ·Δq   1 .  (A.3.3)
 
Let us assign F 1 =Δq 1  in Eqs. A.2.5 and A.2.6. Then
 
 F   1   &lt;q   1 ( X   0 ).  (A.3.4)
 
If we assign
 
 dif=q   1 ( X   0 )− F   1 −ε  (A.3.5)
 
and use the monotony of function q 1 (X), then it is possible to build such a R B  of the varied parameters X, that
 
 F   1   ≦q   1 ( X ),  (A.3.6)
 
so
 
 q   1 ( X )&gt;Δ q   1   (A.3.7)
 
and, therefore, there are no approximately feasible points within the R B . It follows from Eqs. A.3.3 and A.3.5 that
 
 dif&gt;Δq   1 −ε,  (A.3.8)
 
i.e., the feasible change of objective function q 1 (X) has the same degree of accuracy as Δq 1 .
 
     The generated R B  (Eq. A.3.7) does not contain any approximately optimum points belonging to S AO  and, therefore, it could be considered as “blue” core sub-region. 
     Creating a “Blue” Core Sub-Region of the 2 nd  Type: Let us suppose that a core point X 0  is significantly improved by certain approximately feasible point X a  that belongs to the given region X. Then the following system of the inequalities is satisfied for all objective functions:
 
 F   i ( X   a )+Δ F   i   &lt;F   i ( X   0 ),  i =1 , . . . ,m.   (A.3.9)
 
It is assumed for the i th  objective function, that
 
 F   1   =F   i ( X   a ).  (A.3.10)
 
Therefore
 
 F   1   ≦F   i ( X   0 )  (A.3.11)
 
If we assign
 
 dif=F   i ( X   0 )− F   1 −ε,  (A.3.12)
 
and use the monotony of function F i (X), then it is possible to build such a R B  of the varied parameters X, that
 
 F   1   &lt;F   i ( X ),  (A.3.13)
 
so
 
 F   i ( X   a )&lt; F   i ( X )  (A.3.14)
 
     If we build an intersection of m such rectangles, any point X of this intersection could be improved by approximately feasible point X a ∈  X . Thus, this intersection does not contain approximately optimal points from S AO  and, therefore, it can be considered as “blue” core sub-region. 
     Let us note, that for each i, it follows from Eqs.3.9 and 3.12 that,
 
 dif=F   i ( X   0 )− F   i ( X   a )−ε&gt;Δ F   i −ε,  (A.3.15)
 
i.e., the feasible change of objective function F 1 (X) is approximately the same as tolerance ΔF i .
 
A.4. The “Red” Core Sub-Region
 
     Generating the “Red” Core Sub-Region: If it is impossible to generate a “blue” core sub-region corresponding to any core point X 0 , then a “red” core sub-region is generated, which is constructed from the intersection of the current region with, in general case, the regions with bounded variation of objective function (both feasibility and quality) and varied parameters. In other words, conditions A.1.6 must be satisfied for the “red” core sub-region. Furthermore, at the core point in this case none of the conditions of permissibility (Eq. A.1.2) can be substantially disturbed. Otherwise, “blue” core sub-region could be generated for this point. 
     “Green” Point: Let us call the core point of a “red” base sub-region a “green” point. We will show latter on, that by the end of the analysis process the generated set of “green” points is in a certain sense (see subsection Numerical Solution with Pre-Assigned Accuracy) the approximating set S A  for the set of approximately optimal points S AO . 
     Strictly speaking, “green” point must be approximately feasible, otherwise it is possible to use the described above procedure to find an approximately feasible point in the sequential region, or to prove, that there is no such a point. If there are no approximately optimal points in the sequential region, this region should be considered as “blue”. 
     Let us note that at the core point of “red” sub-region none of the conditions of feasibility (Eq. A.1.2) can be substantially disturbed, otherwise “blue” core sub-region is generated for this core point. Therefore, allowing a certain tolerance, it is possible not to search for the green point, but consider the core point as the green one. 
     A.5. Exclusion of a “Red” Sub-Region from the Set of the “Red” Sub-Regions 
     Suppose that we have a “red” sub-region corresponding to a core point X 1 ∈  X . It is possible to find a new approximately feasible core point X 2 ∈  X , which significantly improves point X 1 , during the refining analysis. Then
 
 F   i ( X   2 )+Δ F   i   &lt;F   i ( X   1 ), i =1 , . . . ,m.   (A.5.1)
 
     Let us demonstrate that this point with the certain condition will improve any point of this “red” sub-region. 
     From Eq. A.1.5 follows:
 
 F   i ( X )&gt; F   i ( X   1 )−δ F   i   (A.5.2)
 
or
 
 F   i ( X   1 )&lt; F   i ( X )+δ F   i .  (A.5.3)
 
From (A.3.22) and (A.3.23):
 
 F   i ( X   2 )&lt; F   i ( X   1 )−Δ F   i   &lt;F   i ( X )+δ F   i   −ΔF   i   (A.5.4)
 
or
 
 F   i ( X   2 )&lt; F   i ( X )+δ F   i   −ΔF   i .  (A.5.5)
 
     Now let us add an additional constraint for the approximation accuracy:
 
δ F   i &lt;ΔF i   , i= 1 , . . . ,m,   (A.5.6)
 
i.e., the approximation accuracy must be less than the improvement tolerance. Then
 
 F   i ( X   2 )&lt; F   i ( X ),  i= 1 , . . . ,m.   (A.5.7)
 
     This means that none of the points X of the “red” sub-region can be approximately optimal. Therefore, this “red” sub-region changes its color to “blue”. 
     A.6. Creation of the Approximating Set S A    
     All pairs of “red” core sub-regions and the corresponding “green” points found during the analysis process are put into the Intermediate Set of Points S I . Before any new pair could be added to the S I  it is compared to the already existing pairs. If there is any existing pair, which “green” point could be substantially corrected by the new pair (by more than 1 tolerance), then this old pair is excluded from the S I , and the new one is added instead. Section A.5 demonstrates that the “red” core sub-region of the deleted pair does not contain approximately optimal points (from S AO ) and therefore it can be “re-colored” into “blue”. 
     It is sufficient to show that the S I  by the end of the analysis process possesses all the attributes 1)-3) described in Numerical Solution with Pre-assigned Accuracy, section A.1. In order to prove that S I  could be considered as the approximating set S A  at the end. 
     A.6.1. Let us show that any point, which belongs to the set of approximately optimum points S AO , is approximated with the pre-assigned accuracy by a certain point from S A . 
     The procedure of analysis is built so that any point from the assigned region is covered by at least one of the core sub-regions. Any point from S AO  must be covered by a “red” sub-region, but the green point of a “red” sub-region approximates any of its own points. 
     A.6.2. Section A.4 demonstrates that the conditions of feasibility (see inequality A.1.2) cannot be disturbed by more that 2 improvement tolerances at any “green” point. 
     A.6.3. Let us prove that any point from the approximating set S A , cannot be improved by any approximately feasible point of the given region by more than 2 improvement tolerances. 
     We will use the proof by contradiction method. 
     Suppose a point X 0  belongs to S A , and also suppose there is an approximately feasible point X a ∈  X , which improves point X 0  by more than 2 improvement tolerances. 
     There are two cases to consider: 
     1) Point X a  belongs to a “blue” core sub-region. This could only be a sub-region of the 2 nd  type, since any sub-region of the 1 st  type cannot contain any approximately feasible points by definition. The sub-region of the 2 nd  type consists of the points improved by a certain approximately feasible point, entering the Intermediate Set of Points S I . This point in the process of analysis can be excluded from S I , but in this case a new point is included in S I , which substantially improves previous one. As a result, toward the end of analysis, all points of “blue” sub-region become improved by a point from S A  or, which is the same thing at the end, by a point from S I . 
     Thus, point X a  from a “blue” sub-region improves by more than 2 tolerances point X 0  from S A , and another point from S A  improves point X a . But any point from S A  cannot improve another point from S A  by more than to 1 improvement tolerances (see subsection A.6). So, there is a contradiction, which proves our hypothesis. 
     2) Point X a  belongs to a “red” core sub-region. Suppose X b  is the core point of this sub-region. Then the following conditions are satisfied (see system (A.1.5)):
 
| F   i ( X   a )− F   i ( X   b )|&lt;δ F   i   , i =1 , . . . ,m.   (A.6.1)
 
Thus
 
 F   i ( X   b )≦ F   i ( X   a )+δ F   i   (A.6.2)
 
     Point X b  cannot substantially improve point X 0  by the definition of the approximating set S A . It means that there is such a objective function F j (X), that the following inequalities are satisfied:
 
 F   j ( X   b )+Δ F   j   &gt;F   j ( X   0 ).  (A.6.3)
 
     From (A.6.2) and (A.6.3):
 
 F   j ( X   a )≧ F   j ( X   b )−δ F   j   &gt;F   j ( X   0 )−Δ F   j   −δF   j   &gt;F   j ( X   0 )−2 ·ΔF   j   (A.6.4)
 
     But by the assumption that the point X a  improves point X 0  by more than 2 improvement tolerances the following inequality must be satisfied, which contradicts (A.6.4):
 
 F   j ( X   a )+2 ·ΔF   j   ≦F   j ( X   0 )  (A.6.5)
 
     Thus the statement formulated in topic A.6.3, is proven. 
     A.7. Conclusion 
     We have proven that by the end of the analysis process the Intermediate Set of Points S I  possesses all the attributes 1)-3) of Numerical Solution with Pre-assigned Accuracy, section A.1. So, S I  can be considered as the approximating set S A  in the end. 
     Thus, TERM algorithm, based on the numerical analysis procedures described above and based on mathematically proven results, guarantees finding an approximation S A  of Pareto frontier with pre-assigned accuracy.