Apex Method: A New Scalable Iterative Method for Linear Programming

The article presents a new scalable iterative method for linear programming called the “apex method”. The key feature of this method is constructing a path close to optimal on the surface of the feasible region from a certain starting point to the exact solution of a linear programming problem. The optimal path refers to a path of the minimum length according to the Euclidean metric. The apex method is based on the predictor—corrector framework and proceeds in two stages: quest (predictor) and target (corrector). The quest stage calculates a rough initial approximation of the linear programming problem. The target stage refines the initial approximation with a given precision. The main operation used in the apex method is an operation that calculates the pseudoprojection, which is a generalization of the metric projection to a convex closed set. This operation is used both in the quest stage and in the target stage. A parallel algorithm using a Fejér mapping to compute the pseudoprojection is presented. An analytical estimation of the parallelism degree of this algorithm is obtained. AlsoAdditionally, an algorithm implementing the target stage is given. The convergence of this algorithm is proven. An experimental study of the scalability of the apex method on a cluster computing system is described. The results of applying the apex method to solve problems from the Netlib-LP repository are presented.


Introduction
This article is an expanded and revised version of the conference paper [1]. The following motivation encouraged us to delve into this subject. The rapid development of big big-data storage and processing technologies [2,3] has led to the emergence of optimization mathematical models in the form of multidimensional linear programming (LP) problems [4]. Such LP problems arise in industry, economics, logistics, statistics, quantum physics, and other fields [5][6][7]. An important class of LP applications are is non-stationary problems related to optimization in dynamic environments [8]. For a non-stationary LP problem, the objective function and/or constraints change over the computational process. Examples of non-stationary problems are the following: decision support in high-frequency trading [9,10], hydro-gas-dynamics problems [11], optimal control of technological processes [12][13][14], transportation [15][16][17], and scheduling [18,19].
One of the standard approaches to solving non-stationary optimization problems is to consider each change as the appearance of a new optimization problem that needs to be solved from scratch [8]. However, this approach is often impractical because solving a problem from scratch without reusing information from the past can take too much time. Thus, it is desirable to have an optimization algorithm capable of continuously adapting the solution to the changing environment, reusing information obtained in the past. This approach is applicable for real-time processes if the algorithm tracks the trajectory of the moving optimal point fast enough. In the case of large-scale LP problems, the last requirement necessitates the development of scalable methods and parallel algorithms of LP.
One of the most promising approaches to solving complex problems in real time is the use of neural network models [20]. Artificial neural networks are a powerful universal tool that is applicableapplies to solving problems in almost all areas. The most popular neural network model is the feedforward neural network. Training and operation of such networks can be implemented very efficiently on GPUs [21]. An important property of a feedforward neural network is that the time to solve a problem is a known constant that does not depend on the problem parameters. This feature is necessary for real-time mode. Pioneering work on the use of neural networks to solve LP problems is the article by Tank and Hopfield [22]. The article describes a two-layer recurrent neural network. The number of neurons in the first layer is the number of variables of the LP problem. The number of neurons in the second layer coincides with the number of constraints of the LP problem. The first and second layers are fully connected. The weights and biases are uniquely determined by the coefficients and the right-hand sides of the linear inequalities defining the constraints, and the coefficients of the linear objective function. Thus, this network does not require training. The state of the neural network is described by the differential equationẋ(t) = ∇E(x(t)), where E(x(t)) is an energy function of a special type. Initially, an arbitrary point of the feasible region is fed to the input of the neural network. Then, the signal of the second layer is recursively fed to the first layer. Such processa process leads to convergence to a stable state in which the output remains constant. This state corresponds to the minimum of the energy function, and the output signal is a solution to the LP problem. The Tank and Hopfield approach has been expanded and improved in numerous works (see, for example, [23][24][25][26][27]). The main disadvantage of this approach is the unpredictable number of work cycles of the neural network. Therefore, a recurrent network based on an energy function cannot be used to solve large-scale LP problems in real time.
In the recent paper [28], a n-dimensional mathematical model for visualizing LP problems was proposed. This model makes it possible to use feedforward neural networks, including convolutional networks [29], to solve multidimensional LP problems, the feasible region of which is a bounded nonempty-empty set. However, there are practically no works in scientific periodicals devoted to the use of convolutional neural networks for solving LP problems [30]. The reason isThe reason for this is that convolutional neural networks focus on image processing, but there are no methods for constructing training datasets based on a visual representation of the multidimensional LP problems.
This article describes a new scalable iterative method for solving multidimensional LP problems. This method is called the "apex method". The apex method allows you to generate training datasets for the development of feedforward neural networks capable of finding a solution to a multidimensional LP problem based on its visual representation. The apex method is based on the predictor-corrector framework. At the prediction step, a point belonging to the feasible region of the LP problem is calculated. The corrector step calculates a sequence of points converging to the exact solution of the LP problem. The rest of the paper is organized as follows. Section 2 provides a review of iterative projection-type methods and algorithms for solving linear feasibility problems and LP problems. Section 3 includes the theoretical basis of the apex method. Section 4 presents a formal description of the apex method. Section 4.1 considers the implementation of the pseudoprojection operation in the form of sequential and parallel algorithms and provides an analytical estimation of the scalability of parallel implementation. Section 4.2 describes the quest stage. Section 4.3 describes the target stage. Section 5 presents an informationinformation about the software implementation of the apex method and describes the results of large-scale computational experiments on a cluster computing system. Section 6 discusses the issues related to the main contribution of this article, the advantages and disadvantages of the proposed approach, possible applications, and some other aspects of using the apex method. In Section 7, we present our conclusions and comment on possible further studies of the apex method. The final section Notations contains the main symbols used for describing the apex method.

Related Work
This section provides an overview of works devoted to iterative projection-type methods used to solve linear feasibility and LP problems. The linear feasibility problem can be stated as follows. Consider the system of linear inequalities in matrix form where A ∈ R m×n , and b ∈ R n . To avoid triviality, we assume that m > 1. The linear feasibility problem consists of finding a pointx ∈ R n satisfying matrix inequality system (1). We assume from now on that such a point exists.
Projection-type methods rely on the following geometric interpretation of the linear feasibility problem. Let a i ∈ R n be a vector formed by the elements of the ith row of the matrix A. Then, the matrix inequality Ax b is represented as a system of inequalities Here and further on, ·, · stands for the dot product of vectors. We assume from now on that a i = 0 for all i = 1, . . . , m. For each inequality a i , x b i , define the closed half-spacê and its bounding hyperplane For any point x ∈ R n , the orthogonal projection π(x) of point x onto the hyperplane H i can be calculated by the equation Here and below, · denotes the Euclidean norm. Let us define the feasible polytope that presents the set of feasible points of system (1). Note thatPlease note that in this case, the polytope M is a closed convex set. Here, we always assume that M = ∅, i.e., the solution of system (1) exists. In geometric interpretation, the linear feasibility problem consists of finding a pointx ∈ M.
The forefathers of the iterative projection-type methods for solving linear feasibility problems are Kaczmarz and Cimmino. In [31] (English translation in [32]), Kaczmarz presented a sequential projections method for solving a consistent system of linear equations His method, starting from an arbitrary point x (0,m) ∈ R, calculates the following sequence of point groups: for k = 1, 2, 3, . . . Here, π i (i = 1, . . . , m) is the orthogonal projection onto the hyperplane H i defined by Equation (6). This sequence converges to the solution of system (8). Geometrically, the method can be interpreted as follows. The initial point x (0,m) is projected orthogonally onto hyperplane H 1 . The projection is the point x (1,1) , which now is thrown onto H 2 . The resulting point x (1,2) is then thrown onto H 3 and gives the point x (1,3) , etc. As a result, we obtain the last point x (1,m) from the first point group. The second point group is constructed in the same way, starting from the point x (1,m) . The process is repeated for k = 2, 3, . . . Cimmino proposed in [33] (English description in [34]) a simultaneous projection method for the same problem. This method uses the following orthogonal reflection operation which calculates the point ρ i (x) symmetric to the point x with respect to the hyperplane H i . For the current approximation x (k) , the Cimmino method simultaneously calculates reflections with respect to all hyperplanes H i (i = 1, . . . , m), and then a convex combination of these reflections is used to form the next approximation: where w i > 0 (i = 1, . . . , m), (11) is transformed into the following equation: Agmon [35] and Motzkin and Schoenberg [36] generalized the projection method from equations to inequalities. To solve problem (1), they introduce the relaxed projection where 0 < λ < 2. It is obvious that π 1 i (x) = π i (x). To calculate the next approximation, the relaxed projection method uses the following equation: where Informally, the next approximation x (k+1) is a relaxed projection of the previous approximation x (k) with respect to the furthest hyperplane H l bounding the half-spaceĤ l not containing x (k) . Agmon in [35] showed that sequence x (k) converges, as k → ∞, to a point on the boundary of M.
Censor and Elfving, in [37], generalized the Cimmino method to the case of linear inequalities. They consider the relaxed projection onto the half-spaceĤ i defined as follows: that gives the equation Here, 0 < λ < 2, and w i > 0 (i = 1, . . . , m), In [38], De Pierro proposed an approach to convergence proof for this method, which differs from the approach of Censor and Elfving. De Piero's approach is also acceptable for the case when the underlying system of linear inequalities is infeasible. In this case, for λ = 1, sequence (17) converges to the point that is the minimum of the function , it is a weighted (with the weights w i ) least least-squares solution of system (1).
The Cimmino-like methods allow efficient parallelization, since orthogonal projections (reflections) can be calculated simultaneously and independently. The article [39] investigates the efficiency of parallelization of the Cimmino-like method on Xeon Phi manycore processors. In [40], the scalability of the Cimmino method for multiprocessor systems with distributed memory is evaluated. The applicability of the Cimmino-like method for solving non-stationary systems of linear inequalities on computing clusters is considered in [41].
As a recent work, we can mention article [42], which extends the Agmon-Motzkin-Schoenberg relaxation method for the case of semi-infinite inequality systems. The authors consider the system with an infinite number of inequalities in the finite-dimensional Euclidean space R n : where I is an arbitrary infinite index set. The main idea of the method is as follows. Let the hyperplane H be the biggest violation with respect to x. Let x (0) be an arbitrary initial point. If the current iteration x (k) is not a solution of system (18), then let x (k+1) be the orthogonal projection of x (k) onto a hyperplane H i (i ∈ I) near the biggest violation H (∞) x (k) . If system (18) is consistent, then the sequence x (k) |k = 1, 2, . . . generated by the described method converges to the solution of this system.
Solving systems of linear inequalities is closely related to LP problems, so projectiontype methods can be effectively used to solve this class of problems. The equivalence of the linear feasibility problem and the LP problem is based on the primal-dual LP problem. Consider the primal LP problem in the matrix form: where c, x ∈ R n , b ∈ R m , A ∈ R m×n , and c = 0. Let us construct the dual problem with respect to problem (19):ū where u ∈ R m . The following primal-dual equality holds: In [43,44], Eremin proposed the following method based on the primal-dual approach. Let the inequality system A x b (22) define the feasible region of primal problem (19). This system is obtained by adding to the system Ax b the vector inequality −x 0. In this case, A ∈ R (m+n)×n , and b ∈ R m+n . Let a i stand the ith row of the matrix A . For each inequality a i , x b i , define the closed half-spaceĤ and its bounding hyperplane Let π i (x) stand the orthogonal projection of point x onto the hyperplane H i : Let us define the projection onto the half-spaceĤ i : This projection has the following two properties: Define ϕ 1 : R n → R n as follows: In the same way, define the feasible region of dual problem (20) as follows: where D = A T ∈ R n×m , D ∈ R (m+n)×m , and c ∈ R n+m . Denotê and define ϕ 2 : R m → R m as follows: Now, define ϕ 3 : R n+m → R n+m as follows: which is corresponding to Equation (21). Here, [· , ·] stands for the concatenation of vectors. Finally, define ϕ : R n+m → R n+m as follows: If the feasible region of the primal problem is a bounded and nonempty set, then the sequence converges to the point [x,ū], wherex is the solution of primal problem (19), andū is the solution of dual problem (20).
Article [45] proposes a method for solving non-degenerate LP problems based on calculating the orthogonal projection of some special point, independent of the main part of data describing the LP problem, onto a problem-dependent cone generated by the constraint inequalities. Actually, tThis method solves a symmetric positive definite system of linear equations of a special kind. The author demonstrates a finite algorithm of an active-set family that is capable of calculating orthogonal projections for problems with up to thousands of rows and columns. The main drawback of this method is a a significant increasing increase in the dimension of the primary problem.
In article [46], Censor proposes the linear superiorization (LinSup) method as a tool for solving LP problems. The LinSup method does not guarantee finding to find the minimum point of the LP problem, but it directs the linear feasibility-seeking algorithm that it uses toward a point with a decreasing value of the objective function. This process is not identical with to that employed by LP solvers but it is a possible alternative to the sSimplex method for problems of huge size. The basic idea of LinSup is to add an extra term, called perturbation term, to the iterative equation of the projection method. The perturbation term steers the feasibility-seeking algorithm toward reduced the objective function values. In the case of LP problem (19), the objective function is f (x) = c, x , and LinSup adds −η c c as a perturbation term to iterative Equation (17): Here, 0 < η < 1 is a perturbation parameter. Article [47] presents an enthusiastic artificial-free linear programming method based on a sequence of jumps and the simplex method. It performsis performed in three phases. Starting with phase 1, it guarantees the existence of a feasible point by relaxing all non-acute constraints. With this initial starting feasible point, in phase 2, it sequentially jumps to the improved objective feasible points. The last phase reinstates the rest of the non-acute constraints and uses the dual simplex method to find the optimal point. Article [28] proposes a mathematical model for the visual representation of multidimensional LP problems. To visualize a feasible LP problem, an objective hyperplane H c is introduced, the normal to which is the gradient of the objective function f (x) = c, x . In the case of seeking the maximum, the objective hyperplane is positioned in such a way that the value of the objective function at all its points is greater thenthan the value of the objective function at all points of the convex polytope M, which is the feasible region of the LP problem. For any point g ∈ H c , the objective projection γ M (g) onto M is defined as follows: Here, π H c (x) denotes the orthogonal projection onto H c . On the objective hyperplane H c , a rectangular lattice of points G ∈ R n × R K (n−1) is constructed, where K is the number of lattice points in one dimension. Each point g ∈ G is mapped to the real number γ M (g) − g . This mapping generates a matrix of dimension (n − 1), which is an image of the LP problem. This approach opens up the possibility of using feedforward-forward artificial neural networks, including convolutional neural networks, to solve multidimensional LP problems. One of the main obstacles to the implementation of this approach is the problem of generating a training set. The literature review shows that there is no suitable method capable of constructing such a training set compatible with the described approach. In the next sections, we present such a method.

Theoretical Background
In this section In this section, we present a theoretical background used to construct the apex method. Consider the LP problem in the following form: where c ∈ R n , b ∈ R m , A ∈ R m×n , m > 1, and c = 0. We assume that the constraint x 0 is also included in the system Ax b in the form of the following inequalities: Let P stand for the set of row indices in matrix A: Let a i ∈ R n be a vector formed by the elements of the ith row of the matrix A, and a i = 0 for all i ∈ P. We denote byĤ i the closed half-space defined by the inequality a i , x b i , and by H i the hyperplane boundingĤ i : The geometric meaning of this definition is that a ray outgoing from a point belonging to a half-space in the direction of vector c belongs to this half-space.
The following proposition provides the necessary and sufficient condition for the c-recessivity of the half-space. Proposition 1. Let a half-spaceĤ be defined by the following equation: Then, the necessary and sufficient condition for the c-recessivity of the half-spaceĤ is a, c > 0.
Substituting the right-hand side of Equation (46) instead of x , we obtain a, βa a 2 + λc β.
i.e., e c stands for the unit vector parallel to vector c.

Proposition 2.
Let the half-spaceĤ i be c-recessive. Then, for any point x ∈ R n , and any number η > 0, the point does not belong to the half-spaceĤ i , i.e., Proof. The half-spaceĤ i is c-recessive, therefore, according to Proposition 1, the following inequality holds: Taking (58) into account, we have Substituting the right-hand side of Equation (57) instead of e c in (61), we obtain Since η > 1, by virtue of (60), the inequality η c a i , c > 0 holds. It follows that i.e., I c is the set of indices for which the half-spaceĤ i is c-recessive. We assume from now on that Corollary 1. Let an arbitrary feasible point x of LP problem (38) be given: Then, for any positive number η ∈ R >0 , the point does not belong to any c-recessive half-spaceĤ i , i.e., Proof. From (65), we obtain According to (63) and (57), the following condition holds: Hence, for any i ∈ I c . Fix any j ∈ I c , and define where η > 0. Taking into account (70), it follows that η > 0. Using (66) and (71), we obtain According to Proposition 2, it follows that a j , z > b j , i.e., the point z defined by (66) does not belong to the half-spaceĤ j for any j ∈ I c .
The following proposition specifies the region containing a solution of LP problem (38).

Proposition 3.
Letx be a solution ofto LP problem (38). Then, there is an index i ∈ I c such that i.e., there is a c-recessive half-spaceĤ i such that its bounding hyperplane H i includesx.
Proof. Denote by J c the set of indices for which the half-spaceĤ j is c-neutral-dominant: Sincex belongs to the feasible region of LP problem (38), then Define the ray Y as follows: i.e., the ray Y belongs to the all c-neutral-dominant half-spaces. By virtue of Definition 2, Taking into account (76), it means that i.e., the intersection of the ray Y and any hyperplane H i bounding the c-recessive half-spacê H i is a single point y i ∈ R n . Let i.e., H i is the nearest hyperplane to the pointx for all i ∈ I c . Denote byȳ the intersection of the ray Y and the hyperplane H i :ȳ According to (81),ȳ ∈ i∈I cĤ i , i.e., the pointȳ belongs to the all c-recessive half-spaces. By (78), it follows that i.e.,ȳ belongs to the feasible region of LP problem (38). Let Then, in virtue of (77), Sincex is a solution of LP problem (38), the following condition holds: Comparing this with (84), we obtain that Taking into account that λ 0 and c = 0, by virtue (86) and (88), we obtain λ = 0. By (85), it follows thatx =ȳ. By (82), this means thatx ∈ H i , whereĤ i is a c-recessive half-space.
is a continuous M-Fejér mapping and is the iterative process generated by this mapping, then Proof. The convergence follows directly from Theorem 6.2 and Corollary 6.3 in [43].
Let π i (x) stand for the orthogonal projection of point x onto hyperplane H i : The next proposition provides a continuous M-Fejér mapping, which will be used in the apex method.
For any point x ∈ R n , let us define i.e., J x is the set of indices for which the half-spaceĤ i does not contain the point x. Then, the single-valued mapping ψ : R n → R n defined by the equation is a continuous M-Fejér mapping.
Proof. Obviously, the mapping ψ(·) is continuous. Let us prove that condition (90) holds. Our proof is based on a general scheme presented in [43]. Let y ∈ M, and x / ∈ M. It follows that J x = ∅.
By virtue of the EquationEquation (94), the following inequalities holds for all i ∈ J x . According to Lemma 3.13 in [43], the following inequality holds for all i ∈ J x : It follows that According to (96) and (97) , the following inequality holds: Hence, ∀x / ∈ M, ∀y ∈ R n : ψ(x) − y < x − y .
The correctness of this definition is ensured by Propositions 4 and 5.

Description of Apex Method
In this section, we describe a new scalable iterative method for solving LP problem (38), called the "apex method". The apex method is based on the predictor-corrector framework and proceeds in two stages: quest (predictor) and target (corrector). The quest stage calculates a rough initial approximation of LP problem (38). The target stage refines the initial approximation with a given precision. The main operation used in the apex method is an operation that calculates a pseudoprojection according to Definition 4. This operation is used both in the quest stage and in the target stage. In the next section, we describe and investigate a parallel algorithm for calculating a pseudoprojection.

Algorithm for Calculating Pseudoprojection
In this section, we consider the implementation of the pseudoprojection operation in the form of sequential and parallel algorithms. The pseudoprojection operation ρ M (·) maps an arbitrary point x ∈ R n to a point ρ M (x) belonging to the feasible polytope M, which is the feasible region of LP problem (38). The calculation of ρ M (x) is organized as an iterative process using Equation (95). A sequential implementation of this process is presented by Algorithm 1.
Let us give brief comments on this implementation. The main iterative process of constructing a sequence of Fejér's approximations is are represented by the repeat/until loop implemented in Ssteps 4-20. The Ssteps 5-10 calculate the set J of indices of half-spacesĤ i violated by the point x (k) presenting the current approximation. In Ssteps 14-18, the next approximation x (k+1) is calculated by Equation (95). The process terminates when the distance between adjacent approximations becomes less than , where is a small positive parameter. Computational experiments show that, in the case of large LP problems, the calculation of a pseudoprojection is a process with high computational complexity [48]. Therefore, we developed a parallel implementation of Algorithm 1, presented by Algorithm 2.

16: stop
Algorithm 2 is based on the BSF parallel computation model [49] designed for a cluster computing system. The BSF model uses the master/worker paradigm and requires the representation of the algorithm in the form of operations on lists using higher-order functions Map and Reduce. In Algorithm 2, we use the list L map = [1, . . . , m] of ordinal numbers of constraints of LP problem (38) as the second parameter of the higher-order function Map. As the first parameter of the higher-order function Map, we use the parameterized function F x : P → R n × Z 0 defined as follows: Thus, the higher-order function Map F x , L map transforms the list L map of constraint numbers into a list of pairs (u i , σ i ). Here, u i is the orthogonal projection of the point x onto the hyperplane H i in the case x / ∈Ĥ i , and the zero vector otherwise; σ i is the indicator that x violates the half-spaceĤ i (i = 1, . . . , m): Denote L reduce = [(u 1 , σ 1 ), . . . , (u m , σ m )]. Define a binary associative operation which is the first parameter of the higher-order function Reduce, as follows: The higher-order function Reduce(⊕, L reduce ) folds the list L reduce into the single pair by sequentially applying the operation ⊕ to all elements of the list: In Algorithm 2, a parallel execution of work is organized according to the master/worker scheme. The parallel algorithm includes L + 1 processes: one master process and L worker processes. The master manages the computations, distributes the work among the workers, gathers the results back from them, and summarizes all the results to obtain the final result. For the sake of simplicity, it is assumed that the number of constraints m of LP problem (38) is a multiple of the number of workers L. In Step 1, the master reads the space dimension n and the starting point x (0) . Step 3 of the master assigns zero to the iteration counter k. Steps 4-14 implement the main repeat/until loop calculating the pseudoprojection. In Step 5, the master broadcasts the current approximation x (k) to all workers. Step 9 of the master gathers partial results from all workers. In Step 9, the master folds the partial results into the pair (u, σ), which is used to calculate the next approximation x (k+1) in Step 10.
Step 11 of the master increases the iteration counter k by 1. In Step 12, the master calculates the criterion for stopping the iterative process and assigns the result to the Boolean variable exit. In Step 13, the master broadcasts the value of the Boolean variable exit to all workers. In Step 14, the repeat/until loop ends if the Boolean variable exit takes the value true.
Step 15 of the master outputs the last approximation x (k) as a result of the pseudoprojection.
Step 16 terminates the master process.
All workers execute the same program codes, but with different data. In Step 1, the lth worker reads problem data. In Steps 2 and 3, the lth worker defines its own sublist L map(l) for processing. For convenience, we number the constraints starting from zero. The sublists of different workers do not overlap, and their concatenation represents the entire list to be processed: The repeat/until loop of the lth worker corresponds to the repeat/until loop of the master (Ssteps 4-14). In Step 5, the lth worker receives the current approximation x (k) from the master.
Step 6 of the lth worker executes the higher-order function Map, which applies the parameterized function F x (k) defined by (101) to all elements of the sublist L map(l) , resulting in the sublist L reduce(l) .
Step 7 of the lth worker executes the higher-order function Reduce, which applies the operation ⊕ defined by (103) to all elements of the list L reduce(l) , resulting in the pair (u l , σ l ). In Step 8, the lth worker sends its resulting pair (u l , σ l ) to the master. In Step 13, the lth worker receives a value of the Boolean variable exit from the master. If exit = true, then the worker process is terminated. Otherwise, the repeat/until loop continues its work. The exchange operators Bcast, Gather, RecvFromMaster, and SendToMaster provide synchronization of the master and workers processes.
Let us estimate the scalability boundary of the described pseudoprojection parallel algorithm, using the cost metrics of BSF model [49]. Here, the scalability boundary refers to the number of worker processes at which the maximum speedup is achieved. The cost metric of the BSF model includes the following parameters.

m:
length of the list L map ; D: latency (time taken by the master to send a one one-byte message to a single worker); t c : time taken by the master to send the current approximation x (k) to a single worker and receive the pair (u l , σ l ) from it (including latency); t Map : time taken by a single worker to process the higher-order function Map for the entire list L map ; t a : time taken by computing the binary operation ⊕.
According to Equation (14) from [49], the scalability boundary L max of a parallel algorithm can be estimated as follows: Let us calculate the time parameters in Equation (108). To do this, we introduce the following notation for one iteration of the repeat/until loop implemented in Steps 4-14 of Algorithm 2: quantity of numbers sent from the master to the lth worker and back within one iteration; c F : quantity of arithmetic and comparison operations required to compute the function F x defined by Equation (101); c ⊕ : quantity of arithmetic and comparison operations required to compute the binary operation ⊕ . In Step 5, the master sends to the lth worker one vector of dimension n. Then, in Step 8, the master receives a pair consisting of a vector of dimension n and a single number from the lth worker. In addition, in Step 13, the master sends a single Boolean value to the lth worker. Hence, c c = 2n + 1.
Taking into account Equations (92) and (101), and assuming that a i 2 is calculated in advance, we obtain c F = 3n + 2.
According to (103), the following equations holds for c ⊕ : Let us denote by τ op the execution time of one arithmetic or comparison operation, and by τ tr the time of sending a single real number from one process to another (excluding latency). Then, using (109)-(111), we obtain t c = c c τ tr + 3D = (2n + 1)τ tr + 3D; (112) Recall that the parameterparameter D denotes the latency. Substituting the right-hand sides of these equations into (108), we have where n is the space dimension, m is the number of constraints. For large values of n and m, this is equivalent to This estimation suggests that Algorithm 2 is limited-scalable, and the scalability depends on the number of constraints m.

Quest Stage
The quest stage of the apex method plays the role of a predictor and includes the following steps.

2.
Calculate the apex point z.

3.
Calculate the point u (0) that is the pseudoprojection of the apex point z onto the feasible polytope M.
The feasible pointx, in Step 1, can be calculated by the following equation: where ρ M (·) is the operation of pseudoprojection onto the feasible polytope M (see Definition 4).
Step 2 calculates the apex point z by the following equation: where I c defined by Equation (63) is the set of indices for which the half-spaceĤ i is crecessive, and η ∈ R >0 is a positive parameter. Corollary 1 guarantees that the point z chosen according to Equation (117) does not belong to any c-recessive half-spaceĤ i . This choice is based on the intuition that the pseudoprojection from such a point will not be very far from the exact solution of the LP problem. The interpretation of this intuition comes from Proposition 3, which states that the solution of the LP problem (38) lies on some hyperplane H i bounding the c-recessive half-spaceĤ i . The parameter η can significantly affect the proximity of the point ρ M (z) to the exact solution. The optimal value of η can be obtained by seeking the maximum of the objective function using the successive dichotomy method.
Step 3 calculates the initial approximation u (0) for the target stage by the following equation: Numerous computational experiments show that the process of calculating the pseudoprojection by Definition 4 starting from an exterior point always converges to a point on the boundary of the feasible polytope M. However, at the moment, we do not have a rigorous proof of this fact.

Target Stage
The target stage of the apex method plays the role of a corrector and calculates a sequence of points that has the following properties for all k ∈ {0, 1, 2, . . .}: Here, Γ M stands for the set of boundary points of the feasible polytope M. Condition (120) means that all points of sequence (119) lie on the boundary of the polytope M. Condition (121) states that the value of the objective function at each next point of sequence (119) is greater than at the previous one. According to condition (122), sequence (119) converges to the exact solution of LP problem (38). An implementation of the Target stage is presented in Algorithm 3.
Let us give brief comments on the steps of Algorithm 3.
Step 1 reads the initial approximation u (0) constructed at the quest stage.
Step 2 assigns zero to the iteration counter k.
Step 3 adds the vector δe c to u (k) and assigns the result to v. Here, e c is a unit vector parallel to c, δ is a positive parameter. The parameter δ must be small enough to ensure that x ∈ R n x = (1 − λ)w − λu (k) , 0 λ 1 ⊂ Γ M . Recall that Γ M denotes the set of boundary points of the feasible polytope M.
Step 4 calculates the pseudoprojection ρ M (v) and assigns the result to w. Steps 5-19 implement the main loop. This loop is processed while the following condition holds: Here, f is a small positive parameter.
Step 6 introduces the point u moving along the surface of the polytope M from the point u (k) to the next approximation u (k+1) . Step 7 calculates the vector d, which defines the direction of movement of the point u. The loop in Ssteps 8-14 moves the point u along the surface of the polytope M in this direction as far as possible. To achieve this, the vector d is successively divided in half each time the next step moves u beyond the boundary of the polytope M. The movement stops when the length of the vector d becomes less than d . Here, d is a small positive parameter.
Step 15 sets the next approximation u (k+1) using the value of u.
Step 16 increases the iteration counter k by 1. Steps 17 and 18 calculate new points v and w for the next iteration of the main loop.
Step 20 outputs u (k) as the final approximation of the exact solutionx of LP problem (38). Schematically, the work of Algorithm 3 is shown in Figure 1.

Proposition 6.
Let the feasible polytope M of LP problem (38) be a closed bounded set, and M = ∅. Then, the sequence u (k) generated by Algorithm 3 terminates in finite number of iterations K 0, and Proof. The case when K = 0 is trivial. Let K > 0 or K = ∞. First, we show that for any k < K the following inequality holds: Indeed, inequality (123) implies According to Step 7 in Algorithm 3, it follows that Without loss of generality, we can assume that w − u (k) > d . Then, according to Steps 8-15, we obtain where µ > 0. Taking into account inequality (123) and Step 7 of Algorithm 3, it follows Now, we show that K < ∞. Assume the opposite, i.e., Algorithm 3 generates the infinite sequence of points. In this case, we obtain the monotonically increasing numerical sequence Since the feasible polytope M is bounded, sequence (129) is bounded from above. According to the monotone convergence theorem, a monotonically increasing numerical sequence bounded from above converges to its supremum. This means that there exists It follows ∀k > K : c, w − c, u (k) < d that is equivalent to Thus, we obtain a contradiction with the stopping criterion (123) used in Step 5 of Algorithm 3.
The notion of pseudoprojection is a generalization of the notion of metric projection, which can be defined as follows [43].

Definition 5.
Let Q be a closed convex set in R n , and Q = ∅. The metric projection P Q (x) of the point x ∈ R n onto the set Q is defined by the equation For the metric projection, the following proposition is similar to Proposition 6 for the pseudoprojection holds. Proposition 7. The sequence u (k) generated by Algorithm 3 with the metric projection P M (·) instead of the pseudoprojection ρ M (·) terminates in finite number of iterations K 0, and c, u (0) < c, u (1) < c, u (2) < . . . < c, u (K) . (134) Proof. The proof follows the same scheme as the proof of Proposition 6.
The following proposition states that Algorithm 3 with metric projection converges to the exact solution of the LP problem. Proposition 8. Let the pseudoprojection ρ M (·) be replaced by the metric projection P M (·) in Algorithm 3. Then, Algorithm 3 converges to the exact solutionx of LP problem (38).
Proof. Letū stand for the terminal point of the sequence u (k) generated by Algorithm 3 with the metric projection P M (·). This point exists according to Proposition 7. Assume the opposite, i.e.,ū =x. This is equivalent to According to (135), it follows that Let This is equivalent to It is easy to see that the following inequality holds: Condition (136), (139), and (140) say thatū is not the terminal point of the sequence u (k) generated by Algorithm 3. Thus, we obtain a contradiction, and the proposition is proved.
The convergence of Algorithm 3 with pseudoprojection to the exact solution is based on the intuition that ρ M (v) → P M (v) with δ → 0. However, a rigorous proof of this fact is beyond the scope of this article.

Implementation and Computational Experiments
We implemented a parallel version of the apex method in C++ using the BSF-skeleton [50], which is based on the BSF parallel computation model [49]. The BSF-skeleton encapsulates all aspects related to the parallelization of a program using the MPI library. The source code of this implementation is freely available at https: //github.com/leonid-sokolinsky/Apex-method (accessed on 1 March 2023). Using this program, we investigated the scalability of the apex method. The computational experiments were conducted on the "Tornado SUSU" computing cluster [51], whose specifications are shown in Table 1.
As test problems, we used random synthetic LP problems generated by the program FRaGenLP [52]. A verification of solutions obtained by the apex method was performed using the program VaLiPro [53]. We conducted a series of computational experiments in which we investigated the dependence of speedup and parallel efficiency on the number of worker nodes used. The results are presented in Figure 2.  Here, the speedup α is defined as the ratio of the time T(1) required by the parallel algorithm using one master node and one worker node to solve a problem to the time T(L) required by the parallel algorithm using one master node and L worker nodes to solve the same problem: The parallel efficiency is calculated as the ratio of the speedup α to the number L of worker nodes: The computations were performed with the following dimensions: 5000, 7500, and 10,000. The number of inequalities was 10,002, 15,002, and 20,002, respectively. The experiments showed that the scalability boundary of the parallel apex algorithm depends significantly on the size of the LP problem. For n = 5000, the scalability boundary was approximately 55 worker nodes. For the problem of dimension n = 7500, this boundary increased to 80 nodes, and for the problem of dimension n = 10,000, it was close to 100 nodes. Further increasing the problem size caused the compiler error: "insufficient memory". It should be noted that the computations were performed in the double double-precision floating-point format occupying 64 bits in computer memory. An attempt to use the singleprecision floating-point format occupying 32 bits failed because the apex algorithm stopped to convergeconverging. Parallel efficiency also significantly depends on the size of the LP problem. For n = 5000, the efficiency dropped below 50% at 70 worker nodes. For n = 7500 and n = 10,000, the 50% drop of the efficiency occurred at 110 and 130 worker nodes, respectively.
The experiments have also shown that the parameter η used in Equation (117) to calculate the apex point z at the quest stage has a negligible effect on the total time of solving the problem when this parameter has large values (more then than 100,000). If the apex point is not far enough away from the polytope, then its pseudoprojection-projection can be an interior point of some polytope face. If the apex point is taken far enough away from the polytope (the value η = 20,000 · n was used in the experiments), then the pseudoprojection-projection always fell into one of the polytope vertices. AlsoAdditionally, we would like to note that, in the case of synthetic LP problems generated by the program FRaGenLP, all computed points in the sequence u (k) were vertices of the polytope. The computational experiment showed that more than 99% of the time spent for solving the LP problem by the apex method was taken up by the calculation of pseudoprojections (Step 18 of Algorithm 3). At that, theThe calculation of one approximation u (k) for a problem of dimension n = 10,000 on 100 worker nodes took 44 min.
We also tested the apex method on a subset of LP problems from the Netlib-LP repository [54] available at https://netlib.org/lp/data (accessed on 1 March 2023). The Netlib suite of linear optimization problems includes many real real-world applications like such as stochastic forestry problems, oil refinery problems, flap settings of aircraft, pilot models, audit staff scheduling, truss structure problems, airline schedule planning, industrial production, and allocation models, image restoration problems, and multisector economic planning problems. It contains problems ranging in size from 32 variables and 27 constraints up to 15,695 variables and 16,675 constraints [55]. The exact solutions (optimal values of objective functions) of all problems were obtained from paper [56]. The results are presented in Table 2. These experiments showed that the relative error of the rough solution calculated at the quest stage was less than or equal to 0.2, excluding the adlittle, blend, and fit1d problems. The relative error of the refined solution calculated at the target stage was less than 10 −3 , excluding the kb2 and sc105, for which the error was 0.035 and 0.007, respectively. The runtime varied from a few seconds for afiro to tens of hours for blend. One of the main parameters affecting the convergence rate of the apex method was the parameter used in Step 12 of the parallel Algorithm 2 calculating the pseudoprojection. All runs are available on https://github.com/leonid-sokolinsky/Apex-method/tree/master/Runs (accessed on 1 March 2023).

Discussion
In this section of the article, we will discuss some issues related to the scientific contribution and applicability of the apex method in practice and give answers to the following questions.

1.
What is the scientific contribution of this article? 2.
What is the practical significance of the apex method? 3.
What is our confidence that the apex method always converges to the exact solution of the LP problem? 4.
How can we speed up the convergence of the Algorithm 1 calculating a pseudoprojection on the feasible polytope M?
The main scientific contribution of this article is that it presents the apex method that allows, for the first time, as far as we know, to construct a path close to optimal on the surface of a feasible polytope from a certain starting point to the exact solution of the LP problem. Here, the optimal path refers to a path of the minimum length according to the Euclidean metric. By intuition, moving in the direction of the greatest increase in the value of the objective function will give us the shortest path to the point of maximum of the objective function on the surface of the feasible polytope. We intend to present a formal proof of this fact in a futurefuture work.
The practical significance of the apex method is based on the issue of applying feedforward-forward neural networks, including convolutional neural networks, to solve LP problems. In recenta recent paper [28], a method of visual representation of n-dimensional LP problems was proposed. This method constructs an image of the feasible polytope M in the form of a matrix I of dimension (n − 1) using the rasterization technique. A vector antiparallel to the gradient vector of the objective function is used as the view ray. Each pixel value in I is proportional to the value of the objective function at the corresponding point on the surface of a feasible polytope M. Such an image makes it possible to use a feedforward neural network to construct the optimal path on the surface of the feasible polytope to the solution of the LP problem. Actually, tThe feedforward neural network can directly calculate the vector d in Algorithm 3, making the calculation of pseudoprojection redundant. The advantage of this approach is that the feedforward-forward neural network works in real time, which is important for robotics. We are not aware of other methods that solvessolve LP problems in real time. However, applying a feedforward neural network to solve LP problems involves the task of preparing a training dataset. The apex method provides the possibility to construct such a training dataset.
Proposition 6 states that Algorithm 3 converges to some point on the surface of the feasible polytope M in a finite number of steps, but leaves open the question of whether the terminal point will be a solution to the LP problem. According to Proposition 8, the answer to this question is positive if, in Algorithm 3, the pseudoprojection is replaced by the metric projection. However, there are no methods for constructing the metric projection for an arbitrarily bounded convex polytope. Therefore, we are forced to use the pseudoprojection. Numerous experiments show that the apex method converges to the solution of the LP problem, but this fact requires a formal proof. We plan to make such a proof in our future work.
The main drawback of the apex method is the slow rate of convergence to the solution of the LP problem. The LP problem, which takes several seconds to find the optimal solution by standard linear programming solvers, may take several hours to solve by the apex method. Computational experiments demonstrated that more than 99% of the time spent for solving the LP problem by the apex method was taken by the calculation of pseudoprojections. Therefore, the issue of speeding up the process of calculating the pseudoprojection is urgent. In the apex method, the pseudoprojection is calculated by Algorithm 1, which belongs to the class of projection-type methods discussed in detail in Section 2. In the case of closed bounded polytope M = ∅, the projection-type methods have a low linear rate of convergence: where 0 < C < ∞ is some constant, and q ∈ (0, 1) is a parameter that depends on the angles between the half-spaces corresponding to the faces of the polytope M [57]. This means that the distance between adjacent approximations decreases at each iteration by a constant factor of less than 1. For small angles, the convergence rate can decrease todecrease to values close to zero. This fundamental limitation of the projection-type methods cannot be overcome. However, we can reduce the number of half-spaces used to compute the pseudoprojection. According to Proposition 3, the solution of LP problem (38) belongs to some c-recessive half-space. Hence, in Algorithm 1 calculating the pseudoprojection, we can take into account only the c-recessive hyperplanes. On average, this reduces the number of half-spaces by two times. Another way to reduce the pseudoprojection calculation time is to parallelize Algorithm 1, as was done in Algorithm 2. However, the degree of parallelism in this case, in this case, will be limited by the theoretical estimation (115).

Conclusions and Future Work
In this paper, we proposed a new scalable iterative method for linear programming called the "apex method". The key feature of this method is constructing a path close to optimal on the surface of the feasible region from a certain starting point to the exact solution of the linear programming problem. The optimal path refers to a path of the minimum length according to the Euclidean metric. The main practical contribution of the apex method is that it opens the possibility of using feedforward neural networks to solve multidimensional LP problems.
The paper presents a theoretical basis used to construct the apex method. The halfspaces generated by the constraints of the LP problem are considered. These half-spaces form the feasible polytope M, which is a closed bounded set. These half-spaces are divided into two groups with respect to the gradient c of the linear objective function: c-neutraldominant and c-recessive. The necessary and sufficient condition for the c-recessivity is obtained. It is proved that the solution of to the LP problem lies on the boundary of a crecessive half-space. The equation defining the apex point not belonging to any c-recessive half-space is derived. The apex point is used to calculate the initial approximation on the surface of the feasible polytope M. The apex method constructs a path close to optimal on the surface of the feasible polytope M from this initial approximation to the solution of the LP problem. To do this, it uses a parallel algorithm constructing the pseudoprojection, which is a generalization of the notion of metric projection. For this parallel algorithm, an analytical estimation of the scalability bound is obtained. This estimation says that the scalability boundary of the parallel algorithm, of calculating the pseudoprojection on a cluster computing system, does not exceed O √ m processor nodes, where m is the number of constraints of the linear programming problem. The algorithm constructing a path close to optimal on the surface of the feasible polytope, from the initial approximation to the exact solution of the linear programming problem, is described. The convergence of this algorithm is proven.
The parallel version of the apex method is implemented in C++ using the BSF-skeleton based on the BSF parallel computation model. Large-scale computational experiments were conducted to investigate the scalability of the apex method on a cluster computing system. These experiments show that, for a synthetic scalable linear programming problem with a dimension of 10,000 and a constraint number of 20,002, the scalability boundary of the apex methods is close to 100 processor nodes. At the same time, these experiments showed that more than 99% of the time spent for solving the LP problem by the apex method was taken by the calculation of pseudoprojections.
In addition, the apex method was used to solve 10 problems from the Netlib-LP repository. These experiments showed that the relative error varied from 3.5 × 10 −3 to 8.6 × 10 −9 . The runtime ranged from a few seconds for to tens of hours. The main parameter affecting the convergence rate of the apex method was the precision of calculating the pseudoprojection.
Our future research directions on this subject are as followingfollows. We plan to develop a new method for calculating the pseudoprojection onto the feasible polytope of the LP problem. The basic idea is to reduce the number of half-spaces used in one iteration. At the same time, the number of these half-spaces should remain large enough to enable the efficient parallelization. The new method should outperform Algorithm 2 in terms of convergence rate. We will also need to prove that the new method converges to a point that lies on the boundary of the feasible region. In addition, we plan to investigate the usefulness of utilizusing the linear superiorization technique [46] in the apex method.