Original: Q UANTUM ALGORITHM FOR FINDING THE NEGATIVE CURVATURE DIRECTION
Revised: Q UANTUM ALGORITHM FOR FINDING THE NEGATIVE CURVATURE DIRECTION

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: We present an efﬁcient quantum algorithm aiming to ﬁnd the negative curvature direction for escaping the saddle point, which is a critical subroutine for many second-order non-convex optimization algorithms.
Revised: We present an efﬁcient quantum algorithm aiming to ﬁnd the negative curvature direction for escaping the saddle point, which is a critical subroutine for many second-order non-convex optimization algorithms.

Original: We prove that our algorithm could produce the target state corresponding to the negative curvature direction with query complexity ˜
Revised: We prove that our algorithm could produce the target state corresponding to the negative curvature direction with query complexity ˜

Original: O (polylog( d ) 󰂃 − 1 ) , where d is the dimension of the optimization function.
Revised: O (polylog( d ) ! − 1 ) , where d is the dimension of the optimization function.

Original: The quantum negative curvature ﬁnding algorithm is exponentially faster than any known classical method which takes time at least O ( d 󰂃 − 1 / 2 ) .
Revised: The quantum negative curvature ﬁnding algorithm is exponentially faster than any known classical method which takes time at least O ( d ! − 1 / 2 ) .

Original: Moreover, we propose an efﬁcient algorithm to achieve the classical read-out of the target state.
Revised: Moreover, we propose an efﬁcient algorithm to achieve the classical read-out of the target state.

Original: Our classical read-out algorithm runs exponentially faster on the degree of d than existing counterparts.
Revised: Our classical read-out algorithm runs exponentially faster on the degree of d than existing counterparts.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Algorithms for ﬁnding the minima of functions have attracted signiﬁcant attention due in part to their prevalent applications in machine learning, deep learning and robust statistics; in particular, those with good complexity guarantees that can converge to the local minima.
Revised: Algorithms for ﬁnding the minima of functions have attracted signiﬁcant attention due in part to their prevalent applications in machine learning, deep learning and robust statistics; in particular, those with good complexity guarantees that can converge to the local minima.

Original: Numerous algorithms have been proposed in recent years for ﬁnding points that satisfying
Revised: Numerous algorithms have been proposed in recent years for ﬁnding points that satisfying

Original: [Equation]
Revised: [Equation]

Original: where 󰂃 g , 󰂃 H ∈ (0 , 1) .
Revised: where ! g , ! H ∈ (0 , 1) .

Original: Recent proposals (Nesterov & Polyak, 2006; Conn et al., 2000; Agarwal et al., 2017) based on second-order Newton-type and ﬁrst-order methodology have been analyzed from such a perspective.
Revised: Recent proposals (Nesterov & Polyak, 2006; Conn et al., 2000; Agarwal et al., 2017) based on second-order Newton-type and ﬁrst-order methodology have been analyzed from such a perspective.

Original: However, those methods normally deal with the situations that the iterations may be trapped in the saddle points, since in many cases, such as deep neural networks (Dauphin et al., 2014; Choromanska et al., 2015), existence of many saddle points is the main bottleneck.
Revised: However, those methods normally deal with the situations that the iterations may be trapped in the saddle points, since in many cases, such as deep neural networks (Dauphin et al., 2014; Choromanska et al., 2015), existence of many saddle points is the main bottleneck.

Original: In general non-convex optimization, many algorithms have been proposed to escape the saddle points.
Revised: In general non-convex optimization, many algorithms have been proposed to escape the saddle points.

Original: These algorithms can be divided into the following two categories: the ﬁrst-order gradientbased algorithms and the second-order Hessian-based algorithms.
Revised: These algorithms can be divided into the following two categories: the ﬁrst-order gradientbased algorithms and the second-order Hessian-based algorithms.

Original: Generally, second-order algorithms have better iteration complexity than ﬁrst-order algorithms (cf.
Revised: Generally, second-order algorithms have better iteration complexity than ﬁrst-order algorithms (cf.

Original: Jin et al.
Revised: Jin et al.

Original: However, each iteration in the second-order method involves the computation of the negative curvature direction , namely, the eigenvector of a Hessian matrix H = ∇ 2 f ( x ) with negative eigenvalue.
Revised: However, each iteration in the second-order method involves the computation of the negative curvature direction , namely, the eigenvector of a Hessian matrix H = ∇ 2 f ( x ) with negative eigenvalue.

Original: This computation could take time O
Revised: This computation could take time O

Original: ( d 2 ) when the Hessian matrix is given, or O ( d/ √ 󰂃 ) when Lanczos method is used with Gradient information to approximate the Hessian-vector product.
Revised: ( d 2 ) when the Hessian matrix is given, or O ( d/ √ ! ) when Lanczos method is used with Gradient information to approximate the Hessian-vector product.

Original: Quantum algorithms have shown great potential to become faster alternatives than classical algorithms for many kinds of problems in the ﬁeld of linear algebra, including principal component analysis (Lloyd et al., 2014), support-vector machine (Rebentrost et al., 2014), singular value decomposition (Rebentrost et al., 2018).
Revised: Quantum algorithms have shown great potential to become faster alternatives than classical algorithms for many kinds of problems in the ﬁeld of linear algebra, including principal component analysis (Lloyd et al., 2014), support-vector machine (Rebentrost et al., 2014), singular value decomposition (Rebentrost et al., 2018).

Original: These works encourage us to develop an efﬁcient quantum algorithm for ﬁnding the negative curvature.
Revised: These works encourage us to develop an efﬁcient quantum algorithm for ﬁnding the negative curvature.

Original: To begin with, we formally deﬁne the negative curvature ﬁnding problem as follows.
Revised: To begin with, we formally deﬁne the negative curvature ﬁnding problem as follows.

Original: Negative Curvature Finding (NCF) problem:
Revised: Negative Curvature Finding (NCF) problem:

Original: Given a function f ( x ) : R d → R which has LLipschitz continuous gradient and the corresponding Hessian , we aim to build a quantum algorithm that could efﬁciently provide the unit vector u with the condition:
Revised: Given a function f ( x ) : R d → R which has LLipschitz continuous gradient and the corresponding Hessian , we aim to build a quantum algorithm that could efﬁciently provide the unit vector u with the condition:

Original: [Equation]
Revised: [Equation]

Original: where 0 < α <
Revised: where 0 < α <

Original: L and 0 < 󰂃 <
Revised: L and 0 < ! <

Original: α ; or make the non-vector statement that with high probability there is no unit vector u satisfying the following condition:
Revised: α ; or make the non-vector statement that with high probability there is no unit vector u satisfying the following condition:

Original: [Equation]
Revised: [Equation]

Original: 1. R ELATED WORK
Revised: 1. R ELATED WORK

Original: Optimization methods for non-convex problems can be roughly divided into ﬁrst-ordermethods and second-order methods, depending on the order of the derivative to the objective function they used.
Revised: Optimization methods for non-convex problems can be roughly divided into ﬁrst-order and secondorder methods, depending on the order of the derivative to the objective function they used.

Original: Generally,to ﬁnd the local minima, the second-order methods (Carmon et al., 2018; Agarwal et al., 2017) are exploited to ﬁnd the effective direction to escape the saddle point.
Revised: Generally, the second-order methods (Carmon et al., 2018; Agarwal et al., 2017) are exploited to ﬁnd the effective direction to escape the saddle point.

Original: Speciﬁcally, ﬁnding the Negative Curvature is considered as a critical subroutine to analyze the characteristic of the saddle point.
Revised: Speciﬁcally, ﬁnding the Negative Curvature is considered as a critical subroutine to analyze the characteristic of the saddle point.

Original: First-order algorithms : For the non-convex problem, the ﬁrst-order method (Gradient-based method) can ﬁnd the stationary point, which could be a global minima, local minima or saddle point.
Revised: First-order algorithms : For the non-convex problem, the ﬁrst-order method (Gradient-based method) can ﬁnd the stationary point, which could be a global minima, local minima or saddle point.

Original: However, standard analysis by gradient descent cannot distinguish between saddle points and local minima, leaving open the possibility that gradient descent may get stuck at saddle points.
Revised: However, standard analysis by gradient descent cannot distinguish between saddle points and local minima, leaving open the possibility that gradient descent may get stuck at saddle points.

Original: Recently Ge et al.
Revised: Recently Ge et al.

Original: ; Jin et al.
Revised: ; Jin et al.

Original: (2017; 2019) showed that by adding noise at each step, gradient descent can escape all saddle points in a polynomial number of iterations.
Revised: (2017; 2019) showed that by adding noise at each step, gradient descent can escape all saddle points in a polynomial number of iterations.

Original: Lee et al.
Revised: Lee et al.

Original: (2016) proved that under similar conditions, gradient descent with random initialization avoids saddle points even without adding noise.
Revised: (2016) proved that under similar conditions, gradient descent with random initialization avoids saddle points even without adding noise.

Original: However, each step of Gradient-based methods requires O ( d ) operations and their iteration complexity is higher than second-order algorithms (Jin et al., 2017).
Revised: However, each step of Gradient-based methods requires O ( d ) operations and their iteration complexity is higher than second-order algorithms (Jin et al., 2017).

Original: Second-order algorithms : Traditionally, second-order Newton-based methods can converge to local minima, which use the Hessian information to distinguish between ﬁrst-order and second-order stationary points.
Revised: Second-order algorithms : Traditionally, second-order Newton-based methods can converge to local minima, which use the Hessian information to distinguish between ﬁrst-order and second-order stationary points.

Original: There are two kinds of methods that make use of Hessian information.
Revised: There are two kinds of methods that make use of Hessian information.

Original: Hessianbased: trust-region (Conn et al., 2000) and cubic regularization (Nesterov & Polyak, 2006) are two methods, in which the sub-problem is to ﬁnd the decrease direction based on the given Hessian.
Revised: Hessianbased: trust-region (Conn et al., 2000) and cubic regularization (Nesterov & Polyak, 2006) are two methods, in which the sub-problem is to ﬁnd the decrease direction based on the given Hessian.

Original: The calculation of each iteration involves performing Hessian-vector production, which takes time at least O ( d 2 ) .
Revised: The calculation of each iteration involves performing Hessian-vector production, which takes time at least O ( d 2 ) .

Original: 2) Hessian-free: The Hessian-free methods use Lanczos method to calculate the negative curvature direction and use gradient to approximate the Hessian-vector product (Agarwal et al., 2017;
Revised: 2) Hessian-free: The Hessian-free methods use Lanczos method to calculate the negative curvature direction and use gradient to approximate the Hessian-vector product (Agarwal et al., 2017;

Original: Carmon et al., 2018; Carmon & Duchi, 2016).
Revised: Carmon et al., 2018; Carmon & Duchi, 2016).

Original: The Hessian-free method involves
Revised: The Hessian-free method involves

Original: O ( d 󰂃 − 1 / 2 ) complexity per iteration.
Revised: O ( d ! − 1 / 2 ) complexity per iteration.

Original: The advantage of the second-order algorithm is the superior iteration complexity than the ﬁrst-order algorithm.
Revised: The advantage of the second-order algorithm is the superior iteration complexity than the ﬁrst-order algorithm.

Original: However, using Hessian information usually increases computation time per iteration.
Revised: However, using Hessian information usually increases computation time per iteration.

Revised: Quantum Algorithm for Linear Algebra : There are some proposed quantum algorithms for problems in the related linear algebra ﬁeld.

Revised: For example, given copies to quantum state ρ = # di,j =1 x ij | i 〉〈 j | , where x ij is the i, j -th element of d × d matrix X with eigen-decomposition

Original: 1. O UR CONTRIBUTION
Revised: X = # rank ( X ) i = λ i u i u

Revised: i , previous quantum PCA algorithm

Revised: (Lloyd et al., 2014) could perform the mapping #

Revised: [Equation]

Revised: |

Revised: [Equation]

Revised: in time O (polylog( d ) !

Revised: − 3 ) .

Revised: However, the quantum PCA model use the density matrix ρ to store the information of matrix X , which implicitly assumes the condition !

Revised: X !

Revised: F = 1 and λ min ( X ) .

Revised: Another quantum SVD algorithm

Revised: (Rebentrost et al., 2018) shows an efﬁcient method to estimate the value λ j /d with error !

Revised: in time O ( ! − 3 ) , for d × d matrix

Revised: X with eigenvalues { λ j } dj =1 .

Revised: However, this model only suits the case when λ j /d is relatively large, and it would take time O

Revised: ( d 3 ! − 3 ) to produce !

Revised: -estimation on eigenvalues.

Revised: Moreover, both of these works did not study the classical read-out of the output state, which generally takes time at least

Revised: O ( d ) for d -dimensional state (Aaronson, 2015), and could offset the claimed quantum speed-up.

Revised: 1. O UR CONTRIBUTION

Original: The contribution of this work can be brieﬂy divided into two parts: 1) an efﬁcient quantum algorithm to generate the required quantum state, which corresponds to the negative curvature direction, and 2) an efﬁcient quantum algorithm to obtain the description of the target state | u t 〉 =
Revised: The contribution of this work can be brieﬂy divided into two parts: 1) an efﬁcient quantum algorithm to generate the required quantum state, which corresponds to the negative curvature direction, and 2) an efﬁcient quantum algorithm to obtain the description of the target state | u t 〉 =

Original: [Equation]
Revised: [Equation]

Original: where { s i } ri =1 is an independent vector set selected from columns of Hessian H with rank r .
Revised: where { s i } ri =1 is an independent vector set selected from columns of Hessian H with rank r .

Original: Negative Curvature Finding : We develop an efﬁcient quantum algorithm to produce the target state
Revised: Negative Curvature Finding : We develop an efﬁcient quantum algorithm to produce the target state

Original: | u t 〉 (for case (1)) or make the non-vector statement (for case (2)).
Revised: | u t 〉 (for case (1)) or make the non-vector statement (for case (2)).

Original: We provide Propositionas the main result of this part, which guarantees the time complexity of our NCF algorithm:
Revised: We provide Propositionas the main result of this part, which guarantees the time complexity of our NCF algorithm:

Original: Proposition 1.
Revised: Proposition 1.

Original: There exists a quantum algorithm which could solve the Negative Curvature Finding problem in time ˜ O
Revised: There exists a quantum algorithm which could solve the Negative Curvature Finding problem in time ˜ O

Original: (polylog( d )poly( r ) 󰂃 − 1 ) , by providing the target state | u t 〉 (for case (1)), or making the non-vector statement (for case (2)).
Revised: (polylog( d )poly( r ) ! − 1 ) , by providing the target state | u t 〉 (for case (1)), or making the non-vector statement (for case (2)).

Original: Classical Read-out : The classical read-out problem is one bottleneck for many quantum machine learning algorithms whose results are quantum states.
Revised: Classical Read-out : The classical read-out problem is one bottleneck for many quantum machine learning algorithms whose results are quantum states.

Original: Generally, the read-out of a d -dimensional quantum state takes time at least O ( d ) (Aaronson, 2015), and could offset the claimed quantum speed-up.
Revised: Generally, the read-out of a d -dimensional quantum state takes time at least O ( d ) (Aaronson, 2015), and could offset the claimed quantum speed-up.

Original: In order to solve this dilemma, we develop an efﬁcient quantum algorithm for the classical read-out of the target state.
Revised: In order to solve this dilemma, we develop an efﬁcient quantum algorithm for the classical read-out of the target state.

Original: We notice that the target state | u t 〉 can be written as the linear combination form | u t 〉 = 󰁓 ri =1 x i | s i 〉 , where { s i } ri =1 is a linearly independent basis sampled from column vectors { h j } dj =1 .
Revised: We notice that the target state | u t 〉 can be written as the linear combination form | u t 〉 = # ri =1 x i | s i 〉 , where { s i } ri =1 is a linearly independent basis sampled from column vectors { h j } dj =1 .

Original: The algorithm suits the case when the result quantum state lies in the span of several given states, and may give rise to independent interest.
Revised: The algorithm suits the case when the result quantum state lies in the span of several given states, and may give rise to independent interest.

Original: One advantage of generating the form | u t 〉 =󰁓 ri =1 x i | s i 〉 is that the updating operation for the l -th iteration z ( l +1) =
Revised: One advantage of generating the form | u t 〉 =

Original: z ( l ) + η u t in general non-convex algorithms could be implemented in quantum form | z ( l +1) 〉 ∝ | z ( l ) 〉 + η 󰁓 ri =1 x i | s i 〉 by Linear-Sum-of-States method (Shao, 2018) efﬁciently, which may inspire efﬁcient quantum counterparts for these non-convex algorithms. Note that we could not perform the operation | z ( l +1) ∝ | z ( l ) 〉 + η | u t 〉 directly since the target state | u t 〉 is generated by post-selection instead of standard unitary operations.
Revised: # ri =1 x i | s i 〉 is that it provides the target eigenvector as the linear-sum of r columns, which guides the curvature direction in general second-order methods.

Original: Our state read-out algorithm contains two subroutines named as the Complete Basis Selection and the State Overlap Estimation.
Revised: Our state read-out algorithm contains two subroutines named as the Complete Basis Selection and the State Overlap Estimation.

Original: The main results about the Complete Basis Selection and the Classical Read-out are brieﬂy summarized as following theorems:
Revised: The main results about the Complete Basis Selection and the Classical Read-out are brieﬂy summarized as following theorems:

Original: Theorem 1.
Revised: Theorem 1.

Original: There exists a quantum algorithm which takes time ˜ O
Revised: There exists a quantum algorithm which takes time ˜ O

Original: (poly( r ) 󰂃 − 2 r c ) to ﬁnd an index set { g ( i ) } ri =1 , where r is the rank of H , c
Revised: (poly( r ) ! − 2 r c ) to ﬁnd an index set { g ( i ) } ri =1 , where r is the rank of H , c

Original: = 2 log 4 r 󰀂 H 󰀂 F 󰂃 and { g ( i ) } ri =1 forms a complete basis {| h g ( i ) 〉 } ri =1 with probability at least 3/4.
Revised: = 2 log 4 r " H " F ! and { g ( i ) } ri =1 forms a complete basis {| h g ( i ) 〉 } ri =1 with probability at least 3/4.

Original: Theorem 2.
Revised: Theorem 2.

Original: The classical description of the target state | u t 〉 = 󰁓 ri =1 x i | s i 〉 could be presented in time
Revised: The classical description of the target state | u t 〉 = # ri =1 x i | s i 〉 could be presented in time

Original: ˜ O
Revised: ˜ O

Original: (polylog( d )poly( r ) 󰂃 − 5 ) with error bounds in 󰂃 2 , when the basis set { s j } rj =1 is given.
Revised: (polylog( d )poly( r ) ! − 5 ) with error bounds in ! 2 , when the basis set { s j } rj =1 is given.

Original: The rest of this paper is organized as follows.
Revised: The rest of this paper is organized as follows.

Original: Some preliminaries about quantum information are introduced in Section 2.
Revised: Some preliminaries about quantum information are introduced in Section 2.

Original: In Section 3, we develop an quantum algorithm to solve the NCF problem.
Revised: In Section 3, we develop an quantum algorithm to solve the NCF problem.

Original: In Section 4, we develop an quantum algorithm which aims to read out the target state.
Revised: In Section 4, we develop an quantum algorithm which aims to read out the target state.

Original: We summarize our results and contributions in Section 5.
Revised: We summarize our results and contributions in Section 5.

Original:  P RELIMINARY
Revised:  P RELIMINARY

Original: In this section we present some preliminary concepts.
Revised: In this section we present some preliminary concepts.

Original: Some basic quantum knowledge will be introduced in Section 2.1.
Revised: Some basic quantum knowledge will be introduced in Section 2.1.

Original: Some quantum technics will be introduced in Section 2.2.
Revised: Some quantum technics will be introduced in Section 2.2.

Original: 2. N OTATIONS AND DEFINITIONS
Revised: 2. N OTATIONS AND DEFINITIONS

Original: In this section, we introduce some useful notations and deﬁnitions about quantum computing.
Revised: In this section, we introduce some useful notations and deﬁnitions about quantum computing.

Original: The dirac notation is a standard notation in quantum mechanics to describe the quantum states.
Revised: The dirac notation is a standard notation in quantum mechanics to describe the quantum states.

Original: The form | x 〉 is the state which corresponds to the vector x , and the form 〈 y | is the state which corresponds to the vector y T .
Revised: The form | x 〉 is the state which corresponds to the vector x , and the form 〈 y | is the state which corresponds to the vector y T .

Original: The notation 〈 y | x 〉 denotes the value y T x / ( 󰀂 y 󰀂󰀂 x 󰀂 ) .
Revised: The notation 〈 y | x 〉 denotes the value y T x / ( ! y !! x ! ) .

Original: The notation | y 〉〈 x | denotes the matrix yx T / ( 󰀂 y 󰀂󰀂 x 󰀂 ) .
Revised: The notation | y 〉〈 x | denotes the matrix yx T / ( ! y !! x ! ) .

Original: Quantum state is unitary, which means 󰀂 | x 〉󰀂 2 = 〈 x | x 〉 = 1 .
Revised: Quantum state is unitary, which means ! | x 〉! 2 = 〈 x | x 〉 = 1 .

Original: Thus for vector x ∈ R d , the state | x 〉 is deﬁned as 󰁓 dj =1 x j / 󰀂 x 󰀂 | j 〉 , where x j is the j -th component of vector x and {| j 〉 } dj =1 is the state basis which acts like { e j } dj =1 in classical case.
Revised: Thus for vector x ∈ R d , the state | x 〉 is deﬁned as # dj =1 x j / ! x ! | j 〉 , where x j is the j -th component of vector x and {| j 〉 } dj =1 is the state basis which acts like { e j } dj =1 in classical case.

Original: One could obtain information from the quantum state by performing measurement.
Revised: One could obtain information from the quantum state by performing measurement.

Original: For example, the measurement of | x 〉 on the basis {| j 〉 } dj =1 could randomly produce different index j with probability x 2 j / 󰀂 x 󰀂 2 .
Revised: For example, the measurement of | x 〉 on the basis {| j 〉 } dj =1 could randomly produce different index j with probability x 2 j / ! x ! 2 .

Original: We use [ n ] to denote the set { 1 , 2 , · · · , n } .
Revised: We use [ n ] to denote the set { 1 , 2 , · · · , n } .

Original: We denote the norm 󰀂 · 󰀂 as the 󰀂 · 󰀂 2 norm for vector and the spectral norm for matrix, if there is no more explanation. 
Revised: We denote the norm ! · ! as the ! · ! 2 norm for vector and the spectral norm for matrix, if there is no more explanation. !

Original: 󰀂 A 󰀂 F = ( 󰁓 m i = 󰁓 n j =1 a 2 ij ) 1{+
+} /is the Frobenius norm of matrix A ∈ R m × n .
Revised: A ! F = ( # mi = # nj =1 a 2 ij ) {+
+} /is the Frobenius norm of matrix A ∈ R m × n .

Original: The lowercase form h
Revised: The lowercase form h

Original: i is deﬁned as the i -th column vector of matrix H ∈ R d × d .
Revised: i is deﬁned as the i -th column vector of matrix H ∈ R d × d .

Original: x i is deﬁned as the i -th component of vector x .
Revised: x i is deﬁned as the i -th component of vector x .

Original: The tensor product of two matrix A ∈ R m × n and B ∈ R p × q is deﬁned as C =
Revised: The tensor product of two matrix A ∈ R m × n and B ∈ R p × q is deﬁned as C =

Original: A ⊗ B .
Revised: A ⊗ B .

Original: The tensor product operation could be performed between vectors, since vector is one special kind of matrix.
Revised: The tensor product operation could be performed between vectors, since vector is one special kind of matrix.

Original: The tensor product could be deﬁned between quantum states | x 1 〉 and | x 2 〉 , for example, | x 〉 = | x 1 〉 ⊗ | x 2 〉 . The form | x 1 〉 ⊗ | x 2 〉 could also be written as | x 1 〉 | x 2 〉 .
Revised: The tensor product could be deﬁned between quantum states | x 1 〉 and | x 2 〉 which is written as | x 1 〉 | x 2 〉 .

Original: We present deﬁnitions of smoothness and γ -separation here.
Revised: We present deﬁnitions of smoothness and γ -separation here.

Original: Deﬁnition 1.
Revised: Deﬁnition 1.

Original: (smoothness)
Revised: (smoothness)

Original: A function f : R d → R is L -smooth if it has L -Lipschitz continuous gradient, that is 󰀂∇ f ( x ) − ∇ f ( y ) 󰀂 ≤ L 󰀂 x − y 󰀂 , ∀ x , y ∈ X , where X is the domain of f ( x ) .
Revised: A function f : R d → R is L -smooth if it has L -Lipschitz continuous gradient, that is ! ∇ f ( x ) − ∇ f ( y ) ! ≤ L ! x − y ! , ∀ x , y ∈ X , where X is the domain of f ( x ) .

Original: Deﬁnition 2.
Revised: Deﬁnition 2.

Original: ( γ -separation)
Revised: ( γ -separation)

Original: The set G = { a 1 , a 2 , · · · , a n } is said to be γ -separated if | a i − a j | > γ , ∀ i, j ∈ [ n ] and i ∕ = j .
Revised: The set G = { a 1 , a 2 , · · · , a n } is said to be γ -separated if | a i − a j | > γ , ∀ i, j ∈ [ n ] and i ∕ = j .

Original: Based on these deﬁnitions, we assume that the Hessian H in this article has two properties:
Revised: Based on these deﬁnitions, we assume that the Hessian H in this article has two properties:

Original: Hessian H ∈ R d × d is a r -rank matrix; 2.
Revised: Hessian H ∈ R d × d is a r -rank matrix; 2.

Original: The absolute value of H ’s non-zero eigenvalue is 󰂃 -separated.
Revised: The absolute value of H ’s non-zero eigenvalue is ! -separated.

Original: The ﬁrst property is directly derived from the assumption of previous classical non-convex optimization method (Carmon et al., 2018), and the low-rank Hessian case has been observed in neural networks (Gur-Ari et al., 2018).
Revised: The ﬁrst property is directly derived from the assumption of previous classical non-convex optimization method (Carmon et al., 2018), and the low-rank Hessian case has been observed in neural networks (Gur-Ari et al., 2018).

Original: The second property is assumed such that we could distinguish different eigenvalues by their absolute value.
Revised: The second property is assumed such that we could distinguish different eigenvalues by their absolute value.

Original: We further assume that the Hessian matrix H has the eigen-decomposition H = [-󰁓 rj =
-]
Revised: We further assume that the Hessian matrix H has the eigen-decomposition H = [-󰁓 rj =
-][Equation]

Original: λ j u j u Tj for the convenience of following discussion.
Revised: for the convenience of following discussion.

Original: 2. T ECHNIQUES
Revised: 2. T ECHNIQUES

Original: The motivation idea behind our approach is to perform the quantum singular value estimation model and then generate eigen-states by the post-selection on the output state.
Revised: The motivation idea behind our approach is to perform the quantum singular value estimation model and then generate eigen-states by the post-selection on the output state.

Original: Here we introduce two techniques including oracle models and critical conclusions in previous work.
Revised: Here we introduce two techniques including oracle models and critical conclusions in previous work.

Original: Quantum Oracle Models (Kerenidis & Prakash, 2016):
Revised: Quantum Oracle Models (Kerenidis & Prakash, 2016):

Original: For the whole paper, we assume the existence of following quantum oracles, and discuss the query complexity of our algorithms to these oracles.
Revised: For the whole paper, we assume the existence of following quantum oracles, and discuss the query complexity of our algorithms to these oracles.

Original: Given Hessian H ∈ R d × d , we assume that H is stored in a classical data structure such that the following quantum oracles could be implemented:
Revised: Given Hessian H ∈ R d × d , we assume that H is stored in a classical data structure such that the following quantum oracles could be implemented:

Original: [Equation]
Revised: [Equation]

Original: where ˜ h stands for the d -dimensional vector whose i -th component is 󰀂 h i 󰀂 / 󰀂 H 󰀂 F .
Revised: where ˜ h stands for the d -dimensional vector whose i -th component is ! h i ! / ! H ! F .

Original: The required data structure has a binary tree form.
Revised: The required data structure has a binary tree form.

Original: The sign and square value for each entry are stored in different leaves and the value stored in each parent node is the sum of its children’s value.
Revised: The sign and square value for each entry are stored in different leaves and the value stored in each parent node is the sum of its children’s value.

Original: A detail description about this data structure can be referred to (Kerenidis & Prakash, 2016).
Revised: A detail description about this data structure can be referred to (Kerenidis & Prakash, 2016).

Original: Denote
Revised: Denote

Original: T H as the time complexity of these oracles.
Revised: T H as the time complexity of these oracles.

Original: Quantum Singular Value Estimation (SVE) :
Revised: Quantum Singular Value Estimation (SVE) :

Original: Given matrix H ∈ R d × d which has the eigenvalue decomposition H = 󰁓 rj =

Revised: Given matrix H ∈ R d × d which has the eigenvalue decomposition H = # rj =

Original: λ j u j u j , previous work (Kerenidis & Prakash, 2016) provided a quantum singular value estimation algorithm, which could be used for estimating singular value or generating eigenstate.
Revised: λ j u j u j , previous work (Kerenidis & Prakash, 2016) provided a quantum SVE algorithm, which could be used for estimating singular value or generating eigenstate.

Original: Here we brieﬂy introduce their conclusion about the time complexity of their algorithm:
Revised: Here we brieﬂy introduce their conclusion about the time complexity of their algorithm:

Original: Theorem 3.
Revised: Theorem 3.

Original: (Kerenidis & Prakash, 2016)
Revised: (Kerenidis & Prakash, 2016)

Original: Suppose quantum accesses to oracles (3) and (4) exist.
Revised: Suppose quantum accesses to oracles (3) and (4) exist.

Original: There is an algorithm which could perform the mapping󰁓 j β j | u j 〉 → 󰁓 j β j | u j 〉 | ˆ | λ j | 〉 with time complexity
Revised: There is an algorithm which could perform the mapping

Original: O
Revised: [Equation]

Original:  ( T H polylog( d ) 󰂃 − 1 ) , where ˆ λ j ∈ [ λ j − 󰂃 󰀂
Revised: complexity O ( T H polylog( d ) ! − 1 ) , where ˆ λ j ∈ [ λ j − ! !

Original: H 󰀂 F , λ j + 󰂃 󰀂 H 󰀂 F ] with probability at least− 1 / poly( d ) .
Revised: H ! F , λ j + ! ! H ! F ] with probability at least− 1 / poly( d ) .

Original:  Q UANTUM N EGATIVE C URVATURE F INDING ALGORITHM
Revised:  Q UANTUM N EGATIVE C URVATURE F INDING ALGORITHM

Original: Our main contribution in this section is the quantum Negative Curvature Finding (quantum NCF) algorithm presented in Algorithm 1.
Revised: Our main contribution in this section is the quantum Negative Curvature Finding (quantum NCF) algorithm presented in Algorithm 1.

Original: The quantum NCF algorithm solves the NCF problem by providing the target state | u t 〉 (for case (1)) or making the non-vector statement (for case (2)).
Revised: The quantum NCF algorithm solves the NCF problem by providing the target state | u t 〉 (for case (1)) or making the non-vector statement (for case (2)).

Original: The target state | u t 〉 corresponds to the eigenvector u t which satisﬁes the condition u Tt Hu t ≤ − α + 󰂃 / 2 .
Revised: The target state | u t 〉 corresponds to the eigenvector u t which satisﬁes the condition u Tt Hu t ≤ − α + ! / 2 .

Original: Here we present a tighter restrict on the target state | u t 〉 to keep a 󰂃 / 2 redundancy for the classical read-out of the quantum state.
Revised: Here we present a tighter restrict on the target state | u t 〉 to keep a ! / 2 redundancy for the classical read-out of the quantum state.

Original: The quantum NCF Algorithm uses the Proper Eigenvalue
Revised: The quantum NCF Algorithm uses the Proper Eigenvalue

Original: Labelling (Algorithm 2) and the Target State Generating Algorithm (Algorithm 5 in Appendix) as subroutines proposed in Section 3.2 and Section 3.3, respectively.
Revised: Labelling (Algorithm 2) and the Target State Generating Algorithm (Algorithm 5 in Appendix) as subroutines proposed in Section 3.2 and Section 3.3, respectively.

Revised: u the condition u T Hu ≤ − α

Original: 3. C HALLENGES TO D EVELOP Q UANTUM NCF ALGORITHM
Revised: 3. C HALLENGES TO D EVELOP Q UANTUM NCF ALGORITHM

Original: The core technical component of our quantum algorithm for the NCF problem is the quantum SVE algorithm.
Revised: The core technical component of our quantum algorithm for the NCF problem is the quantum SVE algorithm.

Original: However, there are three major challenges that we have to overcome.
Revised: However, there are three major challenges that we have to overcome.

Original: Firstly, the positive-negative eigenvalue problem.
Revised: Firstly, the positive-negative eigenvalue problem.

Original: In the negative curvature ﬁnding problem, we are interested in obtaining eigenvectors with negative eigenvalues.
Revised: In the negative curvature ﬁnding problem, we are interested in obtaining eigenvectors with negative eigenvalues.

Original: Hence, we cannot directly apply thethat no kind unit vector u which satisﬁes the condition u T Hu ≤ − α quantum SVE algorithm since it only gives the estimation on | λ j | .
Revised: Hence, we cannot directly apply the quantum SVE algorithm since it only gives the estimation on | λ j | .

Original: In order to overcome this critical issue, we develop Algorithm 4 in Appendix to label negative eigenvalues.
Revised: In order to overcome this critical issue, we develop Algorithm 4 in Appendix to label negative eigenvalues.

Original: Secondly, since the quantum SVE Algorithm presents 󰂃 -estimation on singular values with time complexity O ( T H 󰀂 H 󰀂 F polylog( d ) 󰂃 − 1 ) (Theorem 3), we need to provide a tight upper bound for the Frobenius norm 󰀂 H 󰀂 F , which is shown in Lemma 1:
Revised: Secondly, since the quantum SVE Algorithm presents ! -estimation on singular values with time complexity O ( T H !

Revised: H !

Revised: F polylog( d ) !

Revised: − 1 )

Revised: (Theorem 3), we need to provide a tight upper bound for the Frobenius norm !

Revised: H !

Revised: F , which is shown in Lemma 1:

Original: Lemma 1.
Revised: Lemma 1.

Original: Suppose H ∈ R
Revised: Suppose H ∈ R

Original: d × d is the Hessian matrix derived from the function f : R d → R which has the L -Lipschitz continuous gradient.
Revised: d × d is the Hessian matrix derived from the function f : R d → R which has the L -Lipschitz continuous gradient.

Original: Thus the Frobenius norm of H has the upper bound 󰀂 H 󰀂 F ≤ √ rL , where r is the rank of H .
Revised: Thus the Frobenius norm of H has the upper bound ! H ! F ≤ √ rL , where r is the rank of H .

Original: Finally, the input-state problem.
Revised: Finally, the input-state problem.

Original: For the general superposition state 󰁓 j β j | u j 〉 , the output state of quantum SVE algorithm has the form 󰁓 j β j | u j 〉
Revised: For the general superposition state # j β j | u j 〉 , the output state of quantum SVE algorithm has the form # j β j | u j 〉

Original: ||
Revised: ||

Original: ˆ λ j | 〉 .
Revised: ˆ λ j | 〉 .

Original: We could generate different pure state | u j 〉 with probability | β j | 2 by the measurement on eigenvalue register.
Revised: We could generate different pure state | u j 〉 with probability | β j | 2 by the measurement on eigenvalue register.

Original: Thus in order to guarantee a small time complexity, we need to prepare a special input state such that the overlap between the input and the target state is relatively large.
Revised: Thus in order to guarantee a small time complexity, we need to prepare a special input state such that the overlap between the input and the target state is relatively large.

Original: We brieﬂy summarize our conclusion on the time complexity of
Revised: We brieﬂy summarize our conclusion on the time complexity of

Original: Algorithm 1 in Proposition 2.
Revised: Algorithm 1 in Proposition 2.

Original: Proposition 2.
Revised: Proposition 2.

Original: Algorithm 1 takes time O
Revised: Algorithm 1 takes time O

Original: ( T H 
Revised: ( T H !

Original: 󰀂 H 󰀂 5 F polylog( d ) 󰂃 − 1 ) to solve the negative curvature ﬁnding problem by providing the target state | u t 〉 or making the statement that there is no unit vector satisﬁes the condition u T Hu ≤ − α .
Revised: H ! 5 F polylog( d ) ! − 1 ) to solve the negative curvature ﬁnding problem by providing the target state | u t 〉 or making the statement that there is no unit vector satisﬁes the condition u T Hu ≤ − α .

Original: 3. P OSITIVE -N EGATIVE E IGENVALUE D ISCRIMINATION
Revised: 3. P OSITIVE -N EGATIVE E IGENVALUE D ISCRIMINATION

Original: In this section, we propose an algorithm aiming to label the target eigenvalue which is less than − α + 󰂃 / 2 .
Revised: In this section, we propose an algorithm aiming to label the target eigenvalue which is less than − α + ! / 2 .

Original: This algorithm helps verifying the existence of solution to the NCF problem and generating the target state.
Revised: This algorithm helps verifying the existence of solution to the NCF problem and generating the target state.

Original: Since the eigenvalue information of H is unknown to us, we need to build the
Revised: Since the eigenvalue information of H is unknown to us, we need to build the

Original: Algorithm 2 to label the proper eigenvalue, which would beneﬁt the target state generation task in the following section.
Revised: Algorithm 2 to label the proper eigenvalue, which would beneﬁt the target state generation task in the following section.

Original: The proper eigenvalue means the eigenvalue is less than − α + 󰂃 / 2 .
Revised: The proper eigenvalue means the eigenvalue is less than − α + !

Original: We view this kind of eigenvalue as our target eigenvalue.
Revised: We view this kind of eigenvalue as our target eigenvalue.

Original: The mean idea of Algorithm 2 is to use the input state
Revised: The mean idea of Algorithm 2 is to use the input state

Original: [Equation]
Revised: [Equation]

Original: for the quantum SVE model and obtain the state:
Revised: for the quantum SVE model and obtain the state:

Original: [Equation]
Revised: [Equation]

Original: The measurement on the eigenvalue register would lead this entangled state collapse to different states | u j 〉 | u j 〉 for j ∈ [ r ] .
Revised: The measurement on the eigenvalue register would lead this entangled state collapse to different states | u j 〉 | u j 〉 for j ∈ [ r ] .

Original: We could obtain the state | u j 〉 by neglecting the state in any other register.
Revised: We could obtain the state | u j 〉 by neglecting the state in any other register.

Original: Using state | u j 〉 to apply the PNED algorithm (Algorithm 4 in appendix) could provide a discrimination on the positive and negative of the corresponding eigenvalue λ j .
Revised: Using state | u j 〉 to apply the PNED algorithm (Algorithm 4 in appendix) could provide a discrimination on the positive and negative of the corresponding eigenvalue λ j .

Original: Thus, we could label the proper eigenvalue, for the case that the least eigenvalue is less than − α + 󰂃 / 2 ; or make the non-vector statement, for the case that all of eigenvalues are greater than − α .
Revised: Thus, we could label the proper eigenvalue, for the case that the least eigenvalue is less than − α + ! / 2 ; or make the non-vector statement, for the case that all of eigenvalues are greater than − α .

Original: We present the time complexity of Algorithm 2 in Theorem 4.
Revised: We present the time complexity of Algorithm 2 in Theorem 4.

Original: Theorem 4.
Revised: Theorem 4.

Original: Algorithm 2 could label the proper eigenvalue of H with probability 1 − 1 / poly( d ) , or claim with high probability that there is no unit vector u which satisﬁes u T Hu <
Revised: Algorithm 2 could label the proper eigenvalue of H with probability 1 − 1 / poly( d ) , or claim with high probability that there is no unit vector u which satisﬁes u T Hu <

Original: − α , with time
Revised: − α , with time

Original: complexity O
Revised: complexity O

Original: ( T H 
Revised: ( T H !

Original: 󰀂 H 󰀂 5 F polylog( d ) [-󰂃 − 1 ) . 󰀂 H 󰀂 F 󰁓 rj =
-]
Revised: H ! 5 F polylog( d ) [-󰂃 − 1 ) . 󰀂 H 󰀂 F 󰁓 rj =
-]!

Original: λ j | u j j
Revised: − 1 ) .

Original: 3. T ARGET S TATE G ENERATING
Revised: 3. T ARGET S TATE G ENERATING

Original: Suppose the result of Algorithm 2 implies the existence of the target eigenvector u t , which satisﬁes u Tt Hu t ≤ − α + 󰂃 / 2 .
Revised: Suppose the result of Algorithm 2 implies the existence of the target eigenvector u t , which satisﬁes u Tt Hu t ≤ − α + ! / 2 .

Original: Then in order to give a solution to the NCF problem, we need to obtain the vector u t .
Revised: Then in order to give a solution to the NCF problem, we need to obtain the vector u t .

Original: In this section we construct a quantum procedure to generate the state | u t 〉 .
Revised: In this section we construct a quantum procedure to generate the state | u t 〉 .

Original: The classical read-out of | u t 〉 , which means to estimate vector u t from quantum state | u t 〉 , will be discussed in the following section.
Revised: The classical read-out of | u t 〉 , which means to estimate vector u t from quantum state | u t 〉 , will be discussed in the following section.

Original: The idea is very similar to Algorithm 2.
Revised: The idea is very similar to Algorithm 2.

Original: We still use state
Revised: We still use state

Original: [Equation]

Original: 󰁓

Original: [Equation]
Revised: [Equation]

Original: as the input of quantum SVE algorithm to obtain state:
Revised: as the input of quantum SVE algorithm to obtain state:

Original: [Equation]
Revised: [Equation]

Original: Suppose λ t denotes the eigenvalue of | u t 〉 that λ t ≤ − α + 󰂃 / 2 .
Revised: Suppose λ t denotes the eigenvalue of | u t 〉 that λ t ≤ − α + !

Original: The measurement on the eigenvalue register could generate state | u t 〉 | u t 〉 with probability P t = [Equation]
Revised: The measurement on the eigenvalue register could generate state | u t 〉 | u t 〉 with probability P t = λ 2 t " H " 2 F ≥ α 2" H " 2 F .

Original: 󰀂
Revised: Thus the probability of generating at least one state | u t 〉 in N = % 4 " H "

Original: [Equation]
Revised: [Equation]

Original: 2 F .
Revised: 2 log

Original: Thus the probability of generating at least one state | u t 〉 in N = 󰁫

Original: [Equation]
Revised: [Equation]

Original: 󰁬 + 1 times of measurement is 1 − (1 − P t ) N .
Revised: & + 1 times of measurement is 1 − (1 − P t ) N .

Original: There is: 1 − (1 − P t ) N ≥ 1 − e − NP t ≥ 1 − e − log(1 / δ ) =
Revised: There is: 1 − (1 − P t ) N ≥ 1 − e − NP t ≥ 1 − e − log(1 / δ ) =

Original: 1 − δ .
Revised: 1 − δ .

Original: So state | u t 〉 could be generated in N times of measurement with probability at least 1 − δ .
Revised: So state | u t 〉 could be generated in N times of measurement with probability at least 1 − δ .

Original: By considering the time complexity to run the quantum SVE algorithm ( O ( T H 󰀂 H 󰀂 F polylog( d ) 󰂃 − 1 ) ) and setting the probability error bound δ = 1 / poly( d ) , we could derive the time complexity of generating target state in Theorem 5.
Revised: By considering the time complexity to run the quantum SVE algorithm ( O ( T H ! H ! F polylog( d ) ! − 1 ) ) and setting the probability error bound δ = 1 / poly( d ) , we could derive the time complexity of generating target state in Theorem 5.

Original: The detail of Target State Generating algorithm is in Appendix (Algorithm 5).
Revised: The detail of Target State Generating algorithm is in Appendix (Algorithm 5).

Original: Theorem 5.
Revised: Theorem 5.

Original: Suppose that Hessian H has the eigenvector u t with eigenvalue less than − α + 󰂃 2 .
Revised: Suppose that Hessian H has the eigenvector u t with eigenvalue less than − α + ! 2 .

Original: Then state | u t 〉 could be generated in time O
Revised: Then state | u t 〉 could be generated in time O

Original: ( T H 󰀂 H 󰀂 3 F polylog( d ) 󰂃 − 1 ) with probability at least− 1 / poly( d ) .
Revised: ( T H ! H ! 3 F polylog( d ) ! − 1 ) with probability at least− 1 / poly( d ) .

Original:  S TATE R EAD - OUT
Revised:  S TATE R EAD - OUT

Original: In this section, we propose an efﬁcient algorithm to read-out the classical vector u t from the quantum state | u t 〉 .
Revised: In this section, we propose an efﬁcient algorithm to read-out the classical vector u t from the quantum state | u t 〉 .

Original: Generally, the classical read-out of a d -dimensional quantum state takes at least ˜ O
Revised: Generally, the classical read-out of a d -dimensional quantum state takes at least ˜ O

Original: ( d ) times of measurement to obtain the form | x 〉 = 󰁓 di =1 x i e i .
Revised: ( d ) times of measurement to obtain the form | x 〉 = # di =1 x i e i .

Original: Thus the classical read-out of the required state could offset the exponential speed-up (Aaronson, 2015) provided in many quantum machine learning algorithms.
Revised: Thus the classical read-out of the required state could offset the exponential speed-up (Aaronson, 2015) provided in many quantum machine learning algorithms.

Original: In order to avoid this problem, we propose a quantum-classical hybrid procedure to rewrite the target state | u t 〉 as the linear combination of r states, which is selected from column vectors of Hessian H .
Revised: In order to avoid this problem, we propose a quantum-classical hybrid procedure to rewrite the target state | u t 〉 as the linear combination of r states, which is selected from column vectors of Hessian H .

Original: The main result is stated in Proposition 3.
Revised: The main result is stated in Proposition 3.

Original: Proposition 3.
Revised: Proposition 3.

Original: The classical description of the target state | u t 〉 = 󰁓 ri =1 x i | h g ( i ) 〉 1 could be presented in time O
Revised: The classical description of the target state | u t 〉 = [Equation] could be presented in time O

Original: ( T H polylog( d )poly( r ) 󰂃 − 5 ) with error bounds in 󰂃 / 2 , when the complete basis set { h g ( j ) } rj =1 is given.
Revised: ( T H polylog( d )poly( r ) ! − 5 ) with error bounds in ! / 2 , when the complete basis set { h g ( j ) } rj =1 is given.

Original: Recall that our Hessian matrix H ∈ R
Revised: Recall that our Hessian matrix H ∈ R

Original: d
Revised: d

Original: ×
Revised: ×

Original: d has the eigendecomposition H = 󰁓 rj =

Revised: d has the eigendecomposition H = # rj =

Original: λ j u j u Tj , where λ j is the eigenvalue of H with respect to eigenvector u j .
Revised: λ j u j u Tj , where λ j is the eigenvalue of H with respect to eigenvector u j .

Original: Then, any eigenvector of H that corresponds to a non-zero eigenvalue could be represented as the linear combination of vectors in { h j } dj =1 because Hu j = λ
Revised: Then, any eigenvector of H that corresponds to a non-zero eigenvalue could be represented as the linear combination of vectors in { h j } d j =1 because Hu j = λ

Original: j u j can be written as 󰁓 di =1 h
Revised: j u j can be written as # d i =1 h

Original: i u ( i ) j = λ j u j .
Revised: i u ( i ) j = λ j u j .

Original: Since H has the rank of r , there exists a subset of complete basis { h g ( i ) } ri =1 of the column space, which is sampled from the set { h j } dj =1 .
Revised: Since H has the rank of r , there exists a subset of complete basis { h g ( i ) } ri =1 of the column space, which is sampled from the set { h j } dj =1 .

Original: Thus, any eigenvector u j could also be represented as the linear combination of vectors in { h g ( i ) } ri =1 .
Revised: Thus, any eigenvector u j could also be represented as the linear combination of vectors in { h g ( i ) } ri =1 .

Original: Back to the state read-out problem, denote s i as h g ( i ) for simplicity.
Revised: Back to the state read-out problem, denote s i as h g ( i ) for simplicity.

Original: Suppose the target state | u t 〉 that we generated in the previous section can be written as | u t 〉 = 󰁓 ri =1 x i | s i 〉 , where { x i } ri =1 are coordinates of the state | u t 〉 under the basis {| s i 〉 } ri =1 .
Revised: Suppose the target state | u t 〉 that we generated in the previous section can be written as | u t 〉 = # ri =1 x i | s i 〉 , where { x i } ri =1 are coordinates of the state | u t 〉 under the basis {| s i 〉 } ri =1 .

Original: Thus, instead of simply reading out components of vector u t , we could get the classical description of | u t 〉 by calculating each x i .
Revised: Thus, instead of simply reading out components of vector u t , we could get the classical description of | u t 〉 by calculating each x i .

Original: Note that the complete basis {| s i 〉 } ri =1 is not unique and we only need to identify one of them.
Revised: Note that the complete basis {| s i 〉 } ri =1 is not unique and we only need to identify one of them.

Original: Note that the updating operation for the l -th iteration z ( l +1) =

Original: z ( l ) + η u t in general non-convex algorithms does not have a straightforward quantum generalization.

Original: In other words, we could not perform the operation | z ( l +1)

Original: 〉 ∝ | z ( l ) 〉 + η | u t 〉 directly because the target state | u t 〉 is generated by post-selection instead of standard unitary operations.

Original: However, we can use the linear-combinationof-states method (Shao, 2018) to generate the form 󰁓 ri =1 x i | s i 〉 and circumvent the problem caused by the post-selection.

Original: We also notice some recent breakthroughs about quantum-inspired algorithms (Tang, 2019; Arrazola et al., 2019), which are based on sampling technics and FKV Algorithm (Frieze et al., 2004).
Revised: We also notice some recent breakthroughs about quantum-inspired algorithms (Tang, 2019; Arrazola et al., 2019), which are based on sampling technics and FKV Algorithm (Frieze et al., 2004).

Original: These quantum-inspired algorithms could perform approximate SVD which also outputs eigenvector as the linear-sum on a group of column vectors.
Revised: These quantum-inspired algorithms could perform approximate SVD which also outputs eigenvector as the linear-sum on a group of column vectors.

Original: However, in order to cover the whole column space, the quantum-inspired algorithm need to sample at least O ( r 2 󰂃 2 ) number of columns as basis, while our method generate the linear-sum form exactly on r columns.
Revised: However, in order to cover the whole column space, the quantum-inspired algorithm need to sample at least O ( r 2 ! 2 ) number of columns as basis, while our method generate the linear-sum form exactly on r columns.

Original: 4. C OMPLETE B ASIS S ELECTION
Revised: 4. C OMPLETE B ASIS S ELECTION

Original: In this section, we develop a quantum algorithm to select a subset S I
Revised: In this section, we develop a quantum algorithm to select a subset S I

Original: = { g (1) , g (2) , · · · , g ( r ) } from [ d ] , which corresponds to the complete basis {| h g ( i ) 〉 } ri =1 .
Revised: = { g (1) , g (2) , · · · , g ( r ) } from [ d ] , which corresponds to the complete basis {| h g ( i ) 〉 } ri =1 .

Original: The quantum complete basis selection algorithm can be viewed as the quantum version of Gram-Schmidt orthogonalization: ﬁrstly we choose | t 1 〉 = | h g (1) 〉 from the set {| h j 〉 } dj =1 ; then given state set {| t m 〉 } lm =1 , we choose | t l +1 〉 ∝ | h g ( l +1) 〉− 󰁓 lm =1 | t m 〉〈 t m | h g ( l +1) 〉 from the state set {| h j 〉− 󰁓 lm =1 | t m 〉〈 t m | h j 〉 } dj =1 .
Revised: The quantum complete basis selection algorithm can be viewed as the quantum version of Gram-Schmidt orthogonalization: ﬁrstly we choose | t 1 〉 = | h g (1) 〉 from the set {| h j 〉 } d j =1 ; then given state set {| t m 〉 } l m =1 , we choose | t l +1 〉 ∝ | h g ( l +1) 〉 − # lm =1 | t m 〉〈 t m | h g ( l +1) 〉 from the state set {| h j 〉− # lm =1 | t m 〉〈 t m | h j 〉 } dj =1 .

Original: Since the chosen | t l +1 〉 is orthogonal to states {| t m 〉 } l m =1 for each iteration l ∈ [ r − 1] , the state set {|
Revised: Since the chosen | t l +1 〉 is orthogonal to states {| t m 〉 } lm =1 for each iteration l ∈ [ r − 1] , the state set {|

Original: t m 〉 } r m =1 forms an orthonormal basis.
Revised: t m 〉 } rm =1 forms an orthonormal basis.

Original: Note that the state | t m 〉 is generated along with an index g ( m ) for m ∈
Revised: Note that the state | t m 〉 is generated along with an index g ( m ) for m ∈

Original: [ r ] , so we would obtain a complete basis index set { g ( m ) } rm =1 after the implementation of this quantum algorithm.
Revised: [ r ] , so we would obtain a complete basis index set { g ( m ) } rm =1 after the implementation of this quantum algorithm.

Original: The quantum complete basis selection algorithm is provided in Algorithm 3, in which we denote:
Revised: The quantum complete basis selection algorithm is provided in Algorithm 3, in which we denote:

Original: [Equation]
Revised: [Equation]

Original: as the initial state in each iteration.
Revised: as the initial state in each iteration.

Original: The time complexity of Algorithm 3 is analyzed in Theorem 6.
Revised: The time complexity of Algorithm 3 is analyzed in Theorem 6.

Original: The detail about Algorithm 3 is in Appendix.
Revised: The detail about Algorithm 3 is in Appendix.

Original: We also provide Lemma 2 which provides the time complexity of conﬁrming whether a given set { s i } ri =1 are linearly independent.
Revised: We also provide Lemma 2 which provides the time complexity of conﬁrming whether a given set { s i } ri =1 are linearly independent.

Original: Theorem 6.
Revised: Theorem 6.

Original: The Algorithm 3 takes time
Revised: The Algorithm 3 takes time

Original: O ( T H poly( r ) 󰂃 − 2 r 2log(4 r 󰀂 H 󰀂 F / 󰂃 ) ) to ﬁnd an index set { g ( i ) } ri =1 , which forms a complete basis {| h g ( i ) 〉 } ri =1 with probability at least 3/4. 
Revised: O ( T H poly( r ) ! − 2 r 2log(4 r " H " F / ! ) ) to ﬁnd an index set { g ( i ) } ri =1 , which forms a complete basis {| h g ( i ) 〉 } ri =1 with probability at least 3/4. [Equation] [Equation]

Revised: [Equation]

Revised: [Equation]

Original: Lemma 2.
Revised: Lemma 2.

Original: It takes O ( r 3 ) time to check whether the vector set { s i } ri =1 is linearly independent when the classical access to Hessian H is given, where s i is sampled from column vectors of matrix H .[Equation] 󰁓 [Equation]
Revised: It takes O ( r 3 ) time to check whether the vector set { s i } ri =1 is linearly independent when the classical access to Hessian H is given, where s i is sampled from column vectors of matrix H .

Original: [Equation]

Original: [Equation]

Original: t

Original:  C OORDINATES E STIMATION
Revised: 4. C OORDINATES E STIMATION

Original: Assume the complete basis {| s 1 〉 , | s 2 〉 , · · · , | s r 〉 } has been selected out in Section 4.1.
Revised: Assume the complete basis {| s 1 〉 , | s 2 〉 , · · · , | s r 〉 } has been selected out in Section 4.1.

Original: Thus the read-out problem could be viewed as solving the equation | u t 〉 = 󰁓 ri =1 x i | s i 〉 , where x i ∈ R are unknown variables.
Revised: Thus the read-out problem could be viewed as solving the equation | u t 〉 = # ri =1 x i | s i 〉 , where x i ∈ R are unknown variables.

Original: The coordinate { x i } ri =1 could be obtained by solving the r -dimensional linear equation system
Revised: The coordinate { x i } ri =1 could be obtained by solving the r -dimensional linear equation system

Original: Cx = b , where b i = 〈 u t | s i 〉 and c ij =
Revised: Cx = b , where b i = 〈 u t | s i 〉 and c ij =

Original: 〈 s i | s j 〉 for i, j ∈ [ r ] .
Revised: 〈 s i | s j 〉 for i, j ∈ [ r ] .

Original: The equation Cx = b could be solved classically in at most O ( r 3 ) time.
Revised: The equation Cx = b could be solved classically in at most O ( r 3 ) time.

Original: Note that we can only get the approximation to c ij or b i instead of the exact value.
Revised: Note that we can only get the approximation to c ij or b i instead of the exact value.

Original: Theorem 7 veriﬁes the impact of the approximate error to c ij or b i on the read-out of the target state.
Revised: Theorem 7 veriﬁes the impact of the approximate error to c ij or b i on the read-out of the target state.

Original: Theorem 7.
Revised: Theorem 7.

Original: Suppose ˜ c jk is the 󰂃 1 -approximation to c jk = 〈 s j | s k 〉 and ˜ 
Revised: Suppose ˜ c jk is the ! 1 -approximation to c jk = 〈 s j | s k 〉 and ˜ b

Original: b

Original: j is the 󰂃 2 -approximation to b j = 〈 u t | s j 〉 , ∀ j, k ∈ [ r ] , where 󰂃 1 = 󰂃 6 r 2 󰀂 C − 1 󰀂 2 and [-󰂃 
-]
Revised: j is the ! 2 -approximation to b j = 〈 u t | s j 〉 , ∀ j, k ∈ [ r ] , where ! 1 = ! 6 r 2 " C − 1 " 2 and [-󰂃 
-]! 2 = !

Original: = 󰂃 6 r 󰀂 C − 1 󰀂 .
Revised: 6 r " C − 1 " .

Original: Denote vector ˜ x ∈ R r as the solution of ˜ Cx = ˜ b .
Revised: Denote vector ˜ x ∈ R r as the solution of ˜ Cx = ˜ b .

Original: Then ˜ x could lead an approximate eigenvector ˜ u t = 󰁓 rj =1 ˜ x
Revised: Then ˜ x could lead an approximate eigenvector ˜ u t = # rj =1 ˜ x

Original: j s j , such that 󰀂 ˜
Revised: j s j , such that ! ˜

Original: u t − u t 󰀂 ≤ 󰂃 / 2 .
Revised: [Equation] ≤ ! / 2 .

Original: We propose several methods in Appendix to estimate overlap b i = 〈 u t | s i 〉 and c ij =
Revised: We propose several methods in Appendix to estimate overlap b i = 〈 u t | s i 〉 and c ij =

Original: 〈 s i | s j 〉 , which are based on the Quantum SWAP Test (Buhrman et al., 2001) and the Hadamard Test.
Revised: 〈 s i | s j 〉 , which are based on the Quantum SWAP Test (Buhrman et al., 2001) and the Hadamard Test.

Original: Our proposed quantum algorithms could present 󰂃 1 -estimation to c ij = 〈 s i | s j 〉 in time
Revised: Our proposed quantum algorithms could present ! 1 -estimation to c ij = 〈 s i | s j 〉 in time

Original: O ( T H 󰂃 − 2 1 ) and 󰂃 2 -estimation to b i = 〈 u t | s i 〉 in time O
Revised: O ( T H ! − 2 1 ) and ! 2 -estimation to b i = 〈 u t | s i 〉 in time O

Original: (( T Input + T H ) 󰂃 − 4 2 ) , where T Input is the time to generate state | u t 〉 .
Revised: (( T Input + T H ) ! − 4 2 ) , where T Input is the time to generate state | u t 〉 .

Original: Since the time complexity to generate the target state is O ( T H 󰀂 H 󰀂 3 F polylog( d ) 󰂃 − 1 ) as proposed in Theorem 5, we could derive Proposition 3.
Revised: Since the time complexity to generate the target state is O ( T H ! H ! 3 F polylog( d ) ! − 1 ) as proposed in Theorem 5, we could derive Proposition 3.

Original: Considering the time complexity O 
Revised: Considering the time complexity O ( T H !

Original: ( T H 
Revised: H !

Original: 󰀂 H 󰀂 5 F polylog( d ) 󰂃 − 1 ) to label the proper eigenvalue and the time complexityO
Revised: 5 F polylog( d ) ! − 1 ) to label the proper eigenvalue and the time complexity

Original: ( T H poly( r ) 󰂃 − 2 r 2log(4 r 󰀂 H 󰀂 F / 󰂃 ) ) to generate the complete basis set, we could solve the NCF problem in time

Original: O
Revised: O

Original: ( T H polylog( d )poly( r ) 󰂃 − 2( 󰂃 − 3 + r 2log(4 r 󰀂 H 󰀂 F / 󰂃 ) ))
Revised: ( T H poly( r ) ! − 2 r 2log(4 r " H " F / ! ) ) to generate the complete basis set, we could solve the NCF problem in time O ( T H polylog( d )poly( r ) !

Original:  by providing the target vector in the form u t = 󰁓 r i =1 x 
Revised: − 2 ( ! − 3 + r 2log(4 r " H " F / ! ) )) by providing the target vector in the form u t = # ri =1 x i h g ( i ) / !

Original: i h g ( i ) /
Revised: h g ( i ) !

Original: 󰀂 h g ( i ) 󰀂 with error bounded by 󰂃 or making the non-vector statement.
Revised: with error bounded by ! or making the non-vector statement.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: We propose an efﬁcient quantum algorithm for the Negative Curvature Finding problem, which is a critical subroutine in many second-order methods for non-convex optimization.
Revised: We propose an efﬁcient quantum algorithm for the Negative Curvature Finding problem, which is a critical subroutine in many second-order methods for non-convex optimization.

Original: The proposed quantum algorithm could produce the target state in time
Revised: The proposed quantum algorithm could produce the target state in time

Original: O ( T H 󰂃 − 1 poly( r )polylog( d )) with probability 1 − 1 / poly( d ) , which runs exponentially faster than existing classical methods.
Revised: O ( T H ! − 1 poly( r )polylog( d )) with probability 1 − 1 / poly( d ) , which runs exponentially faster than existing classical methods.

Original: Moreover, we propose an efﬁcient hybrid quantum-classical algorithm for the efﬁcient classical read-out of the target state with time
Revised: Moreover, we propose an efﬁcient hybrid quantum-classical algorithm for the efﬁcient classical read-out of the target state with time

Original: complexity
Revised: complexity

Original: O
Revised: O

Original: ( T H poly( r )polylog( d ) 󰂃 − 2 ( 󰂃 − 3 + r 2log(4 r 󰀂 H 󰀂 F / 󰂃 ) )) , which is exponentially faster on the degree of d than existing general quantum state read-out methods.
Revised: ( T H poly( r )polylog( d ) ! − 2 ( ! − 3 + r 2log(4 r " H " F / ! ) )) , which is exponentially faster on the degree of d than existing general quantum state read-out methods.

Original: A A PPENDIX A. T HE PROOF OF T HEOREM
Revised: A A PPENDIX A. T HE PROOF OF T HEOREM

Original: Proof.
Revised: Proof.

Original: The time complexity of Algorithm 1 could be directly obtained by the time complexity of
Revised: The time complexity of Algorithm 1 could be directly obtained by the time complexity of

Original: Algorithm 2 and Algorithm 5, whose complexity analysis are presented in Theorem 4 and Theorem 5, respectively.
Revised: Algorithm 2 and Algorithm 5, whose complexity analysis are presented in Theorem 4 and Theorem 5, respectively.

Original: A. T HE PROOF OF L EMMA
Revised: A. T HE PROOF OF L EMMA

Original: Proof.
Revised: Proof.

Original: Assume λ 1 ≤ λ 2 ≤ · · · ≤ λ d are eigenvalues of H , we have:
Revised: Assume λ 1 ≤ λ 2 ≤ · · · ≤ λ d are eigenvalues of H , we have:

Original: [Equation]
Revised: [Equation]

Original: By the deﬁnition of the Hessian matrix, for unit vector v , we have:
Revised: By the deﬁnition of the Hessian matrix, for unit vector v , we have:

Original: [Equation]
Revised: [Equation]

Original: From above equation, we can obtain:
Revised: From above equation, we can obtain:

Original: [Equation]
Revised: [Equation]

Original: and 
Revised: and v T Hv ≥ −! v ! · ! Hv ! ≥ − lim h → 0 "∇ f ( x + h v ) −∇ f

Revised: ( x

Original: [Equation]
Revised: [Equation]

Original:  Thus, the eigenvalue λ j is bounded in [ − L, L ] for all j ∈ [ d ] .
Revised: h [Equation] = − L . Thus, the eigenvalue λ j is bounded in [ − L, L ] for all j ∈ [ d ] .

Original: We have 󰀂 H 󰀂 2 F = 
Revised: We have ! H ! 2 F = #

Original: [Equation]
Revised: [Equation]

Revised: rL 2 , so !

Revised: H !

Revised: F ≤ √ rL .

Original: Lemma 3.
Revised: Lemma 3.

Original: Hoeffding’s inequality (Hoeffding, 1994)
Revised: Hoeffding’s inequality (Hoeffding, 1994)

Original: Suppose X 1 , X 2 , · · · , X n are independent random variables with bounds X i ∈
Revised: Suppose X 1 , X 2 , · · · , X n are independent random variables with bounds X i ∈

Original: [ a i , b i ] , ∀ i ∈ [ n ] .
Revised: [ a i , b i ] , ∀ i ∈ [ n ] .

Original: Deﬁne X = 1 n 󰁓 ni =1 X
Revised: Deﬁne X = 1 n # n i =

Original:  i , then ∀ 󰂃 > 0 , we have:
Revised: 1 X i , then ∀ ! > 0 , we have:

Original: [Equation]
Revised: [Equation]

Original: and
Revised: and

Original: [Equation]
Revised: [Equation]

Original: A. T HE DETAIL ABOUT A LGORITHM
Revised: A. T HE DETAIL ABOUT A LGORITHM

Original: In Algorithm 4, P ∈ R d 2 × d is the matrix whose column vector p i =
Revised: In Algorithm 4, P ∈ R d 2 × d is the matrix whose column vector p i =

Original: e i ⊗ h i󰀂
Revised: e i ⊗ h i

Original:  h i 󰀂 for i ∈ [ d ] , and
Revised: " h i " for i ∈ [ d ] , and

Original: Q ∈ R d 2 × d is the matrix whose column vector q j = ˜h
Revised: Q ∈ R d 2 × d is the matrix whose column vector q j = ˜

Original: 󰀂 H 󰀂 F ⊗ e j for j ∈ [ d ] .
Revised: h " H " F ⊗ e j for j ∈ [ d ] .

Original: h i is the i -th column vector of matrix H and ˜
Revised: h i is the i -th column vector of matrix H and ˜

Original: h is a d -dimensional vector whose i -th component is 󰀂 h i 󰀂 .
Revised: h is a d -dimensional vector whose i -th component is ! h i ! .

Original: It can be directly obtained that the matrix P and Q satisfy the decomposition H / 󰀂 H 󰀂 F = P T Q and have property
Revised: It can be directly obtained that the matrix P and Q satisfy the decomposition H / ! H ! F = P T Q and have property

Original: P T P = Q T Q
Revised: P T P = Q T Q

Original: = I .
Revised: = I .

Original: Mappings | x 〉 | 0 〉 → | P x 〉 and | 0 〉 | x 〉 → | Qx 〉 can be performed by the quantum oracle U
Revised: Mappings | x 〉 | 0 〉 → | P x 〉 and | 0 〉 | x 〉 → | Qx 〉 can be performed by the quantum oracle U

Original: H and V H respectively.
Revised: H and V H respectively.

Original: Theorem 8.
Revised: Theorem 8.

Original: Positive-negative eigenvalue discrimination.
Revised: Positive-negative eigenvalue discrimination.

Original: For eigenvalue λ of H with property | λ | ≥ a , one could run Algorithm 4 for n = [-
 [ 󰀂-] H 󰀂 2 F alog 1 δ − 12 ] + 3 times, to make a statement that λ is positive or negative, with probability 1 − δ .
Revised: For eigenvalue λ of H with property | λ | ≥ a , one could run Algorithm 4 for n = [-
 [ 󰀂-]2[ " H " 2 F alog 1 δ − 12 ] + 3 times, to make a statement that λ is positive or negative, with probability 1 − δ .

Original: Proof.
Revised: Proof.

Original: The measurement in step 6 of Algorithm 4 outputs 1 with probability:
Revised: The measurement in step 6 of Algorithm 4 outputs 1 with probability:

Original: [Equation]
Revised: [Equation]

Original: Note that 〈 P u | Qu 〉
Revised: Note that 〈 P u | Qu 〉

Original: =
Revised: =

Original: u T P T Qu =
Revised: u T P T Qu =

Original: [Equation]
Revised: [Equation]

Original: u T Hu = λ
Revised: [Equation]

Original: 󰀂

Original: [Equation]
Revised: [Equation]

Original: 󰀂 F , so P (1) = 
Revised: F , so P (1) = [Equation]

Original: 1 −λ / 󰀂 H 󰀂
Revised: −

Original: [Equation]
Revised: [Equation]

Original:  Similarly we have P (0)
Revised: / " H " F. Similarly we have P (0)

Original: = 1+ λ / 󰀂 H 󰀂 F.
Revised: = 1+ λ / " H " F.

Original: Suppose that we need 2 x +1 times of measurement to give an 1 − δ correct statement about whether λ > 0 or λ < 0 .
Revised: Suppose that we need 2 x +1 times of measurement to give an 1 − δ correct statement about whether λ > 0 or λ < 0 .

Original: The problem can be viewed as the biased coin problem.
Revised: The problem can be viewed as the biased coin problem.

Original: Deﬁne random variables
Revised: Deﬁne random variables

Original: X i such that P ( X i = 1) =
Revised: X i such that P ( X i = 1) =

Original: p and P ( X i = 0)
Revised: p and P ( X i = 0)

Original: = 1 − p and S n = 󰁓 ni =1 X i .
Revised: = 1 − p and S n = # ni =1 X i .

Original: Then there has the
Revised: Then there has the

Original: Hoeffding’s inequality P ( S n /n − p ≤ − 󰂃 ) ≤ e − 2 n 󰂃 2 and P ( S n /n − p ≥ 󰂃 )
Revised: Hoeffding’s inequality P ( S n /n − p ≤ − ! ) ≤ e − 2 n ! 2 and P ( S n /n − p ≥ ! )

Original: ≤ e − 2 n 󰂃 2 .
Revised: ≤ e − 2 n ! 2 .

Original: Back to the problem, suppose λ < 0 , by setting n = 2 x + 1 , n ( p − 󰂃 )
Revised: Back to the problem, suppose λ < 0 , by setting n = 2 x + 1 , n ( p − ! )

Original: = x and P = 1 − λ / 󰀂 H 󰀂 F, we have:
Revised: = x and P = 1 − λ / " H " F, we have:

Original: [Equation]
Revised: [Equation]

Original: Similarly for λ > 0 , there is P ( S 2 x +1 ≥ x ) ≤ e − 2 x + a󰀂 H 󰀂 2 F .
Revised: Similarly for λ > 0 , there is P ( S 2 x +1 ≥ x ) ≤ e − 2 x + a" H " 2 F .

Original: Let e − 2 x + a󰀂 H 󰀂 2 F ≤ δ , we have x ≥ [ 󰀂 H 󰀂 2 F alog 1 δ − 12 ] + 1 .
Revised: Let e − 2 x + a" H " 2 F ≤ δ , we have x ≥ [ " H " 2 F alog 1 δ − 12 ] + 1 .

Original: A. T HE PROOF OF T HEOREM
Revised: A. T HE PROOF OF T HEOREM

Original: Proof.
Revised: Proof.

Original: The input state [Equation] rj=
Revised: The input state " H " F # rj

Original: [Equation]
Revised: [Equation]

Original: λ [Equation] | u j 〉 | u j 〉 could be generated with oracles U H and V H :
Revised: λ j | u j 〉 | u j 〉 could be generated with oracles U H and V H :

Original: [Equation]
Revised: [Equation]

Original: Since H has the eigen-decomposition H = 󰁓 rk =1 λ k u
Revised: Since H has the eigen-decomposition H = # rk =1 λ k u

Original: k u Tk , we could rewrite entry h ij as h ij = 󰁓 rk =1 λ k u
Revised: k u Tk , we could rewrite entry h ij as h ij = [Equation] =1 λ k u

Original: ( i ) k u ( j ) k , where u ( i ) k is the i -th component of vector u k .
Revised: ( i ) k u ( j ) k , where u ( i ) k is the i -th component of vector u k .

Original: Thus the state 󰀂 H 󰀂 F 󰁓 di
Revised: Thus the state "

Original: [Equation]
Revised: [Equation]

Original: 󰁓

Original: [Equation]
Revised: [Equation]

Original:  could be written as:
Revised: i 〉 | j 〉 could be written as:

Original: [Equation]
Revised: [Equation]

Original: Then we apply the quantum SVE model on this state.
Revised: Then we apply the quantum SVE model on this state.

Original: In order to give 󰂃 / 4 -estimation on the singular value, the time complexity to run the quantum SVE algorithm is O ( T H 󰀂 H 󰀂 F polylog( d ) 󰂃 − 1 ) by
Revised: In order to give ! / 4 -estimation on the singular value, the time complexity to run the quantum SVE algorithm is O ( T H ! H ! F polylog( d ) ! − 1 ) by

Original: Theorem 3.
Revised: Theorem 3.

Original: Suppose there are eigenvalues λ j which are less than − α + 󰂃 / 2 .
Revised: Suppose there are eigenvalues λ j which are less than − α + !

Original: We denote the least one as λ t and label it as the proper eigenvalue.
Revised: We denote the least one as λ t and label it as the proper eigenvalue.

Original: By Theorem 8, we need to generate n t = 

Revised: By Theorem 8, we need to generate n t =

Original: [ 󰀂 H 󰀂 [Equation] numbers of state | u t 〉 in order to guarantee that λ t < 0 with probability 1 − δ .
Revised: [ " H " 2 F λ 2 t log 1 δ − 12 ] +numbers of state | u t 〉 in order to guarantee that λ t < 0 with probability 1 − δ .

Original: Note that the probability of generating state | u t 〉 in each iteration of step 2-4 in Algorithm 2 is P t = λ 2 t 󰀂 H 󰀂 2 F .
Revised: Note that the probability of generating state | u t 〉 in each iteration of step 2-4 in Algorithm 2 is P t = λ 2 t " H " 2 F .

Original: So averagely we need to perform step 2-4 in Algorithm 2 for n = 󰀂 H 󰀂 2 F λ 2 t { 2[ 󰀂 H 󰀂 2 F λ 2 t log 1 δ − 12 ] + 3 } times.
Revised: So averagely we need to perform step 2-4 in Algorithm 2 for n = " H " 2 F λ 2 t { 2[ " H " 2 F λ 2 t log 1 δ − 12 ] + 3 } times.

Original: The number n can be roughly upper bounded by 4 󰀂 H 󰀂 2 F α(2 4 󰀂 H 󰀂 2 F αlog 1 δ +3) , since for negative curvature case 󰂃 <
Revised: The number n can be roughly upper bounded by 4 " H " 2 F α(2 4 " H " 2 F αlog 1 δ +3) , since for negative curvature case ! <

Original: α , we have | λ t | = α − 󰂃 / 2 > α / 2 .
Revised: α , we have | λ t | = α − ! / 2 > α / 2 .

Original: By considering the time complexity to run the quantum
Revised: By considering the time complexity to run the quantum

Original: SVE algorithm ( O ( T H 󰀂 H 󰀂 F polylog( d ) 󰂃 − 1 ) ) and setting the probability error bound δ = 1 / poly( d ) , we could derive that the time complexity of Algorithm 2 is O ( T H 
Revised: SVE algorithm ( O ( T H ! H ! F polylog( d ) ! − 1 ) ) and setting the probability error bound δ = 1 / poly( d ) , we could derive that the time complexity of Algorithm 2 is O ( T H !

Original: 󰀂 H 󰀂 5 F polylog( d ) 󰂃 − 1 ) .
Revised: H ! 5 F polylog( d ) ! − 1 ) .

Original: A. T ARGET S TATE G ENERATING ALGORITHM
Revised: A. T ARGET S TATE G ENERATING ALGORITHM

Original: Algorithm [Equation]
Revised: Output α for to % 4 " H " 2 F

Original:  log
Revised: 2 log

Original: [Equation]

Original: 󰁬 + 
Revised: & + 1 do

Original: 󰀂 H  F 󰁓 rj =

Revised: Create state " H " F # rj =

Original: λ j | u  〉 | u 
Revised: λ j | u j 〉 | u j 〉 .

Original: Apply the quantum SVE model to obtain the state 󰀂 H 󰀂 F 󰁓 rj [-=
-] λ j | u j 〉 | u j 〉
Revised: Apply the quantum SVE model to obtain the state " H " F # rj [-=
-]=1 λ j | u j 〉 | u j 〉

Original: || ˜
Revised: || ˜

Original: λ
Revised: λ

Original: j | 〉 , where | ˜ λ
Revised: j | 〉 , where | ˜ λ

Original: j | ∈ | λ j | ± 󰂃 / 4 with probability 1 − 1 / poly( d ) .
Revised: j | ∈ | λ j | ± ! / 4 with probability 1 − 1 / poly( d ) .

Original: Measure the eigenvalue register and mark the result.
Revised: Measure the eigenvalue register and mark the result.

Original:  the eigenvalue measured in  step 4 is labelled to be proper in Algorithm 2, then 6: output the state in the ﬁrst register as the target state.
Revised: 5: if the eigenvalue measured in in step 4 is labelled to be proper in Algorithm 2, then 6: output the state in the ﬁrst register as the target state.

Original: 7: end if 8: end for
Revised: 7: end if 8: end for

Original: A. T HE DETAIL ABOUT A LGORITHM
Revised: A. T HE DETAIL ABOUT A LGORITHM

Original: Consider the state:
Revised: Consider the state:

Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: we note that the state | φ ( l ) 1 〉 in Step 3 of Algorithm 3 can be generated by the following procedure: 󰀗
Revised: we note that the state | φ ( l ) 1 〉 in Step 3 of Algorithm 3 can be generated by the following procedure: .

Original: [Equation]
Revised: [Equation]

Original: In step (a), we employ the quantum oracles U H V H on ancillas
Revised: In step (a) [Equation] we employ the quantum oracles U H V H on ancillas

Original: | 0 〉 | 0 〉 .
Revised: | 0 〉 | 0 〉 .

Original: In step (b), an auxiliary register | 0 〉 is appended, followed by a Hadamard gate.
Revised: In step (b), an auxiliary register | 0 〉 is appended, followed by a Hadamard gate.

Original: In step (c), we apply operation󰁔 lm =

Revised: In step (c), we apply operation lm =

Original: [ R m ⊗ | 0 〉〈 

Revised: [ R m ⊗ | 0 〉〈

Original: | + I ⊗ | 1 〉〈 1 | ] .
Revised: | + I ⊗ | 1 〉〈 1 | ] .

Original: The operation R m is deﬁned on the register | g (1) 〉 , · · · | g ( m ) 〉 , | h j 〉 :
Revised: The operation R m is deﬁned on the register | g (1) 〉 , · · · | g ( m ) 〉 , | h j 〉 :

Original: [Equation]
Revised: [Equation]

Original: In step (d), we apply the Hadamard gate on the auxiliary register.
Revised: In step (d), we apply the Hadamard gate on the auxiliary register.

Original: In step (e), we trace out registers󰁔 lj =1 | g
Revised: In step (e), we trace out registers lj [Equation] g

Original: ( j ) 〉 to generate state | φ ( l ) 1 〉 .
Revised: [Equation] j [Equation] 〉 to generate state | φ ( l ) 1 〉 .

Original: The crucial part in Algorithm 3 is to implement the reﬂection R m .
Revised: The crucial part in Algorithm 3 is to implement the reﬂection R m .

Original: For the m + 1 case, there is:
Revised: For the m + 1 case, there is:

Original: [Equation]
Revised: [Equation]

Original: Note that {| t i 〉 } forms the orthogonal basis: 〈 t i | t j 〉 = 0 , ∀ i ∕ = j , and Z m +

Revised: Note that {| t i 〉 } forms the orthogonal basis: 〈 t i | t j 〉 = 0 , ∀ i ∕ = j , and Z m +

Original: = 〈 t m +

Revised: = 〈 t m +

Original: | s m +1 〉 = 
Revised: | s m +1 〉 = !

Original: 󰀂 | s m +1 〉 −
Revised: | s m + [Equation] −

Original: [Equation]
Revised: [Equation]

Original: Denote | t i 〉 ≡ 󰁓 ij =1 x ij | s j 〉 .
Revised: Denote | t i 〉 ≡ # ij =1 x ij | s j 〉 .

Original: The restriction that | t m +1 〉 is normalized and orthogonal to states | s 1 〉 , | s 2 〉 , · · · | s m 〉 could yield Equation (17):
Revised: The restriction that | t m +1 〉 is normalized and orthogonal to states | s 1 〉 , | s 2 〉 , · · · | s m 〉 could yield Equation (17):

Original: [Equation]
Revised: [Equation]

Original: Note that x m +1 ,m +1 = 1 /Z m +1 by Equation (16).
Revised: Note that x m +1 ,m +1 = 1 /Z m +1 by Equation (16).

Original: Deﬁne the m -dimensional vectors x , b , and the m × m matrix C m to be:
Revised: Deﬁne the m -dimensional vectors x , b , and the m × m matrix C m to be:

Original: [Equation]
Revised: [Equation]

Original: where each value c ij =
Revised: where each value c ij =

Original: 〈 s i | s j 〉 could be estimated by Hadamard Test.
Revised: 〈 s i | s j 〉 could be estimated by Hadamard Test.

Original: Thus, we could derive the following linear equations about x from Equation (17):
Revised: Thus, we could derive the following linear equations about x from Equation (17):

Original: [Equation]
Revised: [Equation]

Original: We could obtain the coordinate { x m +1 ,i } m +1 i =1 by solving Equation (18).
Revised: We could obtain the coordinate { x m +1 ,i } m +1 i =1 by solving Equation (18).

Original: There is:
Revised: There is:

Original: [Equation]
Revised: [Equation]

Original: where matrix C ( i ) m denotes the matrix generated from C m by replacing the i -th column with b .
Revised: where matrix C ( i ) m denotes the matrix generated from C m by replacing the i -th column with b .

Original: Suppose now we have obtained the linear combination form | t m +1 〉 =[-󰁓 m +
-]
Revised: Suppose now we have obtained the linear combination form | t m +1 〉 =[-󰁓 m +
-]

Original: i = 1 x m +1 ,i | s i 〉 .
Revised: [Equation]

Original: Thus, we could construct a unitary to generate the state󰁫
Revised: Thus, we could construct a unitary to generate the state

Original: 󰁔 m +1 j =1 |g
Revised: [Equation] |

Original: ( j ) 〉 󰁬
Revised: [Equation]

Original: | t m +1 〉 from the state 󰁫
Revised: from the state %m [Equation]

Original: 󰁔 m +1 j =1 | g
Revised: = [Equation] | g

Original: ( j ) 〉 󰁬 | 0 〉 , by the linear-combination-of-states method (Shao, 2018).
Revised: [Equation] j ) 〉 & | 0 〉 , by the linear-combination-of-states method (Shao, 2018).

Original: The idea of linear combination of states was introduced in Shao (2018), which focuses on the following problem: given quantum states | a 〉 and | b 〉 , to prepare the state | c 〉 = 1 Z c ( x | a 〉 + y | b 〉 ) .
Revised: The idea of linear combination of states was introduced in Shao (2018), which focuses on the following problem: given quantum states | a 〉 and | b 〉 , to prepare the state | c 〉 = 1 Z c ( x | a 〉 + y | b 〉 ) .

Original: The method is based on the fact that R 2 θ =
Revised: The method is based on the fact that R 2 θ =

Original: ( I − 2 | b 〉〈 b | )( I − 2 | a 〉〈 a | ) can be viewed as the clockwise rotation in the plane spanned by | a 〉 and | b 〉 with angle 2 θ , where θ = arccos 〈 a | b 〉 is the angle between | a 〉 and | b 〉 .
Revised: ( I − 2 | b 〉〈 b | )( I − 2 | a 〉〈 a | ) can be viewed as the clockwise rotation in the plane spanned by | a 〉 and | b 〉 with angle 2 θ , where θ = arccos 〈 a | b 〉 is the angle between | a 〉 and | b 〉 .

Original: Thus any clockwise rotation in space SPAN {| a 〉 , | b 〉 } with angle φ could be written as R φ =
Revised: Thus any clockwise rotation in space SPAN {| a 〉 , | b 〉 } with angle φ could be written as R φ =

Original: R φ / 2 θ 2 θ .
Revised: R φ / 2 θ 2 θ .

Original: For the case | c 〉 = 1 Z c ( x | a 〉 + y | b 〉 ) , there is | c
Revised: For the case | c 〉 = 1 Z c ( x | a 〉 + y | b 〉 ) , there is | c

Original: =
Revised: =

Original: R φ | a 〉 , where φ = arccos x + y 〈 a | b 〉 Z c = arccos x + y 〈 a | b 〉 √ x 2 + y 2 +

Revised: R φ | a 〉 , where φ = arccos x + y 〈 a | b 〉 Z c = [Equation] 2 + y 2 +

Original: xy 〈 a | b 〉 .
Revised: xy 〈 a | b 〉 .

Original: The linear sum of 2 states could be generalized to n case:
Revised: The linear sum of 2 states could be generalized to n case:

Original: Theorem 9.
Revised: Theorem 9.

Original: (Shao, 2018)
Revised: (Shao, 2018)

Original: Assume state | φ i 〉 could be prepared by given unitary operation in time T in , for i ∈ [ n ] .
Revised: Assume state | φ i 〉 could be prepared by given unitary operation in time T in , for i ∈ [ n ] .

Original: Then there is a unitary which could prepare the state | φ 〉 =
Revised: Then there is a unitary which could prepare the state | φ 〉 =

Original: [Equation]{+# ni =
+}
Revised: {+# ni =
+}

Original:  i 〉 in time
Revised: α i | φ i 〉 in time

Original: O ( T in n log( n/ 󰂃 ) ) with error 󰂃 .
Revised: O ( T in n log( n/ ! ) ) with error ! .

Original: Note that here we actually perform the state | t ′ m +1 〉 = | g (1) 〉 | g (2) 〉 · · · | g ( m + 1) 〉 | t m +1 〉 from states {| g (1) 〉 | g (2) 〉 · · · | g ( m + 1) 〉 | s i 〉 } m +1 i =1 , and each state (󰁔 m +1 j =1 | g ( j ) 〉 ) | s i 〉 could be performed by oracle U H on state (󰁔 m +1 j =1 | g ( j ) 〉 ) | 0 〉 .
Revised: Note that here we actually perform the state | t ′ m +1 〉 = | g (1) 〉 | g (2) 〉 · · · | g ( m + 1) 〉 | t m +1 〉 from states {| g (1) 〉 | g (2) 〉 · · · | g ( m + 1) 〉 | s i 〉 } m +1 i =1 , and each state ( m +1 j =1 | g ( j ) 〉 ) | s i 〉 could be performed by oracle U H on state ( m +1 j =1 | g ( j ) 〉 ) | 0 〉 .

Original: Denote U m +1 as the unitary which generates the state 󰁫
Revised: Denote U m +1 as the unitary which generates the state %

Original: 󰁔 m +1 j =1 | g

Original: ( j ) 〉 󰁬
Revised: [Equation]

Original:  | t m +1 〉 from the state 󰁫 󰁔 m +1 j =1 | g ( j ) 〉 󰁬 | 0 〉 .
Revised: & | t m +1 〉 from the state %m +1 j =1 | g ( j ) 〉 & | 0 〉 .

Original: The operation in step (c) of procedure (11):[Equation] lm =

Revised: The operation in step (c) of procedure (11): lm =

Original: [ R m ⊗ | 0 〉〈 {+
+}
Revised: [ R m ⊗ | 0 〉〈 {+
+}

Original: [Equation] ⊗ 
Revised: | + I ⊗ | 1 〉〈 1 | ] could be performed by lm

Original: [Equation]
Revised: [Equation]

Original: 1 〉〈 1 | ] could be performed by 󰁔

Original: [Equation]
Revised: [Equation]

Original: A. T HE PROOF OF T HEOREM
Revised: A. T HE PROOF OF T HEOREM

Original: Denote P l as the probability of resulting 0 after the measurement in Step 4 of Algorithm 3.
Revised: Denote P l as the probability of resulting 0 after the measurement in Step 4 of Algorithm 3.

Original: In order to generate the required state, the measurement in Step 4 needs to be performed for O (1 /P l ) times.
Revised: In order to generate the required state, the measurement in Step 4 needs to be performed for O (1 /P l ) times.

Original: The Lemma 4 provides a lower bound on P l .
Revised: The Lemma 4 provides a lower bound on P l .

Original: Lemma 4.
Revised: Lemma 4.

Original: The probability of resulting 0 after the measurement in Step 4 of Algorithm 3 as the lower bound P l ≥ [Equation] [Equation]
Revised: The probability of resulting 0 after the measurement in Step 4 of Algorithm 3 as the lower bound P l ≥ ( r − l ) ! 2" H " 2 F .

Original: Proof.
Revised: Proof.

Original: Suppose λ 21 ≥ λ 22 ≥ · · · ≥ λ 2 r , where λ i is the eigenvalue of H .
Revised: Suppose λ 21 ≥ λ 22 ≥ · · · ≥ λ 2 r , where λ i is the eigenvalue of H .

Original: Since state | t m 〉 is the linear sum of {| h j 〉 } dj =1 , we can assume that | t m 〉 has the decomposition | t m 〉 = 󰁓 ri =1 w mi |
Revised: Since state | t m 〉 is the linear sum of {| h j 〉 } d j =1 , we can assume that | t m 〉 has the decomposition | t m 〉 = # r i =

Original: u
Revised: [Equation]

Original:  i 〉 , for all m = 1 , 2 , · · · , l , where 󰁓
Revised: w mi | u i 〉 , for all m = 1 , 2 , · · · , l , where # ri =1 w mi w ni = δ mn . There is: P l =

Original: [Equation]
Revised: [Equation]

Original: =
Revised: d

Original: [Equation]
Revised: [Equation]

Original: mn . There is:
Revised: h

Original: [Equation]
Revised: [Equation]

Revised: l $ m =

Revised: [Equation]

Revised: t m 〉〈 t m

Revised: [Equation]

Revised: h

Revised: [Equation]

Revised: [Equation]

Revised: =

Revised: [Equation]

Revised: d $ j =1 =

Revised: [Equation]

Revised: h

Revised: [Equation]

Revised: l $ m =

Revised: [Equation]

Revised: h j ! 2 | 〈 t m | h j 〉 | 2 > =

Revised: [Equation]

Revised: [Equation]

Revised: H

Revised: [Equation]

Revised: 2 F d $ j = l $ m =1 = r $ i =

Revised: w mi λ i u ( j ) i > =

Revised: [Equation]

Revised: H !

Revised: 2 F d $ j = l $ m =1 ) * r $ i =

Revised: w 2 mi λ 2 i ( u ( j ) i ) 2 + r $ i ∕ = k w mi w mk λ i λ k u ( j ) i u ( j ) k , - = 1 − !

Revised: H !

Revised: 2 F l $ m = r $ i =

Revised: w 2 mi λ 2 i = 1 − !

Revised: H !

Revised: 2 F r $ i

Revised: =

Original:  where c i = 󰁓 lm =1 w 2 mi .
Revised: c i λ 2 i , where c i = # lm =1 w 2 mi .

Original: Consider the r -dimensional vector w m = 󰁓 ri =1 w mi e i .
Revised: Consider the r -dimensional vector w m = # ri =1 w mi e i .

Original: The vector set { w m } lm =1 forms an orthogonal basis in a l -dimensional subspace.
Revised: The vector set { w m } lm =1 forms an orthogonal basis in a l -dimensional subspace.

Original: Note that we can add w l +1 , · · · w r such that { w m } rm =1 forms an orthonormal basis in the whole r -dimensional space.
Revised: Note that we can add w l +1 , · · · w r such that { w m } rm =1 forms an orthonormal basis in the whole r -dimensional space.

Original: Denote matrix W = ( w 1 , w 2 , · · · , w r ) .
Revised: Denote matrix W = ( w 1 , w 2 , · · · , w r ) .

Original: Since W T W =
Revised: Since W T W =

Original: I .
Revised: I .

Original: Since W is unitary, there is:
Revised: Since W is unitary, there is:

Original: [Equation]
Revised: [Equation]

Original: Thus we have the upper bound: c i =󰁓
Revised: Thus we have the upper bound: c i =

Original: [Equation]
Revised: [Equation]

Original:  mi = 1 .
Revised: =1 w 2 mi ≤ # rm =1 w 2 mi = 1 .

Original: Note that 󰁓 ri =
Revised: Note that # ri =1 c

Original: [Equation]

Original: i
Revised: i

Original: [Equation] 󰁓
Revised: =

Original: [Equation]
Revised: [Equation]

Original: 󰁓
Revised: =

Original: [Equation]
Revised: [Equation]

Original:  l , so there is:
Revised: 2 mi = l , so there is:

Original: [Equation]
Revised: [Equation]

Original: Note that for the case | λ i | ≤ 󰂃 / 2 , ˜ λ
Revised: Note that for the case | λ i | ≤ ! / 2 , ˜ λ

Original: i = 0 is a good estimation for the NCF problem, so we could further assume | λ i | > 󰂃 / 2 for the general case and bound the inequality (21) as P l ≥ ( r − l ) 󰂃 2 4 󰀂 H 󰀂
Revised: i = 0 is a good estimation for the NCF problem, so we could further assume | λ i | > ! / 2 for the general case and bound the inequality (21) as P l ≥ ( r − l ) !

Original: [Equation] F .
Revised: 2 4 " H " 2 F .

Original: The error of implementing | t m +

Revised: The error of implementing | t m +

Original: 〉 comes from the imperfect implementing of the linear- combination-of-states operation and the error of calculating x .
Revised: 〉 comes from the imperfect implementing of the linear- combination-of-states operation and the error of calculating x .

Original: The former has been analyzed in
Revised: The former has been analyzed in

Original: Theorem 9.
Revised: Theorem 9.

Original: The error of calculating x is more complex.
Revised: The error of calculating x is more complex.

Original: Deﬁne vector y =
Revised: Deﬁne vector y =

Original: − Z m +1 x .
Revised: − Z m +1 x .

Original: Note that all parameters c ij = 〈 s i | s j 〉 , i, j ∈ [ m ] and b j = 〈 s m +

Revised: Note that all parameters c ij = 〈 s i | s j 〉 , i, j ∈ [ m ] and b j = 〈 s m +

Original: | s j 〉 , j ∈ [ m ] are estimated by Hadamard test, which takes time O ( T H 󰂃 ′− 2 ) with error bounded in 󰂃 ′
Revised: | s j 〉 , j ∈ [ m ] are estimated by Hadamard test, which takes time O ( T H ! ′− 2 ) with error bounded in !

Original:  (see Appendix A.10 for more information).
Revised: ′ (see Appendix A.10 for more information).

Original: Thus the calculation on vector y =
Revised: Thus the calculation on vector y =

Original: C − 1 m b would have an error.
Revised: C − 1 m b would have an error.

Original: Deﬁne matrix ˜ C m
Revised: Deﬁne matrix ˜ C m

Original: = C m + ∆ C m and ˜
Revised: = C m + ∆ C m and ˜

Original: b = b + ∆ b which are estimations on
Revised: b = b + ∆ b which are estimations on

Original: C m and b .
Revised: C m and b .

Original: Suppose | ˜ c
Revised: Suppose | ˜ c

Original: ij − c ij | ≤ 󰂃 1 and | ˜
Revised: ij − c ij | ≤ ! 1 and | ˜

Original: b i − b i | ≤ 󰂃 1 are error bounds for c ij and b i , respectively, ∀ i, j ∈ [ m ] .
Revised: b i − b i | ≤ ! 1 are error bounds for c ij and b i , respectively, ∀ i, j ∈ [ m ] .

Original: Denote ˜ y =
Revised: Denote ˜ y =

Original: ˜
Revised: ˜

Original: C − 1 m b as the solution to the approximate linear equation and ∆ y
Revised: C − 1 m b as the solution to the approximate linear equation and ∆ y

Original: =
Revised: =

Original: ˜
Revised: ˜

Original: y − y as the error to y .
Revised: y − y as the error to y .

Original: We have:
Revised: We have:

Original: [Equation]
Revised: [Equation]

Original: So there is:
Revised: So there is:

Original: [Equation]
Revised: [Equation]

Original: The norm 󰀂 C − 1 m 󰀂 here denotes the largest norm of eigenvalues of matrix C − 1 m .
Revised: The norm ! C − 1 m ! here denotes the largest norm of eigenvalues of matrix C − 1 m .

Original: Thus, for 󰂃 2 = 3 m 3 / 2 󰀂 C − 1 m 󰀂 2 󰂃 1 , we have bound 󰀂 ∆ y 󰀂 ≤ 󰂃 2 .
Revised: Thus, for ! 2 = 3 m 3 / 2 ! C − 1 m ! 1 , we have bound ! ∆ y ! ≤ ! 2 .

Original: For | t m +1 〉 = 󰁓 m +1{++
+} i =1 x m +1 ,i | s i 〉 and | ˜
Revised: For | t m +1 〉 = # m {++
+} i = 1 x m +1 ,i | s i 〉 and | ˜

Original: t m +1 〉= 󰁓
Revised: t m +1 〉

Original: [Equation] 1 i [Equation]
Revised: =

Original: 1 ˜ x m +1 ,i | s i 〉 , there is: 〈t
Revised: # m +1 i =1 ˜ x m +1 ,i | s i 〉 , there is: 〈

Original: [Equation]
Revised: [Equation]

Original:  |
Revised: m +1 |

Original: [Equation]
Revised: [Equation]

Original:  + 󰁛 i = m+ 󰁛 j
Revised: m +1 〉 = m + $ i = m

Original: [Equation]

Original: [Equation] [Equation] [Equation] =
Revised: +

Original: [Equation]
Revised: [Equation]

Original: Note that the form | ˜ t m +1 〉 =
Revised: Note that the form | ˜ t m +1 〉 =

Original: [Equation]

Original: ,i

Original: [Equation]

Original: i

Original: [Equation]
Revised: [Equation]

Original: is not a normalized state:
Revised: is not a normalized state:

Original: [Equation]
Revised: [Equation]

Original: Thus
Revised: Thus

Original: [Equation]
Revised: [Equation]

Original: the overlap between state | t m +1 〉 and | ˜ t m +1 〉 is:
Revised: the overlap between state | t m +1 〉 and | ˜ t m +1 〉 is:

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: There is:
Revised: There is:

Original: [Equation]
Revised: [Equation]

Original: Let 󰂃 3 / 2 = 3 m 2 󰀂 C − 1 m 󰀂 2 󰂃 1{+! 
+} Z m + .
Revised: Let ! 3 / 2 = 3 m 2 " C − 1 m " 2 {+! 
+} Z m + .

Original: It is clear that to obtain the linear combination form | ˜ t m +1 〉 =󰁓 m +1 i =
Revised: It is clear that to obtain the linear combination form | ˜ t m +1 〉 =

Original: 1 ˜ x m +1 ,i | s i 〉 takes time O ( m 3 + m 2 T H 󰂃 − 2 1 ) , where 󰀂 | ˜ t m +1 〉 / 󰀂
Revised: # m +1 i =1 ˜ x m +1 ,i | s i 〉 takes time O ( m 3 + m 2 T H ! − 2 1 ) , where ! | ˜ t m +1 〉 / !

Original: | ˜ t m +1 〉󰀂 − | t m +1 〉󰀂 ≤󰂃 3 / 2 .
Revised: | ˜ t m +1 〉! − | t m +1 〉! ≤

Original: By Theorem 9, the implementation of state | ˜ t ′ m +1 〉 =
Revised: By Theorem 9, the implementation of state | ˜ t ′ m +1 〉 =

Original: [󰁔 m +1 j =1 | g ( j ) 〉 ] | ˜ t m +1 〉 takes time
Revised: [ m +1 j =1 | g ( j ) 〉 ] | ˜ t m +1 〉 takes time

Original: O ( T H ( m + 1) log(2( m +1) / 󰂃 3 ) ) with error bounds 󰂃 3 / 2 .
Revised: O ( T H ( m + 1) log(2( m +1) / ! 3 ) ) with error bounds !

Original: Thus, we can implement state | t ′ m
Revised: Thus, we can implement state | t ′ m

Original: +1 〉 =
Revised: +1 〉 =

Original: [󰁔 m +1 j =1 | g ( j ) 〉 ] | t m +1 〉 by unitary in time O ( m 3 + m 2 T H 󰂃 − 2 1 + T H ( m +1) [-log(
 (-] m +1) / 󰂃 3 ) ) with error bounds in 󰂃 3 .
Revised: [ m +1 j =1 | g ( j ) 〉 ] | t m +1 〉 by unitary in time O ( m 3 + m 2 T H ! − 2 1 + T H ( m +1) [-log(
 (-]log(2( m +1) / ! 3 ) ) with error bounds in ! 3 .

Original: Now we consider the inﬂuence of imperfect implementation of state | ˜ t ′ m 〉 to Algorithm 3.
Revised: Now we consider the inﬂuence of imperfect implementation of state | ˜ t ′ m 〉 to Algorithm 3.

Original: For simplicity, we neglect the term [󰁔 mj =1 | g ( j ) 〉 ] in state | t ′ m 〉 =
Revised: For simplicity, we neglect the term [ mj =1 | g ( j ) 〉 ] in state | t ′ m 〉 =

Original: [󰁔 mj =1 | g ( j ) 〉 ] | t m 〉 .
Revised: [ mj =1 | g ( j ) 〉 ] | t m 〉 .

Original: Denote Π l =󰁔 li ={+=
+}
Revised: Denote Π l = li {+=
+}

Original: 1 ( I − 2 | t i 〉〈 t i | ) and ˜ Π
Revised: ( I − 2 | t i 〉〈 t i | ) and ˜ Π

Original: l =󰁔 li =1{+=
+} ( I − 2 | ˜ t i 〉〈 ˜ t i | ) .
Revised: l = li {+=
+} ( I − 2 | ˜ t i 〉〈 ˜ t i | ) .

Original: There is 󰀂 Π l − ˜
Revised: There is !

Original: Π l 󰀂 ≤ 2 l 󰂃 3 .
Revised: Π l − ˜ Π l ! ≤ 2 l ! 3 .

Original: Note that the state
Revised: Note that the state

Original: [Equation]
Revised: [Equation]

Original: in step 3 of Algorithm 3 can be written as:
Revised: in step 3 of Algorithm 3 can be written as:

Original: [Equation]
Revised: [Equation]

Original: The probability of generating 0 after the measurement on the last register is:
Revised: The probability of generating 0 after the measurement on the last register is:

Original: [Equation]
Revised: [Equation]

Original: Similarly we deﬁne | ˜ φ ( l 
Revised: Similarly we deﬁne | ˜ φ ( l ) 1 〉 =

Original: [Equation]
Revised: [Equation]

Original: 1 〉 =
Revised: |

Original: [Equation]
Revised: [Equation]

Original:  and ˜ P l = 󰀂 H 󰀂 F
Revised: ] , and ˜ P l = " H [Equation] F

Original: [Equation]
Revised: [Equation]

Revised: dj =1 !

Original: 〉󰀂 2 for the approximate case.
Revised: h j ! 2 ! ˜ Π l + I 2 | h j 〉! 2 for the approximate case.

Original: Since the objective of step 5 is to obtain the index g ( l + 1) such that the column state | h g ( l +1) 〉 = | s l +1 〉 is linearly independent from basis {| s i 〉 } li =1 , we deﬁne P falsel as the probability of selecting out the state | s l +1 〉 ∈ {| s i 〉 } li =1 in the approximate case.
Revised: Since the objective of step 5 is to obtain the index g ( l + 1) such that the column state | h g ( l +1) 〉 = | s l +1 〉 is linearly independent from basis {| s i 〉 } li =1 , we deﬁne P falsel as the probability of selecting out the state | s l +1 〉 ∈ {| s i 〉 } li =1 in the approximate case.

Original: Note that for state | h j 〉 ∈ {| s i 〉 } li =1 , ( Π l + I ) |
Revised: Note that for state | h j 〉 ∈ {| s i 〉 } li =1 , ( Π l + I ) |

Original: h j 〉 = 0 , so there is:
Revised: h j 〉 = 0 , so there is:

Original: [Equation]
Revised: [Equation]

Original: Let 󰂃 3{+! 
+} = 
Revised: Let {+! 
+} = !

Revised: 2 8( r − 1) " H " 2 F , there is:

Original: [Equation]
Revised: [Equation]

Original: 2 F , there is:
Revised: P false

Original: [Equation]
Revised: [Equation]

Original: Thus, by choosing 󰂃 3 = 󰂃 2 8( r − 1) 󰀂 H 󰀂 2 F , Algorithm 3 could select out a complete basis {| s i 〉 } ri =1 with probability at least 34 .
Revised: Thus, by choosing ! 3 = ! 2 8( r − 1) " H " 2 F , Algorithm 3 could select out a complete basis {| s i 〉 } ri =1 with probability at least 3 4 .

Original: Note that in Algorithm 3 we need to perform operations R i
Revised: Note that in Algorithm 3 we need to perform operations R i

Original: = I − 2 | t ′
Revised: = I − 2 | t ′

Original: i
Revised: i

Original: 〉〈 t ′ i | for i = 1 , 2 , · · · , r − 1 , which needs the information of parameters { c ij } r − 1 ,r − 1 i =1 ,j =1 .
Revised: 〉〈 t ′ i | for i = 1 , 2 , · · · , r − 1 , which needs the information of parameters { c ij } r − 1 ,r − 1 i =1 ,j =1 .

Original: In order to guarantee the success probability of Algorithm 3 (Equation (28)), the estimation on each c ij = 〈 s i | s j 〉 should have error bound 󰂃 1 = min m ∈ [ [Equation] − 2]
Revised: In order to guarantee the success probability of Algorithm 3 (Equation (28)), the estimation on each c ij = 〈 s i | s j 〉 should have error bound ! 1 = min m ∈ [ r − 2]

Original: [Equation]
Revised: [Equation]

Original: 󰀂 H 󰀂

Original: [Equation]
Revised: [Equation]

Original: 󰂃 2 .

Original: Thus, the estimation on each c ij takes time O ( T H r 6 󰀂 H 󰀂 4 F 󰂃 − 4 ) and the estimation on the parameter group { c ij } r − 1 ,r − 1 i =1 ,j =1 takes time
Revised: Thus, the estimation on each c ij takes time O ( T H r 6 ! H ! 4 F ! − 4 ) and the estimation on the parameter group { c ij } r − 1 ,r − 1 i =1 ,j =1 takes time

Original: O ( T H r 8 󰀂 H 󰀂 4 F 󰂃 − 4 ) .
Revised: O ( T H r 8 ! H ! 4 F ! − 4 ) .

Original: In order to obtain the description | t m 〉 =
Revised: In order to obtain the description | t m 〉 =

Original: 󰁓 m i = 1 x m,i | s i 〉 , additional time is required for solving (m-1)-dimensional equations for m = 2 , 3 , · · · r − 1 , which results the time complexity
Revised: # mi =1 x m,i | s i 〉 , additional time is required for solving (m-1)-dimensional equations for m = 2 , 3 , · · · r − 1 , which results the time complexity

Original: O ( r 4 ) in total.
Revised: O ( r 4 ) in total.

Original: With given parameters { x m,i } mi =1 , the implementation of operation
Revised: With given parameters { x m,i } mi =1 , the implementation of operation

Original: R m =
Revised: R m =

Original: I − 2 | t ′ m 〉〈 t ′ m | takes time
Revised: I − 2 | t ′ m 〉〈 t ′ m | takes time

Original: O ( T H ( 
Revised: O ( T H ( m + 1) log(2( m +1) / ! 3 ) )

Original: [Equation]
Revised: ≤ O ( T H · r 2log(4 r " H " F / ! ) ) .

Original: Denote T basis as the required time to implement Algorithm 3 and T R i as the required time to implement operation R i .
Revised: Denote T basis as the required time to implement Algorithm 3 and T R i as the required time to implement operation R i .

Original: Since in each iteration of l ∈ [ r − 1] , Algorithm 3 refers operation
Revised: Since in each iteration of l ∈ [ r − 1] , Algorithm 3 refers operation

Original: R 1 , R 2 , · · · , R l for 1 /P l times, there is:
Revised: R 1 , R 2 , · · · , R l for 1 /P l times, there is:

Original: [Equation]
Revised: [Equation]

Original: A. T HE PROOF OF L EMMA
Revised: A. T HE PROOF OF L EMMA

Original: Proof.
Revised: Proof.

Original: Deﬁne the index function g : [ r ] →
Revised: Deﬁne the index function g : [ r ] →

Original: [ d ] such that s i
Revised: [ d ] such that s i

Original: =
Revised: =

Original: h g ( i ) , ∀ i ∈
Revised: h g ( i ) , ∀ i ∈

Original: [ r ] .
Revised: [ r ] .

Original: Consider the eigendecomposition of matrix H :
Revised: Consider the eigendecomposition of matrix H :

Original: [Equation]
Revised: [Equation]

Original: It is natural to generate the decomposition:
Revised: It is natural to generate the decomposition:

Original: [Equation]
Revised: [Equation]

Original: Deﬁne the r × r dimensional matrix C =
Revised: Deﬁne the r × r dimensional matrix C =

Original: ( h Tg (

Original: [Equation]

Original: , h Tg (

Original: [Equation]
Revised: [Equation]

Original: h
Revised: g

Original: [Equation]

Original: [Equation]

Original: h g

Original: [Equation]
Revised: [Equation]

Original: h g ( r ) ) .

Original: There is:
Revised: There is:

Original: [Equation]
Revised: [Equation]

Original: Denote the jk -th element of C as c jk .
Revised: Denote the jk -th element of C as c jk .

Original: Since c jk = h
Revised: Since c jk = h

Original: Tj h k= 󰁓 ri
Revised: Tj h k

Original: [Equation]
Revised: =

Original: 1 λ 2 i u ( j ) i u ( k ) i , there is: 
Revised: # ri =1 λ 2 i u ( j ) i u ( k ) i , there is: det

Original: [Equation]
Revised: [Equation]

Original: 󰀏󰀏󰀏󰀏󰀏󰀏󰀏

Original: [Equation]
Revised: [Equation]

Original: 󰀏󰀏󰀏󰀏󰀏󰀏󰀏󰀏

Original: [Equation]
Revised: [Equation]

Revised: # ri =1 λ 2 i u ( g ( r ))

Revised: i u ( g (1))

Revised: i · · · # ri =1 λ 2 i u ( g ( r ))

Original:  u ( g ( r )) 
Revised: i u ( g ( r )) i CC CC C

Original:  i  r ...
Revised: CC (33) = r $ i 1 = r $ i 2 =1 · · · r $ i r = C CCCCCCC λ 2 i 1 u ( g (1)) iu ( g (1)) i· · · λ 2 i r u ( g (1))

Revised: i r u ( g ( r ))

Revised: i r ...

Original: λ 2 i 1 u ( g ( r )) iu ( g (1))
Revised: λ 2 i 1 u ( g ( r )) iu ( g (1))

Original: i· · · λ 2 i r u ( g ( r ))
Revised: i· · · λ 2 i r u ( g ( r ))

Original: i r u ( g ( r )) 
Revised: i r u ( g ( r )) i r

Original: i r 󰀏󰀏󰀏󰀏󰀏󰀏󰀏󰀏 (34) =
Revised: C CCCCCCC (34) =

Original: r 󰁛 i 1 = r 󰁛 i 2 =1 · · · r 󰁛 i r = ( r 󰁜 j = λ 2 i j )( r 󰁜 j = u 
Revised: r $ i 1 = r $ i 2 =1 · · · r $ i r = ( r + j = λ 2 i j )( r + j = u ( g ( j ))

Original: ( g ( j ))
Revised: i j ) CC

Original: i j ) 󰀏󰀏󰀏󰀏󰀏󰀏󰀏󰀏 u ( g (1))
Revised: C CC CCC u ( g (1))

Original: i· · · u ( g (1))
Revised: i· · · u ( g (1))

Original: i r ...
Revised: i r ...

Original: u ( g ( r ))
Revised: u ( g ( r ))

Original: i· · · u ( g ( r ))
Revised: i· · · u ( g ( r ))

Original: i r󰀏󰀏󰀏󰀏󰀏󰀏󰀏󰀏 . On the other hand, construct the matrix H ′ whose jk -th element is h ′ jk = h g ( j ) ,g ( k ) . There is: det ( H ′ ) =
Revised: i r

Original: [-󰀏󰀏󰀏󰀏󰀏󰀏󰀏 󰁓 ri =
 λ i u ( g (1)) i u ( g (1)) i · · · 󰁓 ri =
 λ i u ( g (1))-]
Revised: [-󰀏󰀏󰀏󰀏󰀏󰀏󰀏 󰁓 ri =
 λ i u ( g (1)) i u ( g (1)) i · · · 󰁓 ri =
 λ i u ( g (1))-]CC C

Original: [-i u ( g ( r )) i ... 󰁓 ri =
 λ i u ( g ( r ))-]
Revised: [-i u ( g ( r )) i ... 󰁓 ri =
 λ i u ( g ( r ))-]CC

Original: [-i u ( g (1)) i · · · 󰁓 ri =
 λ i u ( g ( r )) i u ( g ( r )) i 󰀏󰀏󰀏󰀏󰀏󰀏󰀏 (36) =-]
Revised: [-i u ( g (1)) i · · · 󰁓 ri =
 λ i u ( g ( r )) i u ( g ( r )) i 󰀏󰀏󰀏󰀏󰀏󰀏󰀏 (36) =-]CCC .

Original: r 󰁛 i 1 = r 󰁛 i 2 =1 · · · r 󰁛 i r =1 󰀏󰀏󰀏 󰀏󰀏󰀏󰀏󰀏 λ i 1 u ( g (1)) iu ( g (1)) i· · · λ i r u ( g (1)) i r u ( g ( r )) i r ...
Revised: On the other hand, construct the matrix H ′ whose jk -th element is h ′ jk

Original: λ i 1 u ( g ( r )) iu ( g (1)) i· · · λ i [Equation] 󰀏󰀏󰀏 󰀏󰀏󰀏󰀏󰀏 [Equation]
Revised: = h g ( j ) ,g ( k ) .

Original: 󰀏󰀏󰀏 [Equation] 󰀏󰀏󰀏󰀏 󰀏󰀏󰀏
Revised: There is:

Original: [Equation]
Revised: [Equation]

Original: Note that the determinant in eq(35) and eq(38) is non-zero only if i m ∕ = i n for any different m, n ∈ [ r ] .
Revised: Note that the determinant in eq(35) and eq(38) is non-zero only if i m ∕ = i n for any different m, n ∈ [ r ] .

Original: Consider the summation of i j for all j ∈ [ r ] over { 1 , 2 , · · · , r } , there is:
Revised: Consider the summation of i j for all j ∈ [ r ] over { 1 , 2 , · · · , r } , there is:

Original: [Equation]
Revised: [Equation]

Original: Thus the problem about whether group { h g ( i ) } ri =1 is linearly independent could be solved by calculating the determinant of matrix H ′ .
Revised: Thus the problem about whether group { h g ( i ) } ri =1 is linearly independent could be solved by calculating the determinant of matrix H ′ .

Original: Since H ′ is a r × r dimensional matrix, det ( H ′ ) could be calculated in O ( r 3 ) time (Schwarzenberg-Czerny, 1995).
Revised: Since H ′ is a r × r dimensional matrix, det ( H ′ ) could be calculated in O ( r 3 ) time (Schwarzenberg-Czerny, 1995).

Original: We could claim that the group { h g ( i ) } ri = is linearly independent if det ( H ′ )
Revised: We could claim that the group { h g ( i ) } ri = is linearly independent if det ( H ′ )

Original: ∕ = 0 , or { h g ( i ) } r i =1 is linear dependent if det ( H ′ )
Revised: ∕ = 0 , or { h g ( i ) } ri =1 is linear dependent if det ( H ′ )

Original: = 0 .
Revised: = 0 .

Original: A. T HE PROOF OF T HEOREM
Revised: A. T HE PROOF OF T HEOREM

Original: Proof.
Revised: Proof.

Original: For | ∆ c ij | ≤ 󰂃 1 and | ∆ b j | ≤ 󰂃 2 , there is:
Revised: For | ∆ c ij | ≤ ! 1 and | ∆ b j | ≤ ! 2 , there is:

Original: [Equation]
Revised: [Equation]

Original: The matrix norm 󰀂 · 󰀂 here denotes the largest singular value of the matrix.
Revised: The matrix norm ! here denotes the largest singular value of the matrix.

Original: Note that elements of matrix C and vector b are overlap of quantum states, which are bounded in [ − 1 , 1] , so there is:
Revised: Note that elements of matrix C and vector b are overlap of quantum states, which are bounded in [ − 1 , 1] , so there is:

Original: [Equation]
Revised: [Equation]

Original: C 󰀂 ≤ r and 󰀂 b 󰀂 ≤ √ r.
Revised: and [Equation]

Original: We have:
Revised: We have:

Original: [Equation]
Revised: [Equation]

Original: Thus, for u t = 󰁓 r j =1 x j s j and ˜ u t = 󰁓 r j =1 ˜ x j s j , there is:
Revised: Thus, for u t = # rj =1 x j s j and ˜ u t = [Equation] =1 ˜ x j s j , there is:

Original: [Equation]
Revised: [Equation]

Original: A. T HE ESTIMATION OF c ij = 〈 s i | s j 〉
Revised: A. T HE ESTIMATION OF c ij = 〈 s i | s j 〉

Original: The overlap c ij = 〈 s i | s j 〉 = 〈 h g
Revised: The overlap c ij = 〈 s i | s j 〉 = 〈 h g

Original: ( i ) | h g ( j ) 〉 can be estimated by the Hadamard Test.
Revised: ( i ) | h g ( j ) 〉 can be estimated by the Hadamard Test.

Original: We provide the detail in Algorithm 6:
Revised: We provide the detail in Algorithm 6:

Original: Input: Quantum access to oracle U H .

Original: The index number i and j .

Original: The precision parameter 󰂃 .

Original: The probability error bound δ .

Original: Output: An estimation ˜ c ij to the value c ij = 〈 s i | s j 〉 , such that ˜ c ij ∈ [ c ij − 󰂃 , c ij + 󰂃 ] with probability at least− δ . 1: for k = 1 to n =

Original: [ 2 󰂃 2 log( 2 δ )]

Original: + 1 do 2:

Original: Create state [ | s i 〉 | 0 〉 + | s j 〉 | 1 〉 ] / √ 2 .

Original: Apply the Hadmard gate on the second register to obtain the state | s i 〉 + | s j 〉

Original: [Equation]

Original: Measure the second register and record the result.

Original: 5: end for 6: Count the number of resulting 0 in step 4 as m .

Original: Output 2 m/n − 1 as the estimation to c ij .

Original: Proposition 4.
Revised: Proposition 4.

Original: Algorithm 6 present the 󰂃 -estimation to the overlap c ij = 〈
Revised: Algorithm 6 present the ! -estimation to the overlap c ij = 〈

Original: s i | s j 〉 with probability at least 1 − δ with running time
Revised: s i | s j 〉 with probability at least 1 − δ with running time

Original: O ( T H 󰂃 − 2 log(1 / δ )) .
Revised: O ( T H ! − 2 log(1 / δ )) .

Original: State
Revised: [Equation] s j 〉

Original: [Equation]
Revised: [Equation]

Original:  in step 2 could be generated by performing the following procedure on state | g ( i ) 〉 | g( j ) 〉 | 0 〉 | 0 〉 :
Revised: | 1 〉 [Table] [Equation] in step 2 could be generated by performing the following procedure on state | g ( i ) 〉 | g

Original: [Equation]
Revised: [Equation]

Revised: ) 〉 | 0 〉 |

Original: [Equation] 
Revised: [Equation] [Equation]

Original: [Table]
Revised: [Table]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: The Hadmard 
Revised: The Hadmard gate in (40) acts on the 4-th register. The gate U H ⊗ | 0 〉〈 0 | in (41) acts on the 1-st, 3-rd and 4-th registers. The gate U H ⊗ | 1 〉〈 1 | in (42) acts on the 2-nd, 3-rd and 4-th registers.

Original: A. T HE ESTIMATION OF b i = 〈 u t | s i 〉
Revised: A. T HE ESTIMATION OF b i = 〈 u t | s i 〉

Original: The estimation to the overlap b i = 〈 u t | s i 〉 is more complicated.
Revised: The estimation to the overlap b i = 〈 u t | s i 〉 is more complicated.

Original: Technics like Algorithm 6 is infeasible, due to the post-selection method for generating target state | u t 〉 .
Revised: Technics like Algorithm 6 is infeasible, due to the post-selection method for generating target state | u t 〉 .

Original: Here we introduce another standard quantum algorithm named as Quantum Swap Test (Buhrman et al., 2001), which could estimate the square overlap between two quantum states | φ 〉 and | ψ 〉 .
Revised: Here we introduce another standard quantum algorithm named as Quantum Swap Test (Buhrman et al., 2001), which could estimate the square overlap between two quantum states | φ 〉 and | ψ 〉 .

Original: The circuit of the Quantum Swap Test is illustrated in Figure 1.
Revised: The circuit of the Quantum Swap Test is illustrated in Figure 1.

Original: As shown in Figure 1, Quantum Swap Test performs the operation:
Revised: As shown in Figure 1, Quantum Swap Test performs the operation:

Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: The ﬁnal state could be written as:
Revised: The ﬁnal state could be written as:

Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: The U SWAP gate could be implemented in time O
Revised: The U SWAP gate could be implemented in time O

Original: (polylog( d )) , which performs the swap transformation | φ 〉 | ψ 〉 → | ψ 〉 | φ 〉 for d -dimensional state | φ 〉 and | ψ 〉 .
Revised: (polylog( d )) , which performs the swap transformation | φ 〉 | ψ 〉 → | ψ 〉 | φ 〉 for d -dimensional state | φ 〉 and | ψ 〉 .

Original: The measurement on the ﬁrst qubit produces 0 with probability P 

Revised: The measurement on the ﬁrst qubit produces 0 with probability P

Original: = 12 (1 + | 〈 φ | ψ 〉 | 2 ) .
Revised: = 12 (1 + | 〈 φ | ψ 〉 | 2 ) .

Original: Thus, by replacing step 2-3 in Algortihm 6 with the Quantum Swap Test operation, we could build an algorithm to estimate the square of the state overlap.
Revised: Thus, by replacing step 2-3 in Algortihm 6 with the Quantum Swap Test operation, we could build an algorithm to estimate the square of the state overlap.

Original: Proposition 5.
Revised: Proposition 5.

Original: There exists a quantum algorithm which could present 󰂃 -estimation to value b 2 i = | 〈 u t | s i 〉 | 2 with probability at least 1 − δ in running time
Revised: There exists a quantum algorithm which could present ! -estimation to value b 2 i = | 〈 u t | s i 〉 | 2 with probability at least 1 − δ in running time

Original: O ( T Input polylog( d ) 󰂃 − 2 log(1 / δ )) , where T
Revised: O ( T Input polylog( d ) ! − 2 log(1 / δ )) , where T

Original: Input is the time complexity to generate states | u t 〉 and | s i 〉 .
Revised: Input is the time complexity to generate states | u t 〉 and | s i 〉 .

Original: In order to estimate values b i = 〈 u t | s i 〉 for i ∈
Revised: In order to estimate values b i = 〈 u t | s i 〉 for i ∈

Original: [ r ] , we need to discriminate the positive and negative of b i .
Revised: [ r ] , we need to discriminate the positive and negative of b i .

Original: Note that for state | u t 〉 , the state | − u t 〉 is also a target state which shares the same eigenvalue.
Revised: Note that for state | u t 〉 , the state | − u t 〉 is also a target state which shares the same eigenvalue.

Original: So both states | u t 〉 and | − u t 〉 are legal outputs and indistinguishable for our algorithm in Section 3.
Revised: So both states | u t 〉 and | − u t 〉 are legal outputs and indistinguishable for our algorithm in Section 3.

Original: Thus we analysis the value b i = sgn ( u ( k ) t ) 〈 u t | s i 〉 as the overlap between states | u t 〉 and | s i 〉 , where u ( k ) t is the k -th component of vector u t .
Revised: Thus we analysis the value b i = sgn ( u ( k ) t ) 〈 u t | s i 〉 as the overlap between states | u t 〉 and | s i 〉 , where u ( k ) t is the k -th component of vector u t .

Original: Generally k could be any index such that the corresponding component is non-zero.
Revised: Generally k could be any index such that the corresponding component is non-zero.

Original: Note that b i = sgn ( u ( k ) t ) 〈 u t | s i 〉 = − sgn
Revised: Note that b i = sgn ( u ( k ) t ) 〈 u t | s i 〉 = − sgn

Original: ( 〈 u t | h k 〉 ) 〈 u t | s i 〉 .
Revised: ( 〈 u t | h k 〉 ) 〈 u t | s i 〉 .

Original: Deﬁne two states | ψ + 〉 = 1 Z
Revised: Deﬁne two states | ψ + 〉 = 1 Z

Original: +
Revised: +

Original: ( | h k 〉 + |
Revised: ( | h k 〉 + |

Original: h g ( i ) 〉 ) and | ψ − 〉 = [Equation] − ( | h 
Revised: h g ( i ) 〉 ) and | ψ − 〉 = 1 Z − ( | h k 〉 − |

Original: [Equation] − | h g ( i ) 〉 ) , where Z ± are normalized constants such that Z 2 ± = 2 ± 2 〈 h k |
Revised: h g ( i ) 〉 ) , where Z ± are normalized constants such that Z 2 ± = 2 ± 2 〈 h k |

Original: h g ( i ) 〉 .
Revised: h g ( i ) 〉 .

Original: Then there is:
Revised: Then there is:

Original: [Equation]
Revised: [Equation]

Original: States | ψ + 〉 and | ψ − 〉 could be generated by step 2-4 in Algorithm 6.
Revised: States | ψ + 〉 and | ψ − 〉 could be generated by step 2-4 in Algorithm 6.

Original: The overlap 〈 h k | h g ( i ) 〉 could be estimated by Algorithm 6.
Revised: The overlap 〈 h k | h g ( i ) 〉 could be estimated by Algorithm 6.

Original: The square overlap | 〈 u t | ψ + 〉 | 2 and | 〈 u t | ψ − 〉 | 2 could be estimated by Quantum Swap Test.
Revised: The square overlap | 〈 u t | ψ + 〉 | 2 and | 〈 u t | ψ − 〉 | 2 could be estimated by Quantum Swap Test.

Original: Thus for | 〈 u t |
Revised: Thus for | 〈 u t |

Original: h g ( i ) 〉 | > 󰂃 ′ , one could discriminate the positive and negative of 〈 u t | h k 〉〈 u t |
Revised: h g ( i ) 〉 | > ! ′ , one could discriminate the positive and negative of 〈 u t | h k 〉〈 u t |

Original: h g ( i ) 〉 by calculate the value Z 2+ | 〈 u t | ψ + 〉 | 2 − Z 2 − | 〈 u t | ψ − 〉 | 2 .
Revised: h g ( i ) 〉 by calculate the value Z 2+ | 〈 u t | ψ + 〉 | 2 − Z 2 − | 〈 u t | ψ − 〉 | 2 .

Original: The estimation on the square overlap | 〈 u t | ψ + 〉 | 2 and | 〈 u t | ψ − 〉 | 2 need to have the precision 󰂃 ′
Revised: The estimation on the square overlap | 〈 u t | ψ + 〉 | 2 and | 〈 u t | ψ − 〉 | 2 need to have the precision !

Original: | 〈 u t |
Revised: | 〈 u t |

Original: h k 〉 | / 2 , which takes time
Revised: h k 〉 | / 2 , which takes time

Original: O ( T Input 󰂃 ′− 2 ) .
Revised: O ( T Input ! ′− 2 ) .

Original: For | 〈 u t |
Revised: For | 〈 u t |

Original: h g ( i ) 〉 | ≤ 󰂃 ′ , 0 is an 󰂃 ′ estimation to 〈 u t|
Revised: h g ( i ) 〉 | ≤ ! ′ , 0 is an ! ′ estimation to 〈 u t

Original:  h g ( i ) 〉 .
Revised: | h g ( i ) 〉 .

Original: Since an 󰂃 ′ -estimation to | b i | could be achieved by an 󰂃 ′
Revised: Since an ! ′ -estimation to | b i | could be achieved by an !

Original: 2 -estimation to b 2 i which takes time O
Revised: 2 -estimation to b 2 i which takes time O

Original: ( T Input 󰂃 ′− 4 ) , we could derive the time complexity of estimating b
Revised: ( T Input ! ′− 4 ) , we could derive the time complexity of estimating b

Original: i in Theorem 10.
Revised: i in Theorem 10.

Original: Theorem 10.
Revised: Theorem 10.

Original: There exists a quantum algorithm which could present 󰂃 -estimation to value b i = sgn
Revised: There exists a quantum algorithm which could present ! -estimation to value b i = sgn

Original: ( u ( k ) t ) 〈 u t | s i 〉 with probability at least 1 − δ in running time
Revised: ( u ( k ) t ) 〈 u t | s i 〉 with probability at least 1 − δ in running time

Original: O ( T Input polylog( d ) 󰂃 − 4 log(1 / δ )) , where T Input is the time complexity to generate states | u t 〉 and | s i 〉 .
Revised: O ( T Input polylog( d ) ! − 4 log(1 / δ )) , where T Input is the time complexity to generate states | u t 〉 and | s i 〉 .

Revised: A. G ENERATE THE H ESSIAN MATRIX

Revised: Obtaining the Hessian matrix of a general objective function is computationally expensive.

Revised: However, the calculation can be simpliﬁed in special case.

Revised: For example, consider the binary classiﬁcation problem with the sample set Z = { ( x j , y j ) | j ∈ [ n ] } ⊂ R d × { 0 , 1 } .

Revised: Consider the non-convex loss function with form: F ( x , w ) =

Revised: [ h ( θ ) − y ] 2 , where h : R → R is the non-linear function such that h ( θ ) = 1 1+ e − θ and θ = w ⊤ x + b .

Revised: Denote x ( i ) j as the i th component of x j .

Revised: The total loss function on the set S is deﬁned as f ( w ) =

Revised: 1 n

Revised: [Equation]

Revised: There is:

Revised: [Equation]

Revised: [Equation]

Revised: Deﬁne

Revised: [Equation]

Revised: we have:

Revised: [Equation]

Revised: Thus we could derive the Hessian matrix for the total loss function:

Revised: [Equation]

Revised: [Equation]

Revised: Each term in the sum above is a rank-1 matrix, which means the rank of H is bounded by n .

Revised: Thus, for sparse samples { x j } nj =1 with at most s non-zero elements, we could derive the Hessian as the form { ( i, j, h ij | h ij ∕ = 0) } in time O ( ns 2 ) .

Revised: Note that in practical case, d , the dimension of the sample x j , can be millions large (for example, the number of pixels on an image), while n , the number of sample involved in one iteration of the update, is relatively small.