Embedding of Complete Graphs in Broken Chimera Graphs

In order to solve real world combinatorial optimization problems with a D-Wave quantum annealer it is necessary to embed the problem at hand into the D-Wave hardware graph, namely Chimera or Pegasus. Most hard real world problems exhibit a strong connectivity. For the worst case scenario of a complete graph, there exists an efficient solution for the embedding into the ideal Chimera graph. However, since real machines almost always have broken qubits it is necessary to find an embedding into the broken hardware graph. We present a new approach to the problem of embedding complete graphs into broken Chimera graphs. This problem can be formulated as an optimization problem, more precisely as a matching problem with additional linear constraints. Although being NP-hard in general it is fixed parameter tractable in the number of inaccessible vertices in the Chimera graph. We tested our exact approach on various instances of broken hardware graphs, both related to real hardware as well as randomly generated. For fixed runtime, we were able to embed larger complete graphs compared to previous, heuristic approaches. As an extension, we developed a fast heuristic algorithm which enables us to solve even larger instances. We compared the performance of our heuristic and exact approaches.


Background
Quantum Annealing is a promising new technology which gained attention in recent years due to the development of commercial quantum annealing devices by the company D-Wave Systems. These machines sample from the low energy distribution of a tunable system of interacting quantum bits (qubits) [6]. The energy of the system can be described by an Ising model including local energy fields for single qubits and certain pairwise interactions between the qubits. However, not every qubit interacts with all other qubits. The available couplings can be represented as edges in a graph where every qubit corresponds to a vertex. For currently operating D-Wave hardware these graphs are the so-called Chimera and Pegasus graph [1].
In practice, no ideal Chimera or Pegasus graphs can be realized. Usually there are some qubits or rarely couplings which are taken offline because they do not behave as expected after calibration. In the following we refer to the corresponding vertices as broken vertices and to graphs containing them as broken graphs. Since calibrations are repeated on the order of months or years, a broken hardware graph is of practical relevance for the same amount of time.
Typical applications, however, need much more couplings than typical hardware graphs provide [22,16,20,19]. This problem can be mitigated by a so-called embedding: One vertex of the original graph, also referred to as logical vertex, is mapped to several qubits, also called physical vertices, of the hardware graph such that the induced subgraph is connected. For each edge in the original graph there needs to exist at least one edge connecting the corresponding subgraphs of the two concerned logical vertices. See e.g. [4] for more details. Each set of physical qubits representing a single logical vertex is grouped together by coupling them strongly.
In general, given two arbitrary graphs G and H, to decide whether G can be embedded into H is NP-hard. It is unclear but assumed that this still holds if we fix H to the broken Chimera graph. For a few well structured graphs, like the complete or the complete bipartite graph, the problem is trivial if H is an ideal Chimera graph, due to its regular lattice structure. Although it is the worst case scenario having a complete graph to be embedded, it allows the efficient embedding of all subgraphs of the complete graph. However, if there are just a few inconveniently placed broken vertices the scheme for the ideal Chimera cannot be applied. An important question of practical relevance is therefore: Given a broken Chimera graph, what is the largest complete graph that can be embedded? This is an optimization problem we refer to in the following as largest complete graph embedding (LCGE) problem.
If a graph is embeddable into another it is a so-called minor of the second graph. Therefore the LCGE problem is equivalent to the search for the largest clique minor [2], as the complete graph can be supplemented by the vertices which are not used for the embedding of the complete graph, forming a larger graph. The largest clique of this minor corresponds to the maximal embeddable complete graph.
In this work we focus on the Chimera graph and leave the extension to the Pegasus graph, which has a larger connectivity for the same number of vertices [1], to future research. As Pegasus is derived from the Chimera we are confident that our results are transferable.

Related Work
Graph minors have been a research topic of high interest even before the D-Wave machine was released. Especially the work of Robertson and Seymour has mainly influenced the developments in this area. For instance in [17] they show among others that for every fixed graph G, there is a polynomial algorithm to decide whether graph G is a minor of H for some input graph H. For the reverse case, as we deal with here, there are no comparable results known, even for such a well structured graph as the Chimera. Nevertheless, as the embedding is the first step to be able to run experiments on the D-Wave quantum annealing machine it is studied broadly in this context. Apart from problem specific approaches, as e.g. in [16], current research mainly splits up into two directions: On the one hand the goal is to develop an efficient generic heuristic that can embed as many graphs as possible. The first polynomial algorithm was shown by Cai et al. in [3] and is based on finding shortest paths in the hardware graph H. As it considers both, G and H, to be arbitrary input graphs, broken vertices in a non-ideal Chimera are already taken into account. It is still the standard algorithm the package minorminor of the D-Wave API is based on [7]. An improvement of this algorithm is suggested in [15] and just recently compared to two new algorithms of Zbinden et al. [24], which show even better performance.
Those heuristic approaches work well in practice especially for less broken Chimera graphs or sparse input graphs. However, they have a drawback: If the heuristic fails to embed a graph it remains unclear if an embedding is not possible at all or the heuristic just could not find it. There is no guarantee that an embedding can be found or how often the heuristic needs to be repeated until we find one if it exists. Thus the second strategy is to insert an intermediate step in the embedding process by using a template with a precomputed fixed embedding acting as a 'virtual hardware' graph. This template has a much simpler structure than the Chimera graph. Thus on the one hand the computational resources needed to calculate an embedding is decreased, and once it is found, it can be reused for the whole operational period of the machine. On the other hand simple certificates can be formulated whether a graph is embeddable or not.
A universal template is the complete graph enabling to embed all graphs with the same or a smaller number of vertices or edges. Due to physical restrictions the Chimera graph of D-Wave was designed to be sparse but nevertheless yield an efficient embedding of the complete graph [4]. The TRIAD layout, presented in [4], forms the basis for the triangle embedding structure of the complete graph in the (ideal) Chimera graph as shown in Figure 1(a) for K 12 . There the set of qubits representing single logical vertex forms a so-called chain.
By extending the triangle structure each of the chains becomes cross-shaped, therefore we call them crosses in the following. Additionally each pair of crosses is now connected by two edges. Due to this redundancy the embedding can be extended by splitting one of the crosses into its vertical and horizontal part. Thus we gained one additional logical vertex, as can be seen in Figure 1  Unfortunately, due to broken physical vertices these schemes are unlikely to be applicable in real hardware. Thus in [13] an algorithm was proposed trying to extract a subgraph of the Chimera where the extended triangle embedding can still be applied and has as many chains as possible. In [2] this approach is generalized by breaking up the triangle structure and placing L-shaped blocks such that all of them overlap pairwise. The principle is illustrated in Figure 1(c). As K. Boothby is one of main contributors of the D-Wave API, we assume this algorithm is implemented in the package minorminor to find complete graphs.
Due to the very limited size of the maximal complete graph there are various other graphs with less connectivity but a larger number of vertices considered, too. Another good template candidate is the complete bipartite graph, whose embedding is closely related to the one of the complete graph. The idea of [9] is to find the smallest number of vertices that have to be split up into the two partitions such that the resulting graph is bipartite and thus can be embedded using this template. In [18] this approach is elaborated and generalized to related partitioned graph structures.
Known minors can then be collected in a lookup table. The authors of [10] suggest to precompute all 'maximal minors' of the complete bipartite graph. This means an input graph is embeddable if it is a subgraph of one of the contained minors. Another template family are for instance the Cartesian products of complete graphs as discussed in [23].

Our Approach
The approach of Boothby et. al. [2] to solve the LCGE problem shows a significant advantage over [13] regarding graph sizes. In this work, we further generalize both approaches to still allow for crosses of qubits representing a single logical vertex but also open up the triangle structure. In this construction every row of qubits is connected to a column of qubits like in the extended triangular embedding in Figure 1(b). But in contrast to Figure 1 connecting the horizontal and vertical cross parts do not lie on the diagonal of the Chimera but are distributed over the graph. We call those edges crossroads in the following. As each of the crosses occupies the full horizontal respectively vertical part, every row respectively every column of qubits belongs to a specific cross. For each row and column combination there is a unique crossroad connecting them. Thus such an embedding is defined by a matching of rows to columns. In turn, each matching of rows to columns defines a complete graph embedding in the ideal Chimera graph.
The redundant edges connecting two crosses would again allow for one more logical vertex by spitting one of the crosses at the crossroad. However, we disregard this, as the redundancy offers another opportunity: The ends of the crosses could be cut off to make room for broken qubits as shown in Figure 2(b). There the remaining, shorter crosses still have an edge to every other cross thus form a complete graph embedding. But given an arbitrary broken Chimera graph, how do we place the crosses such that this is fulfilled?
By choosing a certain edge connecting a row and a column to locate a crossroad there, the corresponding cross is well defined: Both the horizontal and the vertical part are extended until we reach the boundary of the Chimera graph or a broken qubit. To place two crossroads we need to ensure the resulting crosses 'meet' each other, meaning there is at least one edge connecting both. Thus the LCGE problem can be reformulated as: How do we match rows with columns to form crossroads, like in Figure 2(c), such that all resulting crosses meet each other? In particular, if the Chimera graph is very broken, which matching results in the largest possible complete graph? This question is an optimization problem, whose construction we show in the following sections.
For simplification of the notation we show the construction for the standard symmetric form of the Chimera graph, like in current hardware. But this approach can be extended to arbitrary dimensions.
In Section 2 we start with introducing a certain indexing of the Chimera graph, followed by the actual derivation of the optimization problem formulation in Section 3. At the end of this section the complete ILP is summarized. Afterwards the problem is analysed theoretically in Section 4. The results of the experiments explained in Section 6 are evaluated in Section 7. Finally, in Section 8 we present our conclusion.

Description of the Hardware Graph
In this section we present the Chimera hardware graph with a specific indexing of the graph vertices, being suitable for the formulation of the LCGE problem, and the variable input parameters. If a set S is the disjoint union of two sets S 1 and S 2 , that means S 1 ∪ S 2 = S and

Chimera Graph Indexing
A Chimera graph is defined by a lattice structure of complete bipartite subgraphs, so called unit cells, where the number of rows or columns can vary as well as the amount of vertices in the subgraph partitions. We refer to the latter as the depth of the Chimera Graph. Based on current hardware the reference is always the ideal symmetric Chimera graph with the number of rows and columns of unit cells given by size s ∈ N and a depth of 4, which we denote by C s,s,4 . Due to the lattice structure each vertex is represented as a tuple of indices referring to its row and column. For C s,s,4 = (V hori · ∪V vert , E cell · ∪E inter ), • the inter unit cell edges E inter ⊂ V 2 hori ∪ V 2 vert connecting vertices of different unit cells, which are not needed explicitly in the following and therefore are not precised here, and • the edges inside of the single unit cells In the latter we use the function u : N → S with u(x) = x 4 , being the mapping from the inner row/column to the unit cell row/column index, in the equality constraints to ensure that the paired vertices lie in the same unit cell. Since by this the unit cell rows and columns are given implicitly we can use the congruent representation in the following. In general we use for providing the row respectively column for a given vertex, whereas r and c (without further index) always refer to some inner row respectively column indices without specifying a certain corresponding vertex. Further we identify the tuple (r, c) with the non-commutative product rc for shortness to describe an inner unit cell edge. An example for the indexing of edges can be seen in Figure 3(c).

Broken Vertices
With regard to real hardware we consider some vertices to be unavailable. For the symmetric Chimera graph C s,s,4 with s ∈ N as described in the previous section let B hori ⊂ V hori and B vert ⊂ V vert be the sets of different broken vertices and B := B hori · ∪ B vert . In our experiments we vary the ratio of broken vertices to the total number of vertices in an ideal Chimera graph, that is While for an ideal Chimera graph the set of possible crossroads defining the crosses in the embedding is just E cell , the available combinations in a broken Chimera graph are restricted to those inner unit cell edges which do not contain a broken vertex:

ILP Formulation
In this section we construct an integer linear optimization program (ILP) for the LCGE problem over arbitrary input parameters s, B hori and B vert as described in the previous section.

Bipartite Matching Problem
In general the LGCE as we consider it here is a matching problem: Which row can be matched with which column to form a crossroad in an optimal embedding following our construction rules?
The decision which of the available combinations is taken can be encoded in binary problem variables x ∈ {0, 1} A with We say a crossroad rc is activated if its corresponding binary variable x rc is activated in an optimal solution meaning it is set to 1. For simplification we use x ∈ {0, 1} N ×N in the following with disabling all unavailable row column pairs by presetting x rc = 0 for all rc ∈ N 2 \ A, although this extends the model with additional variables.
As the goal is to match as much as possible we want to maximize the number of activated binary variables, hence the objective is Our construction is based on crossroads joining full rows and columns. Therefore only one crossroad per row and column is allowed. This can be enforced by the matching constraints Those types of constraints are also called cardinality constraints as they enforce choosing a certain number of members, here just one, out of a given set. By these restrictions the optimal value of the objective function corresponds to the size, meaning the number of vertices, of the largest embeddable complete graph. Additionally they confirm the upper bound on the objective function of n = 4s, which is the maximal size of a complete graph in C s,s,4 using our construction as explained in Section 1.3.
Until now the constructed problem is just a simple maximum bipartite matching problem.
In the following we show further constraints that need to be added.

Mutually Exclusive Sets Constraints
If a horizontal vertex is broken, it interrupts the horizontal path from the left to the right. This prevents a cross occupying this row to be extended to the boundaries of the Chimera graph. It is analogous for a broken vertical vertex and a cross using the corresponding column. This needs to be taken into account when considering possible crossroad candidates for the embedding. Figure 4 depicts an example of such a situation. Due to the broken vertices the corresponding crosses for certain pairs of crossroads might not meet. This means there do not exist any edges between the different vertices of the crosses, even if they reach the same unit cell like in Figure 4(b). But at least one edge is needed to provide a valid embedding of two vertices of the complete graph. Therefore those crossroads cannot be activated together and we need to introduce further constraints enforcing the activation of only one of them.
We will see that there are not only isolated pairs but clusters of crossroads all being pairwise forbidden, which means only one of all of them can be activated. We call those clusters mutually exclusive sets (MES). The construction of those sets differs for certain pairs of broken vertices. We have the following cases, which are handled separately in the next paragraphs: 1. two broken horizontal vertices, 2. two broken vertical vertices, 3. two different broken vertices, one horizontal and one vertical.
For the green crossroads we get symmetrically The intervals of columns, I left and I right , can be derived from the broken vertices' columns depending on the relational position of the vertices. To describe this more formally, for the fixed size n let Figure 6: Representation of interval function.
be the interval to or from s 1 depending on the relation to s 2 for s 1 , s 2 ∈ S. The multiplication with 4 is needed for the conversion of unit cell to inner columns. The behaviour of this function is illustrated in Figure 6 for different relations. By the subtraction of 1 2 we can circumvent the fact that I only returns the left interval for identical inputs when we need the right one. The resulting sets of mutually exclusive crossroads can then be defined for each combination of h and k with Therefore we get the cardinality constraints for i = 1, 2 where the sum, e.g. for i = 1, can also be written as x r k c .

2.
Two vertical broken vertices, with v = (r v , c v ) = w = (r w , c w ) ∈ B vert , can be handled analogously to the case before by exchanging row and column: We can restrict on c v = c w . Taking all rows from the upper boundary to the uppermost broken vertex and all from the bottom to the lowest broken vertex results in the sets of mutually exclusive crossroads Therefore we get exemplary the constraint for i = 1 x rc = r∈I(rv,rw) x rcv + r∈I(rw,rv− 1 2 ) x rcw ≤ 1. 3. The case with two different broken vertices h = (r h , c h ) ∈ B hori and v = (r v , c v ) ∈ B vert is different to the ones above. As it can be seen in Figure 7(a) we have four different cases depending on the relational position of the two vertices, whether the vertical is above or below,

Let us combine the MES for all combinations in
and left or right, of the horizontal broken vertex. Figure 7(b) shows the combination Ia) exemplary. The other cases Ib), IIa) and IIb) can be derived analogously but mirrored to different corners. This is covered by the definition of I, which we use again in the following construction, therefore this holds for all cases. Further we can see in Figure 7(c) that no additional constraints are provided if both vertices lie in the same unit cell row or column, respectively. Therefore we can restrict on cases with u(r h ) = r v and u(c v ) = c h .
Due to the path interruption by the broken vertices we get exactly one crossroad, r h c v ∼ = r h , u(c v ), u(r h ), c v , in the lower left corner of Figure 7(b) illustrated in green, which is pairwise forbidden with all the crossroads in a rectangle, which are shown in blue. In the following we refer to r h c v as the common crossroad. In the case shown in Ia) the rectangle includes all rows from the upper boundary until the unit cell of the broken horizontal vertex v and all columns starting at the unit cell of the broken vertical vertex v until the right boundary, which are the combinations in [4r v ] × [4(c h − 1) + 1; n]. More generally the rectangle is described by The pairwise constraints would therefore be sufficient to describe our problem. But taking advantage of the matching constraints (I) again, we can aggregate the crossroads in the rectangle: either all in one inner row or all in one inner column. To keep the optimization problem description as small as possible, we take the smallest amount of resulting MES. This is given by the minimum of the dimensions of the rectangle, hence the number of rows |I(r v , u(r h ))| or the number of columns |I(c h , u(c v ))|. With describing the aggregated MES for a row r ∈ I(r v , u(r h )), and analogously for a column c ∈ I(c h , u(c v )), we can define choosing the set of MES with the smallest cardinality for a certain pair of broken vertices v and h. With we can finally summarize all cardinality constraints to rc∈X x rc ≤ 1 ∀X ∈ X hori ∪ X vert ∪ X mix .

Embedding ILP in a nutshell
With the definitions of the section before we can summarize the complete embedding problem in the following ILP formulation. If we find an optimal solution to this ILP, its objective value corresponds to the size of the largest embeddable complete graph and the activated variables define the crossroads for a corresponding embedding.

Analysis
In this section, we investigate the structure of the ILP Embedding problem by discussing its size, complexity and variations. The solvability of the problem can be estimated by different parameters. The size of the ILP, more precisely the number of variables and constraints, is of interest when directly passing the constructed ILP to ILP solvers and using them without any further specifications. However, the specific structure of the constraints allows for a deeper complexity analysis of the problem showing fixedparameter tractability. At the end of this section we give a short outlook on how the ILP can be extended to more general Chimera graphs.

Size of the ILP
We estimate the size of the ILP with regard to the input parameters s, B hori and B vert . The number of variables is n 2 = 16s 2 if we also take the unavailable combinations in A into account. By removing them we get n 2 − |A| ≥ n 2 − |B hori | − |B vert |, where the lower bound is achieved only if no two broken vertices meet in one edge.
Apart from the 2n matching constraints in (I) we show that the number of additional constraints is also polynomial in the number of broken vertices. We need to count the number of MES that are constructed in the former section for the different combinations of vertices. Taking two unequal vertices out of the broken horizontal vertices B hori we get combinations. Analogously for two broken vertical vertices out of B vert we have combinations. On the other hand the number of combinations for two different broken vertices is |B hori | |B vert |. Those numbers could be slightly but not significantly reduced when taking pairs into account that lie in the same rows resp. columns.
For each combination of two broken vertices of the same type we have two constraints. Thus we have For the different broken vertices the number of constraints depends on the size of the corresponding rectangles. Here we can only estimate the worst case scenario which is n − 1 constraints, hence |X mix | ≤ (n − 1) |B hori | |B vert | Therefore in total we get additional cardinality constraints in (IV).

Problem Complexity
The described problem is a matching problem on a bipartite graph. The simple version, without additional constraints, can be solved in polynomial time, e.g. with the algorithm of Hopcroft and Karp in O n 2.5 [11], Due to the constraints (IV), introduced in Section 3.2, our ILP corresponds to a so-called restricted maximum matching problem. Those problems are NP-hard in general and this even holds for cardinality constraints with a cardinality of just one like ours [21]. But exploiting the specific structure of those constraints we can derive that the runtime is mainly dominated by the broken vertices compared to the size of the Chimera graph. More formally this means the problem is fixed-parameter tractable with the number of the broken vertices |B| as the parameter. We show the fixed-parameter tractability by enumerating the decisions that have to be made for removing constraints until the problem is a simple maximum bipartite matching problem.
Considering the constraint for two broken vertices of the same type we have two MES, (II) resp. (III). As it was shown in Section 3.2 both MES consist of a left and a right part lying in different rows for broken horizontal vertices, resp. an upper and a lower part in different columns for broken vertical vertices. Since we can only take one of the crossroads in an MES into a solution, this crossroad is either in the left or in the right, resp. upper or lower, part. Imagine we decide in advance for one part of the MES. Considering for instance some X ∈ X hori , with X =: X left ∪ X right for simplicity, we could choose the crossroad to be in X left . Thus none of the crossroads in X right can be activated in the solution, meaning we have to set x rc = 0 for all rc ∈ X right . The corresponding cardinality constraint reduces to As X left only consists of crossroads in a certain row this constraint is weaker than the matching constraint of (I) covering that row fully. Thus we can remove it and the resulting optimization problem, having less variables and less constraints, is easier to solve.
By considering both exclusive options, disregarding X right or X left , and choosing the best solution we get the global optimum. This procedure can be applied for every MES in X hori and X vert , especially this can be done iteratively to already simplified versions. With two parts for each MES this results in total in For different broken vertices we have much more constraints, but they all have one crossroad in common that cannot be matched together with the other concerned crossroads in the rectangle. Therefore we can proceed similarly to above. One option is just taking the single common crossroad into the solution and rejecting all of the rectangle. This means the binary variable corresponding to this crossroad is set to 1 while those for the rectangle are set to 0. By this not only the constraints are removed but the size of the ILP is appreciably reduced, persisting for all problems resulting from subsequent decisions. However, for an increasing size of the rectangle it gets more unlikely that the common crossroad is part of an optimal solution. Hence the second option is rejecting this single crossroad. This again results in weaker remaining constraints than the matching constraints for the whole rectangle and they can be dropped. These two possibilities per broken vertex pair result in total in further 2 |B hori ||Bvert| options.
Finally, we get at maximum 2 |B hori ||Bvert|+|B hori | 2 −|B hori |+|Bvert| 2 −|Bvert| different simplified versions of our original problem. As we removed all of the additional constraints along the decision tree they are now simple maximum bipartite matching problems and can be solved efficiently. With we get a worst case run time in O 2 |B| 2 n 2.5 and the problem is fixed parameter tractable in the choice of the broken vertices.
According to current hardware development we can reasonably assume that |B| is small compared to n. Therefore, considering |B| to be fixed, the problem is efficiently solvable for increasing size n. However, this means at the same time the ratio of broken vertices R is decreasing as it is inversely proportional to n 2 . Just keeping R fixed still provides an exponential runtime. This aspect demands for heuristic solving approaches like presented in the following section. However, once the embedding is computed for a hardware graph, it can be reused during the whole operating period.

Generalization
In Section 3 we have shown the construction of the ILP for the LCGE problem exemplary for the symmetric Chimera graph with a depth of 4. But the whole setup can also be generalized for arbitrary Chimera graphs C s R ,s C ,d , hence which are rectangular meaning s C = s R or which have a different depth d. In the following we briefly mention the adjustments that need to be applied.
If d is different than 4, the unit cell index function changes to u : x → x d . In case of s R = s C we need to split N 2 up in R × C with the row respectively column sets R = [ds R ] and C = [ds C ]. Of course in this case the maximal number of vertices in an embeddable complete graph, even if it is an ideal Chimera, is just d min{s R , s C }. As the amount of rows and columns is not equal anymore we have to adjust the interval function to be able to differ between maximal row or column with With these modifications it is possible to construct the analogous matching constraints as well as the MES for the cardinality constraints.
One might also consider to extend the model by adding broken edges, which could possibly be handled in an analogue case differentiation as for the broken vertices. But in contrast to the restriction to broken vertices the implications on the model construction and therefore the size and complexity are not trivial. Further a broken edge adjoining non-broken vertices is very rare and thus can be handled by marking one of the concerned vertices as broken. Therefore we do not discuss this in more detail here.

Delineation
In our construction the embedding corresponding to a single logical vertex is formed by a cross. In the case of many broken vertices, this assumption might be too restrictive. This can be seen for example in Figure 8 where the solution to the ILP is not as good as the optimal solution to the LCGE problem. We believe, however, that such corner cases are of less practical relevance since they just seem to occur for a very large ratio of broken vertices.

Heuristic ILP
The complexity analysis in Section 4.2 has shown a certain structure of the additional constraints. Especially for the case of two broken vertices of different type there is a strong imbalance: Activating the single common crossroad excludes all the crossroad in the corresponding rectangle. Thus it is very unlikely that this crossroad is part of the optimal solution in particular for growing size of the rectangle. In this section we show the derivation of a simpler ILP whose solution is assumed to be close to the optimal one.

Reducing Size
We decided to test a heuristic approach based on excluding such unlikely common crossroads in advance. This reduces the number of variables and more importantly the number of constraints. Thus we solve only a certain part of the decision tree constructed in Section 4.2 and therefore it is not clear if the optimal value can be achieved.
We introduce a parameter defining which common crossroads shall be removed respectively kept: The so called maximum rectangle ratio, denoted here by m with 0 ≤ m ≤ 1, gives a boundary on the size of the rectangle relative to the Chimera graph size s below which the common crossroad is kept. If the number of unit cell rows times the number of columns of the rectangle exceeds ms 2 the crossroad is excluded. More formally this means for two different broken vertices h = (r h , c h ) ∈ B hori and v = (r v , c v ) ∈ B vert , that we do not use the crossroad r h c v , hence set Thus a ratio of 1 means all common crossroads are kept while a ratio of 0 means none of them remain in the resulting optimization problem.
Given m, let the set of unused crossroads be and further let be the reduced set of MES. With this the corresponding constraints can be simplified by replacing X mix with X m mix in (E). This can be seen in the following section summarizing the heuristic ILP.

Heuristic Embedding ILP in a nutshell
With the same definitions as before and a certain choice of m we can now summarize the heuristically reduced embedding problem in the ILP formulation: 6 Experimental Setup

Random Instances
To be able to compare our approach to current state of the art methods we consider different ratios of broken vertices for growing hardware sizes. We have generated 10 instances for each combination of the following values: The ratio of the broken vertices times the total number of vertices in the ideal Chimera graph results in the number of broken vertices for a certain size. For each of the 10 instances we randomly chose this number out of all vertices and marked them as being broken. Due to rounding to whole vertices the resulting exact ratios differ slightly from the aimed ones above, especially for smaller graph sizes.
As a reference we like to remark the parameters of two real D-Wave 2000Q systems. First, the solver DW_2000Q_6, which we accessed though the Jülich UNified Infrastructure for Quantum computing (JUNIQ), has a size of 16 and seven broken vertices. This corresponds to a ratio of about 0.0034. Second, the older USRA/NASA chip with the same size had 17 broken vertices, resulting in a ratio of about 0.0083 [12]. Thus our experiments are much more exhaustive than current hardware demands.
For the heuristic approach we use m = 0 and m = 0.25 for our experiments as reference points to evaluate the impact of removing a significant number of crossroads.

Solving Strategy
This paper focuses on the presentation of the embedding problem as an ILP. We did not implement an algorithm, yet, which exploits the branching procedure as described in Section 4.2. It is not straightforward how the decision tree could be reduced at certain stages. As we do not consider the ratio of broken vertices to be fixed here, there is still an exponential overhead in the number of final simplified problems. Even the simplified heuristic version is still a hard optimization problem.
Thus using an ILP solver, already taking advantage of implemented branch-and-bound techniques, is a good starting point to evaluate the capabilities of the model. We decided to pass the models (E) and (H) directly to the solver SCIP [8] without further adjustments. It is currently one of the fastest non-commercial solvers for mixed integer programming, which includes ILP.

Specifications
The experiments were run on a Dell Precision 5820 Tower workstation with a Intel Xeon(R) W-2175 CPU @ 2.50GHz × 28, 128 RAM and operating system Ubuntu Linux 18.04.5 LTS. We implemented our code in python and used the python interface package pyscipopt [14] to connect to the solver SCIP with version 6.0.1 [8]. As this interface does not support parallel mode, we could just use one core. We set a timeout of 1 hour for solving each instance with SCIP. Building up the model was not included in there. As we first want to evaluate the capabilities of the model and the derived heuristic version themselves, we did not optimize our code regarding performance. Apart from the timeout we used the default SCIP parameters.

Results
A good reference to estimate the quality of a solution is to compare its objective value, the found graph size, to the largest possible size of a complete graph in the ideal Chimera graph. As stated in Section 1.3 with our construction using crosses the largest complete graph in a Chimera graph of size s is K 4s . Let G s,b,i be the graph size returned by SCIP within one hour for the i'th instance with Chimera size s and ratio of broken vertices b.
As we consider 10 instances for each parameter combination the found graph sizes are averaged and we introduce the averaged solution ratio as a measure for the solution quality. Table 1 shows the resulting ratios for each of the models.
In Table 1(a) we can see a clear boundary between the instances which can be solved in one hour and which cannot. The former are either instances with a small Chimera size or with a small ratio of broken vertices. Here we already see a slight advantage in the achieved graph sizes over [2].
Besides, we also solved the exact model for both versions of the aforementioned D-Wave 2000Q chips with 7 and 17 broken vertices, respectively. Not surprisingly in accordance to the results of Table 1(a), we were able to find an embedding for the complete graph with 64 vertices in both cases.
For the unsolved instances we use the current best solution SCIP provides at the timeout, being a proven lower bound on the actual optimum. As SCIP is a MIP solver it tries to solve a given model to proven optimality and thus is not made for calculating fast approximate solutions. Therefore the found solutions for instances with increasing Chimera sizes and ratios decrease significantly, due to the sizes of the models. The instance combinations (32, 0.2) and (34, 0.2) could not be solved at all with the exact model because SCIP ran out of memory. Nevertheless, the remaining instances provide values comparable to those of [2].
Evaluating the heuristic approach, we can see that the  that the resulting model has only very few solutions left. In these cases the heuristic with m = 0 is much too restrictive and m = 0.25 is advantageous.
In order to compare our approach to previous work by Boothby et.al. [2] we plot the found graph sizes for selected ratios of broken vertices in Figure 9. For larger ratios of broken qubits, e.g. b = 0.1 and b = 0.05, the maximum over the found graph sizes is comparable to [2] for both m = 0.0 and m = 0.25. In contrast, for smaller ratios of broken qubits, e.g. b = 0.01 and b = 0.02 our heuristic approach with m = 0.0 is able to embed larger complete graphs than it was reported in [2]. Note, that the diagonal corresponds to representing the largest possible complete graph size.
All in all, for a ratio of 0.05 or smaller we observe that the proportions from the solved instances with small size and ratio have a value very close to 1.0, meaning most of them yield a maximal or close to maximal complete graph despite the presence of broken vertices. Due to the heuristic results, we expect just a very small decline in the proportions for the exact model for larger Chimera sizes, if we could solve them to the end. This is based on the fact that the heuristics provide a lower bound on the actual optimum of the exact model. Thus despite the shortcomings presented in Section 4.4 our model is indeed very powerful.

Conclusion
We introduced a novel approach for the problem of embedding a complete graph into a faulty Chimera hardware architecture. It is based on a formulation as a bipartite matching optimization problem with additional constraints. We could show by a detailed analysis that the problem is fixed parameter tractable, where the decisive parameter is the number of broken vertices. The formulated optimization problem (E) can be solved to optimality using state-of-the-art MIP solvers for small Chimera sizes or a small ratio of broken vertices. Especially in these parameter settings the optimal value of the heuristic version (H) does not differ significantly from the original one. For larger Chimera graphs with a ratio of broken vertices in a certain range the heuristic performs even better within the given time constraint of one hour, due to the removal of unlikely crossroads and thus several constraints. However, if the ratio is too large, here above 0.1, the heuristic is too restrictive and the solution quality decreases again. Nevertheless the complete graph sizes we have found exceed the ones from previous approaches [13,2].
Further regarding the current developments in the area of quantum annealers, larger graphs with less broken vertices, and operational times of over one year we can produce reusable templates for complete graphs with a reasonable computational power. Nevertheless there is some space for improvements. By exploiting the full potential of the branching strategy shown in Section 4.2 using dedicated bounding techniques we could develop a more customized, exact or heuristic, solver.
Another step is to transfer the approach to the just recently released new hardware graph Pegasus. It yields a larger connectivity for the same number of vertices, but at the same time this makes the Pegasus graph less approachable. The shown constructions for the Chimera graph provide a deeper insight into the structure of such lattice-like graphs and the problems dealing with them. Observing the physical realization by specifically arranged overlapping loops one can see that the Pegasus graph is closely related to the Chimera [5]. Thus we are confident that our model construction for the Chimera can be transferred to the Pegasus topology. Due to the larger vertex degree we even expect less constraints resulting from broken vertex pairs than for the Chimera.