Large-scale Quantum Approximate Optimization via Divide-and-Conquer
LLarge-scale Quantum Approximate Optimization viaDivide-and-Conquer
Junde Li
Pennsylvania State University [email protected]
Mahabubul Alam
Pennsylvania State University [email protected]
Swaroop Ghosh
Pennsylvania State University [email protected]
Abstract —Quantum Approximate Optimization Algorithm(QAOA) is a promising hybrid quantum-classical algorithm forsolving combinatorial optimization problems. However, it cannotovercome qubit limitation for large-scale problems. Furthermore,the execution time of QAOA scales exponentially with the prob-lem size. We propose a Divide-and-Conquer QAOA (DC-QAOA)to address the above challenges for graph maximum cut (Max-Cut) problem. The algorithm works by recursively partitioninga larger graph into smaller ones whose MaxCut solutions areobtained with small-size NISQ computers. The overall solutionis retrieved from the sub-solutions by applying the combinationpolicy of quantum state reconstruction. Multiple partitioningand reconstruction methods are proposed/ compared. DC-QAOAachieves 97.14% approximation ratio (20.32% higher than clas-sical counterpart), and 94.79% expectation value (15.80% higherthan quantum annealing). DC-QAOA also reduces the timecomplexity of conventional QAOA from exponential to quadratic.
I. I
NTRODUCTION
Quantum Computing (QC) can offer unique advantages overclassical computing in many important areas such as, ma-chine learning and optimization [1]–[3]. Approximate hybridquantum-classical algorithms such as, Quantum ApproximateOptimization Algorithm (QAOA) [4] is proposed to work inpresence of noise sources in near-term NISQ machines. QAOAcontains a variational quantum circuit and a classical optimizer(Figure 1(c)) to approximately solve combinatorial optimiza-tion (CO) problems like MaxCut [4]. However, QAOA isclaimed to be 20X slower than its classical counterpart forfinding MaxCut of a 20 node graph since the number ofoperations and circuit depth p in quantum simulation bothscale exponentially with graph size [5]. We propose a divide-and-conquer QAOA (DC-QAOA) to solve large-scale com-binatorial problems and to reduce the QAOA computationalcomplexity. All experiments on quantum optimization areconducted on the representative MaxCut problems. Proposed idea:
DC-QAOA (Figure 1) has two components: (i) Graph splitting which recursively divides the large-scalegraph with nodes greater than the qubit size of a targetquantum hardware into subgraphs by using
Large GraphPartitioning (LGP) policy. The MaxCut of subgraphs can besolved efficiently using QAQA on quantum simulator or realquantum computers. Solution of the original graph is retrievedusing the combination policy of
Quantum State Reconstruction(QSR) . If a pair of subgraphs have a single common nodeand no crossing edges, that would be ideal scenario. Eachsubgraph MaxCut can be solved individually and sub-solutionscan be combined to determine the MaxCut of the large graph. However, real cases can share more nodes that incur extraqubit overhead and also reduce the accuracy of quantum statereconstruction. The objective of
Large Graph Partitioning policy is to minimize the crossing edges and number ofcommon nodes. Figure 1(a) shows a large-scale 10-node graphto be solved on a 6-qubit NISQ machine. Our
Naive LPG approach iteratively increases the number of common nodeswhile avoiding crossing edges until a nodal-separation path isfound (refer to Algorithm 1). With
Naive LPG , path ( , ) isone of the valid separations for graph in Figure 1(a), wherenodes and are shared. Partitioning with minimized numberof common nodes and crossing edges takes up least qubitresources by our DC-QAOA algorithm. We propose the NodeRedundancy Level (NRL) metric to evaluate the effectivenessof the splitting graph.
N RL is the ratio of the sum of subgraphnode size to the original graph node size. (ii) Quantum state reconstruction that aims to reconstructthe full quantum state from experimentally accessible mea-surements for a quantum system [6], [7]. Multiple reconstruc-tion schemes existing in literature, such as, Born’s rule inprobability representation and Wigner function [7]. However,the
Quantum State Reconstruction (QSR) policy used in thecurrent study is different from the conventional reconstructionconcept since we intend to reconstruct a larger quantum statefrom available measurements of its quantum sub-systems.
Onemay intuitively doubt the effectiveness of
QSR policyfor combining subgraph solutions because entanglemententropy cannot be reconstructed from two separate quan-tum systems. Fortunately, qubit entanglement createdby
Controlled-NOT (CNOT) gates between subgraphs isbypassed by our
LGP policy which avoids crossing edges .The combination policy only applies to quantum algorithmslike QAOA due to the requirement of state measurements.After the optimal gate parameters are found in Figure 1(c),we obtain the quantum state frequency distribution by takingcertain number of measurements from each subgraph solutionspace. The larger quantum state is reconstructed by strictlycomplying with the combination criterion of sharing the samecut set S for each common node. For instance, str and str in Figure 1(d) are two highly sampled solution strings fromtheir subgraphs, respectively, and node belongs to the samecut set S and node belongs to the complementary set ¯ S fromeach sub-solution. Therefore, the combined solution string is the optimal cut solution for original graph inFigure 1(a). Once the combination criterion is satisfied, multi- a r X i v : . [ c s . ET ] F e b ig. 1. Finding MaxCut for a large-scale graph using the proposed DC-QAOA algorithm: (a) a graph with 10 nodes that is unsolvable on a small quantumcomputer (say with 6 qubits); (b) graph partitioning heuristic (proposed LGP policy) splits the larger graph into two subgraphs with almost equal number ofnodes (say only nodes 4 and 5 are shared in this graph); (c) MaxCut of each subgraph is solved by the hybrid QAOA, where each cost Hamiltonian is evolvedand measured on the small quantum hardware and variational gate parameters are classically updated during every iteration; (d) the solution for original largegraph is retrieved using the combination algorithm (proposed
QSR policy) which takes the sampling distribution of each subgraph solution as input. ple reconstruction schemes can be adopted, such as, by takingthe minimum of the two solution string frequencies, or takingtheir product, etc. We evaluate the reconstruction quality ofeach scheme using the expectation value and
Kullback–Leiblerdivergence as metric relative to the estimated quantum statefrom the original graph.
Contributions:
We propose, (a) a novel DC-QAOA algo-rithm for solving large-scale MaxCut problems with expo-nential speedup suitable for small NISQ machines; (b) novel
Quantum State Reconstruction policy for approximately re-constructing the quantum state of a large system from its sub-systems; (c) evaluation of
Large Graph Partitioning schemeusing our
Node Redundancy Level metric. Our algorithm onlyapplies to input graphs with connectivity less than maximumallowed qubit size. However, qubits provided by near-termquantum computers or simulator are reasonably sufficient.II. R
ELATED W ORK AND M OTIVATION
Solving large problems on small NISQ hardware:
Dunjkoet al. [8] proposed a hybrid algorithm for solving 3SATproblems on quantum computers with limited number ofqubits. Ge & Dunjko [9] proposed another hybrid algorithmto enhance Eppstein’s algorithm for finding cubic Hamiltoniancircle in degree-3 graphs. However, these hybrid algorithms donot apply to the MaxCut problem addressed in this paper.
QAOA:
The QAOA circuit (see Figure 2) can be configuredwith p layers by repeating the non-H gates for p times, whilethe gate parameter pair ( γ i , β i ) corresponds to layer i . Thefinal quantum state is measured and the expectation value iscalculated accordingly. Classical optimizer updates the gateparameters until convergence is reached (Figure 1(c)).The classical brute-force method runs significantly fasterthan the hybrid QAOA algorithm configured with 10 iterationswithout sampling of quantum states (Figure 3(a)). The QAOAalgorithm with 3000 samples takes 27.77 hours for solving theMaxCut of a 12-node graph, while QAOA without samplingtakes 51.79s compared to 0.08s by brute force method. Allthe four solver schemes scale exponentially with graph size.Figure 3 (b) shows the decreasing approximation ratios ofQAOA in general for all 4 different layers, relative to theground truth cut solutions from brute force. H HH Z Z XXX Q Q Q Fig. 2. QAOA circuit after graph is mapped on a small quantum system forgetting MaxCut solution. Gate parameters ( γ i , β i ) are not shown here. Motivation:
Currently, QAOA is far from achieving quan-tum advantage for MaxCut problems compared to classicalcounterparts. We aim to speed up QAOA algorithm expo-nentially for large-scale graphs with up to 100 nodes. Letus assume a large-scale graph has N nodes and maximumavailable quantum qubit size is K . QAOA running on aquantum simulator has O (2 N ) time complexity, while DC-QAOA achieves O ( N K (1+1 /K ) N ) complexity, where eachsmall problem takes constant time.III. P ROPOSED M ETHODOLOGIES
A. Large Graph Partitioning
Background:
Graph partitioning can be classified into edgeseparator and node separator . Given a graph G ( N, E ) , nodeseparator N s separates the graph G into two disconnectedcomponents G and G if all nodes in N s and incident edgesare removed. We note that node connectivity algorithm is mostrelated to our partitioning policy. Node connectivity is theminimum number of nodes that must be removed to disconnectan input graph. However, node connectivity algorithm cannotbe directly applied to our partition task since the foundseparation nodes are not shared by two subgraphs.
LGP description:
Let G ( V, E ) be an undirected graphwith n vertices an m edges. All the edges are unweighted orconsidered with a weight of 1. LGP partitions G into exactlytwo subsets, S and ¯ S no larger than a given maximum sizeof k (i.e., available qubit size in NISQ computers). Note thatat least one shared node is required such that no edges are Graph node size -20-1001020 T i m e on l og sc a l e brute-force0-sample1000-sample3000-sample Graph node size A pp r o x i m a t i on r a t i o p=1p=2p=3p=4 (a) (b) Fig. 3. (a) Time on log scale (base 2) elapsed for solving MaxCut of thegraphs with node size from 4 to 12 by classical brute force and QAOA withthree different sampling configurations; (b) approximation ratio of QAOA with0-sample configuration at different quantum circuit depth from p = 1 to 4. missing after each partition. The path connecting the sharednodes ( s , s , ..., s i ) forms the final separation line. The metric Node Redundancy Level (NRL) is defined as the ratio ofsum of node sizes from subgraphs to n for measuring thequality of partition. We propose the Naive LGP scheme forapproximately minimizing the cut cost in Algorithm 1.
Algorithm 1
Naive LGP Heuristic (NLGP)
Input: G ( V, E ) - connected graph; k - maximum node size. Output: S = { S , S } - final set of subgraphs.counter = 1 while counter < k do paths = [] if counter = 1 then paths ← V else pos path ← [ v , v , ..., v counter ] if len(unique(pos path)) = counter then paths.append(pos path) endend for p in paths do G ← G(V-p, E) S ← dfs connected components(G ) if len(S) = 2 thenreturn S S and S endend counter ++ end print (G has connectivity above k ) return {} Proposed separation paths:
NLGP heuristic proposes allpossible separation paths with counter number of nodes. For counter = 1 , the paths list incorporates each node. Each edge ( u, v ) is proposed for finding path candidates with two nodesfor counter = 2 . For < counter < k , code block in elsestatement simplifies the counter − nested edges loops thatis the time intensive part O ( m k ) in worst case of NLGP . Select workable path:
Each path candidate is a set p composed of a sequence of nodes. A new graph G is reducedfrom G by removing all nodes in p and incident edges. Thenew graph is fed into Depth-first Search (DFS) algorithm forfinding all connected components. The right separation pathis found until DFS outputs exactly 2 connected components.The NLGP heuristic only separates input graph G into twosubsets S and S , thus subgraphs containing node set S or S will execute the same NLGP heuristic until all final subsetsare within maximum node size k . Two subsets after everypartition may not have equal node size, however, the Naiveheuristic still does not affect the partition efficiency if therecursive process is not employed in parallel. Like usual nodeconnectivity algorithm, NLGP cannot separate input graph G with connectivity greater than k . B. Quantum State Reconstruction
Background:
Unlike conventional quantum state tomogra-phy [6], [10], [11], our
QSR policy approximately reconstructsthe quantum state of a larger system from state distributionsof its two quantum sub-systems. The set of measurementoperators must span all possible Hermitian measurements toaccurately reconstruct the quantum state. However, the numberof measurements grow exponentially with the number of qubitspreventing the quadratic-time execution for large-scale graphs.We only sample the measurements for a certain number oftimes to circumvent the exponential growth rate.
QSR description:
LGP policy avoids crossing edges be-tween two subgraphs, which makes the state construction of aparent system possible by getting rid of qubit entanglementbetween sub-systems. The reconstruction quality is quanti-tatively measured by the similarity between reconstructedquantum state distribution and original quantum state usingKL divergence since our objective is to reconstruct quantumstate as close as to parent quantum state.Algorithm 2 shows the logic for combining bit string solu-tions from the subgraphs. Each bit string solution map keepsthe pairs of quantum state and its corresponding samplingfrequency. The validity code line checks if the aforementioned combination criterion is met before the original bit string isreconstructed. Multiple
QSR schemes may apply here suchas, min , mul , sum , etc. Algorithm 2 takes the example of min scheme where the minimum frequency counts is applied. Sum returns the sum of counts from two solution maps, while mul returns the multiplication. It is worth mentioning that not allbit string solutions are sampled most frequently all the timebecause of the probabilistic nature of quantum measurement.To counteract this unwanted effect, an important re-rankingmechanism is followed by re-ranking the frequency countsbased on the calculated cut sizes of their corresponding bitstrings. The complexity of re-ranking mechanism (not shownin Algorithm 2) is O (2 k ) in worst case.To compare the reconstruction quality of several possible QSR schemes, we conduct several experiments on a toy 5-node graph, shown in Figure 4 (a), where the single node forms the separation path. The quantum basis state of subgraph ig. 4. Quantum state reconstruction demonstration with 1000 samples and circuit depth of 3: (a) a toy graph G partitioned into G and G by a singlecommon node 2; (b-c) quantum state distributions of subgraphs G and G on small quantum hardware (6 optimal solution strings for G and 2 optimalones for G ); (d) quantum state distribution of original graph on a larger hardware (6 optimal solution strings); (e-g) reconstructed quantum state distributionsof three QSR schemes of min , mul and minXmul , respectively (sampling frequency of each scheme is re-scaled with 1000 total samples). G (with node 0, 1 and 2) and G (with rest of the nodes) issampled 1000 times from quantum system with circuit depthof 3, respectively (Figure 4(b-c)). Figure 4(d) displays thebasis state sampling distribution for the original graph. Afterextensive search of possible schemes, min , mul and minXmul (the product of min and mul ) are found to be good candidates(Figure 4(e-g)). Ideally, all measurement results fall on theoptimal 6 basis states corresponding to 6 optimal MaxCutsolutions for the toy graph with equal likelihood of . (in absence of quantum noise and infinite number of samples).Intuitively, min scheme prevents unbalanced distribution forfurther reconstruction compared to the original distributionhowever, non-optimal states are highly weighted. Non-optimalstates are relatively well kept by mul scheme, but frequenciesof optimal states are not as good as minXmul scheme.The reconstruction quality is quantitatively measured with KL divergence and the expectation value metrics.
Mul schemeachieves the lowest entropy ( . ) followed by minXmul ( . ), and min achieves the highest divergence ( . ),relative to the original distribution. Due to the uncertain natureof parent state distribution, we consider mul and minXmul with the same level of reconstruction quality. Note that, lowerentropy score only indicates closer reconstruction to parentstate distribution, but not better quantum expectation value ingeneral. Quantum expectation value is defined as the averagecut size of certain input graph, and also approximation ratioif divided by the known MaxCut. Therefore, expectationvalue of parent quantum system and all QSR schemes arefurther evaluated. Expectation value calculated through thesampling frequencies reaches 3.52 (88% approximation ratio)for original quantum system, with 4 being MaxCut for graph inFigure 4(a). Apparently min scheme achieves the lowest value of 2.97 (74.27% approximation ratio), while minXmul schemeachieves the highest value of 3.72 (93% approximation ratio).By trying more complicated
QSR schemes we can achieveeven higher approximation ratio.
Algorithm 2
Quantum State Reconstruction (QSR)
Input: g , g - two subgraphs with few common nodes; str cnt , str cnt - string solution maps for g and g . Output: com cnt - combined bit string solution map.com cnt ← {} common node ← intersection( g .nodes , g .nodes ) for (str1, cnt1) in str cnt1 dofor (str2, cnt2) in str cnt2 do validity ← [str1[v] = str2[v] for v in common node] if False not in validity then com str ← (cid:48)(cid:48) for i in unique( g .nodes + g .nodes ) doif i in g .nodes then com str.join(str1[i]) else com str.join(str2[i]) endend com cnt[com str] ← min(cnt1, cnt2) endendend com cnt ← sorted(com cnt) return com cnt . DC-QAOA DC-QAOA (Algorithm 3) recursively divides large-scalegraph with
LGP policy and combines sub-solutions with
QSR policy via divide-and-conquer paradigm. The input graph ispartitioned into exactly 2 subgraphs with
LGP policy if itsnode size is greater than allowed qubit size k , or directlysolved by conventional QAOA otherwise. Each subgraphrecursively call the DC-QAOA function until all their sub-solutions str cnt are returned. Note that, two sub-solutionsemploy a weighting mechanism before being combined whichassigns weights based on their respective node sizes to eachfrequency count. The weighting mechanism provides a meansto allocating higher priority to the subgraph with more nodes,though both are within k -node. A parent solution (quantumstate) out cnt is further reconstructed by calling the LGP policy with subgraphs and their sub-solutions as arguments.For output out cnt directly returned from QAOA, solutionpairs are sorted by frequency count, using the same sortingscheme employed by Algorithm 2.
Algorithm 3
Divide-and-Conquer QAOA (DC-QAOA)
Input: g - input graph; p - quantum circuit depth; t - top t samples; s - number of samples; k - max qubit size. Output: out cnt - bit string solution map for g . if len(g.nodes) > k then g , g ← LGP ( g, k ) common node ← intersection( g .nodes , g .nodes ) str cnt ← DC-QAOA ( g ) str cnt ← DC-QAOA ( g ) str cnt ← { k: v*len(k) for k, v in str cnt } str cnt ← { k: v*len(k) for k, v in str cnt } out cnt ← QSR ( g , g , str cnt , str cnt else out cnt ← qaoa maxcut ( g, p ) out cnt ← sorted ( out cnt ) end t (str, cnt) pairs by sorted order out cnt ← abridged ( out cnt, t ) s or around cnt sum ← the sum of all counts in out cntout cnt ← { k: int(s*v/cnt sum) for (k, v) in out cnt } return out cnt At the end, we employ selection and re-scaling. The selec-tion mechanism only retains the top t sorted str-cnt solutionpairs. If some str-cnt pairs with zero count are within the top t , only pairs with non-zero count are retained. The selectionmechanism only keeps top cut solutions which prevents ex-ponential scaling with the number of quantum logical states.It also reduces the noise caused by non-optimal solutionsfor further parent state reconstruction. The re-scaling step isapplied for capping the sum of counts at s otherwise the recon- structed state distribution may become extremely unbalanced(especially for mul QSR scheme) for further reconstruction. D. DC-QAOA Complexity
The worst case time complexity of
Naive LGP policyis O ( m k ) . However, graph partitioning solution is usuallyfound with only few iterations indicating a way more effi-cient average-case run time. Exponential speedup is achievedprimarily due to the selection mechanism in QSR policy whichguarantees constant time for each parent state reconstruction.Each divided small problem is solved by conventional QAOAonly in constant time. Assuming
LGP policy splits graph intosubgraphs with almost equal size, the overall DC-QAOA runtime is dominated by partitioning T ( LGP ) . Each partitionshares at most k common nodes and there are approximately N/k partitions in total. Thus the overall approximate run timeis O ( N K (1 + 1 /K ) N ) .IV. E VALUATION
A. Experimental Setup
A set of large-scale graphs with varied size is randomlygenerated using NetworkX package for evaluating DC-QAOAperformance. We conduct a series of sensitivity analyses forchoosing appropriate parameters of t , s , and k based on asingle 100-node graph. The baseline algorithm chooses t = 20 , s = 1000 and k = 8 . The tuning results are shown inFigure 5. From Figure 5(a), larger number of allowed qubitssignificantly decreases node redundancy level by separatingthe input graph into less number of sub-problems, howeverit increases the overall run time due to exponential growthrate of QAOA. The algorithm is configured with k = 7 tosolve MaxCut of input graph with larger connectivity. As morenumber of quantum basis states are retained, the likelihood ofthese solution strings being optimal reduces. If the numberof kept states are too small it is subjected to quantum statereconstruction noise. We pick t = 20 where the expectationvalue is maximized and the run time is relatively low (Figure5(b)). The approximation ratio in Figure 5(c) depends onthe number of samples in general because quantum statereconstructed from a larger number of measurements reflectsthe real state more accurately. Only 2000 samples are takendue to the exponentially growing sampling time. During allthese 18 experiments, the least approximation ratio of 96.97%is obtained only once at s = 250 , while . is achievedfor 7 times. For all other cases, we noted approximationratio. Therefore, we assume that DC-QAOA is able to generate(near-)optimal MaxCut solution for large-scale graphs as longas enough samples (say, 5000) are measured. B. Comparison
For fair evaluation of DC-QAOA, we also implement severalcounterpart classical MaxCut solvers and quantum annealing.
Classical counterparts:
MaxCut problem has the reducedform of QUBO framework. Therefore, classical QUBO solverssuch as, Random Search [12] and Gubori solver [13] apply toMaxCut problem as well. Gurobi optimizer is able to generate
NRLTime (1000s)
10 20 30
EVTime (1000s)
250 5001000200040008000
ARTime (1000s)
Graph node size A pp r o x i m a t i on R a t i o Random SearchDC-QAOAMaximum cut
Graph node size E x pe c t a t i on v a l ue Quantum AnnealingDC-QAOATime (1000 s) (a) (b) (c) (d) (e)
Fig. 5. (a) Smaller allowed qubit size increases node redundancy level (NRL) but reduces overall run time; (b) number of retained quantum basis statesaffects the expectation value (EV); (c) larger number of measurements (samples) increases approximation ratio (AR); (d) approximation ratio comparison withrepresentative random search classical algorithm, together with ground truth MaxCut from Gurobi optimizer; (e) expectation value comparison with quantumannealing (from D-Wave Systems) together with run time of DC-QAOA for 7 graph instances. optimal solutions by modeling the MaxCut problem withinteger linear programming [14] problem. However, its runtime scales exponentially since integer programming is NP-complete. We compare DC-QAOA with classical algorithmson 7 generated graph instances from NetworkX package withvarying number of graph size. As depicted in Figure 5(d),the classical algorithm Random Search shows compromisedapproximation ratio of 80.73%, while DC-QAOA achieves97.14% which is 20.32% higher. The optimal MaxCut sizecalculated from Gurobi optimizer is also shown here as groundtruth. The classical algorithm runs significantly faster, withina second for each graph instance, at the expense of highlycompromised approximation ratio. Run time of DC-QAOA isdisplayed in Figure 5(e).
Quantum counterparts:
QAOA is unable to efficientlyhandle large-scale problems. Thus we take quantum annealingmethod implemented on D-Wave Systems as the quantumcounterpart of DC-QAOA. Quantum annealer is the hardwarespecifically designed for QUBO problems, and its comparisonwith DC-QAOA implemented on universal quantum comput-ers provides insights on the characteristics of two types ofquantum computing techniques. Quantum annealing involvesthe minor embedding step which maps graph nodes to physicalqubits on the hardware. Even though D-Wave 2000Q systemsupports large qubit size, valid embedding might not be foundif an input graph has just few hundreds of nodes but with denseedge connectivity. Since the probabilistic nature also exists inquantum annealing, expectation value is compared betweenQA and DC-QAOA for these graph instances (Figure 5(e)).Note that QA is able to solve each graph instance within 20seconds, and run time of quantum annealing largely dependson minor embedding process because the annealing processevolves with quantum advantage. Though DC-QAOA is slowerthan QA, its run time curve grows with a polynomial rate.V. C
ONCLUSION
We propose DC-QAOA to solve large-scale MaxCut withexponential speedup compared to conventional QAOA. Theproposed Naive
LGP policy reduces algorithm run time fromexponential to polynomial complexitywhile the
QSR policyrelies on measurements from sub-solution states and enables recursive state reconstruction for parent quantum states. DC-QAOA generates optimal or near-optimal solutions, dependingon the number of measurements on quantum states, while clas-sical algorithms achieve exponential speedup at the expenseof compromised approximation ratio. The selection mecha-nism in
QSR policy guarantees parent string solutions arereconstructed with high quality, making DC-QAOA superiorto quantum annealing in terms of expectation value.A
CKNOWLEDGEMENT
The work is supported in parts by National Science Foun-dation (OIA-2040667, CNS-1722557, CCF-1718474, DGE-1723687 and DGE-182176) and seed grants from Penn StateInstitute for Computational and Data Sciences and Penn StateHuck Institute of the Life Sciences.R
EFERENCES[1] 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 eigenvaluesolver on a photonic quantum processor,”
Nature communications , vol. 5,p. 4213, 2014.[2] J. Biamonte, P. Wittek, N. Pancotti, P. Rebentrost, N. Wiebe, andS. Lloyd, “Quantum machine learning,”
Nature , vol. 549, no. 7671, pp.195–202, 2017.[3] L. Hu, S.-H. Wu, W. Cai, Y. Ma, X. Mu, Y. Xu, H. Wang, Y. Song,D.-L. Deng, C.-L. Zou et al. , “Quantum generative adversarial learningin a superconducting quantum circuit,”
Science advances , vol. 5, no. 1,p. eaav2761, 2019.[4] E. Farhi, J. Goldstone, and S. Gutmann, “A quantum approximateoptimization algorithm,” arXiv preprint arXiv:1411.4028 , 2014.[5] G. G. Guerreschi and A. Y. Matsuura, “Qaoa for max-cut requireshundreds of qubits for quantum speed-up,”
Scientific reports , vol. 9,no. 1, p. 6903, 2019.[6] G. Torlai, G. Mazzola, J. Carrasquilla, M. Troyer, R. Melko, andG. Carleo, “Neural-network quantum state tomography,”
Nature Physics ,vol. 14, no. 5, pp. 447–450, 2018.[7] U. Leonhardt, “Quantum-state tomography and discrete wigner func-tion,”
Physical review letters , vol. 74, no. 21, p. 4101, 1995.[8] V. Dunjko, Y. Ge, and J. I. Cirac, “Computational speedups using smallquantum devices,”
Physical Review Letters , vol. 121, no. 25, p. 250501,2018.[9] Y. Ge and V. Dunjko, “A hybrid algorithm framework for small quantumcomputers with application to finding hamiltonian cycles,”
Journal ofMathematical Physics , vol. 61, no. 1, p. 012201, 2020.[10] Z. Yang, Z.-Y. Fan, L.-Z. Mu, and H. Fan, “Approximate quantum statereconstruction without a quantum channel,”
Physical Review A , vol. 98,no. 6, p. 062315, 2018.[11] D. Greenberger, K. Hentschel, and F. Weinert,
Compendium of quantumphysics: concepts, experiments, history and philosophy . SpringerScience & Business Media, 2009.12] T. Friedrich, A. Gobel, F. Neumann, F. Quinzan, and R. Rothenberger,“Greedy maximization of functions with bounded curvature under par-tition matroid constraints,” vol. 33, pp. 2272–2279, 2019.[13] G. OPTIMIZATION, “Inc. gurobi optimizer reference manual, 2015,” , p. 29, 2014.[14] A. Schrijver,