Fidelity-based Deep Adiabatic Scheduling

1 INTRODUCTION . Many of the algorithms developed for quantum computing employ the quantum circuit model , in which a quantum state involving multiple qubits undergoes a series of invertible transformations . However , an alternative model , called Adiabatic Quantum Computation ( AQC ) ( Farhi et al. , 2000 ; McGeoch , 2014 ) , is used in some of the leading quantum computers , such as those manufactured by D-Wave Systems ( Boixo et al. , 2014 ) . AQC algorithms can achieve quantum speedups over classical algorithms ( Albash & Lidar , 2018 ) , and are polynomially equivalent to the quantum circuit model ( Aharonov et al. , 2008 ) . In AQC , given a computational problem Q , e.g. , a specific instance of a 3SAT problem , a physical system is slowly evolved until a specific quantum state that represents a proper solution is achieved . Each AQC run involves three components : 1 . An initial Hamiltonian Hb , chosen such that its ground state ( in matrix terms , the minimal eigenvector of Hb ) is easy to prepare and there is a large spectral gap . This is typically independent of the specific instance of Q . 2 . A final Hamiltonian Hp designed such that its ground state corresponds to the solution of the problem instance Q . 3 . An adiabatic schedule , which is a strictly increasing function s ( t ) that maps a point in time 0 ≤ t ≤ tf , where tf is total computation time , to the entire interval [ 0 , 1 ] ( i.e. , s ( 0 ) = 0 , s ( tf ) = 1 , and s ( t1 ) < s ( t2 ) iff t1 < t2 and vice versa ) . These three components define a single time-dependent HamiltonianH ( t ) , which can be seen as an algorithm for solving Q : H ( t ) = ( 1− s ( t ) ) · Hb + s ( t ) · Hp ( 1 ) At the end of the adiabatic calculation , the quantum state is measured . The square of the overlap between the quantum state and ground state of the final Hamiltonian , is the fidelity , and represents the probability of success in finding the correct solution . An AQC algorithm that is evolved over an insufficient time period ( a schedule that is too fast ) will have a low fidelity . Finding the optimal schedule , i.e. , the one that would lead to a high fidelity and would keep the time complexity of the algorithm minimal is , therefore , of a great value . However , for most problems , an analytical solution for the optimal schedule does not exist ( Albash & Lidar , 2018 ) . Attempts were made to optimize specific aspects of the adiabatic schedule by using iterative methods ( Zeng et al. , 2015 ) or by direct derivations ( Susa et al. , 2018 ) . Performance was evaluated by examining characteristics of the resulting dynamic ( e.g . the minimum energy gap ) and no improvement was demonstrated on the full quantum calculation . Previous attempts to employ AI for the task of finding the optimal schedule have relied on Reinforcement Learning ( Lin et al. , 2020 ; Chen et al. , 2020 ) . While these methods were able to find schedules that are better than the linear path , they are limited to either learning one path for a family of problems ( without considering the specific instance ) or to rerunning the AQC of a specific instance Q multiple times in order to optimize the schedule . In our work , supervised learning is employed in order to generalize from a training set of problems and their optimal paths to new problem instances . Training is done offline and the schedule our neural model outputs is a function of the specific problem instance . The problem instance is encoded in our model either based on the final HamiltonianHp or directly based on the problem . The suggested neural models are tested using several different problem types : Grover search problems , 3SAT and MAX-CUT problems , and randomized QUBO problems . We show that the evolution schedules suggested by our model greatly outperform the naive linear evolution schedule , as well as those schedules provided by the recent RL methods , and allow for much shorter total evolution times . 2 BACKGROUND . The goal of the scheduling task is to find a schedule s ( t ) that maximizes the probability to get the correct answer for instance Q , using Hb and Hp over an adiabatic quantum computer . The solution to Q is coded as the lowest energy eigenstate ofHp . In order to achieve the solution state with high probability , the system must be evolved “ sufficiently slowly ” . The adiabatic theorem ( Roland & Cerf , 2002 ; Albash & Lidar , 2018 ; Rezakhani et al. , 2009 ) is used to analyze how fast could this evolution be . It states that the probability to reach the desired state at the end of the adiabatic calculation is 1− ε2 for ε < < 1 if∣∣〈E1 ( t ) | ddtH ( t ) |E0 ( t ) 〉∣∣ g2 ( t ) ≤ ε ( 2 ) where the Dirac notation ( Tumulka , 2009 ) is used1 , E0 ( t ) ( E1 ( t ) ) is the ground state ( first excited state ) of the time dependent Hamiltonian H ( t ) , i.e. , the eigenstates that corresponds to the lowest ( 2nd lowest ) eigenvalue , and g ( t ) is the time dependent instantaneous spectral gap between the smallest and second smallest eigenvalues ofH ( t ) . Let tf be the total calculation time . let s ( t ) be an evolution schedule , such that s ( 0 ) = 0 , s ( tf ) = 1 . Applying the adiabatic condition for s ( t ) , we get∣∣〈E1 ( s ( t ) ) | dsdt ddsH ( s ( t ) ) |E0 ( s ( t ) ) 〉∣∣ g2 ( s ( t ) ) ≤ ε⇒ ds dt ≤ ε g 2 ( s ) ∣∣〈E1 ( s ) | ddsH ( s ) |E0 ( s ) 〉∣∣ ( 3 ) we could solve for t ( s ) by integration to get t ( s ) = 1 ε s∫ 0 ∣∣〈E1 ( s ) | ddsH ( s ) |E0 ( s ) 〉∣∣ g2 ( s ) ds ( 4 ) and the total required evolution time is tf = t ( s = 1 ) = 1 ε 1∫ 0 ∣∣〈E1 ( s ) | ddsH ( s ) |E0 ( s ) 〉∣∣ g2 ( s ) ds ( 5 ) 1See appendix A for the conventional matrix notation . We note that finding a numerical solution for eq 4 requires calculating the full eigenvalue decomposition ofH ( x ) . 2.1 MOST-RELATED WORK . Two recent contributions use deep learning in order to obtain , for a given tf , a schedule that outperform the linear schedule . Lin et al . ( 2020 ) suggest using deep reinforcement learning in order to find an optimal schedule for each specific class of problems ( e.g. , 3SAT problems of a certain size ) . In contrast , we study the problem of finding schedules for generic problem instances . They train and benchmark their performance by simulating an adiabatic quantum computer , and scoring the computation results for randomly chosen problem instances . Their results are generally better than the naive linear schedule , and the solution produced by their neural network is somewhat transferable for larger problem sizes . Chen et al . ( 2020 ) also use RL to construct , given a tf , a schedule for 3SAT problems . The most successful technique suggested is a Monte Carlo Tree Search ( MCTS , Silver et al . ( 2016 ) ) , which produces results that significantly outperform the linear schedule . This technique requires running the adiabatic evolution process many times for each problem , in order to find a successful schedule . An approach inspired by alpha-zero ( Silver et al. , 2018 ) is used to adapt the generic MCTS solution to specific problem class , while requiring only a few additional rounds of the adiabatic process for each new instance . In our method , we do not require any run given a new problem instance . 3 METHOD . We consider two types of deep neural models . The first model is designed to get the problem Hamiltonian Hp as an input . For an n qubit problem , the problem Hamiltonian is generally of size 2n×2n . In this work , we consider problem Hamiltonians which are diagonal and can be represented by vector of size 2n . This scenario covers both the Grover search problem and the 3SAT problem we present in Sec . 4 . The second model is designed to get a quadratic unconstrained binary optimization ( QUBO ) problem as an input . The QUBO problem has the following form : x̄ = argminx ( x TQx ) , ( 6 ) where x is a vector of binary variables and Q ∈ Rn×n defines the specific QUBO instance . The QUBO problem is NP-Complete , and many types of common problems can be reduced to QUBO ( Glover et al. , 2018 ) . The QUBO formulation is of special interest in the context of adiabatic quantum computing , since it allows a relatively easy mapping to real quantum annealing devices that do not possess full qubit connectivity ( Cruz-Santos et al. , 2019 ) . A QUBO problem Q can be converted to the Hamiltonian form in the following fashion : Hp = n∑ i=1 Qii ( I + σiz 2 ) + ∑ i6=j Qij ( I + σiz 2 ) ( I + σjz 2 ) , ( 7 ) where σiz is the Pauli matrix σz operating only on qubit i ( Liboff , 2003 ) . The resultingHp is of size 2n × 2n and is diagonal . The prediction target of our models is the desired normalized schedule ŝ ( t ) , which is defined over the range [ 0 , 1 ] as ŝ ( t ) = s ( t/tf ) . For the purpose of estimation , it is sampled at 100 points in the interval t = [ 0 , 1 ] . The representation of this schedule is given as a vector d ∈ [ 0 , 1 ] 99 , which captures the temporal derivative of the schedule . In other words , d is trained to hold the differences between consecutive points on the path , i.e. , element i is given by di = ŝ ( ( i+ 1 ) /100 ) − ŝ ( i/100 ) . Note that the sum of d is one . 3.1 UNIVERSALITY OF THE OPTIMAL SCHEDULE . The reason that we work with the normalized schedule is that the optimal evolution schedule is not dependent upon the choice of tf . As shown next , for every time budget tf , the same normalized schedule would provide the highest fidelity ( neglecting decoherence ) . Let s1 ( t ) : [ 0 , tf ] → [ 0 , 1 ] be a suggested evolution schedule , which outperforms a different suggested schedule s2 ( t ) , for a specific tf = τ1 , i.e . it achieves a greater fidelity at the end of the schedule for a specific problem instance Q . Then , Thm . 1 shows that s1 ( t ) outperforms s2 ( t ) for every possible choice of tf for the same problem Q. Theorem 1 . Let s1 ( t ) and s2 ( t ) be two monotonically increasing fully differentiable bijective functions from [ 0 , tf = τ1 ] to [ 0 , 1 ] . Let Q be an optimization problem , and assume that s1 ( t ) achieves a greater fidelity than s2 ( t ) at the end of a quantum adiabatic computation for Q with total evolution time tf = τ1 . Then , for any other choice tf = τ2 , the scaled schedule s1 ( τ2τ1 t ) will achieve a greater fidelity than s2 ( τ2τ1 t ) for an adiabatic computation over the same problem Q with total evolution time tf = τ2 . The proof can be found in appendix B .

Summary: the paper proposes to learn parametric form of optimal quantum annealing schedule. Authors construct 2 versions of neural network parameterizations mapping problem data onto an optimal schedule. They train these networks on artifically generated sets of problem of different size and test final models on the Grover search problem as well as 3SAT. Experiments demonstrate improved performance in comparison to existing approaches.