Quantum Annealing-Based Software Components: An Experimental Case Study with SAT Solving
QuQuantum Annealing-Based Software Components:An Experimental Case Study with SAT Solving
Tom Kr¨uger
Wolfgang Mauerer
Technical University of Applied Sciences RegensburgSiemens AG, Corporate Research, [email protected]
ABSTRACT
Quantum computers have the potential of solving problems moreefficiently than classical computers. While first commercial proto-types have become available, the performance of such machinesin practical application is still subject to exploration. Quantumcomputers will not entirely replace classical machines, but serveas accelerators for specific problems. This necessitates integratingquantum computational primitives into existing applications.In this paper, we perform a case study on how to augment ex-isting software with quantum computational primitives for theBoolean satisfiability problem (SAT) implemented using a quantumannealer (QA). We discuss relevant quality measures for quantumcomponents, and show that mathematically equivalent, but struc-turally different ways of transforming SAT to a QA can lead tosubstantial differences regarding these qualities. We argue thatengineers need to be aware that (and which) details, although theymay be less relevant in traditional software engineering, requireconsiderable attention in quantum computing.
KEYWORDS
Quantum Computing, Quantum Annealing, Boolean Satisfiability,Experimental Performance Analysis
ACM Reference format:
Tom Kr¨uger and Wolfgang Mauerer. 2020. Quantum Annealing-BasedSoftware Components:An Experimental Case Study with SAT Solving . In
Proceedings of IEEE/ACM42nd International Conference on Software Engineering Workshops , Seoul,Republic of Korea, May 23–29, 2020 (ICSEW’20),
The upcoming end of Moore’s law and the trend towards energyefficient systems, but the likewise ever-growing need for morecomputational power pose substantial challenges to systems engi-neering and software architecture. New computational approachesthat substantially diverge from technologies established during thelast decades start to graduate from research laboratories into firstworking prototypes. Especially quantum computing has gained
Permission to make digital or hard copies of all or part of this work for personal orclassroom use is granted without fee provided that copies are not made or distributedfor profit or commercial advantage and that copies bear this notice and the full citationon the first page. Copyrights for components of this work owned by others than ACMmust be honored. Abstracting with credit is permitted. To copy otherwise, or republish,to post on servers or to redistribute to lists, requires prior specific permission and/or afee. Request permissions from [email protected].
ICSEW’20, Seoul, Republic of Korea © 2020 ACM. 978-1-4503-7963-2/20/05...$15.00DOI: 10.1145/3387940.3391472 substantial attraction during the last years [24]. Programming quan-tum computers (QC) differs drastically from previously establishedtechniques and approaches. Integrating QC into existing appliancesmust not only be addressed at the level of algorithmic implementa-tion, but also concerns many of the broader issues investigated insoftware engineering [4]. In this paper, we argue that the problemat the current stage of development must be considered at a muchlower level of abstraction than is customary in software engineer-ing, and illustrate this by a case study of how to transition a corecomputational primitive—solving binary satisfiability problems—from classical to quantum in existing software architectures. Ourstudy illustrates that defining and testing specific quality propertiesof QC components is one of the crucial challenges. These propertiesdo not play a central role in traditional engineering, but must beconsidered in software architectures with quantum components.We illustrate this by analysing different approaches—one of whichhas been specifically designed for this paper, and improves consid-erably on the state-of-the-art—to solving the binary satisfiability(SAT) problem. We hope this helps readers to form a realistic intu-ition of near- and mid-term capabilities, potentials and challengesof augmenting software with quantum components.
By utilising quantum mechanical properties, QCs are expected tosolve some problems more efficiently than their classical coun-terparts. Simulations of quantum systems [23] and chemical reac-tions [25], breaking of cryptographic codes [28], but also optimisingportfolios [37] are among the list of candidate problems. Recentadvances—although not undisputed—claim quantum supremacy [3],even if for extremely artificial problems. Real-world adoption ofquantum computing, as it matters to software engineering, is likelyto happen in an evolutionary way than by disruptive revolution.We base our considerations on quantum annealers : Many earlypotential industrial use-cases [22, 31, 32] rest on this class of ma-chines, in part because they were among the first offerings availablefor commercial use (discussions about the full quantum mechanicalnature of such machines [27] are not relevant for our purposes).Especially NP-complete problems, which are known to be classi-cally intractable for inputs of growing size when non-approximatesolutions are desired, are candidates for which (polynomial) quan-tum speed-ups would be desirable. Many NP-complete problemsof practical interest are known. Especially the Boolean satisfia-bility problem (SAT) has received substantial attention becausemany use cases, from system verification to constrained planningproblems [13], have SAT at their core. Quantum annealers areparticularly well suited to process problems of this type [16]. They a r X i v : . [ c s . ET ] M a y CSEW’20, May 23–29, 2020, Seoul, Republic of Korea Tom Kr¨uger and Wolfgang Mauerer differ considerably from gate-based approaches in their physicalrealisation, and in the ways programs are engineered.
Software engineering is (ignoring many aspects that we cannotaddress for the lack of space) concerned with development, inte-gration, and testing (verification, validation, performance, quality,. . . ) of software [4]. This impacts quantum software development:
A considerable body of previous researchdevoted to developing languages for programming quantum sys-tems focuses on gate-based approaches ( e.g. , [11, 30, 34]). A grow-ing number of quantum programming languages has been devisedfor this hardware class ( e.g. , [10, 17, 33]). Roughly speaking, gatebased quantum computers relate to quantum annealers like im-perative programming languages do to declarative approaches. Adeep understanding of quantum mechanics is not required to usecurrent QA hardware, which is beneficial from a software point ofview. Engineers can resort to techniques known from constraintprogramming, optimisation, and problem reduction.
As Knill [14] discussed as early as 1996, quan-tum computers will not entirely replace traditional machines, butwill be part of hybrid quantum-classical architectures, not unlikeGPUs [1, 12] or other accelerators (TPUs, FPGAs, . . . ). Quantumannealers can be seen as hardware accelerators for approximatingquadratic unconstrained binary optimisation (QUBO) problems.The ability to easily replace functional components of a softwarearchitecture is a crucial element of component-based software en-gineering [35, 36], and many existing applications are designedalong these ideas. In the following, we consider that a SAT solvingcomponent is supposed to be replaced by a QA device in an existingsoftware architecture.Replacing a library function call to a traditional solver by anetwork-based job submission to a QA device is an easy program-ming tasks that we do not consider any further. However, two dataconversions are necessary, as Figure 1 illustrates: The propositionalcalculus formula for which a solution is sought must be mapped toa QUBO. Once the result of the optimisation process is available, ismust be translated back to the original SAT model. Both steps canbe trivially abstracted by an interface. localremotelocal f ( ) x ⃗ Reduction
QUBO( ) y ⃗ QA Parameterextraction y ⃗ min x ⃗ SAT
Figure 1: Interface wrapping: Classical SAT solvers can bereplaced with a QA based implementation with limited ef-fort.
Miranskyy and Zhang [20] discuss testing as-pects related to verification and validation of quantum programs.Fundamental properties of NP-complete problems guarantee thatsolutions can be verified in polynomial time [29], and consequently,validation and verification of QA programs is not a core challenge. However, quantum annealers usually only deliver approximate solutions to problems, and the quality of approximation is closelyrelated to how “programs” (in the form of mathematical reductions)are created. We focus on the issues arising from this scenario inthe rest of the paper.
The workflow for solving problems on quantum annealers is moreinvolved than for classical constraint optimisation. The necessaryprocess comprises five stages, and choices in some of the stagescan greatly influence performance and accuracy of computations.Consequently, some knowledge of the inner working of the quan-tum annealing process are useful. An AQO computation proceedsalong the following stages [12, 18]:
Problem Reduction:
Like classical constraint optimization solvers,QA machines can optimise a specific class of models. An-nealers can find solutions to quadratic unconstrained binaryoptimization (QUBO) problems [15], which are given bymin [(cid:174) x ] (cid:169)(cid:173)(cid:171)(cid:213) i c ii x i + (cid:213) i , j c ij x i x j (cid:170)(cid:174)(cid:172) (1)with x ∈ { , } and c ∈ R . A QUBO can be represented bya weighted graph with nodes x i and associated weights c ii .Weighted edges are given by c ij .Reducing a given problem p to a QUBO, p ≤ QUBO, re-quires no knowledge of quantum mechanics, and is similarto well-known reductions to Boolean satisfiability prob-lems. As we will discuss later, structurally different (butlogically equivalent) reductions can lead to drastically dif-ferent performance on contemporary hardware.
Hardware Embedding:
Software solvers can react dynamicallyto input, and easily build arbitrary data structures. ForQA, the “data structure” used to represent a given input isfixed in hardware. This step “translates” an input onto thehardware structure [1, 7] (see Figure 2). Mathematicallyequivalent reductions can lead to pronounced differencesin solution quality, as we show in Section 3.
Hardware Programming:
The problem embedding needs tobe transferred to the machine. The physical details of thisoperation are irrelevant to programmers, except that someparameters—most importantly, the duration of the anneal-ing process—can be influenced. Finding an optimal valueis currently a matter of experimentation.
Execution:
The machine finds a solution to the optimisationproblem by “executing” a physical process.
Post Processing:
Results obtained in the previous step are usu-ally only close to the desired optimum. Classical post-processing can improve solution quality [9]. We will ignorethis step in this paper since we are interested in the capa-bilities of QA as such, and not of classical data processing.
All experiments that we discuss in the following were performedon a D-Wave 2000Q quantum annealer, model DW 2000Q 2 1. Themachine can be remotely accessed via a Python-based API. Per-forming computations requires to specify a problem QUBO, and antum-Annealing Based Software Components: A Case Study ICSEW’20, May 23–29, 2020, Seoul, Republic of Korea a1b 1 c1 1-2 a c1b1a
Figure 2: Example for embedding a logical graph that de-scribes couplings between qubits (left) into a physical qubitstructure (right) with limited connectivity. Node “a” ismapped to a chain of two nodes representing “a”, which il-lustrates that the amount of physical qubits required to rep-resent a problem is larger than the amount needed for astructural description. (essentially) anneal time and desired sample size n . Once the QAhas evaluated the problem, a result set with n samples is returned.Each sample contains an assignment for all qubits.While it is possible to arbitrarily weigh the interaction betweenqubits as specified by term c ij from Eq. (1), there are substantialrestrictions on which qubit i can physically and directly interactwith which qubits j (see Ref. [5] for details on the available hardwaregraph structure). This limited connectivity poses a major practicalchallenge when mapping logical to physical problems, since a pairof nodes that requires a logical connection (a non-zero entry c ij inEq. (1)) must be represented by a chain of multiple nodes on thehardware graph. This considerably limits the number of effectivelyusable qubits as compared to the number of physically available qubits—Figure 6 exemplifies the problem visually. In general, longerchains lead to more undesirable physical perturbance, and decreaseresult quality [26]. As a rule of thumb, the number of usable logicalqubits is only about 5-10% the number of physical qubits. Let us now turn our attention to discussing how implementation de-tails of quantum computational primitives can influence qualities ofsoftware. We focus on the problem of finding and comparing reduc-tions of the problem to a machine specific structure. Such low-levelissues are usually not of much relevance in software engineering,and are justifiably perceived as implementation details—however,we show that this level of abstraction is far from reached on quan-tum machines yet.The k -SAT problem, the cornerstone of NP-completeness [13],serves as an example. We first discuss different reductions of k -SAT ≤ P QUBO, and show how differences arise from seemingly smalldetails. We then offer guidance on comparing reductions.
The problem of Boolean satisfiability is well known: Let X : = { x , x , . . . , x n } be a set of Boolean variables, and let literals bedefined as L : = { l | l ∈ { x , x } , x ∈ X } . The set of all clauses is given by l = x l = x l = x l = x l = x l = x l = x l = x l = x Figure 3: Graphical illustration of a QUBO formula that rep-resents f ((cid:174) x ) = ( x ∨ x ∨ x ) ∧ ( x ∨ x ∨ x ) ∧ ( x ∨ x ∨ x ) using Choi’s reduction. Grey nodes represent a satisfyingassignment [ x (cid:55)→ , x (cid:55)→ , x (cid:55)→ ] . C : = { C i | i ∈ [ n ] , C i ⊂ L , | C i | = k } . For each x i ∈ X , there existsat least one C j such that x i ∈ C j . A function f ((cid:174) x ) = (cid:211) C i ∈ C (cid:212) l ∈ C i l that satisfies these conditions is called a k -CNF function. Given a k -CNF function f ((cid:174) x ) , the k -SAT problem is to find an assignment (cid:174) x t such that f ( (cid:174) x t ) = true. It is textbook knowledge [29] that everyCNF formula can be cast in 3-CNF form.The k -SAT problem is the cornerstone of NP-completeness, butnot all specific instances are difficult to solve. The hardness of aninstance depends on the ratio of clauses per variable α = | C || X | [6].For instances with few clauses per variable (small α ), it is easy tofind satisfying assignments. For instances with many clauses pervariable, it is easy to find contradictions. Instances with large orsmall values of α tend to be easy to solve. In an α region surrounding α c ≈ .
25, the probability that a random k -SAT formula can besatisfied drops abruptly from 1 to 0 [6, 21], and the hardest instancesare contained in this parameter regime. Improvements in SATsolving are therefore most desirable around this phase transition . Choi [8] gives a standard reduction from k -SAT to a QUBO. Let l ij be the literal of variable x j in clause i . Two literals l ij and l i (cid:48) j are in conflict if l ij = ¯ l i (cid:48) j . Satisfying a Boolean function in CNF impliesat least one satisfied, but conflict-free literal per clause.The reduction assigns a negative weight − ω to l ij : − (cid:205) l ij ωl ij . Allliterals of a clause are fully connected with positive weighted edges: (cid:205) l ij , l ij (cid:48) ∈ C i δl ij l ij (cid:48) . All conflicting literals of the same variable arepairwise connected with positive edge weights: (cid:205) l ij = ¯ l i (cid:48) j δl ij l i (cid:48) j . Thelast two sums are pure penalty terms and evaluate to 0 for correctassignments. This leads to a definition illustrated in Figure 3: Definition 3.1 ( k -SAT ≤ P QUBO (MIS)).
Let f ((cid:174) x ) be a boolean k -CNF function. The literal of a variable x j ∈ (cid:174) x in a clause C i ∈ C is given by l ij ∈ { , } . Under the constraint ∀ δ , ω : δ > ω > [(cid:174) x ] (cid:169)(cid:173)(cid:173)(cid:171) − (cid:213) l ij ωl ij + (cid:213) l ij , l ij (cid:48) ∈ C i δl ij l ij (cid:48) + (cid:213) l ij = l i (cid:48) j δl ij l i (cid:48) j (cid:170)(cid:174)(cid:174)(cid:172) (2)finds a satisfying assignment for f ((cid:174) x ) if one exists.[8]. CSEW’20, May 23–29, 2020, Seoul, Republic of Korea Tom Kr¨uger and Wolfgang Mauerer
To demonstrate the effect of different reductions on various aspectsof QA performance, consider a different reduction that we havedevised for this paper, and that improves (as we will analyse later)on the reduction given in Eq. (2):
Definition 3.2 ( k -SAT ≤ P QUBO (Backbone)).
Let f ((cid:174) x ) be a Booleanfunction in k -CNF, and let l ij be a literal of x j ∈ (cid:174) x in C i ∈ C , with l ij , x j ∈ { , } . Then q ((cid:174) x ) = ω (cid:169)(cid:173)(cid:171) (cid:213) l ij , l ij (cid:48) l ij l ij (cid:48) + (cid:213) l ij = x j − l ij x j + (cid:213) l ij (cid:44) x j − l ij + l ij x j (cid:170)(cid:174)(cid:172) (3)with ω > q ((cid:174) x ) for which min [(cid:174) x ] represents asatisfying assignment of f ((cid:174) x ) if one exists.Mathematical details of the derivation are given in Appendix A. Quality criteria for software are plentiful, and many of them alsoapply to the relative merits of reductions. Since the developmentof quantum computers is mainly driven by the desire for morecomputational power, we focus on two indicators: Performanceand scalability. There is (despite recent standardisation efforts) nouniversally applicable (and accepted) definition of how to measureperformance of quantum computers; this is particularly hard for QA,were the run-time is not determined by the input, but chosen as aparameter—the annealing time. Consequently, we consider solution quality —how likely is it to obtain a correct answer that does notviolate constraints, and how accurate is the answer ( i.e. , how closeis it to the optimal achievable value)—as proxy for performance.Scalability considers the question of how large problems can besolved on a hardware of given size ( i.e. , number of physical qubits).The achievable accuracy of a reduction depends on its structure(how well do logical connections between qubits match the avail-able physical structure?) and on hardware parameters. While theadiabatic theorem ensures that longer annealing times (runtimes)results in better accuracy, flaws and approximate implementationsof the scheme in real hardware lead to less direct relations. Likewith traditional approximation algorithms, increasing the amountof computes samples also leads to more accurate solutions.
Owing to the lack of a published, physically accurate model ofthe quantum annealer that includes imperfections and noise, de-termining scalability and accuracy is currently only possible withexperimental means [19].When SAT is used to model constrained optimisation problemsin practical applications, the resulting SAT instances often exhibitspecific structural properties, which can guide the generation of use-ful test instances for determining quality properties of reductions.This is, of course, not unlike the well-studied problem of generatingtailored input data for general software testing problems [2].We are interested in a general comparison of reductions, andtherefore base our input data generation on general properties of 3-SAT. We have discussed that the problem exhibits different regimes It is unlikely that such a physically accurate model will be available in the near- ormid-term future. p r o b a b ili t y P M I S ( S A T ) o f f i n d i n g a ss i g n m e n t s MIS method Runtime s s s s s s ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] -interval p r o b a b ili t y P BB ( S A T ) o f f i n d i n g a ss i g n m e n t s Backbone method Runtime s s s s s s Figure 4: Influence of the embedding method on the prob-ability of finding correct satisfying assignments for ran-domly generated 3-SAT instances with varying ratios α ofclauses to variables. The horizontal dashed lines marks thecritical value α c (accompanied by a peak increase in requiredcomputing time when using traditional numeric solvers).The dashed curve represents the probability distribution offinding a satisfying assignment with optimal solvers. Toease comparing quantum and classical result, a logistic re-gression curve is given for each parameter variation.Both (mathematically equivalent) methods arrive at correctconclusions less often than classical solvers, which is causedby imperfections and limitations of the available hardware. in Section 3.1, and systematically generate random 3-SAT instancesthat cover these by sweeping across different values of α . For thenumber of needed qubits, k | C | is the dominant term for both reduc-tion approaches. Keeping | C | fixed and varying | V | produces stableQUBO sizes across the α -spectrum, which guarantees a consistenthardware graph utilization. We generate a data-set containing 250 random 3-SAT instances with42 clauses each. In total, six runs with varying annealing times (5to 2000 µ s) and samples sizes (5 and 100) were performed on thequantum annealer described in Section 2.3. Figure 4 shows resultsfor the two different reduction methods. For Choi’s MIS-based reduction, the annealingtime does not substantially effect the accuracy. Using probabilityamplification by performing a larger number of runs 100 × µs , does antum-Annealing Based Software Components: A Case Study ICSEW’20, May 23–29, 2020, Seoul, Republic of Korea ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] -interval P BB ( S A T ) P M I S ( S A T ) Runtime s s s Figure 5: Accuracy difference (in percentage points) betweenMIS and backbone method. improve the accuracy slightly. Results obtained with the backbonemethod, in contrast, improve with increasing annealing time, andincreasing the number of runs is also accompanied by a largerimprovement as compared to the MIS method. It is also importantto note that using an excessively long annealing time of 2000 µ sresults in a decrease of result quality .Recall from the above discussion that solving SAT instances inthe critical parameter region around α c is most involved for clas-sical solvers, and improvements by quantum computers are mostdesirable in this region. Unfortunately, the MIS method deliverssatisfying solutions in this range with almost zero probability.Figure 4 directly compares accuracy results. The difference inaccuracy reaches up to 60%, and the backbone method is consis-tently more accurate for all scenarios. The decreasing difference inaccuracy at α > α c is a consequence of the low number of satisfi-able instances in this region. Around the critical region, we observemarked differences of around 35%. Figure 6 compares scalability of the two reduc-tions by analysing the amount of required physical qubits, and themean length of chains necessary to connect qubits without directphysical connections (we use the minorminer tool provided as partof the D-Wave API to embed QUBOs into the hardware graph).For the MIS-based method, the amount of physical qubits andmean chain length grow essentially linear with an increasing α ,which follows from the pairwise links between conflicting literals.The backbone method improves upon both aspects because theQUBO is less densely populated, which makes it easier to findembeddings. Especially around the critical value α c , the amount ofrequired physical qubits is only half of what is required for the MISmethod, which in turn implies that substantially larger problemsets can be solved on a hardware of given size. Development and evaluation of quantum software componentsmust address well-established engineering concerns of traditionalSWE. Based on the scenario of replacing SAT solving, a key ele-ment of many applications, with a quantum component, we have This observation does contradict the adiabatic theorem; the effect is likely causedby a large amount of noise leading incorrect initial configurations or random energylevel jumps during the annealing process. Both effects occur with growing probabilityfor increasing annealing times. nu m b e r o f p h y s i c a l q u b i t s a f t e r e m b e dd i n g ( , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] ( . , . ] -interval m e a n c h a i n l e n g t h Reduction
MISBackbone
Figure 6: Number of required physical qubits to after em-bedding a QUBO for a given ratio of variables and clauses(top) and median chain lengths necessary to connect qubitswithout direct interconnections (bottom). shown that careful attention is required in defining and evaluatingrelevant qualities. We have argued that scalability and accuracyare of particular relevance for early existing quantum annealers.While replacing classical with quantum components is not particu-larly involved from a programming perspective, our experimentsindicate that engineers must be aware of crucial details that mightbe perceived as irrelevant in traditional SWE to make informeddecisions on potentials and pitfalls of quantum computing.
REFERENCES [1] Alastair A. Abbott, Cristian S. Calude, Michael J. Dinneen, and RichardHua. 2019. A hybrid quantum-classical paradigm to mitigate embeddingcosts in quantum annealing.
International Journal of Quantum Informa-tion
17, 05 (2019), 1950042. https://doi.org/10.1142/S0219749919500424arXiv:https://doi.org/10.1142/S0219749919500424[2] Saswat Anand, Edmund Burke, Tsong Chen, John Clark, Myra Cohen, WolfgangGrieskamp, Mark Harman, Mary Harrold, and Phil Mcminn. 2013. An orches-trated survey on automated software test case generation.
Journal of Systemsand Software
86 (08 2013), 1978–2001. https://doi.org/10.1016/j.jss.2013.02.061[3] Frank Arute, Kunal Arya, Ryan Babbush, Dave Bacon, Joseph C Bardin, RamiBarends, Rupak Biswas, Sergio Boixo, Fernando GSL Brandao, David A Buell, et al.2019. Quantum supremacy using a programmable superconducting processor.
Nature
Software Architecture in Practice (3rd ed.). Addison-Wesley Professional.[5] Jun Cai, William G Macready, and Aidan Roy. 2014. A practical heuristic forfinding graph minors. arXiv preprint arXiv:1406.2741 (2014).[6] Peter C Cheeseman, Bob Kanefsky, and William M Taylor. 1991. Where the reallyhard problems are.. In
IJCAI , Vol. 91. 331–337.[7] Vicky Choi. 2008. Minor-embedding in adiabatic quantum computation: I. Theparameter setting problem.
Quantum Information Processing
7, 5 (2008), 193–209.https://doi.org/10.1007/s11128-008-0082-9[8] Vicky Choi. 2010. Adiabatic Quantum Algorithms for the NP-CompleteMaximum-Weight Independent Set, Exact Cover and 3SAT Problems.
ArXiv abs/1004.2226 (2010).[9] Thomas Gabor, Sebastian Zielinski, Sebastian Feld, Christoph Roch, ChristianSeidel, Florian Neukart, Isabella Galter, Wolfgang Mauerer, and Claudia Linnhoff-Popien. 2019. Assessing Solution Quality of 3SAT on a Quantum AnnealingPlatform. In
Quantum Technology and Optimization Problems , Sebastian Feld andClaudia Linnhoff-Popien (Eds.). Springer International Publishing, Cham, 23–35.[10] Alexander S Green, Peter LeFanu Lumsdaine, Neil J Ross, Peter Selinger, andBenoˆıt Valiron. 2013. Quipper: a scalable quantum programming language. In
Proceedings of the 34th ACM SIGPLAN conference on Programming language design
CSEW’20, May 23–29, 2020, Seoul, Republic of Korea Tom Kr¨uger and Wolfgang Mauerer and implementation . 333–342.[11] Thomas H¨aner, Damian S Steiger, Krysta Svore, and Matthias Troyer. 2018. Asoftware methodology for compiling quantum programs.
Quantum Science andTechnology
3, 2 (2018), 020501.[12] T S Humble, A J McCaskey, R S Bennink, J J Billings, E F D’Azevedo, B D Sullivan,C F Klymko, and H Seddiqi. 2014. An integrated programming and developmentenvironment for adiabatic quantum optimization.
Computational Science &Discovery
7, 1 (jul 2014), 015006. https://doi.org/10.1088/1749-4680/7/1/015006[13] Richard M Karp. 1972. Reducibility among combinatorial problems. In
Complexityof computer computations . Springer, 85–103.[14] Emmanuel Knill. 1996.
Conventions for quantum pseudocode . Technical Report.Los Alamos National Lab., NM (United States).[15] Mark W. Lewis and Fred Glover. 2017. Quadratic Unconstrained Binary Op-timization Problem Preprocessing: Theory and Empirical Analysis.
ArXiv abs/1705.09844 (2017).[16] Andrew Lucas. 2014. Ising formulations of many NP problems.
Frontiers inPhysics arXiv preprint quant-ph/0511145 (2005).[18] Catherine C. McGeoch. 2014. Adiabatic Quantum Computation and Quantum An-nealing: Theory and Practice. In
Adiabatic Quantum Computation and QuantumAnnealing: Theory and Practice .[19] Catherine C McGeoch. 2019. Principles and guidelines for quantum performanceanalysis. In
International Workshop on Quantum Technology and OptimizationProblems . Springer, 36–48.[20] Andriy V. Miranskyy and Lei Zhang. 2018. On Testing Quantum Programs. (2018), 57–60.[21] David Mitchell, Bart Selman, and Hector Levesque. 1992. Hard and easy distri-butions of SAT problems. In
AAAI , Vol. 92. 459–465.[22] Florian Neukart, Gabriele Compostella, Christian Seidel, David Von Dollen, SheirYarkoni, and Bob Parney. 2017. Traffic flow optimization using a quantumannealer.
Frontiers in ICT
Physical Review A
64, 2(2001), 022319.[24] Ferdinand Peper. 2017. The End of Moore’s Law: Opportunities for NaturalComputing?
New Generation Computing
35 (2017), 253–269.[25] Markus Reiher, Nathan Wiebe, Krysta M Svore, Dave Wecker, and MatthiasTroyer. 2017. Elucidating reaction mechanisms on quantum computers.
Proceed-ings of the National Academy of Sciences
Digitale Welt
4, 1 (01 Jan 2020), 104–104.https://doi.org/10.1007/s42354-019-0244-1[27] Seung Woo Shin, Graeme Smith, John A Smolin, and Umesh Vazirani. 2014. How”quantum” is the D-Wave machine? arXiv preprint arXiv:1401.7087 (2014).[28] Peter W. Shor. 1994. Polynomial-Time Algorithms for Prime Factorization andDiscrete Logarithms on a Quantum Computer.
SIAM J. Comput.
26 (1994), 1484–1509.[29] Michael Sipser. 2006.
Introduction to the Theory of Computation (second ed.).Course Technology.[30] Damian S Steiger, Thomas H¨aner, and Matthias Troyer. 2018. ProjectQ: an opensource software framework for quantum computing.
Quantum
International Workshop on Quantum Technology andOptimization Problems . Springer, 99–110.[32] Tobias Stollenwerk, Bryan O’Gorman, Davide Venturelli, Salvatore Mandr`a, OlgaRodionova, Hokkwan Ng, Banavar Sridhar, Eleanor Gilbert Rieffel, and RupakBiswas. 2019. Quantum annealing applied to de-conflicting optimal trajectoriesfor air traffic management.
IEEE transactions on intelligent transportation systems
21, 1 (2019), 285–297.[33] Krysta Svore, Alan Geller, Matthias Troyer, John Azariah, Christopher Granade,Bettina Heim, Vadym Kliuchnikov, Mariia Mykhailova, Andres Paz, and MartinRoetteler. 2018. Q
Proceedings of the Real World Domain Specific LanguagesWorkshop 2018 . 1–10.[34] Krysta M Svore, Alfred V Aho, Andrew W Cross, Isaac Chuang, and Igor LMarkov. 2006. A layered software architecture for quantum computing designtools.
Computer
39, 1 (2006), 74–83.[35] Muhammad Tahir, Fazlullah Khan, Muhammad Babar, Fahim Arif, and F Khan.2016. Framework for better reusability in component based software engineering. the Journal of Applied Environmental and Biological Sciences (JAEBS)
6, 4S (2016),77–81.[36] Tassio Vale, Ivica Crnkovic, Eduardo Santana De Almeida, Paulo AnselmoDa Mota Silveira Neto, Yguarat˜a Cerqueira Cavalcanti, and Silvio Romero deLemos Meira. 2016. Twenty-eight years of component-based software engineer-ing.
Journal of Systems and Software
111 (2016), 128–148. [37] Davide Venturelli and Alexei Kondratyev. 2019. Reverse quantum annealingapproach to portfolio optimization problems.
Quantum Machine Intelligence
A ALTERNATIVE REDUCTIONS
Loosened Clause Penalties
Choi’s reduction (theorem 3.1), is,in essence, a reduction from k -SAT to the problem of finding themaximal independent set (MIS) of a given graph. Assume a k -SATinstance is reduced to QUBO as described in theorem 3.1, and let G f be the graph representation. Consider a MIS of G f , which isgiven by the largest set of vertices such that there are no connectedvertices. In theorem 3.1 this property is enforced by the constraint δ > ω . Solving a QUBO defined by theorem 3.1 also solves the MISproblem for G f . The problem of finding the MIS G f corresponds tothe problem of finding the maximal number of satisfiable clauses(MAX-k-SAT) in f . The relation between MAX-k-SAT and k-SATis trivial.Theorem A.1. Setting δ = ω in theorem 3.1 does not change thecorrectness of the assignment derived from the QUBO solution. Proof. Let q ( x ) be a sub-QUBO representing one clause like de-scribed in theorem 3.1. Under δ = ω the following holds: min ( E ( n )) = − ω if E ( n ) is the energy of a clause sub-QUBO with n satisfied liter-als. It is straight forward to see that E ( n ) = − nω + (cid:0) n (cid:1) ω . Therefor, E ( ) = E ( ) = E ( ) = − ω . The inequality E ( n ) < E ( n + ) evaluates to − n < − n >
1. This leads to theconclusion that min ( E ( n )) = − ω .Consider a clause C i and its corresponding sub-QUBO q i ( x ) .Now, min ( q i ( x )) = − ω for one or two satisfied literals in q i ( x ) .Therefore, the minimization of q i ( x ) leads to a satisfied clause C i .For two conflict-free clauses C i and C j the combined minimumenergy is given by min ( q i ( x ) + q j ( x )) = − ω . Now we introducea conflict between C i and C j . That activates an additional penaltyterm p ij = ω which leads to min ( q i ( x ) + q j ( x ) + p ij ) = − ω > − ω .This shows that conflicts between clauses always lead to a higherenergy level and thus should be avoided when minimizing thecomplete QUBO q ( x ) . For all satisfiable k-SAT instances f ( x ) with n clauses the minimal energy of their corresponding QUBOs q ( x ) will be min ( q ( x )) = − nω . Every function f ( x ) with minimal QUBOvalue min ( q ( x )) > − nω cannot be satisfied. (cid:3) Backbone
Choi’s reduction represents variables solely by theirliterals. To avoid conflicts, we need to ensure that l ij (cid:44) l i (cid:48) j forall pairs ( l ij , l i (cid:48) j ) ⇔ ( x j , ¯ x j ) . An edge in the QUBO connects theliterals as penalty term, which leads to highly connected graphs forinstances with large values of α . The degree of connectivity canbe improved by introducing a backbone for variables, which allowsus to transitively express equivalence between literals by linkingthem to their corresponding variable. The reduction is given inDefinition 3.2 on page 4.Correctness of theorem 3.2. Let E ( n ) be the energy of a clausesub-QUBO with n satisfied literals. The difference between sub-QUBOs in theorem 3.1 and theorem 3.2 is that in the latter nodeweights of literals l ij (cid:44) x j are moved to the edges ( l ij , x j ) . For everyliteral, there exists exactly one edge to its corresponding variable.Therefore, edge weights can be viewed as node weights, and itfollows that E ( n ) = − nω + (cid:0) n (cid:1) ω . Consequently, min ( E ( n )) = − ω antum-Annealing Based Software Components: A Case Study ICSEW’20, May 23–29, 2020, Seoul, Republic of Korea also holds for theorem 3.2. If two literals l ij and l i (cid:48) j conflict, one of ωl ij x j or ωl i (cid:48) j x j evaluates to ω , while the other evaluates to 0. Therest of the argument follows Theorem A.1., while the other evaluates to 0. Therest of the argument follows Theorem A.1.