Variational Quantum Linear Solver: A Hybrid Algorithm for Linear Systems
Abstract
Solving linear systems of equations is central to many engineering and scientific fields. Several quantum algorithms have been proposed for linear systems, where the goal is to prepare such that . While these algorithms are promising, the time horizon for their implementation is long due to the required quantum circuit depth. In this work, we propose a variational hybrid quantum-classical algorithm for solving linear systems, with the aim of reducing the circuit depth and doing much of the computation classically. We propose a cost function based on the overlap between and , and we derive an operational meaning for this cost in terms of the solution precision . We also introduce a quantum circuit to estimate this cost, while showing that this cost cannot be efficiently estimated classically. Using Rigetti’s quantum computer, we successfully implement our algorithm up to a problem size of . Furthermore, we numerically find that the complexity of our algorithm scales efficiently in both and , with the condition number of . Our algorithm provides a heuristic for quantum linear systems that could make this application more near term.
I Introduction
Linear systems of equations play an important role in many areas of science and technology, including machine learning Alpaydin (2010); Bishop (2006), solving partial differential equations Evans (2010), fitting polynomial curves Bretscher (1995), and analyzing electrical circuits Spielman and Srivastava (2011). In the past decade, significant attention has been given to the possibility of solving linear systems on quantum computers. Classically solving an linear system ( equations for unknowns) scales polynomially in . In contrast, Harrow-Hassidim-Lloyd (HHL) introduced a quantum algorithm that scales logarithmically in , suggesting that quantum computers may provide an exponential speedup for certain linear system problems Harrow et al. (2009). More precisely, the HHL algorithm treats the Quantum Linear Systems Problem (QLSP), where the goal is to prepare a quantum state that is proportional to a vector that satisfies the equation . If both and are sparse, then for a fixed precision in the solution, the complexity of HHL scales polynomially in and , where is the condition number of , i.e, the ratio of the largest to the smallest singular values. Improvements to HHL have been made both in terms of the scaling in and Childs et al. (2017); Ambainis ; Chakraborty et al. ; Subaşı et al. (2019), as well as in terms of sparsity requirements Wossnig et al. (2018).
The aforementioned quantum algorithms hold promise for the future, when large-scale quantum computers exist with enough qubits for quantum error correction. The timescale for such computers remains an open question, but is typically estimated to be on the order of two decades. On the other hand, commercial quantum computers currently exist with noisy qubits, with the number of qubits rapidly increasing. A crucial question is how to make use of such noisy intermediate-scale quantum (NISQ) computers Preskill (2018). In principle, one can implement the aforementioned quantum algorithms on NISQ devices, however noise limits the problem size to be extremely small. For example, the HHL algorithm has been implemented with superconducting qubits Zheng et al. (2017); Lee et al. (2019), nuclear magnetic resonance (NMR) Pan et al. (2014), and photonic devices Cai et al. (2013); Barz et al. (2014), but these experiments were limited to a problem size of . More recently, an alternative approach based on an adiabatic-inspired quantum algorithm Subaşı et al. (2019) was implemented with NMR for an problem, and this appears to be the current record for the largest linear system solved with a gate-based quantum computer Wen et al. (2019).
An interesting strategy to make use of NISQ devices is to employ variational hybrid quantum-classical algorithms (VHQCAs). VHQCAs manage to reduce quantum circuit depth at the expense of additional classical optimization. Specifically, VHQCAs employ a short-depth quantum circuit to efficiently evaluate a cost function, which depends on the parameters of a quantum gate sequence, and then leverage well-established classical optimizers to minimize this cost function. For example, while Shor’s algorithm for factoring is not a near-term algorithm, recently a VHQCA for factoring was introduced potentially making factoring nearer term Anschuetz et al. . Other VHQCAs have been proposed for chemistry Peruzzo et al. (2014); Cao et al. ; Higgott et al. (2019); Jones et al. (2019), simulation Li and Benjamin (2017); Kokail et al. (2019); Heya et al. , data compression Romero et al. (2017); Khoshaman et al. (2019), state diagonalization LaRose et al. (2018); Bravo-Prieto et al. , compiling Khatri et al. (2019); Jones and Benjamin , quantum foundations Arrasmith et al. (2019), and fidelity estimation Cerezo et al. .
In this work, we propose a VHQCA for solving the QLSP. Our algorithm, called the Variational Quantum Linear Solver (VQLS), defines the cost function in terms of the overlap between the quantum states and , which are respectively normalized versions of and . We provide an efficient quantum circuit to estimate this cost, show that it cannot be efficiently estimated classically, and discuss several approaches to optimize it. Furthermore, we derive an operational meaning for our cost function, as an upper bound on . This is crucial since it gives a termination criterion for VQLS that guarantees a desired precision .
It is important to emphasize that all VHQCAs are heuristic algorithms, making rigorous complexity analysis of these algorithms difficult. Nevertheless, our numerical simulations indicate that the run time of VQLS scales efficiently in both and in .
We employ Rigetti’s Quantum Cloud Services Computing to implement VQLS. With their quantum hardware, we were able to successfully solve a particular linear system of size . We are therefore optimistic that VQLS could provide a near-term approach to the QLSP.
Ii Results
ii.1 VQLS Algorithm
ii.1.1 Overview
Figure 1 shows a schematic diagram of the VQLS algorithm. The input to VQLS is: (1) an efficient gate sequence that prepares a quantum state that is proportional to the vector , and (2) a decomposition of the matrix into a linear combination of unitaries of the form
(1) |
where the are unitaries, and the are complex numbers. The assumption that is given in this form is analogous to the assumption that the Hamiltonian in the variational quantum eigensolver Peruzzo et al. (2014) is given as a linear combination of Pauli operators , where naturally one makes the assumption that is only a polynomial function of the number of qubits, . Additionally, we assume and , and that the unitaries can be implemented with efficient quantum circuits.
With this input, the Quantum Linear Systems Problem (QLSP) is to prepare a state such that is proportional to . To solve this problem, VQLS employs an ansatz for the gate sequence that prepares a potential solution . The parameters are input to a quantum computer, which prepares and runs an efficient quantum circuit that estimates a cost function . The precise details of the cost function and its estimation are discussed below. We simply remark here that quantifies how much component has orthogonal to . The value of from the quantum computer is returned to the classical computer which then adjusts (via a classical optimization algorithm) in an attempt to reduce the cost. This process is iterated many times until one reaches a termination condition of the form , at which point we say that .
VQLS outputs the parameters , which can then be used to prepare the quantum state . One can then measure observables of interest on the state in order to characterize the solution vector. Due to the operational meaning of our cost function (discussed below), one can upper bound the deviation of observable expectation values for from those of the true solution, based on the value of the cost function. Hence, before running VQLS, one can decide on a desired error tolerance , where
(2) |
is the trace distance between exact solution and the approximate solution . This then translates into a threshold value that the final cost must achieve (see (9) below for the relation between and ).
ii.1.2 Cost functions
For simplicity, we write as henceforth. Here we discuss several reasonable cost functions. A simple, intuitive cost function involves the overlap between the (unnormalized) projector , with , and the subspace orthogonal to , as follows:
(3) |
We note that one can view this cost function as the expectation value of an effective Hamiltonian
(4) |
which is similar to the final Hamiltonian in Ref. Subaşı et al. (2019). The function is small if is proportional to or if the norm of is small. The latter does not represent a true solution, and hence to deal with this, one can divide by the norm of to obtain
(5) |
where is a normalized state. As shown in Fig. 2, performs significantly better than . Hence, we believe that normalizing the cost is important for the performance of the VQLS algorithm.
Global cost functions such as those in (3) and (5) can have gradients that vanish exponentially in the number of qubits , as noted previously Khatri et al. (2019); LaRose et al. (2018). To improve trainability for large , one can introduce local versions of these costs, as follows:
(6) |
where the effective Hamiltonian is
(7) |
with the zero state on qubit and the identity on all qubits except qubit . One can show that (see Methods)
(8) |
which implies that and . We assume that is not infinite (i.e., that is full rank) and hence that . This implies that all four cost functions vanish under precisely the same conditions, namely, when , which is the case when is a solution to the QLSP.
ii.1.3 Operational meaning of cost functions
Here we provide operational meanings for the aforementioned cost functions. These operational meanings are crucial since they allow one to define termination conditions for VQLS in order to achieve a desired precision. In particular, we find that the following bounds hold in general:
(9) |
Note that one can take the right-hand-sides of these inequalities as the quantity shown in Fig. 1.
We remark that, for and , the bounds in (9) can be tightened (by using the bounds on and in (9)) as follows:
(10) |
Here, is experimentally computable (see (14) below) and satisfies . Hence, when training or , one can employ the right-hand-sides of (10) as opposed to those of (9) as the termination condition .
Furthermore, one can employ the operational meaning of the trace distance Nielsen and Chuang (2011) to note that, for any POVM element , we have , where
(11) |
measures the difference between expectation values on and . Relaxing to the general case where is any Hermitian observable gives , and hence (9) is a bound on observable differences.
Let us now provide a proof for (9). Consider first that , with the eigenstates and eigenvalues of denoted by and , respectively for . By construction is the ground state of with . In what follows we assume for simplicity that is non-degenerate, although the same proof approach works for the degenerate case.
It is clear that for a given , the smallest energy (hence cost) is achieved if the state is a superposition of and only. One can see this by expanding an arbitrary state in the energy eigenbasis, , and noting that depends only on the magnitude of . Hence for a fixed , one is free to vary the set of coefficients , and the set that minimizes the energy corresponds to choosing for all .
So we take:
(12) |
and the associated energy is given by
(13) |
where we used the fact that , and that the first excited state energy satisfies (which was shown in Ref. Subaşı et al. (2019)). The trace distance between and can be easily computed as , which results in . Inserting this into (13) yields . The remaining inequalities in (9) follow from (8) and from the fact that , which implies .
ii.1.4 Classical hardness of computing the cost functions
Here we state that computing the cost functions in (3), (5), and (6) is classically hard under typical complexity assumptions. As shown in Appendix A, the following proposition holds:
Proposition 1.
The problem of estimating the VQLS cost functions , , , or to within precision is -hard.
Recall that the complexity class Deterministic Quantum Computing with 1 Clean Qubit () consists of all problems that can be efficiently solved with bounded error in the one-clean-qubit model of computation Knill and Laflamme (1998). Moreover, classically simulating is impossible unless the polynomial hierarchy collapses to the second level Fujii et al. (2018); Morimae (2017), which is not believed to be the case. Hence, Proposition 1 implies that a classical algorithm cannot efficiently estimate the VQLS cost functions, and hence VQLS cannot be efficiently simulated classically.
ii.1.5 Cost evaluation
In principle, all the aforementioned cost functions can be efficiently evaluated using the Hadamard Test circuit and simple classical post-processing. However, in practice, care must be taken to minimize the number of controlled operations in these circuits. Consider evaluating the term , which can be written as
(14) |
with
(15) |
There are different terms that one needs to estimate, and which can be measured with Hadamard Tests. The Hadamard Test involves acting with on , and then using an ancilla as the control qubit, applying followed by , where denotes controlled- (see Methods for precise circuits).
In addition, for and , one needs to evaluate
(16) |
with
(17) |
The terms are easily estimated by applying to and then measuring the probability of the all-zeros outcome. For the terms with , there are various strategies to estimate . For example, one could estimate the terms of the form with a Hadamard Test, but one would have to control all of the unitaries: , , and . Instead, we introduce a novel circuit called the Hadamard-Overlap Test that directly computes without having to control or at the expense of doubling the number of qubits. This circuit is schematically shown in Fig. 1 and explained in detail in Sec. IV.
Finally, for and , one needs to estimate terms of the form
(18) |
These terms can either be estimated with the Hadamard-Overlap Test or with the Hadamard Test, which are discussed in Sec. IV.
ii.1.6 Ansatz
In the VQLS algorithm, is prepared by acting on the state with a trainable gate sequence . Without loss of generality, can be expressed in terms of gates from a gate alphabet as
(19) |
Here, , where are discrete parameters that identify the types of gates and their placement in the circuit (i.e., on which qubit they act), while are continuous parameters.
When working with a specific quantum hardware, it is convenient to choose a Hardware-Efficient Ansatz Kandala et al. (2017), where is composed of the gates native to that hardware. This reduces the gate overhead that arises when implementing the algorithm in the actual device. We use the term variable-structure ansatz to refer to the case when one allows changes to the gate structure by optimizing over the discrete parameters . On the other hand, a fixed-structure ansatz corresponds to the case when the parameters are fixed and one only optimizes over continuous gate parameters . As discussed below in the Methods Section, in this work we apply both types of ansatz to prepare the states .
In addition to the Hardware-Efficient Ansatz, we also employ the Quantum Alternating Operator Ansatz (QAOA) Farhi et al. ; Hadfield et al. (2019) to construct the unitary . The QAOA consists of evolving the state (where denotes the Hadamard unitary) by two Hamiltonians for a specified number of layers, or rounds. These Hamiltonians are conventionally known as driver and mixer Hamiltonians, and respectively denoted as and . Since the ground state of both and is , we can either use (4) or (7) as the driver Hamiltonian . Evolving with for a time corresponds to the unitary operator . Moreover, we take the mixer Hamiltonian to be the conventional , where denotes Pauli acting on the th qubit. Accordingly, evolving with for a time yields the unitary operator . The trainable ansatz is then obtain by alternating the unitary operators and times:
(20) |
In this ansatz, each is a trainable continuous parameter. We note that QAOA is known to be universal as the number of layers tends to infinity Farhi et al. ; Lloyd , and that finite values of have obtained good results for several problems Wang et al. (2018); Zhou et al. ; Crooks .
Let us remark that Ref. Harrow et al. (2009) showed that it is possible to efficiently generate an accurate approximation to the true solution , i.e., with a number of gates that is polynomial in , assuming certain constraints on and . Therefore, in principle, one may efficiently approximate these sort of solutions with a universal variational ansatz, such as the ones that we discussed above.
ii.1.7 Training algorithm
There are several classical optimizers that may be employed to train the gate sequence and minimize the cost functions of VQLS. For the fixed and variable Hardware-Efficient Ansatzes one can use gradient free optimization methods (e.g., the COBYLA algorithm J. D. Powell (2009)), as well as gradient-based optimization methods (such as the L-BFGS-B algorithm Byrd et al. (1995)). There has been an increasing interest in gradient-based methods in VHQCAs as it has been shown that the first-order gradient information can be directly accessed by measuring observables Mitarai et al. (2018) and can lead to faster rates of convergences to the optimum Harrow and Napp . In order to employ gradient descent optimization strategies, in Sec. IV we derive explicit formulas to compute the gradients of the cost functions, and show that the same circuits used to calculate the cost functions can be used to compute their gradients. Finally, when employing the QAOA ansatz we leverage literature on QAOA-specific training (for instance, Ref. Zhou et al. ).
ii.2 Heuristic Scaling
ii.2.1 Dependence on with Hardware-Efficient Ansatz
In this section we study the scaling of the VQLS algorithm with the condition number . For this purpose we have numerically implemented VQLS to solve three different QLSPs. In all cases we compute the local normalized cost function of Eq. (6). Specifically, we considered the following matrices with different degeneracy in the minimum eigenvalue:
(21) | ||||
(22) | ||||
(23) |
where denotes acting with the operator on qubit and acting with identity on all other qubits. The degeneracy of each matrix is , respectively. We remark that we considered different values of since we noticed that this parameter appeared to affect the VQLS performance. The state is
(24) |
Figure 3 shows our results, plotting runs-per-success versus for the aforementioned matrices. Runs-per-success refers to the mean number of VQLS runs needed to obtain a given error tolerance for . For each matrix we implemented 200 runs of VQLS without noise or finite sampling. In each optimization routine we employed a fixed-structure ansatz (see Section IV.3 for more details), and the initial parameters were randomly set.
In all cases there is a region for small (below the horizontal dashed lines in Fig. 3) where success is almost always achieved. Hence runs-per-success is not a good measure of run time in this region, and this region can be ignored. Then, as the condition number is increased, the number of runs-per-success needed to achieve a given begins to increase with a scaling that appears to be sub-linear. Under the assumption that the examples that we considered are representative of the general case, these results suggest that VQLS scales efficiently (linearly or sub-linearly) with when employing a Hardware-Efficient Ansatz.
ii.2.2 Dependence on with QAOA Ansatz
Let us now numerically analyze the VQLS scaling with when employing the QAOA ansatz. Since poorly conditioned matrices (i.e., large ) are more difficult to invert, we expect that for fixed the number of layers must increase with . While this is generally true, we can also alleviate this issue by evolving with the driver Hamiltonian for a longer time. This corresponds to scaling the parameters for odd in (20) by some value that grows with . As shown in Fig. 4(a) and (b), this scaling can indeed transform the cost landscape such that it contains more regions of low cost and thus makes optimization more likely to be successful.
In Fig. 4(c), we show the number of runs-per-success versus the condition number. Here, we consider the same QLSP on three qubits defined in (22) with given by (24). The condition number was varied from to . For each , VQLS was implemented 100 times with the parameters randomly initialized. For each of the three values of considered, the scaling with is sub-exponential. Hence, these results indicate that VQLS with QAOA also scales efficiently in the condition number . Finally, we emphasize that these results were obtained with only round of QAOA, and remark that additional rounds may lead to better performance.
ii.2.3 Dependence on
In order to determine scaling with of VQLS we have performed numerical simulations to solve the QLSP with and given by Eqs. (22) and (24) respectively, and with . In this case we employed variable structure ansatz where the training of gate parameters was performed with the cost function and the gradient-descent algorithm detailed in Sec. IV.4. The VQLS algorithm was implemented 150 times with randomly initialized parameters.
Figure 5 shows the runs-per-success versus . These results show that as grows, the number of runs-per-success exhibit a logarithmic grow. Such results suggest that VQLS is efficient in and hence is comparable to the scaling in previous quantum linear systems algorithms Childs et al. (2017). It remains to be seen how the scaling of VQLS is affected by finite sampling, which is not accounted for in Fig. 5.
ii.3 Implementation on quantum hardware
In this section we present the results of a (i.e., 5-qubit) implementation of VQLS using Rigetti’s quantum chip 16Q Aspen-4 Computing . Additional implementations were performed as well (see Appendix B for further details).
For the implementation here presented, we have considered the following matrix
(25) |
and . We remark that this particular choice of and is motivated from the fact that they lead to simplified ansatz and cost evaluation circuits. In particular, the ansatz considered consists of gates acting on each qubit.
The results of the VQLS implementations are shown in Figure 6. At each run of the algorithm the parameters were initialized to random angles. It is shown that for every implementation of VQLS the local normalized cost function of (6) achieved a value of . Moreover, once the optimal parameters in were determined, we proceeded to measure the expectation value of different Hermitian observables . According to Eq. (11), we can use as a figure of merit to quantify how good our solution is. As shown in Table 7 of Appendix B, the results have a good agreement with the exact solution.
Iii Discussion
In this work, we presented a variational quantum-classical algorithm called VQLS for solving the quantum linear systems problem. On the analytical side, we presented four different faithful cost functions, we derived efficient quantum circuits to estimate them while showing that they are difficult to estimate classically, and we proved operational meanings for them as upper bounds on . On the numerical side, we studied the scaling of the VQLS run time and found it to be efficient with respect to and . Furthermore, we utilized Rigetti’s Quantum Cloud Services to implement VQLS for particular problems up to a size of , which to our knowledge is the largest implementation of a linear system on quantum hardware.
Interestingly, with our implementation on Rigetti’s hardware, we noticed some preliminary evidence of noise resilience, along the same lines as those discussed in Ref. Sharma et al. for a different variational algorithm. Namely, we noticed optimal parameter resilience, where VQLS learned the correct optimal parameters despite various noise sources (e.g., measurement noise, decoherence, gate infidelity) acting during the cost evaluation circuit. We will explore this in more detail in future work.
Finally, we discuss how VQLS fits into the larger literature on quantum algorithms for linear systems. Most prior algorithms rely on time evolutions with the matrix Harrow et al. (2009); Ambainis ; Childs et al. (2017) or a simple function of it Subaşı et al. (2019). In these algorithms, the duration of the time evolution is in order to prepare a state that is -close to the correct answer. In general, this can only be achieved with a quantum circuit of size linear in as per the “no fast-forwarding theorem” Berry et al. (2007); Atia and Aharonov (2017). This is even true if there exists a very short quantum circuit that prepares the desired state . The non-variational algorithms simply cannot exploit this fact. On the other hand, a variational algorithm with a short-depth ansatz might be used to prepare such a state.
This does not mean, however, that the overall complexity of the variational algorithm does not depend on the condition number. This dependence enters through the stopping criteria given in (9). As the condition number increases, the cost has to be lowered further in order to guarantee an error of . This will undoubtedly require more rounds of the variational algorithm to achieve. In effect, our variational approach trades the gate complexity of non-variational algorithms with the number of rounds for a fixed circuit depth. This trade-off can be useful in utilizing NISQ devices without error correction.
Iv Methods
iv.1 Faithfulness of the cost functions
We now prove (8), which is restated here:
(26) |
For the lower bound, let and . Using the fact that , we have and hence . This implies that and .
For the upper bound, note that . Let denote the set of all bitstrings that have a one at position , and let denote the union of all of these sets. Then
(27) |
Hence we have , which implies and .
Equation (8) implies the faithfulness of the cost functions as follows. Because and , we have that all four cost functions are non-negative. Furthermore, it is clear that if , then we have . Conversely, assuming that implies that and hence that all four cost functions are positive. Therefore, all four cost functions are faithful, vanishing if and only if .
iv.2 Cost evaluation circuits
In this section we present short-depth circuits for computing the cost functions of Eqs. (3), (5) and (6). In particular, we introduce the Hadamard-Overlap Test circuit, which should be of interest on its own as it is likely to have applications outside of the scope of VQLS.
iv.2.1 Hadamard Test
Figure 7(a) shows a Hadamard Test which can be used to measure the coefficients defined in (15), and used to compute as in (14). When the phase gate is excluded, the probability of measuring the ancilla qubit in the state is , while the probability of measuring it in the state is . Hence, by means of the Hadamard Test we can compute the real part of as
(28) |
With a similar argument it can be easily shown that by including the phase gate one can compute .
As we now show, in order to compute the coefficients in (18) we can use the previous result combined with those obtained by means of the Hadamard test of Figure 7(c). In particular, since , then we can express
(29) |
Hence, in order to calculate one only needs to measure the real and imaginary parts of the matrix elements , which can be accomplished by means of the circuit in Fig. 7(c).
iv.2.2 Hadamard-Overlap Test
Consider the circuit in Fig. 7(b), which we refer to as the Hadamard-Overlap Test. A nice feature of the Hadamard-Overlap Test is that it only requires one application of both and , and these unitaries do not need to be controlled, in contrast to the Hadamard Test. As explained below, the circuit for the Hadamard-Overlap Test can be obtained by combining the Hadamard Test with the Overlap circuit of Refs. Garcia-Escartin and Chamorro-Posada (2013); Cincio et al. (2018). This circuit requires qubits and classical post-processing (which scales linearly with ) similar to that of the Overlap circuit, except that here we add a conditional statement.
When the gate in Fig. 7(b) is excluded, and conditioning the measurement on the ancilla qubit to yield the state, we can perform the depth-two Overlap circuit between registers and to get
(30) | ||||
On the other hand, by conditioning the ancilla qubit being measured in the state , we perform the Overlap circuit between subsystems and to obtain
(31) | ||||
Then, combining (30) and (31) yields
(32) |
Following a similar procedure, it can be shown that including the gate allows us to calculate .
Note that the Hadamard-Overlap test can also be used to compute the real and imaginary parts of in (18). In this case an additional random unitary must be initially applied to the qubits in register in order to generate the input state . Specifically, randomly applies a bit-flips to all qubits except qubit :
(33) |
with a random bitstring of length .
iv.3 Ansatz
Let us now discuss the Hardware-Efficient Ansatzes used in the numerical simulations of Section II.2. In the top panel of Fig. 8 we show the fixed structure ansatz employed to solve the linear systems with the matrices presented in Eqs. (21)–(23) and with given by (24). In this specific case, both and have real coefficients, and hence the ansatz can contain only rotations about the axis.
Figure 8(b) depicts the building block of our variable-structure ansatz: the dressed CNOT. The dressed CNOT is a two qubit gate composed of a CNOT preceded and followed by general single-qubit gates acting on each qubit. For the specific cases considered in Section II.2.1, the gates in each dressed CNOT can be rotations. Figure 8(c) shows an example of a variable-structure ansatz, where the placement of the dressed CNOTs is also optimized.
iv.4 Gradient-based optimization
While many gradient-based optimization algorithms exist, in this work we use the gradient descent approach outlined in (Khatri et al., 2019, Appendix 4) and based on Ref. Mitarai et al. (2018). In this section we derive analytical expressions for the gradient of the normalized and the unnormalized cost functions and we show that these gradients can be computed with the circuits introduced in Section IV.2.
For simplicity, let us first consider the global cost functions. Let us recall from (19) that the trainable unitary can be expressed as a sequence of gates , where here we fix the structure and hence we drop the subscripts on . In turn, each gate can always be parametrized by a single-qubit rotation angle of the form . The gradient of with respect to is then given by
(34) |
and each partial derivative is
(35) |
As we now show, the gradient of and can be computed with the Hadamard-Overlap test and the Hadamard test, respectively. Let us consider the partial derivatives
(36) | ||||
(37) |
By means of the identity
(38) | ||||
(39) |
where we have defined
(40) |
Each term in (38) can be computed by means of the Hadamard-Overlap test, while the terms in (39) can be determined via the Hadamard test. These results entail that the gradient with respect of of and are determined by
(41) |
and
(42) |
and hence that they can be computed by means of the Hadamard-Overlap test and the Hadamard test.
A similar derivation can be used to show that
(43) |
and hence the gradient of the local cost functions can also be computed by means of the circuits of Section IV.2.
V Acknowledgements
We thank Rolando Somma for helpful conversations. We thank Rigetti for providing access to their quantum computer. The views expressed in this article are those of the authors and do not reflect those of Rigetti. CBP acknowledges support from the U.S. Department of Energy (DOE) through a quantum computing program sponsored by the Los Alamos National Laboratory (LANL) Information Science & Technology Institute. MC was supported by the Center for Nonlinear Studies at LANL. YS and PJC acknowledge support from the LANL ASC Beyond Moore’s Law project. MC, YS, LC, and PJC also acknowledge support from the LDRD program at LANL. LC was supported by the DOE through the J. Robert Oppenheimer fellowship. This work was also supported by the U.S. DOE, Office of Science, Office of Advanced Scientific Computing Research.
Note Added: After completion of this work, we noticed related work was very recently posted Xu et al. .
References
- Alpaydin (2010) E. Alpaydin, Introduction to Machine Learning, 2nd ed. (The MIT Press, 2010).
- Bishop (2006) C. M. Bishop, Pattern Recognition and Machine Learning (Springer, 2006).
- Evans (2010) L. C. Evans, Partial differential equations (American Mathematical Society, 2010).
- Bretscher (1995) O. Bretscher, Linear Algebra With Applications, 3rd ed. (Prentice Hall, Upper Saddle River NJ, 1995).
- Spielman and Srivastava (2011) D. A. Spielman and N. Srivastava, “Graph sparsification by effective resistances,” SIAM J. Comput. 40, 1913–1926 (2011).
- Harrow et al. (2009) A. W. Harrow, A. Hassidim, and S. Lloyd, “Quantum algorithm for linear systems of equations,” Phys. Rev. Lett. 103, 150502 (2009).
- Childs et al. (2017) A. Childs, R. Kothari, and R. Somma, “Quantum algorithm for systems of linear equations with exponentially improved dependence on precision,” SIAM J. Computing 46, 1920–1950 (2017).
- (8) A. Ambainis, ‘‘Variable time amplitude amplification and a faster quantum algorithm for solving systems of linear equations,” arXiv:1010.4458 [quant-ph] .
- (9) S. Chakraborty, A. Gilyén, and S. Jeffery, “The power of block-encoded matrix powers: improved regression techniques via faster Hamiltonian simulation,” arXiv:1804.01973 [quant-ph] .
- Subaşı et al. (2019) Y. Subaşı, R. D. Somma, and D. Orsucci, “Quantum algorithms for systems of linear equations inspired by adiabatic quantum computing,” Phys. Rev. Lett. 122, 060504 (2019).
- Wossnig et al. (2018) L. Wossnig, Z. Zhao, and A. Prakash, “Quantum linear system algorithm for dense matrices,” Phys. Rev. Lett. 120, 050502 (2018).
- Preskill (2018) J. Preskill, “Quantum computing in the NISQ era and beyond,” Quantum 2, 79 (2018).
- Zheng et al. (2017) Y. Zheng, C. Song, M.-C. Chen, B. Xia, W. Liu, et al., “Solving systems of linear equations with a superconducting quantum processor,” Phys. Rev. Lett. 118, 210504 (2017).
- Lee et al. (2019) Y. Lee, J. Joo, and S. Lee, “Hybrid quantum linear equation algorithm and its experimental test on IBM quantum experience,” Scientific Reports 9, 4778 (2019).
- Pan et al. (2014) J. Pan, Y. Cao, X. Yao, Z. Li, C. Ju, et al., “Experimental realization of quantum algorithm for solving linear systems of equations,” Phys. Rev. A 89, 022313 (2014).
- Cai et al. (2013) X.-D. Cai, C. Weedbrook, Z.-E. Su, M.-C. Chen, Mile Gu, et al., “Experimental quantum computing to solve systems of linear equations,” Phys. Rev. Lett. 110, 230501 (2013).
- Barz et al. (2014) S. Barz, I. Kassal, M. Ringbauer, Y. O. Lipp, B. Dakić, et al., “A two-qubit photonic quantum processor and its application to solving systems of linear equations,” Scientific Reports 4, 6115 (2014).
- Wen et al. (2019) J. Wen, X. Kong, S. Wei, B. Wang, T. Xin, and G. Long, ‘‘Experimental realization of quantum algorithms for a linear system inspired by adiabatic quantum computing,” Phys. Rev. A 99, 012320 (2019).
- (19) E. R. Anschuetz, J. P. Olson, A. Aspuru-Guzik, and Y. Cao, “Variational Quantum Factoring,” arXiv:1808.08927 [quant-ph] .
- Peruzzo et al. (2014) A. Peruzzo, J. McClean, P. Shadbolt, M.-H. Yung, X.-Q. Zhou, P. J. Love, A. Aspuru-Guzik, and J. L. O’Brien, “A variational eigenvalue solver on a photonic quantum processor,” Nature Communications 5, 4213 (2014).
- (21) Y. Cao, J. Romero, J. P. Olson, M. Degroote, P. D. Johnson, et al., “Quantum chemistry in the age of quantum computing,” arXiv:1812.09976 [quant-ph] .
- Higgott et al. (2019) O. Higgott, D. Wang, and S. Brierley, “Variational Quantum Computation of Excited States,” Quantum 3, 156 (2019).
- Jones et al. (2019) T. Jones, S. Endo, S. McArdle, X. Yuan, and S. C. Benjamin, “Variational quantum algorithms for discovering Hamiltonian spectra,” Phys. Rev. A 99, 062304 (2019).
- Li and Benjamin (2017) Y. Li and S. C. Benjamin, “Efficient variational quantum simulator incorporating active error minimization,” Phys. Rev. X 7, 021050 (2017).
- Kokail et al. (2019) C. Kokail, C. Maier, R. van Bijnen, T. Brydges, M. K. Joshi, P. Jurcevic, C. A. Muschik, P. Silvi, R. Blatt, C. F. Roos, and P. Zoller, “Self-verifying variational quantum simulation of lattice models,” Nature 569, 355–360 (2019).
- (26) K. Heya, K. M. Nakanishi, K. Mitarai, and K. Fujii, “Subspace variational quantum simulator,” arXiv:1904.08566 [quant-ph] .
- Romero et al. (2017) J. Romero, J. P. Olson, and A. Aspuru-Guzik, “Quantum autoencoders for efficient compression of quantum data,” Quantum Science and Technology 2, 045001 (2017).
- Khoshaman et al. (2019) A. Khoshaman, W. Vinci, B. Denis, E. Andriyash, and M. H. Amin, “Quantum variational autoencoder,” Quantum Science and Technology 4, 014001 (2019).
- LaRose et al. (2018) R. LaRose, A. Tikku, É. O’Neel-Judy, L. Cincio, and P. J. Coles, “Variational quantum state diagonalization,” npj Quantum Information 5, 1–10 (2018).
- (30) C. Bravo-Prieto, D. García-Martín, and J. I. Latorre, “Quantum Singular Value Decomposer,” arXiv:1905.01353 [quant-ph] .
- Khatri et al. (2019) S. Khatri, R. LaRose, A. Poremba, L. Cincio, A. T. Sornborger, and P. J. Coles, “Quantum-assisted quantum compiling,” Quantum 3, 140 (2019).
- (32) T. Jones and S. C Benjamin, “Quantum compilation and circuit optimisation via energy dissipation,” arXiv:1811.03147 [quant-ph] .
- Arrasmith et al. (2019) A. Arrasmith, L. Cincio, A. T. Sornborger, W. H. Zurek, and P. J. Coles, “Variational consistent histories as a hybrid algorithm for quantum foundations,” Nature communications 10, 3438 (2019).
- (34) M. Cerezo, A. Poremba, L. Cincio, and P. J. Coles, “Variational quantum fidelity estimation,” arXiv:1906.09253 [quant-ph] .
- (35) Rigetti Computing, “https://www.rigetti.com/qpu,” .
- Nielsen and Chuang (2011) M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information: 10th Anniversary Edition, 10th ed. (Cambridge University Press, New York, NY, USA, 2011).
- Knill and Laflamme (1998) E. Knill and R. Laflamme, “Power of one bit of quantum information,” Phys. Rev. Lett. 81, 5672–5675 (1998).
- Fujii et al. (2018) K. Fujii, H. Kobayashi, T. Morimae, H. Nishimura, S. Tamate, and S. Tani, “Impossibility of Classically Simulating One-Clean-Qubit Model with Multiplicative Error,” Phys. Rev. Lett. 120, 200502 (2018).
- Morimae (2017) T. Morimae, “Hardness of classically sampling the one-clean-qubit model with constant total variation distance error,” Phys. Rev. A 96, 040302 (2017).
- Kandala et al. (2017) A. Kandala, A. Mezzacapo, K. Temme, M. Takita, M. Brink, J. M. Chow, and J. M. Gambetta, “Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets,” Nature 549, 242 (2017).
- (41) E. Farhi, J. Goldstone, and S. Gutmann, “A quantum approximate optimization algorithm,” arXiv:1411.4028 [quant-ph] .
- Hadfield et al. (2019) S. Hadfield, Z. Wang, B. O’Gorman, E. G. Rieffel, D. Venturelli, and R. Biswas, ‘‘From the quantum approximate optimization algorithm to a quantum alternating operator ansatz,” Algorithms 12, 34 (2019).
- (43) S. Lloyd, “Quantum approximate optimization is computationally universal,” arXiv:1812.11075 [quant-ph] .
- Wang et al. (2018) Z. Wang, S. Hadfield, Z. Jiang, and E. G. Rieffel, “Quantum approximate optimization algorithm for MaxCut: A fermionic view,” Phys. Rev. A 97, 022304 (2018).
- (45) L. Zhou, S.-T. Wang, S. Choi, H. Pichler, and M. D. Lukin, “Quantum approximate optimization algorithm: performance, mechanism, and implementation on near-term devices,” arXiv:1812.01041 [quant-ph] .
- (46) G. E. Crooks, “Performance of the quantum approximate optimization algorithm on the maximum cut problem,” arXiv:1811.08419 [quant-ph] .
- J. D. Powell (2009) M. J. D. Powell, “The BOBYQA algorithm for bound constrained optimization without derivatives,” Technical Report, Department of Applied Mathematics and Theoretical Physics (2009).
- Byrd et al. (1995) P. Byrd, R. H.and Lu, J. Nocedal, and C. Zhu, “A limited memory algorithm for bound constrained optimization,” SIAM Journal on Scientific Computing 16, 1190–1208 (1995).
- Mitarai et al. (2018) K. Mitarai, M. Negoro, M. Kitagawa, and K. Fujii, “Quantum circuit learning,” Phys. Rev. A 98, 032309 (2018).
- (50) A. Harrow and J. Napp, “Low-depth gradient measurements can improve convergence in variational hybrid quantum-classical algorithms,” arXiv:1901.05374 [quant-ph] .
- (51) K. Sharma, S. Khatri, M. Cerezo, and P. J. Coles, “Noise resilience of variational quantum compiling,” arXiv:1908.04416 [quant-ph] .
- Berry et al. (2007) D. W. Berry, G. Ahokas, R. Cleve, and B. C. Sanders, “Efficient quantum algorithms for simulating sparse Hamiltonians,” Communications in Mathematical Physics 270, 359–371 (2007).
- Atia and Aharonov (2017) Y. Atia and D. Aharonov, “Fast-forwarding of hamiltonians and exponentially precise measurements,” Nature communications 8, 1572 (2017).
- Powell (1978) M. J. D. Powell, “A fast algorithm for nonlinearly constrained optimization calculations,” in Numerical analysis (Springer, 1978) pp. 144–157.
- Garcia-Escartin and Chamorro-Posada (2013) J. C. Garcia-Escartin and P. Chamorro-Posada, “Swap test and Hong-Ou-Mandel effect are equivalent,” Phys. Rev. A 87, 052330 (2013).
- Cincio et al. (2018) L. Cincio, Y. Subaşı, A. T. Sornborger, and P. J. Coles, “Learning the quantum algorithm for state overlap,” New Journal of Physics 20, 113022 (2018).
- (57) X. Xu, J. Sun, S. Endo, Y. Li, S. C. Benjamin, and X. Yuan, “Variational algorithms for linear algebra,” arXiv:1909.03898 [quant-ph] .
Appendix A Proof of Proposition 1
Here we prove Proposition 1, which we restate for convenience.
Proposition 1.
The problem of estimating the VQLS cost functions , , , or to within precision is -hard.
Proof.
Let us first show that estimating and is -hard. Our proof is a reduction from the problem of estimating the Hilbert-Schmidt inner-product magnitude between two quantum circuits and acting on -qubits Khatri et al. (2019), where we have defined
(44) |
with .
In particular, let us consider the following specific case of estimating , which in turn can be identified as a specific instance of approximating the cost functions or . Let , and let and be -qubit states given by
(45) | ||||
(46) |
where is an efficient unitary gate that produces a maximally entangled state (e.g., a depth-two circuit composed of Hadamard and CNOT gates). Note that here and correspond to the Choi states of and , respectively. The global cost function is given by
(47) | ||||