An infeasible interior-point arc-search method with Nesterov’s restarting strategy for linear programming problems

An arc-search interior-point method is a type of interior-point meth-ods that approximate the central path by an ellipsoidal arc, and it can often reduce the number of iterations. In this work, to further reduce the number of iterations and computation time for solving linear programming problems, we propose two arc-search interior-point methods using Nesterov’s restarting strategy that is well-known method to accelerate the gradient method with a momentum term. The ﬁrst one generates a sequence of iterations in the neighborhood, and we prove that the convergence of the generated sequence to an optimal solution and the computation complexity is polynomial time. The second one incorporates the concept of the Mehrotra type interior-point method to improve numerical stability. The numerical experiments demonstrate that the second one reduced the number of iterations and computational time. In particular, the average number of iterations was reduced by 6% compared to an existing arc-search interior-point method due to the momentum term.


Introduction
Numerical methods for solving linear programming (LP) problems have been studied well in the literature, since LP problems have wide-range applications including practical ones and theoretical ones.In particular, the simplex method, the gradient method and the interior-point method are well-known methods.The interior-point method was originally proposed by Karmarkar [8] in 1984, and it has been improved by, for example, the primaldual interior-point method [11] and Mehrotra type predictor-corrector method [13].For more details, see Wright [20] and references therein.
The computational efficiency of higher-order algorithms [1,5,6,9,13,15] using secondorder or higher derivatives in framework of interior-point methods has been getting a lot of attention.Mehrotra type predictor-corrector method [13] can be considered as one of the high-order algorithms.Lustig et al. [12] reported that Mehrotra type predictorcorrector method was effective in reducing the computation time.The method has also been implemented in software packages [21,22].However, the higher-order algorithms sometimes had a worse polynomial bound, or the analysis of computational complexity was not simple.
The arc-search interior-point method [25] proposed for linear programming also employs higher derivatives, and Yang and Yamashita [29] proved that the number of iterations in the arc-search infeasible interior-point method can be bounded by O(nL), which is equal to the best known polynomial bound for the infeasible interior-point algorithms.The arc-search interior-point method has been extended for quadratic programming with box constraints [26], second-order cone programming [24], semidefinite programming [31], complementarity problem [30], and general nonlinear programming [23].
A main idea of the arc-search interior-point method is to approximate the central path with an ellipsoidal arc and this leads to a reduction of the number of iterations.The central path is a smooth curve that converges to an optimal solution, but standard interior-point methods use a linear approximation to trace the central path and apply a line search.Since the central path is a curve, it can be expected that an ellipsoidal arc can approximate the central path better than the line search with a fixed search direction.In fact, Yang and Yamashita [29] showed through numerical experiments that the arc-search interior-point method reduces the number of iterations for solving LP test instances.
However, the computational time for each iteration in the arc-search interior-point method tends to increase compared to line-search methods due to calculations of the higher-order derivatives.Therefore, reducing the number of iterations further without calculating the higher-order derivatives is one of important issues to attain better computational time.
On the other hand, Nesterov's restarting strategy [17] is widely employed to improve the computation time of first-order methods.Nesterov proved that this technique reduces the worst-case convergence rate of the gradient methods for minimizing smooth convex functions from O(1/k) to O(1/k 2 ).Dozat [4] utilized this technique in a framework of stochastic gradient descent methods in Deep Learning.
For LP problems, Morshed and Noor-E-Alam [16] examined a method that combines Nesterov's restarting strategy with the affine scaling method and proved that their method is polynomial time.In addition, their numerical results showed that their method reduces the computation time compared to a conventional affine scaling method.To the best of the author's knowledge, however, Nesterov's restarting strategy has not been introduced in the arc-search interior-point methods.
In this paper, we propose a new arc-search method for LP problems combined with Nesterov's restarting strategy so that the arc-search interior-point method can further reduce the number of iterations.We establish the convergence of a generated sequence of the proposed method to an optimal solution, and we also show that the proposed method is a polynomial-time algorithm.Furthermore, to reduce actual computation time, we modify the proposed method by introducing a concept of the Merhotra type interiorpoint method.From numerical experiments on Netlib test instances [2], we observed that this modified method achieved better performance than existing methods in terms of both the number of iterations and computation time.In particular, the number of iterations is successfully reduced by 5.4% compared to an existing arc-search method.
This paper is organized as follows.Section 2 introduces the standard form of LP problems in this paper and gives a brief summary of arc-search interior-point methods.We describe the proposed method in Section 3, and we discuss its convergence properties in Section 4. In Section 5, we modify the proposed method to improve performance in numerical experiments and compare it with existing methods.Finally, we give a conclusion of this paper and discuss future directions in Section 6.

Notations
We denote i-th element of a vector x by x i and the Hadamard product (the elementwise product) of two vectors x and s by x • s.We use ∥x∥ and ∥x∥ ∞ for the Euclidean norm and the infinity norm of a vector x, respectively.The identity matrix and the vector of all ones of an appropriate dimension are denoted by I and e, respectively.We use a superscript ⊤ to denote the transpose of a vector or a matrix.The block column vector x ⊤ , s ⊤ ⊤ is shortly expressed by (x, s).For x ∈ R n , we will use the capital character X ∈ R n×n for the diagonal matrix that puts the components of x at its diagonal positions.

Preliminaries
We consider a linear programming (LP) problem in the following standard form: where where λ is the dual variable vector, and s is the dual slack vector.Let S denote the set of the optimal solutions of ( 1) and (2).It is well known that (x * , λ * , s * ) ∈ S if (x * , λ * , s * ) satisfies the following KKT conditions: We denote the residuals of the equality constraints in ( 1) and ( 2) by and the duality measure by In this paper, we make the following assumption for (1) and ( 2).This assumption is a mild one and is used in many papers-for example, see [20,28].(A2) The row vectors in A are linear independent.
Assumption 2.1 guarantees the existence of optimal solutions and the boundedness of S-see [28].

Arc-search interior-point method
Interior-point methods are iterative methods, and we denote the kth iteration by ( Given a strictly positive iteration (x k , λ k , s k ) such that (x k , s k ) > 0, an infeasible predictor-corrector method [28] traces a smooth curve called an approximate center path: where (x(t), λ(t), s(t)) is the unique solution of the following system As t approaches 0, (x(t), λ(t), s(t)) converges to an optimal solution in S. Though the existence of the curve C is guaranteed by the implicit function theorem, it does not admit an analytical form.
The key idea in the arc-search type interior-point algorithms [27] is to approximate the curve C with an ellipsoidal arc in the 2n + m dimensional space.An ellipsoidal approximation of (x(t), λ(t), s(t)) at (x k , λ k , s k ) for an angle α ∈ (0, π) is explicitly given by (x(α), λ(α), s(α)) with Here, the first derivative ( ẋ, λ, ṡ) and the second derivative (ẍ, λ, s) are the solutions of the following systems: In the remainder of this section, we introduce definitions that are necessary to discuss the convergence.In the same way as Yang [28], we introduce the neighborhood of the central path by By generating a sequence in this neighborhood N (θ), Yang [28] proved that the algorithm converges in polynomial time.Similarly to Miao [14] and Kojima [10], we also choose a sufficiently large parameter ρ ≥ 1 and an initial point x 0 , λ 0 , s 0 such that x 0 , λ 0 , s 0 ∈ N (θ), x * ≤ ρx 0 , s * ≤ ρs 0 (11) for some (x * , λ * , s * ) ∈ S. Let ω f and ω o be the distances of feasibility and optimality from the initial point as follows: From (12), there exists a feasible solution (x, λ, s) satisfying In addition, from (13), there is an optimal solution (x * , λ * , s * ) ∈ S satisfying We will use these definitions to discuss the convergence of the proposed method.

The proposed method
We introduce Nesterov's restarting strategy [17] for the arc-search interior-point method.
Nesterov's restarting strategy has been described in the literature to accelerate convergence in gradient descent algorithms, and Morshed and Noor-E-Alam [16] applied Nesterov's restarting strategy to an affine scaling method.
To combine Nesterov's restarting strategy into the arc-search interior-point method, we employ the momentum term with a strictly positive point x 0 > 0, and we construct z k by where β k ≥ 0 is a weight of the momentum term which will be calculated by Here, β ∈ (0, 1) is a parameter that is given before starting algorithms.In (17), z k with the momentum δ(x k ) is adopted if it is in the neighborhood N (θ).We use this z k instead of x k to compute the arc in each iteration.The first and the second derivatives at (z k , λ k , s k ) with respect to t are given by and we denote the duality measure at (z k , λ k , s k ) by A framework of the proposed method is given as Algorithm 1.

Theoretical proof
We discuss theoretical aspects of Algorithm 1, in particular, we focus on the convergence of the generated sequence and the number of iterations.In this section, let {(x k , λ k , s k )} be the sequence generated by Algorithm 1.
To compute the first and the second derivatives at (z k , λ k , s k ) uniquely by (19) and (20), the following matrix must be nonsingular for all k: Since A is full rank matrix from Assumption 2.1 and S k is a positive diagonal matrix due to Proposition 4.1 below, the nonsingularity of ( 26) is ensured.
Proposition 4.1.There exists The proof of Proposition 4.1 will be given later.The following lemma indicates that z k is a positive vector.Lemma 4.1.Suppose x k and z k are obtained at the kth iteration of Algorithm 1.Then, for all i ∈ {1, 2, . . ., n}, Proof.
for all i, where the last equality holds from x k > 0. The definition of β k (18) indicates so we can get (27) since β ∈ (0, 1).
Corollary 4.1.Suppose x k , s k and z k are obtained at the kth iteration of Algorithm 1.Then,

Convergence of Algorithm 1
To discuss the convergence of the generated sequence by Algorithm 1, we first evaluate the residuals of the equality constraints.Some proofs in this section can be done in similar ways to the reference [28], but will be described in this paper for the sake of completeness, since we are using z k instead of x k .
To prove the monotonic decrement of the residuals in the constraints (4), we first show that the signs in the primal constraint remain same.Lemma 4.2.Let x k and z k be generated by Algorithm 1.Then, Proof.From (4a), ( 25), (23a), ( 20), ( 24) and ( 19), it holds that We give the proof by induction on the iteration number k. 17) is satisfied, thus both (i) and (ii) hold.We assume r b (z k ) j ≤ r b (x k ) j with k = t, and discuss the case of k = t + 1 and z k = x k + β k δ(x k ).From (4a) and ( 16), we derive We consider the case of (i).From ( 29) and r b (x t ) j ≥ r b (z t ) j , we know thus, we get r b (x t+1 ) j ≥ r b (z t+1 ) j from (30).In addition, we can get r b (x t+1 ) j ≥ 0 from (29) and r b (z t ) j ≥ 0, and 18), so we obtain = 0, therefore, we can get r b (x t+1 ) j ≥ r b (z t+1 ) j ≥ 0 and this shows the case of (i).The proof for (ii) can be given similarly.
Next, we prove the convergence of the residuals of constraints.
Theorem 4.1.The residuals (4) shrink at a rate of at least (1 − sin(α k )) in each iteration, more precisely, Proof.From Lemma 4.2, r b (z t ) j ≤ r b (x t ) j holds regardless of the sign of r b (x 0 ) j .Hence, from (29), we obtain for each j.
Lastly, we prove the second part.From (4b), ( 25), ( 23), ( 20), ( 24) and ( 19), we know Owing to the momentum term, the residual of every primal constraint can shrink at the ratio of (1 − sin(α k )) or faster.To evaluate the primal residual r b (z k ) more precisely, we introduce the following lemma.Lemma 4.3.For each k, there exists τ k such that 0 ≤ τ k ≤ 1 and Proof.We give a proof by the induction on the iteration number k.When k = 0, r b (x 1 ) = (1 − sin(α 0 ))r b (x 0 ), then (31) is satisfied with τ 0 = 1.For a positive integer t, we assume that (31) holds for any k such that k ≤ t.The sign of each component of r b (x t ) does not change due to Lemma 4.2, thus we know τ k ≥ 0 for k ≤ t.If 1 − sin(α t ) = 0 or τ t = 0 hold, Theorem 4.1 implies r b (x t ′ ) = 0 for all t ′ ≥ t.Then, we can choose arbitrary τ t ′ from the range 0 ≤ τ t ′ ≤ 1, and we can satisfy (31).From here, therefore, we focus on the case at k = t + 1 when 1 − sin(α k ′ ) > 0 and τ k ′ > 0 hold for all k ′ ≤ t.
The next lemma shows the reduction speed of the duality measure.
Lemma 4.4.Let the sequence {(x k , λ k , s k )} be generated by Algorithm 1.Then, it holds that Lemma 4.4 can be proved in the same way as Yang [29, Lemma 3.1], because this lemma does not depend on using z k , therefore we omit the proof.
Next, we prepare several lemmas to prove in Lemma 4.12 that there exists a strictly positive constant ᾱ > 0 such that α k > ᾱ through all iterations until the algorithm termination.In Lemmas 4.10 and 4.11 below, we will derive upper bounds for ż, ṡ, z, s.For these lemmas, we first prove the upper bound of where (x * , λ * , s * ) ∈ S is a solution that attains the minimum of (13).
The proof of Lemma 4.7 can be done with similar steps in [28, Lemma 6.4].However, since the coefficients of (36) are slightly different from those in [28], we include the proof here.
For the latter discussions, let We introduce the following lemma to prove that D k −1 ż and D k ṡ have upper bounds.
In Lemmas 4.9 and 4.10 below, upper bounds of D k −1 ż and D k ṡ can be derived.This allows us to prove the lower bound of sin(α k ) in the same way as in [29].Lemma 4.9.Let ( ż, ṡ) be defined by (19).Then, Proof.Let (x, λ, s) be the feasible solution of ( 1) and ( 2) that attains the minimum of (12).From (33a), Similarly, since From the third row of ( 19), we also have By combining (43), ( 44) and (45) into a matrix form, we have Putting , we apply Lemma 4.8 to obtain the upper bounds of Considering (39) with i = 2, we can get and this is equal to Thus, from ( 46) and (48), we have Similarly, for i = 3, we have which is equivalent to Thus, from (47) and (50), we have From (40a), Using (40b), it holds that Using (40c), we have Therefore, from (53), ( 54) and (36), Therefore, from (49) and (51), The upper bounds derived in Lemma 4.7 and 4.9 depend on the value of β.If β is very close to 1, the upper bounds would be very large.Conversely, if it is close to 0, the momentum term has only a small effect.For the proof, we use β ∈ (0, 1), and we will discuss the effect of β numerically through numerical results in Section 5.4.1 and 5.4.3.
Lemma 4.9 leads to the following lemma.
Lemma 4.10.Let the sequence {(x k , λ k , s k )} be generated by Algorithm 1 and let ( ż, λ, ṡ) be obtained from (19).Then, there is a positive constant C 0 satisfying and independent of n.
Lemma 4.10 can be proved by replacing x k and ẋ in [28, Lemma 6.7] by z k and ż.In this case, C 0 is taken such that From Lemma 4.10, we can give an upper bound on the norm of the search directions.
We can apply the same discussion as Yang [29,Lemma 4.4] to prove the above lemma, by replacing x and µ k with z and µ z k , respectively.The above lemma allows us to make an estimation regarding the lower bound of sin (α k ).Lemma 4.12.Let the sequence {(x k , λ k , s k )} be generated by Algorithm 1.Then, α k satisfies the following inequality: , .
The proof of Lemma 4.12 can be done in a similar way to [29, Lemma 4.5] with a replacement µ k by µ z k .Lemma 4.12 enables to establish polynomial-time complexity from the same argument as in [29].We consider the following stopping criterion at Step 1 of Algorithm 1: Theorem 4.2.Let {(x k , λ k , s k )} be generated by Algorithm 1 with an initial point given by (11) and L = ln(µ 0 /ϵ) for a given ϵ > 0.Then, the algorithm will terminate with The proof of Theorem 4.2 is the essentially same as Wright [20, Theorem 3.2] as well as [29,Theorem 4.1].Therefore, Algorithm 1 reaches a solution up to the stopping threshold ϵ.

Proof for Proposition 4.1
Lastly, we give the proof of Proposition 4.1 for nonsingularity of (26).For this purpose, since (x k , λ k , s k ) is in the neighborhood N (θ), we prove that there is a lower bound that is greater than 0 on s k by finding an upper bound for x k .Lemma 4.13.There is a positive constant κ such that The proof of Lemma 4.13 is given similarly to [20,Lemma 6.3].

Numerical experiments
We conducted numerical experiments to compare the proposed method with the existing methods, i.e., arc-search method and line-search method.In addition, we also investigate the effect of the restarting parameter β.The numerical experiments were executed on a Linux server with Opteron 4386 (3.10GHz), 16 cores and 128 GB RAM.We implemented the methods with Python 3.10.9.
In the following, an existing arc-search interior-point method [27] is called "Arcsearch" and an existing Mehortra type line-search interior-point method [13] "Linesearch".Both of these implementations are built upon the algorithms described in the referenced papers.

Test problems
For the test problems, we used the Netlib test repository [2].We chose 85 problems in the experiment 1 .
The Netlib instances are given in the following format: (There exist cases where b LO = b U P .)To transform it into the form of (1), we employ the following setting: where s G , s L , and s B are slack variables for inequality constraints such that Though another setting like x b − s LO = b LO can be considered, the above setting has fewer constraints.
In addition, we apply the preprocessing described in [27,Section 4.2] to each problem.Therefore, the size (n, m) of each problem in this paper is not always the same as the size reported at the Netlib webpage [2].The variable size n ranges from 51 to 9,253, and the number of constraints m from 27 to 4,523.

The modified algorithm
To improve practical performance of Algorithm 1, we modify it into Algorithm 2 with the Mehrotra type implementation [13] similarly to [27,Algorithm 3.1].The comparison of numerical experiments in Section 5.4.1 will show that Algorithm 2 is numerically superior to Algorithm 1.In the following, we discuss the main differences.
Based on the concept of Mehrotra type implementation, we slightly perturb the second derivative (20) to prevent the step size from diminishing to zero: Here σ k ∈ (0, 0.5] is called the centering parameter, and is selected in the same way as Mehrotra [13]. As for the setting of β k , we use two formulas of computation: the formula in ( 18) and its simplified formula: Although the term was used in the proof, we mainly use (64) for setting β k because (64) was more efficient in preliminary numerical experiments.A comparison of the difference in β k will be reported in Section 5.4.2.
In addition, Algorithm 2 does not use the neighborhood N (θ), thus z k is evaluated as follows: In other words, the momentum term is employed in all the iterations.

Implementation details
In the following, we discuss more details on implementation.In Algorithm 1, we set θ = 0.25.

Initial points
In Algorithm 1, the components of x 0 and s 0 are all set to 100 and those of λ 0 is all set to 0 to ensure that the initial point (x 0 , λ 0 , s 0 ) is in neighborhood N (θ).In contrast, the initial point is set the same as Yang [27, Section 4.1] in Algorithm 2, Arc-search and Line-search.

Step size
In Algorithm 1, since it is difficult to obtain the solution of ( 22) analytically, Armijo's rule [20] is employed to determine an actual step size α k that satisfies (22).In Algorithm 2, we decide α z max and α s max by (66) on the same strategy as Yang [27, Section 4.8].
The step scaling factor γ k in Algorithm 2 is calculated as γ k = 0.9 for guaranteeing the positiveness of x k and s k .Although Yang [28, Section 7.3.9]proposed the scaling factor of γ k = 1 − e −(k+2) , it is not robust for numerical errors in our implementation because it converges to 1 too quickly.

Stopping criteria
In Theorem 4.2, we used (61) as the stopping criterion for Algorithm 1.However, the part µ k ≤ ϵ does not take the magnitude of the data into consideration, thus, it is not practical especially when the magnitude of the optimal values is relatively large.In addition, (61) depends on the initial point, though we set different initial points for Algorithms 1 and 2 as described in Section 5.3.1.Therefore, we employed the following stopping criterion in the numerical experiment: where we set the threshold ϵ = 10 −7 .
In addition, we stopped the iteration immaturely when one of three conditions was detected; (i) the iteration count k reached 100, (ii) the step size α k was too small like α k < 10 −7 , or (iii) the linear systems (19), (20) or (63) could not be solved accurately due to numerical errors.

Numerical results
We report numerical results as follows.In Section 5.4.1, we compare Algorithms 1 and 2, and show that Algorithm 2 is superior to Algorithm 1 in the numerical experiments.Therefore, we use Algorithm 2 in Section 5.4.2 and thereafter.Section 5.4.2 compares the settings (18) or (64) for β k in Algorithm 2, and Section 5.4.3 evaluates the effect of the value of β.Lastly, Section 5.4.4 compares the numerical performance of Algorithm 2 with the existing methods, using the formula (64) chosen from Section 5.4.2 and the best β from Section 5.4.3.

Comparison between Algorithm 1 and Algorithm 2
Table 1 reports the number of Netlib problems solved by Algorithms 1 and 2 with different settings of β.The value of β k is set by (64) except a case of β = 0.5 in Algorithm 2 that investigates both (18) and (64).The table also shows the number of unsolved problems due to (i) the iteration limit, (ii) the diminishing step length or (iii) numerical errors-see Section 5.3.3.From Table 1, we can see that Algorithm 2 improves the number of solvable problems from Algorithm 1.When β = 0.5 and the setting of β k was (18), Algorithms 1 and 2 could not solve ten and six problems, respectively, among the 85 problems due to the iteration limit.As we will see soon in Figure 2, Algorithm 2 can reduce the number of iterations compared to Algorithm 1, therefore, Algorithm 2 can reach more optimal solutions before the iteration limit as shown in Table 1.
In addition, Table 1 indicates Algorithm 1 with setting β = 1 does not affect the number of solvable problems remarkably, despite the upper bounds on max D k −1 ż , D k ṡ in Lemma 4.9 diverges when we take ∈ N (θ) holds and z k = x k is selected in (17).As can be inferred from this, the closer β is to 1, the more likely z k = x k , and such an iteration is the same as the case of β = 0. Therefore, the divergence of C 0 is unlikely to occur in actual computation up to numerical errors.
The performance profile [7,19] on the number of iterations in Algorithm 1 with different β is shown in Figure 1.In the performance profiling, the horizontal axis is a scaled value τ and the vertical axis P (r ≤ τ ) is the proportion of test problems.For example, for the number of iterations, P (r ≤ τ ) corresponds the percentage of test problems that were solved by less than a τ times the number of iterations of the best algorithm.Simply speaking, a good algorithm has a larger value P (r ≤ τ ) from smaller τ .To output the performance profile, we used a Julia package [18].In Figure 1, the numbers of iterations with β = 0.999 are the exactly same as those with β = 1, thus the plot for β = 0.999 is hidden by that for β = 1 in the figure.Figure 1 shows that the momentum term improves the number of iterations when β is 0.001.In contrast, when β is close to 1, x k +β k δ(x k ) tends to be out of the neighborhood N (θ), therefore, selecting z k = x k by (17) in many iterations makes the effect of the momentum term small.Figure 2 compares Algorithm 1 and 2 under the setting of β = 0.001.Figure 2 indicates that the result of Algorithm 2 is significantly better than that of Algorithm 1, since Algorithm 2 uses the momentum term through all the iterations.
From the above result, we use the results of Algorithm 2 in the following numerical experiments instead of Algorithm 1.

Effect of the choice of the weight of the momentum term
Theorem 4.1 indicates that β k by (18) can guarantee the decreasing of r b (x k ), thus the number of solvable problems with (18) should be larger than (64).In contrast, the numerical result in Table 1 shows that Algorithm 2 with β = 0.5 and the formula (18) is 79, while the algorithm with β = 0.5 and the formula (64) is 78, therefore, the difference in solvable problems between (18) and ( 64) is only one.In Figure 3, we plot the residuals and the duality measure on a test instance KB2 solved with β k in ( 18) and ( 64).When we use (18), the primal residual r b (x k ) ∞ decreases monotonically in the first six iterations to a level of 10 −8 .In contrast, when we use (64), r b (x k ) ∞ slightly increases at the fifth iteration.However, both ( 18) and (64) decrease r b (x k ) ∞ sufficiently in 25 iterations.
Figure 4 shows the performance profile on the number of iterations, and we can see that (64) is better.

Numerical sensitivity of the restarting parameter
Here, we investigate influence of the restarting parameter β.
Figure 5 shows the performance profiling on the number of iterations of Algorithm 2 with different β from 0.001 to 1.We can observe there that larger β tends to lead to a slightly less number of iterations, and this implies that a momentum term is effective to reduce the iterations.
In the following, we fix β = 0.9 in Algorithm 2 which solves more problems in Table 1, and we compare Algorithm 2 with the existing methods.

Comparison with existing methods
Figure 6 shows a performance profile that compares Algorithm 2 and the two existing methods, Arc-search [27] and Line-search [13].The results in Figure 6 indicates that Algorithm 2 performs better than the two existing methods in terms of the number of iterations.The detailed numerical results of the three methods are reported in Table 2 of Appendix.Among 76 problems in which all three methods found optimal solutions, Algorithm 2 reduces the number of iterations in 45 problems compared to Arc-search and Line-search (or finishes the iterations within at most the same numbers of iterations in 67 problems).
We also discuss the computational time.Since the results of small problems are too short, we calculate average computational times on problems for which all the three methods spent 30 seconds or longer.The average computational times are 252.51 in Algorithm 2, 272.73 in Arc-search, and 264.04 in Line-search, therefore, Algorithm 2 reduce the average time by about 5.4%.

Conclusion
In this work, we proposed an iterative method for LP problems by integrating Nesterov's restarting strategy into the arc-search interior-point method.In particular, we approximated the central path with an ellipsoidal arc based on the point z k that is computed from x k with the momentum term δ(x k ).By keeping all the iterations in the neighborhood N (θ), we established the convergence of a generated sequence of the proposed method to an optimal solution and showed the proposed method achieves the polynomial-time computational complexity.In order to improve numerical performance, we also proposed the modified method with a concept of the Mehrotra type interior-point method.From the numerical experiments with the Netlib benchmark problems, we observed that the modified method achieved better performance than existing arc-search and line-search interior-point methods.
As a future direction, we consider that Nesterov's restarting strategy in arc-search interior-point methods can be extended to more general types of problems, such as Figure 4: Performance profile of the number of iterations with different setting of β k second-order cone programming, semidefinite programming, linear constrained quadratic programming, and more general conic programming.In particular, there is room for further discussions on how the restarting strategy behaves in nonlinear-constrained cases.
In addition, the multiple centrality correction discussed in [3,6] may also be combined to improve the numerical performance, since the step size can be larger when the iteration points are closer to the central path.

Appendix Details on numerical results
Table 2 reports the numerical results in Section 5.4.4.The first column of the table is the problem name, while the second and the third are the variable size n and the number of constraints m, respectively.The fourth to ninth columns reports the numbers of iterations and the computation time of the methods.A mark '-' indicates the unsolved problem due to (i), (ii) or (iii) in Section 5.3.3.or that the step size α k is too small.The results in bold face indicate the best results among the three methods.

Table 1 :
The numbers of problems solved by Algorithm 1

Figure 1 :
Figure 1: Performance profile of the number of iterations with different restarting parameters in Algorithm 1

Figure 2 :
Figure 2: Performance profile of the number of iterations in Algorithms 1 and 2 with β = 0.001

Figure 3 :
Figure 3: Trajectories for r b (x k ) ∞ .The left is the result with the setting of (18), and the right is with (64).

Figure 6 :
Figure 6: Performance profile of the number of iterations with Algorithm 2 and existing methods