Abstract
We propose two new algorithms – SpringBased MinorMiner (SPMM) and CliqueBased MinorMiner (CLMM) – which take as input the connectivity graph of a Quadratic Unconstrained Binary Optimization (QUBO) problem and produce as output an embedding of the input graph on a host graph that models the topology of a quantum computing device. As host graphs, we take the Chimera graph and the Pegasus graph, which are the topology graphs of DWave’s 2000 qubit (first introduced in 2017) and 5000 qubit (expected 2020) quantum annealer devices, respectively. We evaluate our algorithms on a large set of random graph QUBO inputs (ErdősRényi \(G_{n,p}\), BarabásiAlbert and dregular graphs) on both host topologies against other embedding algorithms. For the Pegasus topology, we find that CLMM outperforms all other algorithms at edge densities larger than 0.08, while SPMM wins at edge densities smaller than 0.08 for ErdősRényi graphs, with very similar transition densities for the other graph classes. Surprisingly, the standard DWave MinorMiner embedding algorithm – while also getting slightly outperformed by SPMM for sparse and very dense graphs on Chimera – does not manage to extend its overall good performance on Chimera to Pegasus as it fails to embed even mediumdensity graphs on 175–180 nodes which are known to have clique embeddings on Pegasus.
Research presented in this article was supported by the Laboratory Directed Research and Development program of Los Alamos National Laboratory under project numbers 20180267ER / 20190065DR. Los Alamos report number LAUR2022259.
You have full access to this open access chapter, Download conference paper PDF
Similar content being viewed by others
1 Introduction
Quantum annealers such as the DWave 2000Q offer high quality solutions to hard optimization problems, and have a relatively large number of (currently up to 2000) qubits, while the nextgeneration DWave Advantage (due in 2020) will have more than 5000 qubits. Because of the technological challenges in connecting qubits, existing qubit connectivity topologies are far from the desirable alltoall topology, as a result limiting the sizes of the problems that can be solved on these devices. In fact, the currently used Chimera has degree 6 [7], while the Pegasus topology (available in 2020 with DWave Advantage) has degree 15 [5]. The programming model for the DWave quantum annealer consists of setting the coefficients of a quadratic optimization function on binary variables (called a Quadratic Unconstrained Binary Optimization (QUBO) problem) so that linear terms map to qubits and quadratic terms map to couplers between the corresponding qubits. In practical applications, we are given an input QUBO whose set of linear and quadratic weights does not directly map onto the physical topology of the DWave device, so we have to represent each variable by a set of qubits (chain) and decide how to map variables onto chains. This problem is usually modeled as a graph theoretic problem: Finding a minor embedding of the input QUBO graph into an input topology host graph, a classical algorithmic problem that is generally NPhard [25]. The ability to embed practical QUBOs at larger and larger size directly correlates to the success and operational applicability of DWave devices when competing with classical devices.
In this paper, we propose and test two new embedding algorithms – Springbased MinorMiner (SPMM) and Cliquebased MinorMiner (CLMM). We study the performance of these algorithms as compared to two previously proposed methods: MinorMiner (MM) [9, 13] and a recent adaptation, LayoutAware MinorMiner (LAMM) [28, 29]. All four algorithms are benchmarked on a large set of random input QUBO graphs that need to be embedded onto the Chimera and Pegasus topologies. As random graph classes, we study ErdősRényi \(G_{n,p}\) graphs, BarabásiAlbert graphs, and random dregular graphs. Each of these graph classes has a density parameter and a graph order (size) that we vary in our experiments. We assess the performance of the four algorithms based on whether they are able to embed graphs. The parameters of our experimental study are given in Table 1. Our main findings are:

On the Pegasus host graph, our Cliquebased MinorMiner (CLMM) is a clear winner with our alternative SpringBased MinorMiner (SPMM) algorithm edging out both CLMM and MM for very sparse graphs only. The relative ranking of the algorithms is the same across all three QUBO input classes with SPMM’s advantage at sparse graphs most pronounced for dregular graphs. Somewhat surprisingly, a threshold edge density exists that is very similar for all three random graph classes (at about \(E/\left( {\begin{array}{c}V\\ 2\end{array}}\right) \approx 0.08\)) such that CLMM and SPMM win at edge densities larger and smaller than the threshold, respectively (E, V denote edges and nodes of the QUBO graph).

On the Chimera host graph, SPMM wins over MM and LAMM at sparse and dense graphs, whereas MM and LAMM perform slightly better at medium density graphs. Again, SPMM’s advantage at large sparse graphs is most pronounced for dregular graphs.

On the Chimera host graph, all algorithms easily manage to embed the previously largest known embeddable clique (at 65 vertices), whereas on Pegasus only CLMM finds embeddings of cliques with more than 180 nodes. In fact, using SPMM for Chimera and CLMM for Pegasus we find largest embeddable cliques at sizes 65 and 185 respectively.
The paper is organized as follows: We introduce the concepts of QUBOs, embeddings, host graphs and other background material including related work in more detail in Sect. 2. We describe the embedding algorithms in Sect. 3, and give details about the experimental design in Sect. 4. We present our results for the Pegasus host graph in Sect. 5 and for the Chimera host graph in Sect. 6, before concluding in Sect. 7.
2 Background
2.1 Quadratic Unconstrained Binary Optimization (QUBO)
Quadratic Unconstrained Binary Optimization (QUBO) is the problem of minimizing a quadratic function of binary variables, in one of the forms
The two formulations are equivalent via bijective relations \(h_i = \tfrac{1}{2}\left( a_i+\smash {\sum _j} b_{ij}\right) \), \(J_{ij} = \tfrac{b_{ij}}{4}\). Note that \(J_{ij}\) is nonzero if and only if \(b_{ij}\) is nonzero. Hence QUBO problems are naturally represented by a graph \(P=(V_P,E_P)\), where in \(V_P\) each variable \(z_i\) is represented as a node \(z_i\) with weight \(h_i\), and in \(E_P\) we have for every pair \(i<j\) with nonzero \(J_{ij}\) an edge \(e = \{z_i, z_j\}\) with edge weight \(J_{ij}\).
We remark that QUBOs are a class of NPhard optimization problems; as we can use QUBOs to optimize the number of satisfied constraints in an instance of 0/1 Integer Programming – one of Karp’s original 21 NPcomplete problems [21].
2.2 Solving QUBOs on Quantum Annealers
Quantum Annealers such as DWave’s 2000Q and the upcoming DWave Advantage [5] have quantum processors with a set of qubits \(\mathcal {Q}\) and a set of couplers \(\mathcal {C}\) between some pairs of qubits. If we identify the qubits with a node set \(V_H\) and the couplers with an edge set \(E_H\), the resulting connected structure is a graph \(H=(V_H, E_H)\), called the host graph. The DWave programming model lets us set weights \(h_i\) for every qubit \(q_i \in \mathcal {Q}\) and weights \(J_{ij}\) for every coupler \(c_{ij} \in \mathcal {C}\). In an actual DWave calculation, the device uses quantum annealing to sample from lowenergy eigenstates of the Hamiltonian
with PauliZ operators \(\sigma _z^{(i)}\) acting on qubit \(q_i\).^{Footnote 1} As such, the spin configuration of a groundstate corresponds to an optimum solution of a QUBO in Ising formulation with the same weights \(h_i, J_{ij}\).
However, most users will have QUBO problems from their application domains with corresponding QUBO graphs that are far from being subgraphs of the host graph. In order to be able to solve QUBOs using a quantum annealer, the standard approach (see Fig. 1) is to find a minor embedding of the QUBO graph into the host graph [11] and to set the \(h_i, J_{ij}\) parameters accordingly [10]; i.e. one chains multiple qubits of the host graph with ferromagnetic couplings \(J_{ij} \ll 0\) to represent a single variable of a QUBO (indicated by shared colors in Fig. 1 (center)/(right)). The better the embedding algorithm, the more QUBO problems can be solved by an annealer. Designing and testing capable embedding algorithms that are able to embed a large set of QUBO graphs is thus crucial to expand the set of applications for a quantum device such as DWave. The same holds true for CMOS annealers, such as those of Hitachi [33, 36].
We note in passing that adiabatic quantum computing [15] – the theoretical inspiration for quantum annealer technology – is equivalent in power to standard gatebased quantum computing [2] that implements arbitrary unitary operations. However, the mapping challenge on gatebased quantum devices differs substantially from quantum annealers as logical variables are mapped only to single qubits and not to chains. To implement a gate between two nonneighboring qubits in a gate device, qubit states are swapped along paths of the host topology, giving a “timedependent mapping”, sometimes called routing. Depending on the application, this can be done heuristically [12], with exact solvers [35], or using a swap network [26]. Comparing stateoftheart approaches to equality constraints implementation on a quantum annealer [34] and on a gatebased quantum computer [8] shows, on a concrete application, how different the mapping problem is for the two platforms.
2.3 Minor Embeddings
A minor embedding of a pattern graph \(P = (V_P,E_P)\) into a host graph \(H = (V_H,E_H)\) is a mapping \(\varphi \) of each node in \(V_P\) to a subset of nodes in \(V_H\):
where \(2^{V_H}\) is the set of all subsets of \(V_H\), such that

1.
For each node v in \(V_P\), the set of nodes \(\varphi (v)\) induces a connected subgraph in H, called the chain of v.

2.
For every edge \(e =\{u,v\}\) in \(E_P\), there exist nodes \(\tilde{u}\in \varphi (u)\) and \(\tilde{v} \in \varphi (v)\) such that \(\{\tilde{u}, \tilde{v}\}\in E_H\).

3.
\(\varphi (v)\cap \varphi (u) = \emptyset \) for all \(u \ne v \in V_P\), i.e., each node \(\tilde{v}\) of the host graph H appears in the mapping of at most one node of the pattern graph P.
We call a mapping \(\varphi \) a chain mapping if it satisfies Condition . A chain mapping \(\varphi \) is called a semivalid embedding if it satisfies Condition and is called a chain placement if it satisfies Condition . Only if all three conditions are satisfied do we have a minor embedding. Colloquially, we abbreviate minor embedding with just embedding.
Finding a minorembedding is NPcomplete [25] except for (small) fixed pattern graphs [30], and the best known algorithms [1] are exponential in \(V_P\) and the branchwidth or treewidth of H (which is \(\varOmega (\sqrt{V_H})\) for current annealers). Research on minorembedding for annealers has therefore focused on finding fast and hiqhquality heuristics. Existing approaches can best be described along one of two trajectories: (i) iteratively modify a semivalid embedding to reduce the number of multiply used nodes \(\tilde{v} \in V_H\) (the approach shared by the algorithms benchmarked in this paper), (ii) iteratively modify a chain placement to increase the number of represented edges \(e\in E_P\) (recently proposed [32] for King’s graphs, the topology of Hitachi CMOS annealers [33]).
Furthermore, good minor embeddings are known for highly structured pattern graphs such as cliques [6, 24], cartesian products thereof [37], bicliques [19], cubic grids [20] and cylindrical lattices (squareoctogonal and triangular) [23].
2.4 Chimera and Pegasus Topologies
The host graphs of current and upcoming DWave annealers can be understood starting from an intersection graph of axisparallel rectangles (the qubits):
In Chimera [7], \(4\times 4\) intersecting orthogonal qubits with internal couplers give rise to biclique \(K_{4,4}\) tiles. External couplers to adjacent horizontal respectively vertical qubits arrange these in a grid, where neighboring tiles are connected by 4 edges. All qubits (except those on the border) have degree 6, see Fig. 2 (left). The Chimera graph C16, such as in the DWave 2000Q, has \(16\times 16\) tiles for a total of 2048 qubits. We illustrate a smaller C3 in Fig. 1.
In Pegasus [5], qubit rectangles are longer and connect to 12 orthogonal qubits. Furthermore, horizontal and vertical qubits are shifted asymmetrically, and have additional odd couplers that connect pairs of neighboring parallel qubits, such that qubits have degree 15. This results in cells that are connected by 4, 8, or 16 edges, see Fig. 2 (right). The Pegasus graph P16, such as in the upcoming DWave Advantage, has \(15\times 15\times 3\) cells, plus some partial cells on the border, for a total of 5640 qubits. We illustrate P4 in Fig. 3.
2.5 QUBO Random Graph Classes
To extend the range of embeddable QUBOs on current and nextgeneration devices, we benchmark embedding algorithms based on their performance in finding embeddings. Other metrics such as average or maximum chain lengths [29] are not a focus of this paper; hence the actual values of nonzero QUBO terms do not matter. Similarly, we only consider connected graphs (as one can always solve connected components independently) and do not consider any divideandconquer strategies [27]. We use three classes of random graphs as benchmarks:
(i) ErdősRényi graphs \(G_{n,p}\) [18], where edges are included in the graph i.i.d with probability p, (ii) BarabásiAlbert graphs \(BA_{n,m}\) [3, 4], in which, starting from m isolated nodes, we insert \(mn\) nodes one by one, connecting each to m existing nodes with preferential attachment proportional to the current degree distribution, (iii) random dregular graphs, in which each node has degree d. By varying p, d and m, respectively, we generate graphs of various densities.
We chose these three graph classes in order to test our algorithms on a diverse set of graphs: ErdősRényi graphs have a binomial (Poisson for small p) degree distribution, BarabásiAlbert graphs have a powerlaw degree distribution (modeling networks), and dregular graphs have a constant degree distribution.
In the following Section, we briefly present existing algorithms that we either compare to or use as a subroutine in our algorithms, which then follow next.
3 Minor Embedding Heuristics
3.1 Existing Embedding Algorithms
MinorMiner. The MinorMiner algorithm (MM), proposed in 2014 [9], is arguably the most prominent embedding algorithm, given its inclusion in DWave’s Ocean software stack [13]. Given any QUBO graph P and host graph H as an input, it tries to find an embedding; and if not successful after a certain number of steps it returns an empty embedding. The MM algorithm starts from an initial chain mapping (with chains empty by default) and repeatedly loops over the nodes of P, to determine for each node \(v \in V_P\) a (preliminary) chain as follows:

1.
Remove the chain \(\varphi (v) \subseteq E_H\) from the existing chain mapping.

2.
Compute a nodeweighted shortest paths tree in H from each nonempty chain \(\varphi (u)\), where u is a neighbor of v in P (\(\{u,v\} \in E_P\)). The node weights in H come with a high penalty term for using nodes in multiple chains.

3.
Choose an optimal node \(\tilde{v} \in V_H\) that minimizes the sum of distances according to the computed shortest paths trees. Extend \(\tilde{v}\) to a chain \(\varphi (v)\) by backtracking along the shortest paths trees, and readd \(\varphi (v)\) to the chain mapping.
This naturally splits MinorMiner into two phases: First, MM completes a single loop over the vertices \(V_P\), after which the chain mapping \(\varphi \) is in fact a semivalid embedding (in which chains might still share qubits).
Secondly, MM enters a fixing phase, where consecutive loops over nodes in \(V_P\) have the goal of fixing this semivalid embedding. The algorithm restarts when there has been no progression for too many steps in a row^{Footnote 2}, with limiting parameters on the total number of steps and number of restarts allowed. Thus, when the algorithm terminates, it might either return a valid embedding when it found one, or an empty embedding if it did not.
MM has a few other controls, such as the \(\texttt {initial\_chain}\) parameter. This parameter can be used to feed the algorithm an initial chain mapping, which is then used in the first phase of finding a semivalid embedding. However, the algorithm still iterates over all nodes. When it reaches a node which was assigned an initial nonempty chain, it still deletes and replaces that chain with the procedure outlined above.
LayoutAware MinorMiner. A recent contribution to MinorMiner [29] has as its main focus QUBOs that come with a natural graph layout in the plane (think, e.g., of lattices in the simplest case). The implementation [28] takes a QUBO graph and its layout together with the host graph and a plane host graph layout as an input. The algorithm maps each variable node of the QUBO graph layout to the closest (in Euclidean metric) qubit node of the host graph layout. An additional diffusion phase shifts this mapping to achieve an even spreading of initial chains across tiles/cells of the topology, and then starts MinorMiner with the computed initial_chain mapping. However, not all QUBOs come with a natural layout; if the graph comes without a layout, their algorithm runs a FruchtermanReingold spring embedding algorithm to generate such a layout.
Clique Embedding. DWave has a hostspecific clique embedding algorithm [6], which can quickly embed any clique up to a certain size \(c_{\mathrm {host}}\) into the Pegasus or the Chimera graph (this also implies an embedding algorithm for any graph with up to \(c_{\mathrm {host}}\) nodes). For Pegasus P16, the maximal clique size embeddable this way is \(c_{\mathrm {host}} = 180\), for Chimera C16 it is \(c_{\mathrm {host}} = 64\). Chains gained from this embedding have a very special shape: they are all paths which are “Lshaped” if drawn into the 2Dlayout of the respective host graph, see Fig. 3.
3.2 Our Contribution
We propose, implement and compare two new algorithms: Cliquebased MinorMiner (CLMM) and Springbased MinorMiner (SPMM).
For CLMM, we construct an initial chain mapping for a subset of QUBO nodes, able to implement a coupling between any two chains of this node subset. For SPMM, we give an initial chain mapping for all QUBO nodes \(V_P\), based on a forcedirected graph drawing of P. In the second approach, there are no guarantees for existing couplings between chains. We then pass this initial chain mapping to MinorMiner with the \(\texttt {initial\_chain}\) parameter.
CliqueBased MinorMiner (CLMM). For CLMM, we construct an initial chain mapping as follows: We run DWaves clique embedding algorithm for a clique of size \(k = \min (V_P, c_{\mathrm {host}})\). The k chains found this way are assigned to k nodes of the QUBO graph, with the assignment depending on the density of P: If \(E_P / \left( {\begin{array}{c}V_P\\ 2\end{array}}\right) \ge 0.55\), they are assigned to the k nodes of lowest degree, otherwise to k random nodes. The remaining QUBO nodes are mapped to empty chains.
We also tested a wide variety of other density and degreebased assignments, as well as a splitting or a multiassignment of chains in exploratory runs. In contrast to these approaches, the presented (albeit simpler) settings performed significantly better and were thus used in the final experiments.
SpringBased MinorMiner (SPMM). For SPMM, we construct an initial chain mapping as follows: (i) We use standard DWave layout functions to get a drawing of the Pegasus/Chimera host graph in the plane (cf. the host graphs in Fig. 2), and a tuned FruchtermanReingold algorithm (see below) to get a QUBO graph layout as well. (ii) We rescale both plane layouts to fit into a \([1,1]\times [1,1]\) square. (iii) We map each of the QUBO nodes v to the closest qubit node in Euclidean metric.
FruchtermanReingold [16] is a forcedirected graph drawing algorithm that computes a plane layout based on two principles: nodes pairwise repel each other, but nodes connected by an edge at the same time attract each other. The strength with which the latter takes place can be set for each edge individually; smaller weights implying a smaller attraction. For an edge \(e=\{u,v\}\) we set \(\mathrm {weight}(e) = \left( 2E_P/V_P\right) ^2\cdot \left( \mathrm {deg}(u)\, \mathrm {deg}(v)\right) ^{1}\), where the weighting by node degrees ensures that neighboring nodes with high degrees are not too close to each other (as, intuitively, their chains need more space in the host graph) and where the first term is a normalization factor (normalizing weights in regular graphs to 1).
While SPMM and LAMM have some similarities, we find a significant performance difference on Pegasus graphs due to SPMM’s improved use of edge weights for node attraction, substituting LAMM’s consecutive diffusion phase.
4 Experimental Design
We present the results of a large factorialdesign experiment to compare our two algorithms Cliquebased MinorMiner (CLMM) and SpringBased MinorMiner (SPMM) with the established MinorMiner (MM) and the recently proposed LayoutAware MinorMiner (LAMM). We test the algorithms on the random QUBO graph classes \(G_{n,p}\), BarabásiAlbert, and dregular. As host graphs, we use the DWave Pegasus host graph (used in the 5000 qubit model first out in 2020) as well as the previous Chimera topolgy (used until the 2000 qubit model).
For the ErdősRényi \(G_{n,p}\) graph model, we generate five random graphs for each combination of values \(n = \{1, \ldots , 425\}\) and \(p = \{.01, .02, \ldots , 1.00 \}\). While this would result in a total of \(5\cdot 450\cdot 100 = 212,500\) graphs, we actually reduced this number to around 26, 000 graphs by carefully pruning the set of graphs for a specific algorithm once it has become clear – based on results for smaller/larger values of n or p – that the algorithm will always/never find an embedding. \(G_{n,p}\) graphs have a sharp threshold of \(n\cdot p > \ln n\) of being connected [14].
For the dregular graph model (on Pegasus), we generate five graphs each for all combinations of \(n = \{1, \ldots , 1200\}\) and \(d = \{3, \ldots , 183\}\), employing again a pruning mechanism. On Chimera, we also use five graphs and cut off at 380 vertices and maximum \(d = 64\) to account for the smaller host graph. Random dregular graphs can be sampled quickly for \(d\le n/2\) [31] and uniformly at random for \(d\in \mathcal {O}(n^{1/3\varepsilon })\) [22]; we sample \((nd)\)regular graphs as complements of dregular graphs. dregular graphs only exist for \(2E=n\cdot d\) even and \(d<n\).
For the BarabásiAlbert graph model, we generate five graphs each for \(n = \{1, \ldots , 1200\}\) and \(m = \{1, \ldots , 110\}\) and employ pruning. The number of edges in \(BA_{n,m}\) is \((nm)\cdot m \le (\tfrac{nm+m}{2})^2= n^2/4\) by AMGM, with equality for \(m = n/2\). Hence we get increasing graph density for m up to n/2, and we restrict ourselves to this regime. All graphs are constructed with Python’s networkx.
Our experiments were executed on LANL’s Darwin Cluster [17] using a trivially parallel approach. Running times for individual graphs ranged from milliseconds to more than 10 min per graph, largely proportional to graph vertex and edge counts. Overall, the study consumed around 100, 000 core hours. We assess the different algorithms on whether they succeed in finding an embedding with the default parameters of MinorMiner, and not by running times, but overall we observed that running times were very comparable for all the tested algorithms.
5 Embeddings on the Pegasus Host Graph
Embedding ErdősRényi Graphs on Pegasus. Figure 4 shows our results for \(G_{n,p}\) graphs on Pegasus for the four algorithms MM, LAMM, CLMM, and SPMM. The plot structure is as follows: The blue area on the bottom shows where \(n\cdot p < \ln (n)\), the region of disconnected QUBOs excluded from this study. The red vertical line displays \(c_{\mathrm {host}}=180\). Heatplot areas are colored using the greentowhite color scheme on the right of the plot. The color assigned to a point (n, p) corresponds to the number of times the algorithm succeeds at finding an embedding for the five \(G_{n, p}\) graphs tested at point (n, p). The large darkergreen area on the left are pruned points, as we can be reasonably sure that the algorithm would always find an embedding since it does find embeddings reliably for larger graphs. Similarly, the light gray area on the right side of the plot represents pruned points, where we are reasonably sure that the algorithm would not find an embedding as it did not find embeddings on smaller and less dense graphs. More precisely, if an algorithm manages to embed a \(G_{n, p}\) QUBO with high probability, it is even more likely that it will manage to embed a \(G_{nk, p}\) QUBO graph. Therefore, after testing for each p where the transition from embeddable QUBO to non embeddable QUBO is, we tested a cone of width at least 10 on both sides around them as interesting points before pruning.
Contrasting the performance of the four algorithms, we note the following: The LAMM algorithm does not perform particularly well, perhaps unsurprisingly as \(G_{n,p}\) graphs do not have a natural layout that would play to LAMM’s core design element; LAMM does show a fairly quick transition from being able to embed all graphs (dark green) to no graphs (white). This transition is in fact more spreadout in the overall better performing SPMM algorithm. The standard MM algorithm sees an even farther spreadout transition when compared to both LAMM and SPMM and clearly outperforms LAMM and SPMM on dense graphs, while being outperformed by SPMM on very sparse graphs. However, MM is remarkably far off from being able to embed a clique of size 180 (the red vertical line). CLMM easily outperforms MM on dense graphs and interestingly shows a very cleanly defined transition from embeddable to nonembeddable.
We get a more indepth understanding of performance difference by looking at the difference plot in Fig. 5. Its structure is similar to the individual performance plots, except the color bar ranges from green (positive) to white (zero) to purple (negative). A point (n, p) above (below) the blue line at \(p=0.08\) is assigned a color based on the number of embeddings found by CLMM (SPMM, respectively) minus the maximum of the number of embeddings found by the clique embedding algorithm or by MM. This way we capture the improvement SPMM gains for sparse graphs and the improvement CLMM gains on dense graphs in one plot. The transition between areas where CLMM and where SPMM are the respective best performing algorithms is sharp, around an edge density value of \(E_P/\left( {\begin{array}{c}V_P\\ 2\end{array}}\right) \approxeq p=0.8\). In combination, our algorithms manage to outperform the already existing algorithms at every value of p, gaining the most around \(p = 0.20\), and for \(p = 0.02\) where the graphs get sparse enough such that SPMM’s advantage over MM starts to get significant.
Embedding BarabásiAlbert and dregular Graphs on Pegasus. Figure 6 (top) shows a similar picture as Fig. 5, with CLMM outperforming MM on dense graphs and SPMM taking the lead on sparse graphs. However, as BarabásiAlbert graphs for small m are sparser than the sparsest ErdősRényi graphs we tested, the improvement of SPMM over MM is much more pronounced, being largest for \(m = 2\). We again observe a sharp transition threshold between CLMM and SPMM at \(m=12\) around \(n=240\), corresponding to an edge density of \((nm)m/\left( {\begin{array}{c}n\\ 2\end{array}}\right) \approx 0.095\).
Figure 6 (bottom) shows that on dregular graphs, performance of CLMM, SPMM and MM mirrors their performance on ErdősRényi and BarabásiAlbert graphs. Since dregular graphs only exist for even \(n\cdot d\), we omit odd n columns from the plot (but not from the experiments, see the concluding data in Sect. 7). SPMM again gains the biggest advantage on the sparsest graphs, namely \(d=3\), while CLMM outperforms MM on dense graphs, with a transition threshold at \(d=18\), \(n=233\), corresponding to an edge density of \(d/(n1) \approx 0.078\).
Discussion. We first discuss MM’s poor performance on Pegasus, where the picture is quite bleak: Here, graphs have to be very sparse until MM manages to embed a graph of order 180 nodes, even though there exists a hostspecific embeddable clique of size 180.^{Footnote 3} In trying to find out why MM fails on instances which are still easy embeddable via a hostspecific clique embedding, we look at the characteristic pattern given by such a clique embedding. Recall that each QUBO node is mapped to a chain, where the qubit nodes in the chain form a path, linked mostly by edges that are horizontal or vertical in the graph (see Fig. 3). Looking at the layout of Pegasus, these are both the sparsest connections between neighboring cells as well as the edges which have the longest length. Therefore, the chains are able to “spread through the graph” using as few qubits as possible, leaving many unused edges suitable as couplers between different chains. However, MM does not distinguish between different types of cellconnecting edges when recomputing a chain of the chain mapping, possibly resulting in a worse solution at the end. In contrast, the edges between tiles of Chimera are all equivalent, so this kind of misstep cannot happen.
Secondly, we look at the link between CLMM and SPMM’s performance and the sparsity of the graph. In embeddings for dense graphs, chains often form a path through a large part of the host graph, with few or no nodes of induced degree larger than two. We believe that providing initial “Lshaped” chains such as in CLMM may promote newly built chains to take on such shapes as well. On the other hand, for sparse graphs a wellchosen initial singlequbit chain such as in SPMM can enable short connections to neighboring chains, reducing the qubit footprint of a semivalid embedding created after the first phase of MinorMiner.
6 Embeddings on the Chimera Host Graph
On Chimera, we only compare the three algorithms MM, LAMM and SPMM. We did not test CLMM in great detail, as MM performs very similar, and since preliminary observations could not find any improvements of CLMM over MM.
Embedding ErdősRényi Graphs on Chimera. For each nonpruned parameter combination (n, p), we generated five \(G_{n,p}\) graphs which we tried to embed using MM, LAMM and SPMM. Figure 7 shows the performance of both MM (left) and LAMM (right) as well as the relative improvements made by SPMM (bottom). Perhaps a bit surprisingly, all algorithms manage to embed cliques of size 65, the largest embeddable clique and one node larger than the maximal clique found by the hostgraph specific clique embedder.
SPMM performs better than MM on graphs with \(p\ge 0.8 \) and graphs with \(p\le 0.3\). However, for \(0.3<p<0.8\), both algorithms perform comparably well. The performance difference between SPMM and LAMM is similar to the one between SPMM and MM. However, while SPMM still beats LAMM for \(p\le 0.2\), for larger p LAMM outperforms SPMM slightly.
Embedding BarabásiAlbert and dregular Graphs on Chimera. While SPMM delivers the best overall performance in embedding both BarabásiAlbert and dregular graphs on Chimera, the second place depends on the graph class (MM for BarabásiAlbert, LAMM for dregular graphs). In Fig. 8 (top), we show the performance difference between SPMM and MM on BarabásiAlbert graphs. While MM outperforms SPMM slightly on \(m\ge 20\), the advantage of SPMM on small m is much more apparent, especially at \(m = 2\).
Figure 8 (bottom) shows the difference between embedding performances of SPMM and LAMM on dregular graphs. For \(15\le d \le 64\), both algorithms perform comparably well, with a slight advantage to LAMM. For smaller degree, SPMM starts to clearly outperform LAMM (and MM), with the most significant improvement at \(d=3\). Again, we omit odd n columns in the plot.
7 Conclusion
We studied the performance of two new embedding algorithms, Springbased MinorMiner (SPMM) and Cliquebased MinorMiner (CLMM), and contrasted these to existing embedding heuristics for the two different DWave host graph topologies Pegasus and Chimera. To the best of our knowledge, this is the first such study on the upcoming Pegasus topology. While we observed that the existing MinorMiner heuristic does not extend its overall good performance on Chimera to Pegasus, we show how to remedy the situation with our Cliquebased and Springbased MinorMiner variants, see Table 2.
We found that for certain values of the density parameters p, m, d (used in ErdősRényi, BarabásiAlbert and dregular graphs, respectively) our algorithms significantly outperform the existing methods, increasing the number of embeddable QUBO graphs by doubledigit percentages and enlarging the range of embeddable sparse graphs to graphs with over a hundred additional nodes. Detailed statistics are given in Fig. 9, where for each studied value of p, m and d, we show the number of additionally embeddable graphs, both in absolute numbers (bar plots) as well as a percentage increase (line plot). We note that absolute numbers are normalized by the number of sampled graphs per data point (i.e. 5), and that for dregular graphs, the bar plots show the expected factor 2 difference between odd and even values of d (with the exception of 3regular graphs, on which SPMM shows an exceptionally massive increase).
In conclusion, we studied different random graphs to represent a wide variety of possible QUBO graphs and gave a detailed analysis of the performance of CLMM, SPMM, MM and the recent LAMM. A relative ranking of the algorithms based on the total number of found embeddings is given in Table 2. While SPMM and CLMM are the clear winners in their respective density domains, the order of the competitors can change depending on the graph class studied.
Though SPMM and CLMM outperform the standard algorithm MM, their simplicity is somewhat remarkable and of course they build upon the work of both the original MinorMiner paper [9] and its implementation [13] as a subroutine. We suggest that the MinorMiner parameter initial_chain be extended with ‘clique’ and ‘spring’ parameters to serve as calls to the respective CLMM and SPMM algorithms presented in this work.
Future Work. Future research directions are threefold: First, we intend to add case studies of realworld QUBO instance graphs to include them in a full version of this paper, together with plots and results of all our experiments.
Secondly, we would like to study other (CMOS) host graphs [36] and compare our algorithms to simulated annealingbased approaches which were recently proposed in the literature [32] but not yet published as software.
Finally, applying various embedding algorithms to the same QUBO problem will result in embeddings with different characteristics, such as the distribution of chain lengths. These characteristics, in turn, will influence the chance of success and hence the overall timetosolution of solving QUBO problems with a quantum annealer. Once the Pegasus architecture becomes available, it will be useful to compare embedding algorithms with respect to these metrics, as was done for Chimera before [29].
Notes
 1.
We have \(\sigma _z = \left( {\begin{matrix}1 &{} 0 \\ 0 &{} \text {}1\end{matrix}}\right) \), \( Id =\left( {\begin{matrix}1 &{} 0 \\ 0 &{} 1\end{matrix}}\right) \), and tensor product \(\sigma _z^{(i)} = Id ^{\otimes i1} \otimes \sigma _z \otimes Id ^{\otimes ni}\).
 2.
Even if the algorithm is already in a state with a valid embedding, progression is measured for example in having a smaller maximal chain size.
 3.
Especially compared to Chimera, where MM manages to find an embedding for \(K_{65}\), the largest embeddable clique, given that \(\mathrm {treewidth}(K_{65}) = 64 = \mathrm {treewidth}(C16)\).
References
Adler, I., Dorn, F., Fomin, F.V., Sau, I., Thilikos, D.M.: Faster parameterized algorithms for minor containment. Theor. Comput. Sci. 412(50), 7018–7028 (2011). https://doi.org/10.1016/j.tcs.2011.09.015
Aharonov, D., van Dam, W., Kempe, J., Landau, Z., Lloyd, S., Regev, O.: Adiabatic quantum computation is equivalent to standard quantum computation. SIAM J. Comput. 37(1), 166–194 (2007). https://doi.org/10.1137/S0097539705447323
Albert, R., Barabási, A.L.: Statistical mechanics of complex networks. Rev. Modern Phys. 74(1), 47–97 (2002). https://doi.org/10.1103/RevModPhys.74.47
Barabási, A.L., Albert, R.: Emergence of scaling in random networks. Science 286(5439), 509–512 (1999). https://doi.org/10.1126/science.286.5439.509
Boothby, K., Bunyk, P., Raymond, J., Roy, A.: Nextgeneration topology of dwave quantum processors. Technical Report 14–1026AC, DWave Systems (2019). https://www.dwavesys.com/resources/publications?type=white
Boothby, T., King, A.D., Roy, A.: Fast clique minor generation in Chimera qubit connectivity graphs. Quantum Inf. Process. 15(1), 495–508 (2015). https://doi.org/10.1007/s1112801511506
Bunyk, P.I., et al.: Architectural considerations in the design of a superconducting quantum annealing processor. IEEE Trans. Appl. Superconductivity 24(4), 1–10 (2014). https://doi.org/10.1109/TASC.2014.2318294
Bärtschi, A., Eidenbenz, S.: Deterministic preparation of dicke states. In: Fundamentals of Computation Theory, pp. 126–139. FCT 2019 (2019). https://doi.org/10.1007/9783030250270_9
Cai, J., Macready, W.G., Roy, A.: A practical heuristic for finding graph minors. https://arxiv.org/abs/1406.2741 (2014)
Choi, V.: Minorembedding in adiabatic quantum computation: I. The parameter setting problem. Quantum Inf. Process. 7(5), 193–209 (2008). https://doi.org/10.1007/s1112800800829
Choi, V.: Minorembedding in adiabatic quantum computation: II. Minoruniversal graph design. Quantum Inf. Process. 10(3), 343–353 (2011). https://doi.org/10.1007/s1112801002003
Cowtan, A., Dilkes, S., Duncan, R., Krajenbrink, A., Simmons, W., Sivarajah, S.: On the qubit routing problem. In: 14th Conference on the Theory of Quantum Computation, Communication and Cryptography, TQC 2019, pp. 5:1–5:32 (2019). https://doi.org/10.4230/LIPIcs.TQC.2019.5
DWave Systems: minorminer. https://github.com/dwavesystems/minorminer (2017), a heuristic tool for minor embedding
Erdős, P., Rényi, A.: On random graphs I. Publicationes Mathematicae 6, 290–297 (1959). https://www.renyi.hu/~p_erdos/195911.pdf
Farhi, E., Goldstone, J., Gutmann, S., Sipser, M.: Quantum Computation by Adiabatic Evolution. https://arxiv.org/abs/quantph/0001106 (2000)
Fruchterman, T.M.J., Reingold, E.M.: Graph drawing by forcedirected placement. Software: Practice and Experience 21(11), 1129–1164 (1991). https://doi.org/10.1002/spe.4380211102
Garrett, C.K.: The Darwin Cluster. Technical Report, LAUR1825080, Los Alamos National Laboratory (2018). https://doi.org/10.2172/1441285
Gilbert, E.N.: Random graphs. Ann. Math. Stat. 30(4), 1141–1144 (1959). https://doi.org/10.1214/aoms/1177706098
Goodrich, T.D., Sullivan, B.D., Humble, T.S.: Optimizing adiabatic quantum program compilation using a graphtheoretic framework. Quantum Inf. Process. 17(5), 1–26 (2018). https://doi.org/10.1007/s1112801818634
Harris, R., et al.: Phase transitions in a programmable quantum spin glass simulator. Science 361(6398), 162–165 (2018). https://doi.org/10.1126/science.aat2025
Karp, R.M.: Reducibility among Combinatorial Problems, pp. 85–103. Springer, US (1972). https://doi.org/10.1007/9781468420012_9
Kim, J.H., Vu, V.H.: Generating random regular graphs. In: 35th ACM Symposium on Theory of Computing, pp. 213–222. STOC 2003 (2003). https://doi.org/10.1145/780542.780576
King, A.D., et al.: Observation of topological phenomena in a programmable lattice of 1,800 qubits. Nature 560(7719), 456–460 (2018). https://doi.org/10.1038/s415860180410x
Klymko, C., Sullivan, B.D., Humble, T.S.: Adiabatic quantum programming: minor embedding with hard faults. Quantum Inf. Process. 13(3), 709–729 (2013). https://doi.org/10.1007/s1112801306839
Matoušek, J., Thomas, R.: On the complexity of finding iso and other morphisms for partial ktrees. Dis. Math. 108(1), 343–364 (1992). https://doi.org/10.1016/0012365X(92)90687B
O’Gorman, B., Huggins, W.J., Rieffel, E.G., Whaley, K.B.: Generalized swap networks for nearterm quantum computing (2019). https://arxiv.org/abs/1905.05118
Pelofske, E., Hahn, G., Djidjev, H.: Solving large minimum vertex cover problems on a quantum annealer. In: 16th ACM International Conference on Computing Frontiers, pp. 76–84. CF 2019 (2019). https://doi.org/10.1145/3310273.3321562
Pinilla, J.P.: Embera (2019). https://github.com/joseppinilla/embera, a collection of minorembedding methods and utilities
Pinilla, J.P., Wilton, S.J.E.: Layoutaware embedding for quantum annealing processors. In: High Performance Computing, pp. 121–139. ISC 2019 (2019). https://doi.org/10.1007/9783030206567_7
Robertson, N., Seymour, P.: Graph. Minors. XIII the disjoint paths problem. J. Combinatorial Theory Ser. B 63(1), 65–110 (1995). https://doi.org/10.1006/jctb.1995.1006
Steger, A., Wormald, N.C.: Generating random regular graphs quickly. Combinatorics Probability Comput. 8(4), 377–396 (1999). https://doi.org/10.1017/S0963548399003867
Sugie, Y., et al.: Graph minors from simulated annealing for annealing machines with sparse connectivity. In: Theory and Practice of Natural Computing, pp. 111–123. TPNC 2018 (2018). https://doi.org/10.1007/9783030040703_9
Takemoto, T., Hayashi, M., Yoshimura, C., Yamaoka, M.: A 2x30kSpin multichip scalable annealing processor based on a processinginmemory approach for solving largescale combinatorial optimization problems. In: IEEE International SolidState Circuits Conference, pp. 52–54. ISSCC 2019 (2019). https://doi.org/10.1109/ISSCC.2019.8662517
Vyskocil, T., Djidjev, H.: Embedding equality constraints of optimization problems into a quantum annealer. Algorithms 12(4), 77 (2019). https://doi.org/10.3390/a12040077
Wille, R., Burgholzer, L., Zulehner, A.: Mapping quantum circuits to IBM QX architectures using the minimal number of SWAP and H Operations. In: 56th Annual Design Automation Conference 2019, DAC 2019, p. 142 (2019). https://doi.org/10.1145/3316781.3317859
Yamaoka, M., Yoshimura, C., Hayashi, M., Okuyama, T., Aoki, H., Mizuno, H.: A 20kspin ising chip to solve combinatorial optimization problems with CMOS annealing. IEEE J. SolidState Circ. 51(1), 303–309 (2016). https://doi.org/10.1109/JSSC.2015.2498601
Zaribafiyan, A., Marchand, D.J.J., Changiz Rezaei, S.S.: Systematic and deterministic graph minor embedding for Cartesian products of graphs. Quantum Inf. Process. 16(5), 1–26 (2017). https://doi.org/10.1007/s111280171569z
Author information
Authors and Affiliations
Corresponding author
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2020 Springer Nature Switzerland AG
About this paper
Cite this paper
Zbinden, S., Bärtschi, A., Djidjev, H., Eidenbenz, S. (2020). Embedding Algorithms for Quantum Annealers with Chimera and Pegasus Connection Topologies. In: Sadayappan, P., Chamberlain, B.L., Juckeland, G., Ltaief, H. (eds) High Performance Computing. ISC High Performance 2020. Lecture Notes in Computer Science(), vol 12151. Springer, Cham. https://doi.org/10.1007/9783030507435_10
Download citation
DOI: https://doi.org/10.1007/9783030507435_10
Published:
Publisher Name: Springer, Cham
Print ISBN: 9783030507428
Online ISBN: 9783030507435
eBook Packages: Computer ScienceComputer Science (R0)