On Post-Processing the Results of Quantum Optimizers

TL;DR

This paper analyzes the effectiveness of post-processing techniques, especially the Multi Qubit Correction algorithm, in improving quantum optimizer results, and compares it with built-in methods to guide future research and application choices.

Contribution

The paper provides a detailed analysis of MQC's strengths and weaknesses and experimentally compares it with D-wave's built-in optimization, offering insights for better post-processing strategies.

Findings

MQC often outperforms D-wave's built-in optimization.

Pairing heuristics can influence MQC results.

Built-in post-processing rarely surpasses MQC in tests.

Abstract

The use of quantum computing for applications involving optimization has been regarded as one of the areas it may prove to be advantageous (against classical computation). To further improve the quality of the solutions, post-processing techniques are often used on the results of quantum optimization. One such recent approach is the Multi Qubit Correction (MQC) algorithm by Dorband. In this paper, we will discuss and analyze the strengths and weaknesses of this technique. Then based on our discussion, we perform an experiment on how pairing heuristics on the input of MQC can affect the results of a quantum optimizer and a comparison between MQC and the built-in optimization method that D-wave Systems offers. Among our results, we are able to show that the built-in post-processing rarely beats MQC in our tests. We hope that by using the ideas and insights presented in this paper, researchers and developers will be able to make a more informed decision on what kind of post-processing methods to use for their quantum optimization needs.

Tables

Table 1. Table 1: Comparison between MQC done for raw and sampling (smpl) results

Runs	mqc on raw vs mqc on smpl
	raw $=$ smpl	raw smpl	raw $>$ smpl
1000	31	18	1
2000	40	8	2

Table 2. Table 2: Comparison between MQC and built in optimization post-processing

Runs	Mode	mqc vs pp (built-in opt. pp)
		mqc$=$pp	mqcpp	mqc$>$pp
1000	raw	4	46	0
1000	sampling	5	42	3
2000	raw	9	41	0
2000	sampling	9	38	3

Table 3. Table 3: Comparison between standard MQC and MQC with pairing heuristics

Runs	Mode	mqc vs rnk (Rank Order MQC)			mqc vs mdf-mqc( Max. Diff MQC)
		mqc$=$rnk	mqcrnk	mqc$>$rnk	mqc$=$mdf	mqcmdf	mqc$>$mdf
1000	raw	48	1	1	48	1	1
1000	sampling	34	5	11	27	18	5
2000	raw	50	0	0	47	3	0
2000	sampling	41	5	4	34	13	3

Equations

$$F(h,J)=\sum _a{h}_a{\sigma }_a+\sum _{a<b}{J}_{ab}{\sigma }_a{\sigma }_b$$

$$P(\sigma )$$

$$\text{where }Z$$

$$C$$

$$B$$

$$\text{where }{\sigma }^{(z)}$$

$${\sigma }_a^{(z)}=({\otimes }_{i=1}^{a-1}I)\otimes ({\sigma }^{(z)})\otimes ({\otimes }_{i=a+1}^{N}I)$$

$${\sigma }_a^{(x)}=({\otimes }_{i=1}^{a-1}I)\otimes ({\sigma }^{(x)})\otimes ({\otimes }_{i=a+1}^{N}I)$$

$$I_{run1}^i(h,J)=\sum _{a\in T^i}{h}_a{\sigma }_a^{(run1)}+\sum _{a\in T^i}\sum _{b\in S}{J}_{ab}{\sigma }_a^{(run1)}{\sigma }_b$$

$$\begin{array}{r}\text{Cost of calculating energy}\sim O(|V_{T^1}|+|V_{T^2}|+...+|V_{T^k}|\\ +|E_{T^1}^{out}|+|E_{T^2}^{out}|+...+|E_{T^k}^{out}|)\\ \text{or, }O(|V_{D_{max}}|+|E_{D_{max}}^{out}|)\sim O(|V|+|E|)\end{array}$$

$$\text{Cost per pair}\sim O(|V|+|E|)$$

$$\text{Total Number of pairs}=N/2+N/4+N/8...+1$$

$$\text{Total Cost}\sim O((|V|+|E|)N)$$

Full text

1 Introduction

We are entering the era of Noisy Intermediate Scale Quantum (NISQ) devices [34], as of the time of writing this paper. But these devices may not be fault-tolerant to run the traditional quantum algorithms (like Shor’s or Grover’s Algorithm [35, 16]) for doing computation on a useful scale. However, applications such as quantum chemistry [32], sampling [3] and optimization [11, 25] among others, are the first to make use of such devices.

It is important to understand that when we talk about NISQ devices, we are also considering quantum annealers such as the D-wave 2000Q to be in that category. This is because, as Preskill points out in his work [34], the quantum annealer is a noisy implementation of adiabatic quantum computing. While there is still controversy about the lack of conclusive evidence of a quantum speedup, research has highlighted areas of promise [3, 30, 29, 17].

For the scope of this work, our domain of interest is quantum optimization. In particular, it is the post-processing that is applied on the results returned by quantum optimizers. The basic hypothesis is that [10], even if quantum devices cannot reach the global minimum for a hard problem, it can still reach the neighborhood of such a solution. Thus, post-processing the output of quantum solvers (irrespective of the type) can be helpful to find an improved solution at the very least, if not the best one.

Our aim in this paper is to study some prominent post-processing techniques used in the field, with a special focus on Multi Qubit Correction (MQC) [10]. Then based on our study, we perform some experiments on it. Section 2 covers the required background information. Section 3 deals with the review of some of the most prominent post-processing techniques. In section 4, we discuss and theoretically analyze MQC. Based on what we learn in section 4, we perform experiments in section 5 on how the order of inputs given to MQC can affect the final result of the optimization. We lay out future work based on those empirical results in section 6. Finally, we end with concluding remarks in section 7.

The techniques discussed and proposed in this paper will focus around results from the D-wave quantum annealer. However, they are not limited to the D-wave (except for reverse annealing) and can be applied on results of Quantum Approximation Optimization Algorithm (QAOA) [11], Coherent Ising Machines (CIM) [18], Quantum Inspired Digital Annealers (QIDA) [5] and even various classical optimizers based on the Ising model.

2 Background

In this section, we shall lay out the terms and concepts we will use in the rest of the paper.

2.1 The Ising Model

The Ising Model is a mathematical model originally used in statistical mechanics for ferromagnetism [14]. However, it has applicability beyond statistical mechanics, especially for modeling NP-Hard problems. Quantum Annealers [20] and gate-based optimization approaches like QAOA [11] are also based on the Ising Model. The two dimensional Ising model, on which the D-wave 2000Q is based, has the following objective function :

[TABLE]

where $\sigma_{a}$ is a binary variable which can take either $-1$ or $+1$, $h_{a}$ and $J_{ab}$ [8] are the coefficients for the linear and quadratic terms respectively. The $\sigma_{a}$’s binary variables are mapped to qubits in a quantum computer. The quantum optimizer’s job is to return the set of values for $\sigma_{a}$s that would correspond to the smallest value of $F(h,J)$ (or the largest value for QAOA).

2.2 Quantum Annealing

The Quantum Annealing process uses quantum mechanics to search the energy landscape of the Ising model to find the ground state configuration of $\sigma_{a}$ variables from Eqn(1). The $\sigma_{a}$ variables are called as qubits spins in quantum annealing, essentially being quantum bits.

The process begins with the qubits in equal quantum superposition: which means that at this stage, all the potential qubit configurations have an equal probability of being measured. It then attempts to find the lowest energy configuration of the objective function $F(h,J)$ by varying the tunneling field strength (and gradually reducing it to 0), generating the stochastic distribution proportional to $e^{-F(h,J)}$. Under some conditions, these devices can sample from thermal distribution proportional to $e^{-\beta F(h,J)}$ where $\beta$ is the inverse temperature parameter [36]. Here the tunneling field plays a similar role to that of the ‘temparature’ parameter in simulated annealing. It is not yet clear if the D-wave quantum annealer adheres to the adiabatic principle completely (mostly due to technical constraints and noise). A more detailed description [12] can be found in the book by Tanaka et al. [36].

For our purposes however, we are interested mainly in the results that the quantum annealer provides us. From an accuracy perspective, a quantum annealer is essentially trying to take samples of a Boltzmann distribution whose energy is the Ising objective function [3]

[TABLE]

Eqn(2) tells us that the qubit configuration of the global minimum would have the highest probability to be sampled. Because the quantum annealer is a probabilistic machine, we run it multiple times to get a set of solutions. The run (a configuration of values for the variables in the problems) with the lowest energy is taken as the final result. Alternatively, these runs can be fed into a post-processing method in the hopes of getting a better result.

2.3 Quantum Approximate Optimization Algorithm (QAOA)

This is a hybrid quantum/classical algorithm that gained popularity due to its simple approach [11], can run well on NISQ devices [34] and is a candidate for being able to achieve ‘quantum supremacy’ [13], a term coined for a situation where a quantum computer would be able to do a task on a scale that’s not practical on classical computers [33].

For the basics of gate-based quantum computation, we recommend the text by Nielsen and Chuang [26]. The QAOA algorithm requires the Hermitian matrix $C$, a Hamiltonian of of Eqn(1) [4] and another Hermitian matrix $B$ represented as

[TABLE]

Each $\sigma_{a}^{(z)}$ and $\sigma_{a}^{(x)}$ can be represented as

[TABLE]

The algorithm is based on the Hamiltonian simulation of $B$ and $C$. The strength of this algorithm is that it uses a set of $2p$ angles in order to optimize (maximize) the objective function (where $p$ can be chosen to be far lesser than $N$). The classical part of the algorithm is to search those angles. These can be done by various techniques like grid search, bayesian optimization etc. For more detailed information, we recommend Farhi et. al’s paper [11].

3 Post-processing techniques : a review

In this section we shall review a few prominent post-processing techniques. This will help the theoretical analysis in the next section.

3.1 Built-in Optimization Postprocessing

The D-wave developer guide offers a optimization postprocessing technique [2] that is based on heuristics to decompose the problem graphs [24] (either the native hardware graph or a logical graph) into several low treewidth graphs. Then each of these subgraphs are solved locally based on belief propagation on junction trees [19] in the hopes of getting a better solution.

It is also important to mention that the D-wave API offers a sampling post-processing technique [2] to create an approximate Boltzmann distribution for a user defined inverse temperature parameter $\beta$. However, since the focus of this work is enhancing quantum optimization, we are not going into the details of such a technique.

3.2 Multi Qubit Correction (MQC)

In 2018, the Multi Qubit Correction (MQC) technique by Dorband [10] was proposed as a simple,fast and effective technique to improve upon the results of an Ising problem optimizer (focused on, but not limited to the D-wave quantum annealers). The MQC technique is especially beneficial when an optimizer returns solutions near the actual global minimum or has components of the global minimum.

The technique works by pairing runs $run1$ and $run2$. It then makes a set of indices of qubits $D$ that have different values across the two runs and a set $S$ for those that have the same values. Then within the set $D$, we find all $T^{i}$ subsets of qubits (also known as tunnels) that are transitively connected to each other, i.e $D=\{T^{1},T^{2},...T^{k}\}$ where $k$ is the total number of connected components. Figure 1 shows an example of tunnels being formed for a pair of runs. In other words, we find all the connected components in $D$. No qubit from a subset $T^{i}$ is connected to a qubit in $T^{j}$ ($i\neq j$). Once that is done, we look at the relative energy each $T^{i}$ contributes to the global energy. This is done by

[TABLE]

Eqn(9) is the energy contribution by the tunnel $T^{i}$ for the configuration of $run1$. A Similar equation can be created for the energy contribution of $run2$ for the same tunnel. We then select the configuration (from the two paired runs) that contributes the lowest of the two. This is done for each tunnel.

The $N$ runs obtained from the quantum optimizer are paired for applying MQC. The result of step above are $N/2$ new ‘runs’ that go through the same procedure. In this manner, $N$ runs are reduced down to 1 run.

3.3 High Precision Enhancement (HPE)

Another work by Dorband in 2018 proposed a specialized post-processing technique for Ising Problems that have higher precision requirements than what the quantum hardware supports [9]. This is done by scaling the problem $F(h,J)$ by $l,l\in L$ where $L$ is a set of scaling factors. This is because, although the various scaled problems have the same solution configuration for their global minimums, the quantum hardware would treat them as different problems due to the limitations of precision for coefficients.

Each of the $|L|$ scaled problems are then fed into the quantum optimizer to obtain the set $R^{l}$ (results from the optimizers) where $l\in L$ . Then we pick one run for each of the $|L|$ problems (from the $R^{l}$s) and reduce it to 1 run using MQC. We repeat this procedure till we cover all $|L|\times n$ runs (where $n=|R^{l}|,\forall l\in L$). Finally, when we are left with the aggregated $n$ runs (from the previous $|L|$ iterations), we use MQC to systematically aggregate it into the final run, which is our result. For more details, we recommend the original work to the readers [9].

In this way, the classical postprocessing overcomes the lack of precision in the quantum optimizer, without having to work on all the variables (qubits). It is also important to note that HPE is a different type of post-processing technique than the others discussed in this paper. This is because it serves a different purpose than the other techniques and can be seen as a meta-technique that can incorporate other post-processing methods as a subroutine.

3.4 Other post-processing techniques

3.4.1 Reverse Annealing:

This is a feature of the D-wave annealers introduced in 2017 with the D-wave 2000Q [7, 6, 28], that allows for the usage of a previous run of the D-wave as a starting point for new runs. In its initial form, it was first proposed by Perdomo-Ortiz et al. [31]. The utility value of doing such a thing is based on the conjecture that even if the global minimum has not been found by the quantum annealer, the annealer’s solution can act as a good starting point to search for better solutions in the neighborhood.

Instead of starting off with equally weighted qubit variables, we start of with the solution and work backwards to a mid-anneal superposition. After that the forward anneal starts again in order to search for another (hopefully better) solution. The search for a suitable mid-aneal superposition is controlled by the reversal distance parameter.

3.4.2 Sample Persistence:

In 2016, Karimi and Rosenberg proposed a technique to improve the results received from a quantum annealer [21]. It involves fixing the qubits whose values stay the same across the various runs (within a threshold) when retrieved from the quantum annealer, and then run a subset of the original problem (for qubits that are not fixed). This would require us to modify the subset of the problem such that the $J$ coefficients of the couplings that connect to the fixed variables are added (or subtracted, as per the sign of the fixed variable) to the $h$ values of the qubits on the other end of those couplings (i.e. the ones inside the subset).

The idea behind this approach is the conjecture that it is easier to solve a smaller subset of the problem with a greater chance of success than it is to solve the complete problem in one go. It also assumes that the qubits that show the same configuration across multiple runs are more likely to be the correct values for the global minimum solution and thus, they are fixed. More details about their work can be found in their papers [21, 22]

3.4.3 Ochoa et al.’s technique:

Recently, we came to know of the work done by Ochoa et al. [27] for improving the sampling done by a quantum annealer. The aim of this approach is to arrive at lower energy samples (or runs) (compared to the set of samples/runs that it begins with) during its polynomial time sampling procedure. In contrast, the MQC procedure follows a greedy descent type of approach. A comparison between these two would be an interesting future work.

4 Analysis and Discussion of MQC

4.1 On the time complexity of MQC

Although it is not guaranteed that MQC would reach the global minimum, it is still important to consider the amount of time the entire post-processing would require. In the work by Dorband [10], it was stated that $N$ runs can be aggregated to $1$ run in $O(\text{ceil}(\log N))$ aggregation steps. While this is true, its not the complete time complexity, for which we must analyze the computation within each run.

Let $q$ be the total number of qubits in the problem. Let $D_{max}$ be the largest set of differing qubits that would be encountered when the N runs are being aggregated into 1 run. Each pair would require

A linear search to see whether the qubits match or differ : $q$ or $|V|$, since $V$ is the set of all the vertices in our graph (this can either be the logical problem graph or the hardware graph like the chimera), 2. 2.

A connected component analysis using DFS to find the transitive connectivity : $O(|V_{Dmax}|+|E_{Dmax}|)$. We can simplify this to $O(|V|+|E|)$ since they are bounded by the total number of vertices and edges. 3. 3.

A check of each tunnel $T^{i}$ for the relative energy it contributes: $O(|V_{T^{i}}|+|E_{T^{i}}^{\text{out}}|)$ (this is for calculating the energy associated with Eqn(9)) $E_{T^{i}}^{\text{out}}$ is the edge set that connects qubits in $T^{i}$ with qubits in the $S$ set. We do this for k tunnels. So we can see that :

[TABLE]

where $|V_{D_{max}}|$ and $|E^{out}_{D_{max}}|$ is the summation of all the vertices and edges (that connect to set $S$) that are in $D_{max}$.

Thus each step takes about $O(|V|+|E|)$ operations.

[TABLE]

The total number of pairs to process go down by half in each step. Thus it is

[TABLE]

In big O notation, $O(N/2+N/4+N/8...+1)\sim O(N)$ Thus the cost of reducing $N$ runs down to 1 run using MQC is

[TABLE]

For a sparse graph like the D-wave’s Chimera, the complexity will simplify to $O(|V|N)$. However, as the graph approaches full connectivity (i.e. $|E|\rightarrow\binom{|V|}{2}$), the complexity will go up to $O(|V|^{2}N)$. But it should be noted that MQC will have a harder time with denser graphs and become totally ineffective when the graphs become fully connected (explained in the next section).

4.2 MQC is ineffective for fully connected graphs

The MQC technique relies upon two conditions for it to be effective :

4.2.1 Condition 1:

At least two tunnels need to be formed for a given pair of runs, $run1$ and $run2$

**Condition 2: ** The configuration of qubits that contribute the lowest energy for the tunnels shouldn’t be all from $run1$ or $run2$ exclusively

Hence, if for a pair of runs, only a single tunnel is formed, irrespective of the run pair, then selecting either the tunnel configuration from $run1$ or $run2$ would make no difference as it would be equivalent of selecting the entire configuration of $run1$ or $run2$.

Theorem 4.1

If the graph of the Ising Problem in question is fully connected. Then the MQC algorithm will not be able to optimize on the set of runs $R$ it receives from the Ising solver.

Proof

A fully connected graph will have every qubit (or vertex) be connected with every other qubit in the graph. Thus even when we have a set of qubits $D$ that differ across $run1$ and $run2$, we won’t be able to find multiple tunnels since there will be a single connected component in the subgraph. In other words, since each qubit is connected with every other qubit in the set of all qubits $S\cup D$ or $V$, the qubits within $D$ are also fully connected. This leaves us with a single tunnel. Since Condition 1 is a necessary condition for MQC to do optimization, this will result in a failure to optimize the runs received.

4.3 The result of MQC can depend on how the runs are paired

In the general case of the Ising problem, the way runs are paired together can affect the final result of the MQC algorithm. In other words, the result of MQC is not independent of the initial pair configuration of the runs retrieve from the Ising solver.

Given a set of tunnels T = $\{T^{1}_{(1,2)},T^{2}_{(1,2)}...T^{k}_{(1,2)}\}$ for two runs $r_{1}$ and $r_{2}$, it is important for us to understand that when we optimize for each tunnel (by selecting which energy is lower amongs $r_{1}$ and $r_{2}$ for that tunnel), we are essentially doing local optimization.

Conjecture : *In the general case, MQC can produce a different final result if the initial pairing is done differently, for a given set of runs $R$ in the general case Ising problem.

*As we aggregate the runs down to the final result, the possibility of encountering multiple other tunnels being formed over the problem graph (logical or hardware) is high. This can be thought of as a sequence of local optimizations occurring as and when the tunnels get formed.

Now if we form the pairs of runs from $R$ in a different way than we do before, we may get a different set of tunnels being formed over the problem graph as the runs get reduced. This opens a possibility of optimizations happening differently, leading up to a different result. The reason for this is because MQC decides the configuration of a tunnel with respect to the contribution to the global energy (i.e with respect to what is outside the tunnel). In other words, the configuration of qubits in $S$ also influences the choices made for each tunnel by MQC. Even if we get to encounter the same kinds of tunnels in the $\log N$ steps, the possibility that they may appear in a different sequence would be equivalent of doing a different sequence of local optimizations. Which opens a possibility of a different final result.

It is important to note that this argument is solely based upon the working of the MQC technique. It does not take into consideration what optimizer is attached to it. There might still exist proofs for the pairing order of the input not affecting the result, when it comes to specific optimizers.

4.4 Discussion

Based on the theoretical analysis of MQC done above, we would like to make a few other comments on it. These points may prove useful for future work.

4.4.1 MQC relies on a lot of unique samples to be effective:

Because the core of MQC essentially requires choosing between two configurations that are mirror opposites for each tunnel, it is safe to say that we miss out on a more nuanced approach for optimizing these tunnels. Thus, because of the simplicity of the technique and the fact that solutions don’t get worse as they are processed [10], more sampled runs would mean more opportunities for improvements of the result.

4.4.2 Sample Persistence and MQC:

Both MQC and Sample Persistence work on two common principles : (i) the concept of fixed variables/qubits based on which qubits have the same values across runs and (ii) the qubits that have differing values across runs form ‘tunnels’, that need to be optimized. The difference arises in how they treat the set of runs received from the quantum optimizer, and how they treat the tunnels. Where MQC is a purely classical technique, the Sample Persistence method believes in using the quantum annealer multiple times, in order to resolve the tunnels.

Thus, in theory one can expect a better solution in the case of Sample Persistence, since it does more than just compare between two configurations of a set of qubits. Maybe its even possible that it is more effective than MQC for a smaller number of samples. However, Sample Persistence is a highly parameterized technique [21], this brings about a different set of problems as different parameters need to be tested out in order for the technique to be effective. A thorough empirical comparison between MQC and Sample Persistence would be beneficial for us to assess which of these techniques is better. Unfortunately, this falls outside the scope of this paper but we would like to suggest it as a future work.

Even if Sample Persistence turns out to be more effective than MQC, a case can still be made for MQC because it is a polynomial time algorithm that requires classical resources. Sample Persistence requires additional calls to be made to the quantum optimizer. Thus, in the case where cost of classical resources is cheaper than the cost of accessing quantum resources (in terms of monetary value), it may be economical to use MQC over Sample persistence.

4.4.3 Sample persistence cannot be used for HPE:

Despite the advantages that Sample Persistence may have over MQC, it cannot be used as a subroutine for HPE. This is because HPE depends on a post-processing that requires a higher precision capability than the quantum optimizer that processes the result. This is possible (and convenient) by using classical computation for the post-processing.

5 Experiment

Based on the analysis and discussion in the previous section, we want to empirically observe how pairing schemes might affect MQC’s final result. By using the information of section 4.3, we can choose to consciously pair the runs in a particular manner. For the purposes of our experiment, we will use two heuristics to pair the input runs:

On the basis of similar energy (Rank Ordering) 2. 2.

On the basis of difference in qubit values (Maximum Difference)

The inspiration for the first heuristic is the evolutionary computational approach [15], where the fitness of the individuals (or runs) inside the population (or the set of runs) is evaluated and the best-fit individuals are selected for reproduction (or form an input for MQC in our case).

The logic behind the second heuristic is based on the property of MQC that the output cannot be worse than both runs in the input pair. Hence, we pair runs in a way that are the most different from each other, based on the values of qubits. In this way, we hope to extract useful tunnels that may help improve the results of MQC. It should be noted however that this heuristic will cost an additional $O(|V|N^{2})$ (${N\choose 2}$ comparisons and $|V|$ per comparison) for each of the $N$ runs.

Another objective of this experiment is to compare MQC with the built-in post-processing technique that the D-wave API offers. This has not been done in any of the related works till date.

5.1 Experiment setup

For this experiment, we create a set of 50 different problems based on the Ising objective function for the on-chip graph of a D-wave 2000Q machine. This is not the lower noise machine released to the public in May of 2019 [1]. We used the OCEAN SDK with Python 2.7 for this task. Each one of our 50 problems utilizes all the 2038 available qubits of our D-wave solver: DW_2000Q_2_1. The coefficients are created by random uniform sampling (seeded to 316) in the range of $[-2,2]$ for $h$ coefficients and $[-1,1]$ for $J$s. It should be noted that random chimera graph problems like these may not be considered as problems against which quantum speedup could be achieved [23]. However, these experiments are about studying the behavior of MQC and its variants on the results of quantum annealing.

The above problems are annealed in three modes : (a) without any post-processing, (b) sampling post-processing mode and (c) optimization post-processing mode. The reason for using the sampling post-processing is to create a more diverse range of solutions in terms of configuration and energy. This is done to see how the various versions of MQC perform on a set of runs that are not extremely similar to each other.

The results from (a) and (b) are then run through standard MQC, MQC with heuristic 1(Rank Ordering) and MQC with heuristic 2 (Maximum Difference).

Each of above 3 annealing operations is done for obtaining results for 1000 and 2000 runs of the machine. Each run has an anneal time of $20\mu s$.

5.2 Results and discussion

Each value in the tables above is the number of instances or problems for which an energy comparison holds true (as indicated by its respective column).

In our results, there were no problem instances where the raw energies of the D-wave’s results were better than the standard MQC’s. During our tests, as Table 2 indicates, there were a total of only 6 instances where the (standard) MQC had worse energy than the built-in optimization post-processing. All of these 6 instances were when the sampling mode was used to generate the runs. While in the raw mode, there was no instance where a better solution was derived from built-in post processing over MQC. However, the amount of instances for which MQC has an advantage over the built-in technique drops as we move from 1000 to 2000 runs. This indicates that MQC is more effective when used for fewer runs, though further testing is required.

Table 1 shows the comparison between MQC done on raw runs and those obtained from the sampling mode. For the most part, the final results of MQC done on raw inputs is equivalent to the results of MQC done on the sampling mode. This number grows as we move from 1000 to 2000 runs. There are a very few cases where MQC done on the sampling mode got a better energy, which is good since operating MQC on the raw results would save computation time as well.

From our results in Table 3, we can see that neither ranked order nor max difference heuristics are conclusively better than standard MQC for general use. However, the experiment empirically shows that pairing order of the input can have an effect on the output of MQC. This would also indicate that there exists a pairing order that minimizes the end result the most, and it is not evident that the standard MQC is the best way to do so. The results from the sampling mode are more affected by permutation of inputs than the raw results of the D-wave. This means that the raw results of the D-wave are (a) robust against pairing order and (b) very close to each other. This is a good indication of the quality of solutions that D-wave provides. It will be interesting to see the behavior of MQC when it is used with optimizers other than the D-wave. The results with the sampling mode indicate that MQC would be more sensitive to the pairing order when it receives dissimilar outputs (in this case, approximating a Boltzmann distribution). However, this sensitivity to pairing order seems to diminish as the number of runs are increased. Further testing is recommended.

6 Future Work

A thorough comparison of the Sample Persistence [22] technique, Ochoa et al.’s technique [27] and MQC would be useful for the research community. Also, as mentioned in the section above, it may be a good idea to test out MQC vs other techniques over larger number of runs. Finally, the effectiveness of MQC also needs to be compared for different types of optimizers : quantum annealers [1], QAOA [11], digital annealers [5], Coherent Ising Machines [18] etc.

7 Concluding Remarks

In this paper, we first reviewed the prominent post-processing techniques used on the results of quantum optimization. We then theoretically analyzed and discussed the strengths and weaknesses of the Multi Qubit Correction (MQC) technique by Dorband. It was followed by an experiment where we show how the pairing order could effect the final result of the MQC process. We also show that in most instances of our tests, MQC performs better or at par compared to the built-in post-processing technique for optimization. Finally, we outline possible areas of interesting research work that may hold promise when it comes to quantum optimization.

7.1 Acknowledgment

We would like to thank John Dorband, Milton Halem and Samuel Lomonaco from UMBC for their feedback and discussion on the topics in this paper. We would also like to thank Nicholas Chancellor from Durham University and Helmut Katzgraber from Microsoft for their suggestions and feedback. And finally, a thanks to D-wave Systems for providing us access to their machines.