Decomposition algorithms for solving NP-hard problems on a quantum annealer
DDecomposition algorithms for solving NP-hard problems on aquantum annealer
Elijah Pelofske, Georg Hahn, and Hristo DjidjevLos Alamos National Laboratory
Abstract
NP-hard problems such as the maximum clique or minimum vertex cover problems, twoof Karp’s 21 NP-hard problems, have several applications in computational chemistry, bio-chemistry and computer network security. Adiabatic quantum annealers can search for theoptimum value of such NP-hard optimization problems, given the problem can be embed-ded on their hardware. However, this is often not possible due to certain limitations of thehardware connectivity structure of the annealer. This paper studies a general framework fora decomposition algorithm for NP-hard graph problems aiming to identify an optimal setof vertices. Our generic algorithm allows us to recursively divide an instance until the gen-erated subproblems can be embedded on the quantum annealer hardware and subsequentlysolved. The framework is applied to the maximum clique and minimum vertex cover prob-lems, and we propose several pruning and reduction techniques to speed up the recursivedecomposition. The performance of both algorithms is assessed in a detailed simulationstudy.
Keywords : Decomposition algorithm; D-Wave; Maximum clique; Minimum vertex cover; NP-hard; Optimization.
Novel computing technologies allows one to search for solutions of NP-hard (graph) problemsthat are very hard to solve classically (Chapuis et al., 2017). One such device is the quantumannealer of D-Wave Systems, Inc. (D-Wave, 2016), which can propose approximate solutions ofquadratic unconstrained binary optimization (QUBO) and Ising problems given by the minimumof a function of the form H ( x , . . . , x n ) = n (cid:88) i =1 a i x i + (cid:88) i The development of exact algorithms for NP-hard problems has been an area of constant atten-tion in the literature (Johnson and Tricks, 1996; DIMACS, 2000; Woeginger, 2008).In particular, the minimum vertex cover problem has been widely studied in the literaturefrom a variety of aspects (Downey and Fellows, 1992; Balasubramanian et al., 1998; Stege andFellows, 1999; Chen et al., 2000, 2001; Niedermeier and Rossmanith, 2003). For instance, Chenet al. (2010) present a selection of techniques to reduce the size of an MVC instance and introduce3 polynomial space and exponential time algorithm of the order of O (1 . k ), where k is thesought maximal size of the MVC, thus improving over the O (1 . k ) algorithm of Niedermeierand Rossmanith (2007). A variation of the MVC problem, the weighted MVC problem, isstudied in Xu et al. (2016).Decomposition algorithms, such as the algorithm presented in this article, have already beensuggested in Tarjan (1985) and successfully applied to solve a variety of NP-hard problems suchas graph coloring, see Rao (2008).For quantum annealing, a decomposition algorithm for the maximum clique problem has beenproposed in Chapuis et al. (2017) and Pelofske et al. (2019a). In Pelofske et al. (2019a), theauthors additionally investigate a variety of techniques to prune subproblems during the recursivedecomposition, for instance by computing bounds on the clique size. Similarly, to solve themaximum independent set problem, an equivalent formulation of the maximum clique problem,several algorithms are known including some relying on graph decomposition (Giakoumakis andVanherpe, 1997; Courcelle et al., 2000).The algorithm of Bron and Kerbosch (1973) solves a related problem, that is the problem ofenumerating all maximum cliques in a graph. Parallel version of this algorithm are available inthe literature (Rossi et al., 2015). The algorithm of Carraghan and Pardalos (1990) is anotherexact method to partially enumerate all maximum cliques.Further exact algorithms have been developed in recent year, see for instance Robson (1986,2001) and Xiao and Nagamochi (2013), including those based on principles such as measure andconquer (Fomin et al., 2006).Another area of research are branch-and-prune heuristics, including algorithms which usedifferent solvers when the subproblems are sufficiently small (as we do in this work), see Houet al. (2014) and Morrison et al. (2016) for a survey. This section describes a generic algorithm to decompose an NP-hard optimization graph problemthat aims to find an optimal set of vertices minimizing or maximizing a given objective function.Our basic algorithm targets problems with binary decisions for each vertex: for instance, in (2)and (3), we are interested in the value of the binary indicator x v for each v ∈ V which encodeswith x v = 1 that vertex v belongs to the maximum clique (or the minimum vertex cover).The aim of our decomposition is to split up a problem instance into two subproblems withthe property that (a) both subproblems are strictly smaller than the original instance, and(b) solving each exactly allows to reconstruct the optimal solution of the original instance inpolynomial time. Applying the decomposition recursively thus allows one to decompose a givenproblem instance into arbitrarily small subproblems. Algorithm 1 illustrates the general structure of our decomposition algorithms assuming theproblem is of minimization type. We start with an input graph G = ( V, E ), a current solution S (initialized as the empty set), and a value µ of the objective function for the current solution.4or instance, for MC, the set S will be the set of vertices belonging to the maximum clique, and µ will be the clique size. If the graph problem under investigation is a minimization problem,we start with µ = ∞ . Additionally, we require some cutoff size s max , which determines the sizeat which we stop the decomposition as the subproblems are small enough to be solved with aquantum or classical method.First, a vertex v for splitting the solution space is selected. Possible choices investigated inthis work are given in Section 2.2. The splitting vertex v is used to split G into two graphs G + and G − on which the optimization problem (e.g., MC or MVC) will be solved, where theprecise splitting routine is problem dependent. For graph G + , we assume that v belongs to theoptimal solution (e.g., the maximum clique), and for G − we assume it does not. Sections 2.3and 2.4 give specific implementations of the splitting techniques for the maximum clique andthe minimum vertex cover problems, respectively.Before decomposing G + and G − further in a similar fashion, we aim to reduce the compu-tational burden in Algorithm 1 by using context-specific knowledge about the graph problem tocompute lower and upper bounds on the solutions in G + and G − (see Section 3.1 for a list ofbounds we employ). If it is impossible that G + or G − contain a solution that improves upon µ , the value of the best solution found so far, we can discard them. Otherwise, we again usecontext-specific knowledge to reduce the size of existing subproblems through vertex and edgeremoval techniques (see Section 3.2 for reduction techniques for MC and Section 3.3 for MVC).If any of the subgraphs ( G + or G − ) contains more vertices than the cutoff value s max , thesplitting is recursively called on that subgraph using the current values of S and µ . Otherwise,i.e., if the corresponding subgraph ( G + or G − ) is within the size limit s max , we solve theoptimization problem using any classic or quantum algorithm of choice and update the valuesof S and µ appropriately. At the end of the recursion, S and µ contain the correct values of thesolution and the corresponding value of the objective function.If a maximization problem ought to be solved, we initialize µ = −∞ . In line 5 of Algorithm 1,we discard problems G + or G − if improvement over µ is impossible, in the sense that the solutionof the subproblems G + or G − will be less than µ . In line 11, we return S + , ˜ µ + if ˜ µ + ≥ ˜ µ − .Algorithm 1 does not require that subproblems are solved on a quantum device such as theD-Wave annealer. In principle, any suitable device or method can be used to exactly solve anyof the generated subproblems at any stage of the decomposition. However, one straightforwardchoice is to stop decomposing a subproblem further once it can be embedded on the D-Wavehardware, that is once the subgraph size is at most s max = 46 vertices for the D-Wave 2X at LosAlamos National Laboratory (the largest size of an arbitrary problem that can be embeddedon the hardware). For the D-Wave 2000Q at Los Alamos National Laboratory, this cutoff is s max = 64 vertices, and for D-Wave Advantage it is s max = 180 vertices.Algorithm 1 can also be applied probabilistically: If the solver applied to the subgraphsat leaf level finds optimal solutions with some probability p , our decomposition algorithm willreport the correct solution for the original graph G with a probability that is a function of p .5 lgorithm 1: decomposition for a minimization problem input: G = ( V, E ), S ← ∅ , µ ← ∞ , s min , additional parameters; Choose v ∈ V according to some selection criterion; Denote by S ∗ any optimal solution for G . Using context-specific knowledge about theNP-hard graph problem, define the following proper subgraphs of G : a) G + = ( V + , E + ) such that S ∗ is an optimal solution for G + if v ∈ S ∗ ; Update µ + ; b) G − = ( V − , E − ) such that S ∗ is an optimal solution for G − if v (cid:54)∈ S ∗ ; Update µ − ; c) Bound the value of the optimal solutions in G + and G − , and discard any of them (set G + or G − to ∅ ) if improvement over µ is impossible; d) Attempt to reduce the size of the subgraphs G + and G − through vertex and edgeremoval techniques; if | V + | > s min then S + , ˜ µ + = decomposition ( G + , S ∪ { v } , µ + , s min ); else Solve graph problem directly on G + and update set of solution vertices S + andvalue ˜ µ + ; if | V − | > s min then S − , ˜ µ − = decomposition ( G − , S, µ − , s min ); else Solve graph problem directly on G − and update set of solution vertices S − andvalue ˜ µ − ; if ˜ µ + ≤ ˜ µ − then return S + , ˜ µ + ; else return S − , ˜ µ − ; One tuning parameter of Algorithm 1 is the procedure for selecting the vertex v that is usedin each iteration to split the current graph instance G into two new graphs. Possible choicesinclude:1. a vertex v of lowest degree.2. a vertex v of median degree.3. a vertex v of highest degree.4. a vertex v chosen at random.In any of the above cases, if multiple vertices satisfy the selection criterion, the vertex v whichis extracted is chosen at random. The aforementioned vertex selection approaches are experi-mentally explored in Section 4.1. Using Algorithm 1 as a framework, we now fill out the details of the generic implementation toarrive at a decomposition algorithm for MC.We use the CH-partitioning introduced in Djidjev et al. (2015), see also Chapuis et al. (2017),in order to split a large input graph G = ( V, E ) into smaller subgraphs on which a maximumclique is found. Denoting the unknown maximum clique as V (cid:48) ⊆ V , there are two cases. Either v ∈ V (cid:48) or v / ∈ V (cid:48) , each case leading to a subproblem of reduced size. If v ∈ V (cid:48) , we extract thesubgraph G + containing all neighbors of v and all edges between them. We also set µ + := µ + 1.If v / ∈ V (cid:48) , the vertex v and all edges adjacent to v are removed from G , thus creating the graph G − (and µ − := µ ). This is visualized in Figure 1.6igure 1: Illustration of the vertex splitting at a vertex v for MC.Figure 2: Illustration of the vertex splitting at a vertex v for MVC.Since the cases v ∈ V (cid:48) and v / ∈ V (cid:48) are exhaustive, we continue to compute MC on bothsubgraphs G + and G − . Since neither of the generated subgraphs G + and G − contains v , thegraph size is reduced by at least one in each recursion level, thus guaranteeing the terminationof the algorithm. The clique number ω ( G ) of G is equal to min( ω ( G + ) + 1 , ω ( G − )). We again select an arbitrary vertex v ∈ V to split the input graph G , see Figure 2. Denoting theunknown MVC as V (cid:48) ⊆ V , there are again two cases leading to subproblems of reduced sizes.If v ∈ V (cid:48) , we add v to the MVC, update µ + , and remove v and all edges adjacent to v from thegraph since those edges are already covered by the choice of v . The resulting graph is G + asillustrated in Figure 2.If v / ∈ V (cid:48) , we observe that for all edges with endpoint v , that is for all ( v, u ) ∈ E , it musthold true that u ∈ V (cid:48) ( µ − is updated accordingly). This is true since, if v / ∈ V (cid:48) , those edgesmust still be covered by their other endpoint u in the MVC. Also, we can remove v from G sincewe know it is not in the MVC. Likewise, we can remove all u with ( u, v ) ∈ V and the adjacentedges of all such u since those vertices are known to belong to the MVC. In Figure 2, under7he assumption that v (cid:54)∈ V (cid:48) , all vertices inside the blue circle must belong to the MVC. Afterremoving v and all its adjacent edges, and assigning all encircled vertices to the MVC, we areleft with the subgraph G − .As for the MC problem, the cases v ∈ V (cid:48) and v / ∈ V (cid:48) are exhaustive. In a recursiveapplication, some bookkeeping is needed to keep track of the current set of cover vertices foreach generated subgraph. Apart from the MC and MVC problems considered in Sections 2.3 and 2.4, the decompositionalgorithm of Section 2.1 can be applied to a much broader class of NP-hard problems. Thissection gives a brief overview of how such decompositions might work. We assume that anygraph problem listed below is defined on some input graph G = ( V, E ).1. Graph partitioning into two components is a classic NP-hard problem. One can decomposeit by assuming that an edge is either a cut edge or it is not, implying that the two adjacentvertices are in different partitions or the same one.2. Graph coloring with n colors has a QUBO formulation with | V | · n variables in whichvariable x v,i indicates with a 1 if vertex v has color i ∈ { , . . . , n } (Lucas, 2014). We candecompose this problem easily by assigning a set of feasible colors to each vertex. We thenselect a random vertex v ∈ V and probe each possible color i for v , implying that color i is removed from the available colors of all vertices adjacent to v .3. Hamiltonian Cycles can likewise be encoded with | V | binary variables in which variable x v,i indicates with a 1 the i th place of vertex v ∈ V in the sorted order of visited vertices.We can decompose this problem into | V | subproblems by selecting a random vertex andassigning it each possible rank in the sorted order of visited vertices. For each assignedrank, the possible ranks for all other vertices decrease by one, and moreover we know thatone of the adjacent vertices to v will have rank i − 1, and another rank i + 1.4. The Traveling Salesman problem is defined on a graph with edge weights. The optimalTraveling Salesman solution is a Hamiltonian Cycle of minimal total edge weight. Usingthe same indicators x v,i for v ∈ V , we can use the same strategy as the one for HamiltonianCycles to decompose such a problem.In general, any arbitrary QUBO or Ising model can be trivially decomposed using a techniquecalled probing in Boros and Hammer (2002). For this, we select a random binary variable x i and create two new QUBOs (or Ising models) by setting x i := 0 and x i := 1 (or − x i but also reduce allquadratic terms involving x i to linear terms. The resulting QUBO (or Ising model) can then beanalysed using general purpose bounding or reduction techniques such as the ones in Boros andHammer (2002) in order to prune subproblems.8 Pruning techniques for MC and MVC The recursive decomposition proposed in Section 2.1 allows us to specify problem-specific tech-niques to bound the optimal solution contained in the generated subproblems, and to reduce thesize of the generated subproblems with the help of reduction techniques. The specific boundsand reductions we consider in the simulations are discussed in this section. We bound the size of the MC and MVC of each generated subgraph. The MC and MVC problemsare in a way complementary problems, as the sum of the size of the MVC of a graph G and thesize of the MC of the complement of G equals the number of the vertices of G (due to the factthat C is a clique in G if and only if V \ C is a vertex cover in the complement of G ). Hence,a lower bound technique on one can be used for an upper bound on the other, and vice versa.As an example for using bounds, in the case of MVC, if a lower bound on the vertex cover inany subgraph is greater than or equal to the current best vertex cover size, we do not need toconsider that subproblem for further decomposition as it cannot contain a better solution thanthe one already known.The following are upper bounds for MC and lower bounds for MVC:1. First, we take the minimum (for MC) or maximum (for MVC) of three easy to computebounds.(a) The function min weighted vertex cover of the NetworkX package (Hagberg et al.,2008) computes an approximate vertex cover of at most twice the size of the optimalcover using the algorithm of Bar-Yehuda and Even (1985). Hence, dividing its resultby a factor of two results in a lower bound on the size of the MVC, which is an upperbound on the size of MC.(b) We employ the matrix rank upper bound on the size of the maximum independentset of Budinich (2003). Since a clique in G is an independent set in G , we obtain anupper bound on the clique size. Likewise, since the complement of any independentset of vertices is a vertex cover, any upper bound on the maximum independent setsize corresponds to a lower bound on the MVC size.(c) We use the easy to compute minimum degree bound of (Willis, 2011, page 20).We will refer to this bound as deterministic bound .2. Any graph coloring provides an upper bound on the chromatic number , or the minimumnumber of colors needed to color the vertices of a graph so that each edge connects verticesof different colors. Since all vertices in a maximum clique need to be assigned differentcolors, the chromatic number is again an upper bound of MC. This means that it gives anupper bound on the size of the maximum independent set of the complement graph andthus a lower bound on MVC. We will refer to this bound as chromatic bound . Computingthe chromatic number is NP-hard, so its exact computation would be intractable, but thereare much better heuristics for its approximation compared with the ones for e.g. the clique9umber. Therefore, a greedy search heuristic for the chromatic number provides an easilycomputable bound. To compute a graph coloring, we use the heuristic function greedy color of the NetworkX package (Hagberg et al., 2008), which is applied to the complement G of G .Analogously, the following are lower bounds for MC and upper bounds for MVC:1. For MC, G − is the larger of the two subgraphs and it contains G + . (However, notethat G + cannot simply be ignored since the MC number of G is computed as ω ( G ) =min( ω ( G + ) + 1 , ω ( G − )).) For MVC, G + is the larger subgraph. Thus at any point in thedecomposition tree, the best solution found so far in G − ( G + ) can be used to get a lower(upper) bound on the size of the MC (MVC). Therefore, we first follow the appropriaterecursive branches in the decomposition until we can compute the MC or MVC on anyof the generated subgraphs: its size can then be used to get a good lower (upper) boundfor the size of MC (MVC) in all the other (smaller) generated subgraphs. We call thisstrategy the decomposition bound .2. We apply the fmc maximum clique solver (Pattabiraman et al., 2013) in fast heuristicmode to G , thus giving us a lower bound on the size of MC. Since the size of the MVC of G added to the clique number of G equals the size of G , finding an approximation of theclique number in G with the help of the fmc heuristic translates to an upper bound on thesize of the MVC of G . We will denote this strategy as the fmc bound .The above bounds are employed during the recursion to prune those subproblems which cannotcontain vertices belonging to the MC or MVC of the input graph. In addition to using upper and lower bounds, we also use two reduction techniques that allow usto reduce the size of a subproblem during the decomposition. The first reduction works directlyon the subgraphs, the second one works with the QUBO formulation of MC given in (2).1. The (vertex) k -core algorithm can reduce the number of vertices of the input graph insome cases, and the edge k -core algorithm (Chapuis et al., 2017; Batagelj and Zaversnik,2011) can reduce the number of edges.The (vertex) k -core of a graph G = ( V, E ) was defined in Section 2.2 as the maximalsubgraph of G in which every vertex has a degree of at least k . Therefore, if a graph hasa clique C of size k + 1, then this clique C must be contained in the k -core of G and allvertices outside of the k -core can be removed.The edge k -core of a graph G is defined in Chapuis et al. (2017). It is easily shown thatfor two vertices v , w in a clique of size c , the intersection N ( v ) ∩ N ( w ) of the two neighborlists N ( v ) and N ( w ) of v and w has size at least c − 2. Denoting the current best lowerbound on the clique size as L , we can therefore choose a random vertex v and remove alledges ( v, w ) satisfying | N ( v ) ∩ N ( w ) | < L − 1, since such edges cannot be part of a cliquewith size larger than L . 10. Another reduction technique works on the QUBO formulation of MC given in (2). Inparticular, for any subgraph produced by our algorithm, we generate the correspondingQUBO formulation of the MC problem (2), which is then analyzed. Several general-purpose preprocessing techniques are capable to identify values of a subset of variables,called persistencies , in a QUBO or Ising problem. Persistencies determine the value ofcertain variables in every global minimum (strong persistencies) or at least one globalminimum (weak persistencies). In Boros and Hammer (2002), a comprehensive overviewof such techniques is given. Suppose variable x v for vertex v (see Section 1) is assigned thevalue x v = 1 in the persistency analysis: we can then add v to the current set of verticesbelonging to the maximum clique and remove v and its adjacent edges from the subgraph.If x v = 0, we can remove v and its adjacent edges without further processing. We employthe qpbo Python bindings of Rother et al. (2007) to carry out the persistency analysis.We use the vertex and edge k -core algorithms with k being set to the current best lower boundvalue for the clique number, thus allowing one to prune entire subgraphs that cannot contain aclique of size larger than the best current one. Similarly to Section 3.2, we employ three reduction techniques to reduce the size of MVC in-stances during the decomposition. The first two are applied to the subgraphs, the last one worksdirectly on the QUBO formulation of MVC given in (3).1. We coin the first method neighbor-based vertex removal (abbreviated as nbvr ). Essentially,we search and remove triangles, vertices of degree one, and vertices of degree zero in anysubgraph. Since in a triangle, any two arbitrarily chosen degree two triangle vertices belongto the MVC, we add a contribution of two to the overall size of the MVC and remove thetriangle. Analogously, vertices of degree one are automatically in the MVC and can beremoved, along with the only neighbor of that vertex, after adding a contribution of oneto the current size of the MVC. Vertices of degree zero can be removed without furtherprocessing.2. In Akiba and Iwata (2015a), the authors state a variety of reduction techniques for MVCthat have been used in the theoretical study of exponential-complexity branch-and-reducealgorithms. For instance, those techniques include degree-one reductions , decomposition , dominance rules , unconfined vertex reduction , LP- and packing reductions , as well as folding- , twin- , funnel- and desk reductions . We employ only the reduction methods fromthe Java package vertex cover-master of Akiba and Iwata (2015b). For a given inputgraph, vertex cover-master returns a superset of the MVC. This means that any vertexnot contained in the output of vertex cover-master is definitely not part of the MVC andcan be removed. The code can be applied repeatedly until no further vertices are foundthat can be removed.3. As for MC, we compute the QUBO formulation for MVC given by (3) for any generatedsubgraph and apply persistency analysis to it using the qpbo Python implementation of11other et al. (2007). Resolved variables during the analysis, e.g., those with x v = 1 forany v ∈ V , indicate that a particular vertex belongs to the minimum vertex cover. We canthen add that vertex v to the current optimal solution and remove it from the subgraphtogether with its adjacent edges. Analogously we remove those v ∈ V with x v = 0.The simulations in Section 4 assess the effectiveness of the aforementioned bounds (Section 4.2)and reduction techniques (Section 4.3). In the experiments we look at various aspects of the proposed decomposition method in Algo-rithm 1. We start with an assessment of the vertex choice of Section 2.2. We then evaluate theproposed bounds (Section 3.1) and reduction techniques (Sections 3.2 and 3.3). Using the bestcombination of vertex choice, bounding and reduction techniques, we concretize the algorithmsfor MC (Section 2.3) and MVC (Section 2.4) and evaluate them in Section 4.4. An applicationof our algorithms to real world graphs is presented in Section 4.5. A prediction regarding theirscaling behavior on future D-Wave architectures is presented in Section 4.6.Throughout the simulations we use three measures to assess the performance in all experi-ments:1. subgraph count: The total number of subgraphs produced during the decomposition.2. preprocessing CPU time: The total time for the decomposition alone without actual solvingof any subproblems.3. predicted solution time: This time accounts for the total preprocessing time and factors inan average QPU access time of 1 . × . . . . We start with an assessment of the strategies for vertex selection discussed in Section 2.2.Figure 3 presents results for subgraph count, preprocessing and predicted solution times forMC and the four vertex selection choices of Section 2.2. We observe that the four strategiesroughly agree for low densities across all measures, though for very low densities the randomvertex selection has a slight advantage in terms of subgraph count. However, for densities above0 . 5, selecting a lowest degree vertex yields best performance across all measures, while a highestdegree vertex selection performs worst. 12 .1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density10 s u bg r a p h c o un t highlowmedrand0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density10 t i m e [ s ] highlowmedrand0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density10 t i m e [ s ] highlowmedrand Figure 3: Vertex selection strategies for MC:high, low, median degree vertex and randomvertex. Subgraph count (top), preprocessingtime (middle) and predicted solution time (bot-tom) as a function of the graph density. Log-arithmic scale on the y-axis. Error bars of onestandard deviation. s u bg r a p h c o un t highlowmedrand0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density10 t i m e [ s ] highlowmedrand0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density10 t i m e [ s ] highlowmedrand Figure 4: Vertex selection strategies for MVC:high, low, median degree vertex and randomvertex. Subgraph count (top), preprocessingtime (middle) and predicted solution time (bot-tom) as a function of the graph density. Log-arithmic scale on the y-axis. Error bars of onestandard deviation.13or MVC, which is the inverse problem of MC, we also observe an inverted picture in Figure 4.Here, selecting a highest degree vertex yields best performance across all measures for low graphdensities, while lowest degree vertex selection performs worst. The intuition here is that, if thevertex degree is k , then the graph G − will have k − G . For higher densities,the four strategies yield roughly similar results. We now evaluate the lower and upper bounds discussed in Section 3.1. For MC, the decom-position and fmc bounds are lower bounds, while the chromatic and deterministic bounds areupper bounds. Results are shown in Figure 5. We observe that all combinations of bounds yieldhigh reductions for low and moderate densities, and that the bounds become less effective forhigh densities. Of the four combinations tested, using the decomposition lower bound and thechromatic upper bound seems most advantageous as it yields the lowest subgraph count, is thequickest to compute, and results in an overall fastest runtime.Figure 6 repeats the assessment of the lower and upper bounds for MVC. Now, lower boundsfor MVC are the chromatic and deterministic bounds, while the decomposition and fmc boundsare upper bounds. Since MC and MVC are inverse problems, the bounds are now less effectivefor low graph densities, and become highly effective for moderate and high densities. We againobserve that overall, the combination of lower chromatic bound and upper decomposition boundis most advantageous. Figure 7 assesses the behavior of the two reduction techniques for MC discussed in Section 3.2.Those are the qpbo reduction which analyses the QUBO representation of MC given in (2), andthe k -core reduction which works on the graph itself.We observe a particular behavior of these reductions in Figure 7: overall, reductions arehighly effective for low and moderate graph densities, and become less effective for high densities.While for low densities, k -core is better than qpbo, both techniques draw equal for moderatedensities and qpbo overtakes k -core for high densities. The fact that qpbo becomes more effectivefor high densities has already been observed in Hahn and Djidjev (2017). As shown in the plotdepicting the preprocessing time, k -core is computationally efficient for all densities, while thecomputational complexity of qpbo is more complex but generally increases for high densities.The behavior of the predicted solution time again reflects the behavior of the subgraph count,with k -core being faster for low and medium densities, and slower for high densities.Figure 8 shows a similar comparison for the three reduction techniques for MVC outlined inSection 3.3. Those are qpbo working on the QUBO representation of MVC in (3), the reductiontechniques of Akiba and Iwata (2015a) given in the Java package vertex cover-master of Akibaand Iwata (2015b), and the neighbor based vertex removal (nbvr).We observe that all reductions are able to reduce the subproblems most effectively for mediumand high densities. Neighbor based vertex removal is fastest to compute, and persistency analysisagain becomes slower with increasing graph density. Overall, neighbor based vertex removal is14 .1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density0100200300400500 s u bg r a p h c o un t lower_decomp_upper_chromlower_decomp_upper_determlower_fmc_upper_chromlower_fmc_upper_determ0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density05101520 t i m e [ s ] lower_decomp_upper_chromlower_decomp_upper_determlower_fmc_upper_chromlower_fmc_upper_determ0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density0100200300400500600700800 t i m e [ s ] lower_decomp_upper_chromlower_decomp_upper_determlower_fmc_upper_chromlower_fmc_upper_determ Figure 5: All combinations of lower and upperbounds for MC. Lower bounds are the decom-position and fmc bounds, upper bounds are thechromatic and deterministic bounds (see Sec-tion 3.1). Subgraph count (top), preprocessingtime (middle) and predicted solution time (bot-tom) as a function of the graph density. Errorbars of one standard deviation. s u bg r a p h c o un t lower_chrom_upper_decomplower_chrom_upper_fmclower_determ_upper_decomplower_determ_upper_fmc0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density0510152025 t i m e [ s ] lower_chrom_upper_decomplower_chrom_upper_fmclower_determ_upper_decomplower_determ_upper_fmc0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density0100200300400500600 t i m e [ s ] lower_chrom_upper_decomplower_chrom_upper_fmclower_determ_upper_decomplower_determ_upper_fmc Figure 6: All combinations of lower and upperbounds for MVC. Lower bounds are the chro-matic and deterministic bounds, upper boundsare the decomposition and fmc bounds (see Sec-tion 3.1). Subgraph count (top), preprocessingtime (middle) and predicted solution time (bot-tom) as a function of the graph density. Errorbars of one standard deviation.15raph name No. No. CPU No. Time [s]vertices edges time subgraphsbn-macaque-rhesus-interareal- 93 2700 0.0701 1 1.670cortical-network-2ENZYMES-g8 88 133 0.016 1 1.616ENZYMES-g123 90 127 0.0167 1 1.617rt-retweet 96 117 0.0199 1 1.619polbooks 105 441 0.0329 1 1.633ia-enron-only 143 623 0.0756 1 1.676ia-infect-hyper 113 2196 0.0846 1 1.685johnson16-2-4 120 5460 2.611 531 852.211Table 1: Predicted solution time in seconds for real world graphs based on a single run usingDBK.fastest to compute, yields the lowest number of subgraphs during decomposition and the lowestoverall runtime. Using our preparatory experiments of Sections 4.1 to 4.3, we can now fully specify the decom-position algorithm for MC introduced in Section 2.3. To be precise, we employ the algorithm ofSection 2.3 with low degree vertex selection (Section 4.1), the decomposition lower and chromaticupper bounds (Section 4.2), and the k -core reduction strategy as determined in Section 4.3. Asin Pelofske et al. (2019a), we call the resulting algorithm the DBK algorithm (Decomposition,Bounds, K -core).Figure 9 shows scaling results of DBK as a function of the graph size ranging from 60 to180 vertices, and for three graph densities d ∈ { . , . , . } . We observe that the scaling issuperpolynomial in the graph size, which is to be expected when solving an NP-hard problem.We also observe that as expected, denser graphs require a higher solver runtime since for densegraphs the extracted subgraphs on average contain more vertices and thus take longer to befully decomposed.We repeat the same scaling experiment for the MVC problem. To fully specify the algorithmof Section 2.4, we now employ the high degree vertex selection (Section 4.1), the decompositionupper and chromatic lower bounds (Section 4.2), and the neighbor based vertex removal reduc-tion strategy as determined in Section 4.3. As in Pelofske et al. (2019b), we call the resultingalgorithm the DBR algorithm (Decomposition, Bounds, Reduction).Analogously to the MC scaling, Figure 10 shows scaling results for MVC. Importantly, andas expected due to the inverse relationship of the MC and MVC problems, the DBR algorithmalso has a superpolynomial scaling, where higher graph densities result in a lower runtime. To demonstrate the applicability of our proposed algorithms, we apply them to find cliques orvertex covers in real world graphs (Rossi and Ahmed, 2015; Rossi et al., 2014, 2012; Cohen,2009; Amunts et al., 2013; SocioPatterns, 2012; Rossi and Ahmed, 2014; Bader et al., 2013). For16 .1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density0100200300400 s u bg r a p h c o un t persistency analysisk-core0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density05101520253035 t i m e [ s ] persistency analysisk-core0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density0100200300400500600700 t i m e [ s ] persistency analysisk-core Figure 7: Persistency analysis and k -core re-duction techniques for MC. Subgraph count(top), preprocessing time (middle) and pre-dicted solution time (bottom) as a function ofthe graph density. Error bars of one standarddeviation. s u bg r a p h c o un t persistency analysisB&Rnbvr0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density0246810 t i m e [ s ] persistency analysisB&Rnbvr0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9density100200300400500600700 t i m e [ s ] persistency analysisB&Rnbvr Figure 8: Persistency analysis, B&R reductionand neighbor based vertex removal (nbvr) re-duction techniques for MC. Subgraph count(top), preprocessing time (middle) and pre-dicted solution time (bottom) as a function ofthe graph density. Error bars of one standarddeviation.17 s u bg r a p h c o un t t i m e [ s ] t i m e [ s ] Figure 9: Performance of the DBK algorithmas a function of the graph size. Graph densities d ∈ { . , . , . } . Subgraph count (top),preprocessing time (middle) and predicted so-lution time (bottom) as a function of the graphdensity. Logarithmic scale on the y-axis. Errorbars of one standard deviation. 60 80 100 120 140 160 180graph size10 s u bg r a p h c o un t t i m e [ s ] t i m e [ s ] Figure 10: Performance of the DBR algorithmas a function of the graph size. Graph densities d ∈ { . , . , . } . Subgraph count (top),preprocessing time (middle) and predicted so-lution time (bottom) as a function of the graphdensity. Logarithmic scale on the y-axis. Errorbars of one standard deviation.18raph name No. No. CPU No. Time [s]vertices edges time subgraphsbn-macaque-rhesus-interareal- 93 2700 0.104 1 1.704cortical-network-2ENZYMES-g8 88 133 0.0233 2 3.223ENZYMES-g123 90 127 0.0205 1 1.620rt-retweet 96 117 0.0161 1 1.602polbooks 105 441 0.060 1 1.660ia-enron-only 143 623 0.169 6 9.769ia-infect-hyper 113 2196 0.350 22 35.550johnson16-2-4 120 5460 0.536 2 3.736Table 2: Predicted solution time in seconds for real world graphs based on a single run usingDBR.MC, Table 1 shows results for the DBK algorithm, demonstrating that graphs with hundredsof vertices and thousands of edges can be solved in a few seconds. We also observe that thebounding and reduction techniques result in a strong pruning of the generated subproblems,since the number of created subproblems is typically very low.For MVC, an assessment of the DBR algorithm in Table 2 confirms these results. When using our algorithms in connection with the D-Wave annealer, DBR or DBK will be rununtil the size of a subproblem created during the decomposition reaches at most 46 vertices forD-Wave 2X (64 for D-Wave 2000Q, and 180 for D-Wave Advantage), since QUBOs of this sizeare guaranteed to be embeddable on the qubit architectures. It is interesting to investigate howthe scaling behavior of our algorithms depends on this cutoff of the decomposition. For this weapply our DBR and DBK algorithms to random graph instances of fixed density, and decomposethose graphs until a limit is reached that depends on the D-Wave architectures we investigate.This allows us to report numbers of generated subgraphs (subgraph count) for each architectureand preprocessing times. Assuming a fixed time of 1 . . 5, Figure 11 shows runtime predictions for DBR. As expected,a higher cutoff leads to a faster runtime. Notably, we observe almost no difference betweenD-Wave 2X and 2000Q, but a pronounced speedup on D-Wave Advantage. It seems as if theslope for the 180 vertex cutoff on D-Wave Advantage slightly decreases, but this remains forfurther investigation.Prediction results for the DBR algorithm (Figure 12) are qualitatively similar. This article proposed a novel decomposition framework for NP-hard graph problems character-ized by finding an optimal set of vertices. The framework recursively splits a given instance of aNP-hard graph problem into smaller subproblems until, at some recursion level, the generatedsubproblems can be solved with any method of choice. This includes but is not limited to a19 80 200 220 240 260 280graph size10 s u bg r a p h c o un t t i m e [ s ] t i m e [ s ] Figure 11: Performance prediction of the DBKalgorithm on future D-Wave architectures as afunction of the graph size. Recursion cutoff atsubgraph sizes of 46, 64, and 180 vertices. Sub-graph count (top), preprocessing time (middle)and predicted solution time (bottom) as a func-tion of the graph size. Logarithmic scale on they-axis. Error bars of one standard deviation.Graph density 0 . 180 200 220 240 260 280graph size10 s u bg r a p h c o un t t i m e [ s ] t i m e [ s ] Figure 12: Performance prediction of the DBRalgorithm on future D-Wave architectures as afunction of the graph size. Recursion cutoff atsubgraph sizes of 46, 64, and 180 vertices. Sub-graph count (top), preprocessing time (middle)and predicted solution time (bottom) as a func-tion of the graph size. Logarithmic scale on they-axis. Error bars of one standard deviation.Graph density 0 . Acknowledgments Research presented in this article was supported by the Laboratory Directed Research andDevelopment program of Los Alamos National Laboratory under project numbers 20180267ERand 20190065DR. 21 eferences Akiba, T. and Iwata, Y. (2015a). Branch-and-reduce exponential/fpt algorithms in practice:A case study of vertex cover. , pages 1–12.Akiba, T. and Iwata, Y. (2015b). Vertex cover solver. https://github.com/wata-orz/vertex cover.Amunts, K., Lepage, C., Borgeat, L., Mohlberg, H., Dickscheid, T., Rousseau, M.-´E., Bludau,S., Bazin, P.-L., Lewis, L. B., Oros-Peusquens, A.-M., Shah, N. J., Lippert, T., Zilles, K.,and Evans, A. C. (2013). Bigbrain: An ultrahigh-resolution 3d human brain model. Science ,340(6139):1472–1475.Bader, D. A., Meyerhenke, H., Sanders, P., and Wagner, D. (2013). Graph Partitioning andGraph Clustering. 10th DIMACS Implementation Challenge Workshop February 13-14, 2012. Contemp Math , 588.Balasubramanian, R., Fellows, M., and Raman, V. (1998). An improved fixed parameter algo-rithm for vertex cover. Information Processing Letters , pages 163–168.Bar-Yehuda, R. and Even, S. (1985). A local-ratio theorem for approximating the weightedvertex cover problem. Ann Discrete Math , 25:27–46.Barahona, F. (1982). On the computational complexity of ising spin glass models. J Phys A:Math Gen , 15:3241–3253.Batagelj, V. and Zaversnik, M. (2011). An O(m) Algorithm for Cores Decomposition of Net-works. Adv Dat An Class , 5(2).Boros, E. and Hammer, P. (2002). Pseudo-boolean optimization. Discrete Appl Math , 123(1–3):155–225.Bron, C. and Kerbosch, J. (1973). Algorithm 457: Finding all cliques of an undirected graph. Commun ACM , 16(9):575–577.Budinich, M. (2003). Exact bounds on the order of the maximum clique of a graph. DiscreteApplied Mathematics , 127(3):535–543.Carraghan, R. and Pardalos, P. (1990). An exact algorithm for the maximum clique problem. Operations Research Letters , 9(6):375–382.Chapuis, G., Djidjev, H., Hahn, G., and Rizk, G. (2017). Finding Maximum Cliques on theD-Wave Quantum Annealer. Proceedings of the 2017 ACM International Conference on Com-puting Frontiers (CF’17) , pages 1–8.Chen, J., Kanj, I., and Jia, W. (2001). Vertex cover: further observations and further improve-ments. Journal of Algorithms , 41:280–301. 22hen, J., Kanj, I., and Xia, G. (2010). Improved upper bounds for vertex cover. TheoreticalComputer Science , 411:3736–3756.Chen, J., Liu, L., and Jia, W. (2000). Improvement on vertex cover for low degree graphs. Networks , 35:253–259.Choi, V. (2008). Minor-embedding in adiabatic quantum computation: I. the parameter settingproblem. Quantum Information Processing , 7:193–209.Cohen, W. (2009). Enron email dataset. Proceedings of the 16th Annual Symposium on The-oretical Aspects of Computer Science STACS 99. ∼ enron. Accessedin 2009.Courcelle, B., Makowsky, J., and Rotics, U. (2000). Linear time solvable optimization problemson graphs of bounded clique-width. Theor Comput Syst , 33(2):125–150.D-Wave (2016). Technical Description of the D-Wave Quantum Processing Unit . D-Wave.DIMACS (2000). Workshop on Faster Exact Algorithms for NP-hard problems. Princeton, NJ.Djidjev, H., Chapuis, G., Hahn, G., and Rizk, G. (2016). Efficient Combinatorial OptimizationUsing Quantum Annealing. LA-UR-16-27928. arXiv:1801.08653 .Djidjev, H., Hahn, G., Niklasson, A., and Sardeshmukh, V. (2015). Graph Partitioning Methodsfor Fast Parallel Quantum Molecular Dynamics. SIAM Workshop on Combinatorial ScientificComputing CSC16 .Downey, R. and Fellows, M. (1992). Fixed-parameter tractability and completeness. CongressusNumerantium , 87:161–187.Erd¨os, P. and R´enyi, A. (1960). On the Evolution of Random Graphs. Publication of the MathInst of the Hungarian Academy of Sciences , 5:17–61.Fomin, F. V., Grandoni, F., and Kratsch, D. (2006). Measure and Conquer: A Simple O (2 . n )Independent Set Algorithm. SODA ’06: Proceedings of the seventeenth annual ACM-SIAMsymposium on Discrete algorithm , pages 18–25.Giakoumakis, V. and Vanherpe, J. (1997). On extended P4-reducible and extended P4-sparsegraphs. Theoret Comput Sci , 180:269–286.Hagberg, A., Schult, D., and Swart, P. (2008). Exploring network structure, dynamics, andfunction using NetworkX. Proceedings of SciPy2008 , pages 11–15.Hahn, G. and Djidjev, H. N. (2017). Reducing binary quadratic forms for more scalable quantumannealing. IEEE International Conference on Rebooting Computing (ICRC) , pages 1–8.Hou, Y. T., Shi, Y., and Sherali, H. D. (2014). Branch-and-bound framework and application ,pages 95–121. Cambridge University Press.Johnson, D. and Tricks, M. (1996). Cliques, Coloring and Satisfiability, Second DIMACS Im-plementation Challenges. 23ucas, A. (2014). Ising formulations of many NP problems. Front Phys , 2(5):1–27.Morrison, D., Jacobson, S., Sauppe, J., and Sewell, E. (2016). Branch-and-bound algorithms:A survey of recent advances in searching, branching, and pruning. Discrete Optimization ,19:79–102.Niedermeier, R. and Rossmanith, P. (2003). On efficient fixed-parameter algorithms for weightedvertex cover. Journal of Algorithms , 47:63–77.Niedermeier, R. and Rossmanith, P. (2007). Upper bounds for vertex cover further improved.In Proceedings of the 16th Symposium on Theoretical Aspects of Computer Science (STACS) .Pattabiraman, B., Patwary, M. M. A., Gebremedhin, A. H., Liao, W.-k., and Choudhary, A.(2013). Fast algorithms for the maximum clique problem on massive sparse graphs. In Bonato,A., Mitzenmacher, M., and Pra(cid:32)lat, P., editors, Algorithms and Models for the Web Graph ,pages 156–169, Cham. Springer International Publishing.Pelofske, E., Hahn, G., and Djidjev, H. (2019a). Solving large maximum clique problems on aquantum annealer. Proceedings of the International Workshop on Quantum Technology andOptimization Problems QTOP’19 , pages 123–135.Pelofske, E., Hahn, G., and Djidjev, H. (2019b). Solving large Minimum Vertex Cover problemson a quantum annealer. Proceedings of the Computing Frontiers Conference CF’19 , pages76–84.Rao, M. (2008). Solving some NP-complete problems using split decomposition. Discrete ApplMath , 156(14):2768–2780.Robson, J. (1986). Algorithms for Maximum independent Sets. J Algorithms , 7:425–440.Robson, J. M. (2001). Finding a maximum independent set in time o (2 n/ ).Rossi, R., Gleich, D., and Gebremedhin, A. (2015). Parallel Maximum Clique Algorithms withApplications to Network Analysis. SIAM J. Sci. Comput. , 37(5):C589–C616.Rossi, R. A. and Ahmed, N. K. (2014). Coloring large complex networks. In Social NetworkAnalysis and Mining , pages 1–51.Rossi, R. A. and Ahmed, N. K. (2015). The network data repository with interactive graphanalytics and visualization. In Proceedings of the Twenty-Ninth AAAI Conference on ArtificialIntelligence .Rossi, R. A., Gleich, D. F., Gebremedhin, A. H., and Patwary, M. A. (2012). What if CLIQUEwere fast? Maximum Cliques in Information Networks and Strong Components in TemporalNetworks. arXiv preprint arXiv:1210.5802 , pages 1–11.Rossi, R. A., Gleich, D. F., Gebremedhin, A. H., and Patwary, M. A. (2014). Fast maximumclique algorithms for large graphs. In Proceedings of the 23rd International Conference onWorld Wide Web (WWW) . 24other, C., Kolmogorov, V., Lempitsky, V., and Szummer, M. (2007). Optimizing binary MRFsvia extended roof duality. CVPR Technical Report 318, Department of Computer Science, ETH Zurich .Tarjan, R. (1985). Decomposition by clique separators. Discrete Math , 55(2):221–232.Willis, W. (2011). Bounds for the independence number of a graph. Master’s thesis, VirginiaCommonwealth University. https://scholarscompass.vcu.edu/etd/2575.Woeginger, G. (2008). Open problems around exact algorithms. Discrete Applied Mathematics ,156(3):397–405.Xiao, M. and Nagamochi, H. (2013). Exact Algorithms for Maximum Independent Set. In CaiL., Cheng SW., Lam TW. (eds) Algorithms and Computation. ISAAC 2013. Lecture Notesin Computer Science , volume 8283. Springer, Berlin, Heidelberg.Xu, H., Kumar, T., and Koenig, S. (2016). A new solver for the minimum weighted vertexcover problem.