A hybrid algorithm framework for small quantum computers with application to finding Hamiltonian cycles

TL;DR

This paper introduces a hybrid quantum-classical framework that enables polynomial speedups for solving large combinatorial problems, even with quantum computers significantly smaller than the problem size.

Contribution

It generalizes previous quantum speedup approaches to a broader class of divide-and-conquer algorithms with small quantum devices.

Findings

Achieves polynomial speedup for Hamiltonian cycle problem

Framework applicable to quantum computers with arbitrarily small size

Enhances classical algorithms with quantum subroutines

Abstract

Recent works have shown that quantum computers can polynomially speed up certain SAT-solving algorithms even when the number of available qubits is significantly smaller than the number of variables. Here we generalise this approach. We present a framework for hybrid quantum-classical algorithms which utilise quantum computers significantly smaller than the problem size. Given an arbitrarily small ratio of the quantum computer to the instance size, we achieve polynomial speedups for classical divide-and-conquer algorithms, provided that certain criteria on the time- and space-efficiency are met. We demonstrate how this approach can be used to enhance Eppstein's algorithm for the cubic Hamiltonian cycle problem, and achieve a polynomial speedup for any ratio of the number of qubits to the size of the graph.

Equations

$$s(R_i(P))\le s(P)-C_{ij}\text{or}\text{textsc}Trivial(R_i(P))=1$$

$$T(s^{\prime })\le \underset{j=1,\dots ,k}{\max }(T(s^{\prime }-C_{1j})+\cdots +T(s^{\prime }-C_{l_{j}j}))+O(\mathrm{poly}(n(P)))$$

$$G(\lambda n,n)=nF(\lambda )+O(\log n)$$

$$s(P^{\prime })\le n(P)F^{-1}\left(c-\frac{a\ln n(P)}{n(P)}\right)=:\tilde{s}$$

$$T_H(s^{\prime })=O(2^{{\gamma }_Q{s}^{\prime }}\mathrm{poly}(n(P)))$$

$$T_H(s^{\prime })\le \underset{j=1,\dots ,k}{\max }(T_H(s^{\prime }-C_{1j})+\cdots +T_H(s^{\prime }-C_{l_{j}j}))+O(\mathrm{poly}(n(P)))$$

$$T_H(s^{\prime })=O(2^{\gamma (s^{\prime }-\tilde{s})+{\gamma }_Q\tilde{s}}\mathrm{poly}(n(P)))=O(2^{\gamma s^{\prime }-(\gamma -{\gamma }_Q)\tilde{s}}\mathrm{poly}(n(P)))=O(2^{\gamma s^{\prime }-f(c)n(P)}\mathrm{poly}(n(P))),$$

$$T_H(n)=O(2^{(\gamma -\frac{c}{{\log }_{2}n})n}\mathrm{poly}(n))).$$

$$C=\left(\begin{array}[]{cc}1&\Delta\\ 1&\Delta\\ 0&\Delta\\ \vdots&\vdots\\ 0&\Delta\end{array}\right).$$

$$T(r)\le \max \left(2T(r-1),t^2{2}^{\Delta }T(r-\Delta )\right),$$

$$|x⟩{|0⟩}^{\otimes l}\mapsto |f(x)⟩{|0⟩}^{\otimes l}.$$

$$|{\mathrm{Enc}}_{N}S⟩:=|(y_1{)}_2⟩|2⟩|(y_2-y_1{)}_2⟩|2⟩\dots |(y_k-y_{k-1}{)}_2⟩|2⟩|0⟩\dots |0⟩,$$

$$|{\mathrm{Enc}}_{N}S⟩=|110212112101210200000⟩.$$

$$\lceil {\log }_2(y_1+1)\rceil$$

$$\le {\log }_2(y_1+1)+{\log }_2(y_2-y_1+1)+\cdots +{\log }_2(y_k-y_{k-1}+1)+2k$$

$$\le k{\log }_2((y_k+k)/k)+2k$$

$$\le k{\log }_2(N/k+1)+2k,$$

$${\text{Contains}}_{N,k}|{\mathrm{Enc}}_{N}S⟩|x⟩|0⟩=|{\mathrm{Enc}}_{N}S⟩|x⟩|x\in S?⟩$$

$${\text{Convert}}_N|x⟩|0⟩=|x⟩|{\mathrm{Enc}}_N\{x\}⟩$$

$${\text{Union}}_{N,k_1,k_2}|{\mathrm{Enc}}_N{S}_1⟩|{\mathrm{Enc}}_N{S}_2⟩|0⟩=|{\mathrm{Enc}}_N{S}_1⟩|{\mathrm{Enc}}_N{S}_2⟩|{\mathrm{Enc}}_N{S}_1\cup S_2⟩$$

$$|{\mathrm{EffEnc}}_{N}Z⟩:=|{\mathrm{Enc}}_N\{x_1,\dots ,x_{k_1}\}⟩|{\mathrm{Enc}}_N\{x_{k_1+1},\dots ,x_{k_2}\}⟩\dots |{\mathrm{Enc}}_N\{x_{k_{s-1}+1},\dots ,x_k\}⟩.$$

$$|{\mathrm{EffEnc}}_{N}Z⟩=|{\mathrm{Enc}}_N\{x_1,x_2,x_3,x_4,x_5,x_6,x_7,x_8\}⟩|{\mathrm{Enc}}_N\{x_9,x_{10},x_{11},x_{12}\}⟩|{\mathrm{Enc}}_N\{x_{13}\}⟩.$$

$$\sum _{l=0}^{\lfloor {\log }_{2}k\rfloor }\left(2^l{\log }_2\frac{N+2^l}{2^l}+2^{l+1}\right)$$

$$\le \sum _{l=0}^{\lfloor {\log }_{2}k\rfloor }{2}^l{\log }_2\frac{N+k}{k}+\sum _{l=0}^{\lfloor {\log }_{2}k\rfloor }{2}^{l+1}+k\sum _{l=0}^{\lfloor {\log }_{2}k\rfloor }\frac{2^l}{k}{\log }_2\frac{k}{2^l}$$

$$\le 2k{\log }_2\left(\frac{N}{k}+1\right)+4k+2k\sum _{l=0}^{\lfloor {\log }_{2}k\rfloor }\frac{1}{2^{\lceil {\log }_{2}k\rceil -l}}(\lceil {\log }_{2}k\rceil -l)$$

$$\le 2k{\log }_2\left(\frac{N}{k}+1\right)+4k+2k\sum _{j=0}^{\infty }\frac{j}{2^j}$$

$$\le 2k{\log }_2\left(\frac{N}{k}+1\right)+8k,$$

$${\text{EffContains}}_{N,k}|\mathrm{EffEnc}Z⟩|x⟩|0⟩=|\mathrm{EffEnc}Z⟩|x⟩|x\in Z?⟩$$

$${\text{Calculate}}_i|\nu ⟩|\mathrm{EffEnc}{Z}_{i-1}⟩|0⟩|0⟩=|\nu ⟩|\mathrm{EffEnc}{Z}_{i-1}⟩|x_i⟩|0⟩,$$

$$|\nu ⟩|0⟩\mapsto |\nu ⟩|\mathrm{EffEnc}{Z}_r⟩$$

$$R_{i,l}|\nu ⟩|\mathrm{EffEnc}{Z}_i⟩|0⟩=|\nu ⟩|\mathrm{EffEnc}{Z}_i⟩|\mathrm{Enc}\{x_{i+1},\dots x_{i+2^l}\}⟩$$

$$|\mathrm{EffEnc}{Z}_i⟩|\mathrm{Enc}\{x_{i+1},\dots ,x_{i+2^l}\}⟩=|\mathrm{EffEnc}{Z}_{i+2^l}⟩.$$

$$R_{0,l}|\nu ⟩|0⟩=|\nu ⟩|\mathrm{Enc}\{x_1,\dots ,x_{2^l}\}⟩=|\nu ⟩|\mathrm{EffEnc}{Z}_{2^l}⟩$$

$$R_{i,0}={\text{Calculate}}_{i+1}^{-1}\text{Convert}{\text{Calculate}}_{i+1}$$

Full text

I Introduction

Although fully scalable quantum computers may be far off, small quantum computers may be achievable in the forseeable future. Such devices may able to provide solutions to toy or specialised problems of small size (e.g. in quantum chemistry Yung et al. (2014)), it was however until recently unclear whether they could also be utilised for speeding up more general and common computations of much larger problem instances. Indeed, quantum and classical algorithms usually exploit global structures inherent to the problem, and it is generally difficult to utilise small quantum computers without breaking that structure. For example, the ability to factor $n/10$-digit integers is unlikely to be of much help for the task of factoring $n$-digit integers. One would therefore naively expect that for structured problems, small quantum computers would only be useful for small problem sizes.

Recently in Dunjko et al. (2018), it was show that this is not generally true: given a quantum computer with only $M$ qubits, it was shown that one can obtain a significant speedup of Schöning’s algorithm for solving 3SAT involving $n\gg M$ variables. More precisely, the speedup can be expressed in terms of the ratio $c=M/n$ of available qubits to the problem size, and it was shown that an asymptotic polynomial speedup can be achieved for arbitrarily small values of $c$. The latter is non-trivial, since it was also shown that employing a naive approach to speed up the classical algorithm breaks the exploited problem structure, thus resulting in no improvement unless $c$ is quite large.

One of the main insights of Dunjko et al. (2018) was that classical divide-and-conquer algorithms inherently don’t suffer from this “threshold effect” since they naturally maintain the structure of the problem despite breaking it into smaller subproblems, and are thus well-suited for being enhanced using small quantum computers. Yet, to achieve genuine speedups, the quantum subroutines employed must meet stringent criteria for space- and time-efficiency, which in general are non-trivial to fulfil and, in the case of Dunjko et al. (2018), required specialised data-structures and careful memory management. Moreover, Dunjko et al. (2018) exclusively considers the example of Schöning’s 3SAT algorithm, and while it demonstrated how divide-and-conquer structures can in principle be exploited, it left open a formal characterisation of the criterion for when this approach works, and whether other examples beyond Schöning’s 3SAT algorithm exist where similar speedups can be obtained111Note that since reductions of one NP-complete problem to another generally incur significant polynomial slowdowns, and we only expect polynomial speedups, a speedup for 3SAT does not imply a speedup for other NP-complete problems. Consequently, each problem and algorithm must be treated individually.. Given the ubiquity of classical divide-and-conquer algorithms, a general framework for developing such hybrid algorithms to obtain speedups using only small quantum computers would thus be highly desirable.

In this work, we formalise and generalise the criteria for the hybrid approach of Dunjko et al. (2018), and show that indeed, there are other problems and algorithms that can be enhanced with that approach, using only small quantum computers. Specifically, we develop a general framework for constructing hybrid algorithms that speed up certain classical divide-and-conquer algorithms using significantly fewer qubits than the problem size, which also makes precise the relation between the speedup obtained on the one hand, and the space requirements and runtime of the underlying quantum subroutines on the other. We then apply this formalism to finding Hamiltonian cycles on cubic graphs, which is another fundamental NP-complete problem. This provides the first example of the applicablity of these techniques beyond the example of Schöning’s 3SAT algorithm given in Dunjko et al. (2018). Our framework operates on the algorithmic level and is distinct from the circuit-level techniques of Bravyi et al. (2016); Peng et al. (2019), which aim to simulate general quantum circuits on fewer qubits. The efficiency of the latter depends on sparseness or decomposability assumptions on the original circuits which will in general prevent speedups for the algorithms we consider here.

We provide our formalism for constructing hybrid algorithms from classical algorithms in the form of a “toolkit” comprising two parts. The first part, which we term the divide-and-conquer hybrid approach, shows general criteria for the kind of classical algorithms one can speed up using our techniques, and relates the speedup to the number of available qubits. The second part, which we term efficient reversible set generation, comprises specialised data-structures. These are specifically designed to bridge the gap between two seemingly irreconciliable properties required of the quantum algorithm for a polynomial speedup in the divide-and-conquer hybrid approach: reversibility on the one hand, and being extremely space-efficient on the other. The set generation procedure we develop makes the task of developing quantum algorithms suitable for our hybrid approach significantly easier: we show that it suffices to find space-efficient implementations for a few problem-specific quantum operations.

Finally, we illustrate how this framework is applied to speed up Eppstein’s algorithm Eppstein (2007) for the cubic Hamiltonian cycle problem with only a small quantum computer. The cubic Hamiltonian cycle problem asks if a given cubic graph of $n$ vertices has a Hamiltonian cycle, i.e. a cycle visiting every vertex exactly once. This problem is NP-complete, and a special case of the general Hamiltonian cycle problem (where no restrictions on the maximum degree of the graph is assumed), which in turn is closely linked to the travelling salesman problem. Brute-force search requires $O(n!\operatorname{poly}(n))$ time, there is however also a trivial path-search algorithm with runtime $O(2^{n}\operatorname{poly}(n))$. In 2004, Eppstein Eppstein (2007) gave a divide-and-conquer algorithm of runtime $O(2^{n/3}\operatorname{poly}(n))=O(1.2599^{n}\operatorname{poly}(n))$, which heavily exploits the cubic structure of the graph. Quantum speedups for Eppstein’s algorithm have previously been obtained using arbitrarily-sized quantum computers Moylett et al. (2017). In this work, we obtain a polynomial speedup using only $M=cn$ qubits for arbitrarily small $c>0$.

The outline of the remainder of this paper is as follows. In Section II, we give a brief overview of the results and clarify some notation. In Section III, we formulate the divide-and-conquer hybrid approach for a general class of classical algorithms. In Section IV, we provide the details of the efficient and reversible set generation procedure. In Section V, we apply these tools to Eppstein’s algorithm for the cubic Hamiltonian cycle problem. Finally, we close the paper with some concluding remarks and open questions in Section VI.

II Overview of results

We briefly summarise the results and main ideas of this paper.

Sections III and IV set up the general framework for designing hybrid algorithms for quantum computers significantly smaller than the problem size. Specifically, Section III introduces the divide-and-conquer hybrid approach, and outlines the general criteria for the kind of classical algorithms which our framework is applicable to. Theorem 1 then formalises the trade-off between the number of available qubits, the space-requirement of the underlying quantum subroutine, and the speedup obtained. The main idea of this hybrid approach is to take a classical divide-and-conquer algorithm, which calls itself on ever smaller problem instances, and to replace the recursive call with a suitable quantum algorithm once the problem instance is sufficiently small to fit the number of available qubits. While the basic idea is simple, in order to obtain a polynomial speedup over the original classical algorithm, the replacing quantum algorithm has to fulfill strict criteria for space-efficiency whilst also being polynomially faster. In many cases, the main contribution to the quantum algorithm’s space-requirement comes from the necessity of generating and storing large sets.

Section IV then shows how to do the latter efficiently. In particular, Theorem 2 provides a (classical) reversible set generation routine which can be used to obtain quantum algorithms that are compatible with a polynomial speedup when used in Theorem 1. To that end, specialised set encodings are first introduced which are designed to overcome the main challenge of such an implementation: the ability to uncompute encodings of previously generated sets without resulting in either large computational overheads or large memory requirements.

Section V then provides an example of how these tools can be applied in practice. Eppstein’s algorithm for finding Hamiltonian cycles on cubic graphs is a classical divide-and-conquer algorithm that naturally fits the framework of Theorem 1. The main ingredient for a speedup then becomes a polynomially faster quantum algorithm that solves this problem using sufficiently few qubits. Theorem 3 proves the existence of such a quantum algorithm. The proof of Theorem 3 heavily utilises the set generation routine of Theorem 2, which reduces the task to implementing a small number of problem-specific, i.e. graph-theoretic, operations. Theorem 3, together with Theorem 1, then immediately imply a polynomial speedup of Eppstein’s algorithm using only significantly fewer qubits than the size of the graph, which is formally stated in Theorem 4.

Throughout this paper, we will use standard bra/ket notation for quantum states. We will also use bra/ket notation in the context of classical reversible circuits, since they can be seen as special cases of quantum circuits.

Moreover, for simplicity of notation, we will often make several notational simplifications. First, we often simply write $\left|0\right\rangle$ for $\left|0\right\rangle^{\otimes L}$ for any known $L\in\mathbb{N}$. The value of $L$ will always be clear from context. Second, for operators acting on some registers of a multi-register state, we will normally not explitly write the complementing identiy operators (e.g., we will simply write $A\left|a\right\rangle\left|b\right\rangle\left|c\right\rangle\left|d\right\rangle$ instead of $(\mathds{1}\otimes A\otimes\mathds{1})\left|a\right\rangle\left|b\right\rangle\left|c\right\rangle\left|d\right\rangle$ if $A$ acts on the middle two registers). It will always be clear from context which registers which operators act on.

III The divide-and-conquer hybrid approach

In this section, we formalise the divide-and-conquer hybrid approach, generalising the techniques of Dunjko et al. (2018), for designing hybrid algorithms using only quantum computers significantly smaller than the problem size. The main idea is to take a classical divide-and-conquer222Many algorithms that are not a priori given in this form can be formulated as such. algorithm that calls itself on ever smaller (effective) problem sizes, and replace the recursive calls with a quantum algorithm once the problem size becomes sufficiently small.

Let $\mathcal{P}$ be a countable set, $\mathcal{A}:\mathcal{P}\rightarrow\{0,1\}$ be a decision problem333For simplicity, we formulate the divide-and-conquer hybrid approach for decision problems here. The approach can be generalised to algorithms with more general outputs, subject to size constraints of the output., and $n:\mathcal{P}\rightarrow\mathbb{N}$ be a problem parameter. We refer to $n(P)$ as the problem size of $P$.

Suppose that $\mathcal{A}(P)$ can be decided by a classical recursive algorithm444In general, the recursive algorithm can also take additional parameters, but these can be incorporated into $P$. of the form given in Alg. 1, where $l\geq 2$ is an integer, $R_{1},\ldots,R_{l}:\mathcal{P}\rightarrow\mathcal{P}$, $g:\{0,1\}^{l}\rightarrow\{0,1\}$, and $f,\textsc{Trivial}:\mathcal{P}\rightarrow\{0,1\}$. We assume that $\textsc{Trivial}(P),R_{1}(P),\ldots,R_{l}(P)$ can be calculated in $O(\operatorname{poly}(n(P)))$ time, and that $f(P)$ can be calculated in $O(\operatorname{poly}(n(P)))$ time if $\textsc{Trivial}(P)=1$. The maps $R_{1},\ldots,R_{l}$ can be thought of as “reduction operations”, mapping the problem to a smaller instance, whereas $\textsc{Trivial}(P)$ signifies if $P$ is sufficiently simple to be solved directly. We assume that for all $P\in\mathcal{P}$ and $i=1,\ldots,l$, $n(R_{i}(P))\leq n(P)$.

The runtime of such divide-and-conquer algorithms can often be bounded by introducing an effective problem size $s:\mathcal{P}\rightarrow\mathbb{N}$. In general, $s(P)$ and $n(P)$ can be different, we assume however that for all $P\in\mathcal{P}$, $s(P)\leq n(P)$. We assume that both $n(P)$ and $s(P)$ can be calculated in time $O(\operatorname{poly}(n(P)))$. We moreover assume that there is a universal constant $C\in\mathbb{N}$ such that $s(P)\leq C$ implies $\textsc{Trivial}(P)=1$.

To ensure that $\textsc{Alg}(P)$ has a runtime of the form $O(2^{\gamma s(P)}\operatorname{poly}(n(P)))$ for some constant $\gamma>0$, we assume that there exist integers $k>0$, $C_{ij}>0$ for $1\leq i\leq l,1\leq j\leq k$, and $l_{1},\ldots,l_{k}\in\{1,\ldots,l\}$ such that for all $P\in\mathcal{P}$ with $\textsc{Trivial}(P)=0$, there exists some $j\in\{1,\ldots,k\}$ such that for all $i=1,\ldots,l$, we have

[TABLE]

for $i=1,\ldots,l_{j}$, and $\textsc{Trivial}(R_{i}(P))=1$ for $i=l_{j}+1,\ldots,l$. Here, $j\in\{1,\ldots,k\}$ labels one of $k$ possible cases for effective problem size reductions, and $l_{j}\leq l$ the effective number of recursive branches of that case, whereas the positive integers $C_{ij}$ are lower bounds on the decrease of the effective problem size, guaranteeing that the algorithm terminates.

Under these assumptions, it is easy to derive the stated upper bound on the runtime of running $\textsc{Alg}(P)$. Indeed, (1) implies a recursive runtime bound $T(s(P))$ depending only on $s(P)$ given by

[TABLE]

and $T(s^{\prime})=O(\operatorname{poly}n(P))$ for $s^{\prime}\leq C$. Using standard methods for solving recurrence relations Bentley et al. (1980), this leads to a runtime of $T(s^{\prime})=O(2^{\gamma s^{\prime}}\operatorname{poly}(n(P)))$ for some $\gamma>0$. Thus, $\textsc{Alg}(P)$ has a runtime of $O(2^{\gamma s(P)}\operatorname{poly}(n(P)))$.

Our aim is to provide criteria for when a reduction of the value of $\gamma$, i.e. a polynomial speedup, can be achieved.

Theorem 1** (Divide-and-conquer hybrid approach).**

Suppose that there is a quantum algorithm QAlg that decides $\mathcal{A}(P)$ using at most $G(s(P),n(P))$ qubits in time $O(2^{\gamma_{Q}s(P)}\operatorname{poly}(n(P)))$ for some constant $\gamma_{Q}\in[0,\gamma)$. Suppose that $G:[0,\infty)\times[0,\infty)\rightarrow[0,\infty)$ has the property that for all nonnegative integers $s\leq n^{\prime}\leq n$, $G(s,n^{\prime})\leq G(s,n)$. Suppose moreover that there exists some $\tilde{\lambda}\in(0,1)$ such that for all $\lambda\in[0,\tilde{\lambda}]$ and $n\in\mathbb{N}$,

[TABLE]

for some strictly monotonically increasing and continuously differentiable $F:[0,\tilde{\lambda}]\rightarrow[0,\infty)$ such that $F(0)=0$ and $F^{\prime}$ is bounded away from [math].

Let $c\in(0,F(\tilde{\lambda}))$ be an arbitrary constant. Then, given a quantum computer with $M=cn(P)$ qubits, there exists a hybrid quantum-classical algorithm that decides $\mathcal{A}(P)$ in a runtime of $O(\max(2^{\gamma s(P)-f(c)n(P)},2^{\gamma_{Q}s(P)})\operatorname{poly}(n(P)))$, where $f(c)=(\gamma-\gamma_{Q})F^{-1}(c)>0$. In particular, $\mathcal{A}(P)$ can be decided in $O(2^{(\gamma-f(c))n(P)}\operatorname{poly}(n(P)))$.

Proof.

The proof is based on the ideas developed in Dunjko et al. (2018) in the context of 3SAT. The main idea of the hybrid algorithm is to call $\textsc{QAlg}(P^{\prime})$ instead of $\textsc{Alg}(P^{\prime})$ in the recursive step of Alg when $s(P^{\prime})$ is sufficiently small.

By assumption, running $\textsc{QAlg}(P^{\prime})$ for any $P^{\prime}\in\mathcal{P}$ with $n(P^{\prime})\leq n(P)$ requires at most $G(s(P^{\prime}),n(P^{\prime}))\leq G(s(P^{\prime}),n(P))\leq n(P)F(s(P^{\prime})/n(P))+a\ln n(P)$ qubits for some constant $a>0$. Hence, if $n(P^{\prime})\leq n(P)$, then

[TABLE]

is a sufficient condition for being able to run $\textsc{QAlg}(P^{\prime})$ with $M=cn(P)$ qubits. Note that since $F$ is strictly increasing and continuously differentiable with its derivative bounded away from [math], the same applies to $F^{-1}$. Thus, by the mean value theorem, $\tilde{s}=F^{-1}(c)n(P)-O(\log n(P))$.

Let $\textsc{HybridAlg}(P^{\prime})$ be the algorithm which calls $\textsc{QAlg}(P^{\prime})$ if $s(P^{\prime})\leq\tilde{s}$ and $\textsc{Alg}^{\prime}(P^{\prime})$ otherwise, where $\textsc{Alg}^{\prime}$ is the same algorithm as Alg except that in line 5 of Alg, the calls to Alg are replaced by calls to HybridAlg. Note that since $n(R_{i}(P^{\prime}))\leq n(P^{\prime})$ for all $P^{\prime}\in\mathcal{P}$ and $i=1,\ldots,l$, $M=cn(P)$ qubits suffice to run $\textsc{HybridAlg}(P)$.

We now analyse the runtime of HybridAlg. Note that its runtime can be bounded by the function $T_{H}(s(P))$ depending only on $s(P)$, where $T_{H}$ is given recursively by

[TABLE]

for $s^{\prime}\leq\tilde{s}$ and

[TABLE]

for $s^{\prime}>\tilde{s}$. Using standard recurrence relation techniques, we therefore obtain

[TABLE]

for $s^{\prime}>\tilde{s}$, which proves the claim. ∎

We remark that the assumptions of Theorem 1 can be relaxed in various ways. First, it is sufficient for QAlg to only decide $\mathcal{A}(P)$ for $P\in\bigcup_{i=1}^{l}R_{i}(\mathcal{P})$. Second, $F$ being continuously differentiable can be relaxed to $F^{-1}$ being locally Lipschitz-continuous.

Note moreover that the assumption that $F^{\prime}$ is bounded away from [math] ensures that the degree of the polynomial overhead of the hybrid algorithm can be bounded by a constant independent of $c$. More precisely, if $F^{\prime}(\lambda)\geq\kappa>0$ for all $\lambda\in[0,\tilde{\lambda}]$, then the hybrid algorithm decides $\mathcal{A}(P)$ in a runtime of $O(\max(2^{\gamma s(P)-f(c)n(P)},2^{\gamma_{Q}s(P)})n(P)^{O(1/\kappa)})$.

Example 1**.**

Suppose that in Theorem 1, running $\textsc{QAlg}(P)$ requires $O(s\log(n/s)+s+\log n)$ qubits, where here we just write $s,n$ instead of $s(P),n(P)$ for simplicity. In that case, $G(s,n)=As\ln(n/s)+Bs+O(\log n)$ for some constants $A,B>0$. Then, $F(\lambda)=A\lambda\ln(1/\lambda)+B\lambda$, which is monotonically increasing on $(0,e^{B/A-1})$. It can be shown that $F^{-1}(c)=-c/(AW_{-1}(-ce^{-B/A}/A))$, where $W_{-1}$ is the $-1$ branch of the Lambert $W$ function. It is easy to see that for small values of $c$, $F^{-1}(c)=\Theta(c/\log(1/c))$.

The curious expression $O(s\log(n/s)+s)$ stems from the information-theoretic cost of encoding a subset of $\{1,\ldots,O(n)\}$ of size $O(s)$. It is moreover the scaling obtained in Ref Dunjko et al. (2018) (see Example 3 below) and also later in Section IV and V. $\blacksquare$

Example 2**.**

Suppse that QAlg requires $\geq s\log_{2}n$ qubits instead. Note that this does not satisfy the requirements of Theorem 1. Then, with the same notation as in the proof of Theorem 1, $\tilde{s}=cn/\log_{2}n$, and hence

[TABLE]

Note that this does not yield a polynomial speedup over Alg, since the value of $\gamma$ is not reduced by a constant.

The importance of this example lies in that while a qubit scaling of $O(s\log n)$ is, in many cases, easy to achieve (e.g. through storing an ordered list of $O(s)$ numbers in $\{1,\ldots,O(\operatorname{poly}n)\}$), it however does not lead to a polynomial (albeit still asymptotic) speedup. A similar result can also be seen for a scaling of $O(s\log s)$. $\blacksquare$

Note that the strictness of the space requirement for QAlg to obtain a polynomial speedup comes from the premise of only having a quantum computer of size $M=cn$. Note that if in Example 2, we were given a quantum computer with $M=cn\log n$ qubits instead, a polynomial speedup would still be obtained. The strength of the speedup therefore critically depends what is considered a “natural” scaling of $M$ relative to $n$. In many of the typical applications, the search space of typical classical algorithms (e.g. brute-force search) can be enumerated using $O(n)$ classical bits. Using amplitude amplification, one can then often obtain a quantum algorithm using $O(n)$ qubits that is usually polynomially (and often quadratically) faster than the corresponding classical algorithm Ambainis (2004). In these cases, $M=cn$ is the natural scaling because if the scaling were to be relaxed to $M=cq(n)$ qubits with $q(n)$ being superlinear in $n$, then even for arbitrarily small $c$, the above quantum algorithm would require asymptotically fewer qubits than the hybrid algorithm, which would be inconsistent with the notion that $M$ should be significantly smaller than the number of qubits required by a full quantum algorithm.

Example 3**.**

We now show that the results of Dunjko et al. (2018) also fit in this paradigm. We use the nomenclature of Dunjko et al. (2018), and refer the interested reader to Dunjko et al. (2018); Moser and Scheder (2011) for further details.

In Dunjko et al. (2018), Alg was taken to be the algorithm from Moser and Scheder (2011) for the Promise-Ball-SAT problem. There, $P=(F,\mathbf{x},r)$ comprises an $n$-variable $3$SAT formula $F$, a trial assignment $\mathbf{x}\in\{0,1\}^{n}$ and a radius $r\in\{1,\ldots,n\}$. The effective problem size $s(P)$ was simply taken to be its radius $r$ of $P$.

In Moser and Scheder (2011), it was shown that there are two possible cases ($k=2$) in the recursive algorithm. In the first case, two subproblems of radius $r-1$ are created. In the second case, at most $t^{2}2^{\Delta}$ subproblems of radius $r-\Delta$ are created, where $\Delta\in\mathbb{N}$ is a constant chosen below and $t=3\Delta$.

Then, with the notation of this section, $l=t^{2}2^{\Delta}$, $k=2$, $l_{1}=2$, $l_{2}=l$, and

[TABLE]

This leads to a recursive runtime bound of

[TABLE]

leading to a runtime of $T(r)=O((2t^{2/\Delta})^{r}\operatorname{poly}(n))=O(2^{(1+\varepsilon)r}\operatorname{poly}(n))$, where $\varepsilon=2\Delta^{-1}\log_{2}(3\Delta)$. Note that $\varepsilon\rightarrow 0$ as $\Delta\rightarrow\infty$.

Ref Dunjko et al. (2018) then constructs a quantum algorithm solving the Promise-Ball-SAT problem in time $O(2^{\gamma_{Q}r}\operatorname{poly}(n))$ with $\gamma_{Q}=\log_{2}(3)/2<1$, and using at most $O(r\log(n/r)+r+\log n)$ qubits. Thus, Theorem 1 and the observation in Example 1 implies that Promise-Ball-SAT can be solved in time $O(\max(2^{(1+\varepsilon)r-\tilde{f}(c)n},2^{\gamma_{Q}r})\operatorname{poly}(n))$ with $\tilde{f}(c)=\Theta(c/\log(1/c))$. Note that $\Delta$ can be chosen such that $\varepsilon<\tilde{f}(c)/2$. The results from Dantsin et al. (2002), which reduce 3SAT to Promise-Ball-SAT, then imply that given a quantum computer with $M=cn$ qubits, $n$-variable 3SAT can be solved in time $O(2^{(\gamma-f(c))n}\operatorname{poly}(n))$, where $f(c)=\tilde{f}(c)/2$ and $\gamma=\log_{2}(4/3)$. This is a polynomial speedup of the 3SAT algorithm obtained in Moser and Scheder (2011) (which in turn can be seen as a derandomised version of Schöning’s algorithm Schöning (1999)), which is the central result of Dunjko et al. (2018). $\blacksquare$

IV Efficient and reversible set generation

The previous section highlights the importance of the space-efficiency of the quantum algorithm used in Theorem 1. In many instances, this quantum algorithm require the storing and manipulation large sets, e.g. to keep track of changes to $P$. As observed in Dunjko et al. (2018), this is in general a non-trivial task when constrained by limited memory.

In this section, we formulate a general process to space- and time-efficiently generate an encoding of a set in a reversible manner, designed to be compatible with the use of Theorem 1 to obtain a polynomial speedup using small quantum computers.

Note that most of the required subroutines can trivially be implemented space-efficiently if one assumes that ancillary memory registers can be erased at will. However, we naturally require our computations to be reversible. This is in general an issue, since turning non-reversible computations into reversible ones in the canonical fashion either introduces many ancillas, or can incur exponential overheads (see e.g. Buhrman et al. (2001)), both of which are non-starters for our needs. Combining the seemingly competing requirements of reversibility, small memory requirements and computational efficiency for our purposes is non-trivial. To illustrate the problem (see also Dunjko et al. (2018)), note that if sets $S=\{x_{1},\ldots,x_{r}\}\subset\{1,\ldots,N\}$ are simply stored as ordered lists $\left|x_{1}\right\rangle\ldots\left|x_{r}\right\rangle$, the memory requirement of $O(r\log N)$ qubits is too large for a polynomial speedup if $r=O(s(P))$ and $N=O(n(P))$ (see Example 2). On the other hand, if sets are encoded as genuine sets (i.e., without storing any ordering of the elements in the set), the operation $\left|\{x_{1},\ldots,x_{i-1}\}\right\rangle\left|x_{i}\right\rangle\mapsto\left|\{x_{1},\ldots,x_{i}\}\right\rangle$ is non-reversible, because the information on which element was added last is lost. The naive way to make this reversible would be to first implement the operation $\left|\{x_{1},\ldots,x_{i-1}\}\right\rangle\left|x_{i}\right\rangle\mapsto\left|\{x_{1},\ldots,x_{i-1}\}\right\rangle\left|x_{i}\right\rangle\left|\{x_{1},\ldots,x_{i}\}\right\rangle$ and then to uncompute the $\left|\{x_{1},\ldots,x_{i-1}\}\right\rangle\left|x_{i}\right\rangle$ registers by applying the inverse of the circuit up to that point. It is easy to see however that this incurs a computational overhead of $O(2^{i})$, which is too large. Indeed, suppose that $\textsf{SetGen}_{i}\left|0\right\rangle=\left|\{x_{1},\ldots,x_{i}\}\right\rangle$ and $\textsf{Calculate}_{i}\left|0\right\rangle=\left|x_{i}\right\rangle$. Then, the naive (recursive) implementation of $\textsf{SetGen}_{i}$ would be to first apply $\textsf{Calculate}_{i}\textsf{SetGen}_{i-1}$ to generate $\left|\{x_{1},\ldots,x_{i-1}\}\right\rangle\left|x_{i}\right\rangle$, then implementing $\left|\{x_{1},\ldots,x_{i-1}\}\right\rangle\left|x_{i}\right\rangle\mapsto\left|\{x_{1},\ldots,x_{i-1}\}\right\rangle\left|x_{i}\right\rangle\left|\{x_{1},\ldots,x_{i}\}\right\rangle$, and finally applying $(\textsf{Calculate}_{i}\textsf{SetGen}_{i-1})^{-1}$ to uncompute the ancillas. The resulting recursive runtime would be $|\textsf{SetGen}_{i}|>2|\textsf{SetGen}_{i-1}|$, leading to an exponential gate count of $O(2^{i})$.

In this section, we describe a general formalism to overcome this problem based on the ideas of Dunjko et al. (2018). Specifically, we will show how the above task can in fact be implemented with $O(r\log(N/r)+r+\log N)$ memory and $O(\operatorname{poly}(N))$ runtime. Of course, one of the key aspects of our implementation is the continuous uncomputation of any ancillas we introduce along the way once they are no longer needed. Once they are uncomputed (i.e., reset to a known initial state, say $\left|0\right\rangle$), they can be re-used for later computational steps. This allows us to keep the overall number of ancillas used low. The primary challenge is to do this in a way which avoids the exponential overhead mentioned above.

In Section IV.1, we first introduce the data-structures which allow this suitable trade-off between space-efficiency and computational overhead of uncomputation. Specifically, we develop a space-efficient encoding of large sets which adds just enough ordering information to allow for efficient uncomputation. Afterwards, in Section IV.2, we describe the general algorithm for generating such an encoding of a set, given only access to operations which generate single elements of the set.

All algorithms considered in the remainder of this section are classical and will be written as reversible circuits. For convenience, we also introduce the following notion of reversible implementation and note the subsequent trivial observation.

Definition 1**.**

Let $q,l,g\in\mathbb{N}$, $\mathcal{X}\subset\{0,1\}^{q}$ and $f:\mathcal{X}\rightarrow\{0,1\}^{q}$ be injective. We say that $f$ can be implemented reversibly using $l$ ancillas and $g$ gates if there exists a classical reversible circuit of at most $g$ elementary gates which for all $x\in\mathcal{X}$ implements the operation

[TABLE]

Proposition 1**.**

Let $q,t\in\mathbb{N}$, $\mathcal{X}_{1},\ldots,\mathcal{X}_{t}\subset\{0,1\}^{q}$ and $f_{i}:\mathcal{X}_{i}\rightarrow\{0,1\}^{q}$, $i=1,\ldots,t$, be injective such that $f_{i}$ can be implemented reversibly using $l_{i}$ ancillas and $g_{i}$ gates. Suppose that $f_{i}(\mathcal{X}_{i})\subset X_{i+1}$ for $i=1,\ldots,t-1$. Then, $f_{t}\circ f_{t-1}\circ\cdots\circ f_{1}$ can be implemented reversibly using $\max_{i=1,\ldots,t}l_{i}$ ancillas and $g_{1}+\cdots+g_{t}$ gates.

IV.1 Efficient set encodings

In this section we describe how to efficiently encode sets in a way which allows for efficient uncomputation whilst maintaining reversibility. We first describe “basic” set encodings, which use little memory but by themselves do not allow for efficient uncomputation. After that, we describe an efficient encoding composed of multiple basic encodings that allows for efficient uncomputation.

Definition 2**.**

Let $N,k\in\mathbb{N}$ be positive integers with $k\leq N$, and let $S\subset\{1,\ldots,N\}$ with $|S|=k$. Define the basic encoding $\left|\operatorname{Enc}_{N}S\right\rangle$ of $S$ to be a sequence of $\lfloor k\log_{2}(N/k+1)\rfloor+2k$ trits set to

[TABLE]

where $S=\{y_{1},\ldots,y_{k}\}$ with $y_{1}<\cdots<y_{k}$, and for a positive integer $y$, $\left|(y)_{2}\right\rangle$ denotes a sequence of $\lceil\log_{2}(y+1)\rceil$ trits encoding the binary representation of $y$ on the $\{0,1\}$ subspace555Note that the binary representation without leading zeros of a positive integer $y$ has $\lceil\log_{2}(y+1)\rceil$ bits..

Example 4**.**

Suppose $N=20$, $k=5$, and $S=\{6,7,10,15,17\}$. Then, $\lfloor k\log_{2}(N/k+1)\rfloor+2k=21$, and $y_{1}=6=110_{2}$, $y_{2}-y_{1}=1=1_{2}$, $y_{3}-y_{2}=3=11_{2}$, $y_{4}-y_{3}=5=101_{2}$, and $y_{5}-y_{4}=2=10_{2}$. Thus,

[TABLE]

$\blacksquare$

To see that $\lfloor k\log_{2}(N/k+1)\rfloor+2k$ indeed suffice for $\left|\operatorname{Enc}_{N}S\right\rangle$, note that the number of trits required is

[TABLE]

where (16) follows from Jensen’s inequality. Note that this is significantly less than the naive encoding of $S$ as an ordered list, which uses $O(k\log N)$ bits.

In Dunjko et al. (2018), it was shown how to perform basic set operations on $\left|\operatorname{Enc}_{N}S\right\rangle$.

Definition 3**.**

Let $N$ be a positive integer.

1. (i)

For any positive integer $k\leq N$, let $\textsf{Contains}_{N,k}$ be the operation that performs

[TABLE]

for any $S\subset\{1,\ldots,N\}$ with $|S|=k$, where the last bit on the right-hand side of (18) is $1$ if $x\in S$ and [math] otherwise. 2. (ii)

Let $\textsf{Convert}_{N}$ be the operation that performs

[TABLE]

for any $x\in\{1,\ldots,N\}$. 3. (iii)

For any positive integers $k_{1},k_{2}$ with $k_{1}+k_{2}\leq N$, let $\textsf{Union}_{N,k_{1},k_{2}}$ be the operation that performs

[TABLE]

for any disjoint $S_{1},S_{2}\subset\{1,\ldots,N\}$ with $|S_{1}|=k_{1}$ and $|S_{2}|=k_{2}$.

Proposition 2** (Dunjko et al. (2018), Lemma 2,5,6 in Supplemental Material).**

Let $N$ be a positive integer. Then,

1. (i)

for any positive integer $k\leq N$, $\textsf{Contains}_{N,k}$ can be implemented reversibly using $O(\log N)$ ancillas and $O(\operatorname{poly}(N))$ gates. 2. (ii)

$\textsf{Convert}_{N}$* can be implemented reversibly using $O(\log N)$ ancillas and $O(\operatorname{poly}(N))$ gates666Note that in the Supplemental Material of Dunjko et al. (2018), $\textsf{Convert}_{N}$ was called $\textsf{Append}_{0}$..* 3. (iii)

for any positive integers $k_{1},k_{2}$ with $K=k_{1}+k_{2}\leq N$, $\textsf{Union}_{N,k_{1},k_{2}}$ can be implemented reversibly using $O(K\log(N/K)+K+\log N)$ ancillas and $O(\operatorname{poly}(N))$ gates.

Note in particular that in Proposition 2(i) and (iii), the runtime bound (i.e., the degree of the polynomial) does not depend on $k$ or $k_{1},k_{2}$, respectively. In fact, none of the operations depend on the set-sizes in any relevant way.

Although $\left|\operatorname{Enc}_{N}S\right\rangle$ is itself space-efficient, it does not allow for a set generation procedure that is simultaneously space- and time-efficient as well as reversible, for the reasons explained at the beginning of this section. We now define a memory-structure that allows for this task.

Definition 4**.**

Let $N,k$ be positive integers with $k\leq N$. Let $S\subset\{1,\ldots,N\}$ with $|S|=k$, and let $Z=(x_{1},\ldots,x_{k})$ be a permutation of the elements of $S$. Then, the efficient encoding $\left|\operatorname{EffEnc}_{N}Z\right\rangle$ of $Z$ is definded as follows: suppose that $k$ has binary representation $k=2^{a_{1}}+\cdots+2^{a_{s}}$ with integers $\lfloor\log_{2}k\rfloor=a_{1}>a_{2}>\cdots>a_{s}\geq 0$. For $j=1,\ldots,s$, let $k_{j}:=2^{a_{1}}+\cdots+2^{a_{j}}$. Then, $\left|\operatorname{EffEnc}_{N}Z\right\rangle$ is defined as

[TABLE]

Example 5**.**

Suppose $k=13=8+4+1$ and $Z=(x_{1},\ldots,x_{13})$. Then,

[TABLE]

$\blacksquare$

Proposition 3**.**

For any positive integers $k\leq N$ and distinct integers $x_{1},\ldots,x_{k}\in\{1,\ldots,N\}$, $\left|\operatorname{EffEnc}_{N}Z\right\rangle$ comprises at most $\lfloor 2k\log_{2}(N/k+1)\rfloor+8k=O(k\log(N/k)+k)$ trits, where $Z=(x_{1},\ldots,x_{k})$.

Proof.

For any $S^{\prime}\subset\{1,\ldots,N\}$, $\left|\operatorname{Enc}_{N}S^{\prime}\right\rangle$ comprises at most $|S^{\prime}|\log_{2}(N/|S^{\prime}|+1)+2|S^{\prime}|$ trits. Thus, the number of trits in $\left|\operatorname{EffEnc}_{N}Z\right\rangle$ is at most

[TABLE]

which proves the claim. ∎

Note that since we always assume that we work with sets of known sizes, basic set operations can be “lifted” from $\left|\operatorname{Enc}_{N}S\right\rangle$ to $\left|\operatorname{EffEnc}_{N}Z\right\rangle$.

Definition 5**.**

For any positive integers $N,k$ with $k\leq N$, let $\textsf{EffContains}_{N,k}$ be the operation that performs

[TABLE]

for any integer $x\in\{1,\ldots,N\}$ and distinct integers $x_{1},\ldots,x_{k}\in\{1,\ldots N\}$, where $Z=(x_{1},\ldots,x_{k})$ and the last bit on the right-hand side of (28) is $1$ if $x=x_{j}$ for some $j\in\{1,\ldots,k\}$ and [math] otherwise.

Proposition 4**.**

For all positive integers $N,k$ with $k\leq N$, $\textsf{EffContains}_{N,k}$ can be implemented reversibly using $O(\log N)$ ancillas and $O(\operatorname{poly}(N))$ gates.

In particular, the runtime bound in Proposition 4 does not depend on $k$.

Proof of Proposition 4.

This follows immediately from Proposition 2(i): Introduce $s\leq\log_{2}k=O(\log N)$ ancilla bits (where $s$ is defined as in Definition 4), run $\textsf{Contains}_{N,2^{a_{j}}}$ on $\left|\operatorname{Enc}_{N}\{x_{k_{j-1}+1},\ldots,x_{k_{j}}\}\right\rangle\left|x\right\rangle$ for all $j=1,\ldots,s$ (where $a_{1},\ldots,a_{s}$ and $k_{1},\ldots,k_{s}$ are defined as in Definition 4) such that the outcome is stored in the $j$th ancilla, apply a logical OR over the $s$ ancilla bits, and finally uncompute the $s$ ancilla bits by running $\textsf{Contains}_{N,2^{a_{j}}}^{-1}$ for $j=1,\ldots,N$. ∎

Note that if $N^{\prime}>N$ are integers and $S\subset\{1,\ldots,N\}$, then $\left|\operatorname{Enc}_{N}S\right\rangle$ and $\left|\operatorname{Enc}_{N^{\prime}}S\right\rangle$ only differ in the number of additional $\left|0\right\rangle$’s at the end of the encoding. For the remainder of the paper, whenever the value of $N$ is clear from context, we will drop the subindex $N$ for simplicity of notation and simply write $\left|\operatorname{Enc}S\right\rangle$, $\left|\operatorname{EffEnc}Z\right\rangle$, $\textsf{Contains}_{k}$, Convert, $\textsf{Union}_{k_{1},k_{2}}$ and $\textsf{EffContains}_{k}$ instead.

IV.2 Efficient and reversible set generation

Suppose we want to generate a set $X(\nu)=\{x_{1}\ldots,x_{r}\}\subset\{1,\ldots,N\}$ of size $r$ from some input register $\left|\nu\right\rangle$. We assume that we can generate the elements iteratively, i.e. we have access to circuits that generate $x_{i}$ from $\nu$ and $\{x_{1},\ldots,x_{i-1}\}$. As discussed in at the beginning of this section, simply using the basic encoding $\left|\operatorname{Enc}X\right\rangle$ and adding one elment $x_{i}$ to $\left|\operatorname{Enc}X\right\rangle$ at a time is problematic, as this incurs problems with reversibility or exponential computational overheads. In this subsection, we show how this can be circumvented using the $\left|\operatorname{EffEnc}Z\right\rangle$ encoding from the previous subsection.

The intuition for why $\left|\operatorname{EffEnc}Z\right\rangle$, unlike $\left|\operatorname{Enc}X\right\rangle$, allows for time-efficient uncomputation is that by splitting $X$ into smaller subsets, we can generate and uncompute these subsets more efficiently, thus avoiding the necessity of uncomputing the entire set for each newly added element, which can be seen as the reason for the exponential overhead in the naive reversible implementation given at the beginning of this section.

Theorem 2**.**

Let $N,r$ be known positive integers with $r\leq N$, and let $\mathcal{I}$ be a finite set. Let $X:\mathcal{I}\rightarrow\mathcal{P}_{r}([N])$, where $\mathcal{P}_{r}([N]):=\{S\subset\{1,\ldots,N\},|S|=r\}$. Suppose that for $i=1,\ldots r$, $\textsf{Calculate}_{i}$ are reversible circuits such that for all $\nu\in\mathcal{I}$, there is a permutation $(x_{1},\ldots,x_{r})$ of the elements of $X(\nu)$ such that for all $i=1,\ldots,r$,

[TABLE]

where $Z_{i}=(x_{1},\ldots,x_{i})$, and the last register in (29) comprises at most $A$ ancillas. Then, the operation

[TABLE]

can be implemented reversibly using $O(r\log(N/r)+r+\log N+A)$ ancillas, $O(r^{2})$ calls to $\textsf{Calculate}_{i}$ for some $i\in\{1,\ldots,r\}$, and $O(\operatorname{poly}(N))$ additional gates.

Proof.

For any positive integer $i$, write $g(i)$ to be the largest integer $g$ such that $2^{g}$ divides $i$. Then, for all $i\in\{1\ldots,r-1\}$ and $l\in\{0,\ldots,g(i)\}$ such that $i+2^{l}\leq r$, let $R_{i,l}$ be the operation that performs

[TABLE]

for all $\nu\in\mathcal{I}$, where $x_{1},\ldots,x_{r}$ and $Z_{1},\ldots,Z_{r}$ are as in the statement of the theorem. Note that if $l\leq g(i)-1$, then

[TABLE]

We also define $R_{0,l}$ for all $l\leq\lfloor\log_{2}r\rfloor$ to be the operation that performs

[TABLE]

for all $\nu\in\mathcal{I}$. Note that since $\textsf{Convert}\left|x_{i}\right\rangle\left|0\right\rangle=\left|x_{i}\right\rangle\left|\operatorname{Enc}\{x_{i}\}\right\rangle$, a reversible implementation of $R_{i,l}$ can be obtained recursively via

[TABLE]

for all $i\in\{0,\ldots,r-1\}$, and

[TABLE]

for all $i\in\{0,\ldots,r-1\}$ and $l\in\{0,\ldots,g(i)-1\}$ such that $i+2^{l+1}\leq r$. Indeed, for $i\in\{1,\ldots,r\}$ and $l\leq g(i)-1$, (32) implies that

[TABLE]

Hence, $R_{i+2^{l},l}R_{i,l}$ maps $\left|\nu\right\rangle\left|\operatorname{EffEnc}Z_{i}\right\rangle\left|0\right\rangle\left|0\right\rangle\left|0\right\rangle$ to

[TABLE]

and $\textsf{Union}_{2^{l},2^{l}}$ maps the latter to

[TABLE]

Finally, $R_{i,l}^{-1}R_{i+2^{l},l}^{-1}$ uncomputes the registers containing $\left|\operatorname{Enc}\{x_{i+1},\ldots,x_{i+2^{l}}\}\right\rangle\left|\operatorname{Enc}\{x_{i+2^{l}+1},\ldots,x_{i+2^{l+1}}\}\right\rangle$, proving Eq. (35) for $i\in\{1,\ldots,r\}$. A similar argument also shows that (35) holds for $i=0$.

Suppose that $r$ has binary expansion $r=2^{a_{1}}+2^{a_{2}}+\cdots+2^{a_{s}}$, with integers $\lfloor\log_{2}r\rfloor=a_{1}>a_{2}>\cdots>a_{s}=g(r)$. For $j=1,\ldots,s$, define $r_{j}:=2^{a_{1}}+\cdots+2^{a_{j}}$, and

[TABLE]

Note that $a_{j}\leq g(r_{j-1})-1$ for all $j\in\{2,\ldots,s\}$, so (32) implies that (39) is well-defined. Note moreover that $R_{j}\left|\nu\right\rangle\left|0\right\rangle=\left|\nu\right\rangle\left|\operatorname{EffEnc}Z_{r_{j}}\right\rangle$ for all $j\in\{1,\ldots,s\}$. In particular, $R_{s}$ performs the desired operation (30).

It follows from (35) that each individual $R_{i,l}$ constitutes a reversible implementation using at most $O(r\log(N/r)+r+\log N+A)$ ancillas. Hence, Proposition 1 implies that $R_{s}$ can be implemented reversibly using at most $O(r\log(N/r)+r+\log N+A)$ ancillas.

To bound the number of calls to $\textsf{Calculate}_{i^{\prime}}$ and additional gate count of $R_{s}$, let $L_{i,l}$ be the number of calls of $R_{i,l}$ to $\textsf{Calculate}_{i^{\prime}}$ for some $i^{\prime}\in\{1,\ldots,r\}$, and let $M_{i,l}$ be the number of additional gates of $R_{i,l}$, respectively. Let $L_{l}=\max\{L_{i,l}:i\in\{0,\ldots,r-1\},l\leq g(i),i+2^{l}\leq r\}$ and $M_{l}=\max\{M_{i,l}:i\in\{0,\ldots,r-1\},l\leq g(i),i+2^{l}\leq r\}$. Eq. (34) and (35) clearly imply $L_{l}=2\cdot 4^{l}$. Moreover, since $\textsf{Union}_{2^{l},2^{l}}$ can be implemented using at most $p(N)$ gates, where $p$ is a polynomial independent of $l$, it follows from (35) that $M_{l+1}\leq 4M_{l}+p(N)$, implying $M_{l}=O(4^{l}\operatorname{poly}(N))$. Thus, $R_{s}$ uses at most

[TABLE]

calls to $\textsf{Calculate}_{i^{\prime}}$ for some $i^{\prime}\in\{1,\ldots,r\}$, and

[TABLE]

additional gates. ∎

Theorem 2 generates the efficient encoding $\left|\operatorname{EffEnc}Z_{r}\right\rangle$ of the set $X(\nu)$ instead of the simple encoding $\left|\operatorname{Enc}X(\nu)\right\rangle$. For most applications, the former is sufficient, since the value of $r$ is known and simple set queries for checking properties of $X(\nu)$ (e.g. checking if $X(\nu)$ contains certain elements) are generally just as simple to implement reversibly using $\left|\operatorname{EffEnc}Z_{r}\right\rangle$ as with $\left|\operatorname{Enc}X(\nu)\right\rangle$ (see Proposition 4). We remark however that $\left|\operatorname{EffEnc}Z_{r}\right\rangle$ can be converted to $\left|\operatorname{Enc}X(\nu)\right\rangle$ using a sequence of calls to Union (for appropriate set sizes) and uncomputations. Since at most $O(\log r)$ union operations are required, is easy to see that this can be implemented with $O(\operatorname{poly}(N))$ calls to $R_{i,l}$ (as defined in the proof of Theorem 2) for suitable values of $i,l$, and $O(\operatorname{poly}(N))$ additional gates.

Corollary 1**.**

With the same notation as in Theorem 2, the operation

[TABLE]

can be implemented reversibly using $O(r\log(N/r)+r+\log N+A)$ ancillas, $O(\operatorname{poly}(N))$ calls to $\textsf{Calculate}_{i}$, and $O(\operatorname{poly}(N))$ additional gates.

V Speedup of Eppstein’s algorithm

In this section, we provide an example of how to use the toolkit – the divide-and-conquer hybrid approach from Section III and the set-generation procedure from Section IV – to polynomially speed up Eppstein’s algorithm Eppstein (2007) for the cubic Hamiltonian cycle problem using a small quantum computer. The problem asks whether a given cubic graph $G=(V,E)$ has a Hamiltonian cycle, i.e. a cycle going through every vertex exactly once.

V.1 Eppstein’s algorithm

In this section, we review Eppstein’s classical algorithm for solving this problem in time $O(2^{n(G)/3}\operatorname{poly}(n(G)))$, where $n(G)$ denotes the number of vertices of a graph $G$.

Note first of all that, without loss of generality, one can assume that the graph is triangle-free, since triangles can be removed by merging the three vertices of a triangle into a single vertex.

Eppstein’s algorithm introduces the concept of “forced” edges that a Hamiltonian cycle has to contain. In other words, if an edge is forced, we are only looking for Hamiltonian cycles which contain that edge.

Definition 6**.**

Let $G=(V,E)$ be a simple triangle-free graph with maximum degree at most $3$, and $F\subset E$. Then, the forced cubic Hamiltonian cycle (FCHC) problem asks whether $G$ has a Hamiltonian cycle containing all edges in $F$. We call edges in $F$ forced, and edges in $E\backslash F$ unforced. We call $(G,F)$ an FCHC instance.

Roughly speaking, Eppstein’s algorithm solves FCHC by recursively selecting an unforced edge and creating two subinstances by either adding that edge to $F$ or removing it from $G$. In both cases, the fact that $G$ is cubic induces additional edges to be either added to $F$ or to be removed.

The details of Eppstein’s algorithm are given in Alg. 2. The formulation of the algorithm here has been modified from Eppstein’s original formulation in several places. In particular, we adapted it to the Hamiltonian cycle problem (instead of the travelling salesman problem777The result can be generalised to the travelling salesman problem, subject to constraints on the distances depending on the number of available qubits.) and solve it as a decision problem (rather than finding a Hamiltonian cycle). We also made several smaller changes to make the transition the the quantum algorithm later easier. For clarity, and to make this section self-contained, Eppstein will in the following always refer to the algorithm in Alg. 2 instead of the original formulation of this algorithm in Eppstein (2007).

We first introduce a few important concepts.

Definition 7**.**

An FCHC instance $(G,F)$ is called trivial-reduction-free if

1. (i)

$G$ does not contain any vertices of degree two with unforced incident edges, 2. (ii)

$G$ does not contain any vertices of degree three with exactly two forced edges, and 3. (iii)

$G$ does not contain any cycles of four unforced edges such that two of its opposite vertices are incident to a forced edge and at least one of the other vertices is incident to an unforced edge that is not part of the cycle.

In other words, an FCHC instance is trivial-reduction-free if and only if none of the conditions of step 1 of Eppstein apply.

Definition 8**.**

Let $G=(V,E)$ be a simple, triangle-free graph with maximum degree at most $3$, $\omega$ be a cycle of four edges, and $F\subset E$. We say that $\omega$ unforced-isolated w.r.t. $F$ if all edges of $\omega$ are in $E\backslash F$, and each of the four vertices of $\omega$ is incident to an edge in $F$. Moreover, denote by $C(G,F)$ the set of $4-$cycles in $G$ which are unforced-isolated w.r.t. $F$.

Note that if $(G,F)$ is trivial-reduction-free, then all unforced $4$-cycles are unforced-isolated w.r.t. $F$. The correctness of Alg. 2 is given by the following proposition.

Proposition 5**.**

Let $(G,F)$ be a trivial-reduction-free FCHC instance. Suppose that $G$ has only vertices of degree $2$ or $3$, and that no three edges in $F$ meet in a single vertex. Suppose moreover that $G\backslash F$ is a collection of disjoint $4$-cycles and isolated vertices. Then, $G$ has a Hamiltonian cycle containing all edges in $F$ if and only if $G$ is connected.

Proof.

The “only if” direction is trivial. Assume that $G=(V,E)$ is connected. Note first of all that all vertices outside of $C(G,F)$ have degree $2$ and both their incident edges are in $F$.

For each $4$-cycle $\omega\in C(G,F)$, let $h_{1}(\omega),h_{2}(\omega)$ be two opposite edges in $\omega$ and $h_{3}(\omega),h_{4}(\omega)$ be the other two edges in $\omega$. Let $F_{1}:=F\cup\{h_{1}(\omega),h_{2}(\omega):\omega\in C(G,F)\}$. Note that every vertex in $G$ is incident to an edge in $F_{1}$ and that every vertex in $G_{1}=(V,F_{1})$ has degree two. Thus, $G_{1}$ is a collection of cycles. Consider the graph $G_{2}$ whose vertices are the connected components of $G_{1}$, and two connected components $H_{1},H_{2}$ of $G_{1}$ are joined by an edge in $G_{2}$ iff there exists a $4$-cycle $\omega\in C(G,F)$ which “separates” $H_{1},H_{2}$ in $G$, i.e., $h_{1}(\omega)\in H_{1}$ and $h_{2}(\omega)\in H_{2}$ or vice-versa. Note that since $G$ is connected, so is $G_{2}$. Note moreover that if $H_{1}$ and $H_{2}$ are adjacent in $G_{2}$ and separated by $\omega\in C(G,F)$ in $G$, replacing $h_{1}(\omega),h_{2}(\omega)$ with $h_{3}(\omega),h_{4}(\omega)$ in $G_{1}$ would result in replacing the two disconnected cycles $H_{1}$, $H_{2}$ by a single cycle going through the same vertices. Thus, consider a spanning tree of $G_{2}$ and let $G_{1}^{\prime}=(V,F_{1}^{\prime})$ be the graph obtained from $G_{1}$ by replacing $h_{1}(\omega),h_{2}(\omega)$ with $h_{3}(\omega),h_{4}(\omega)$ for all $\omega$ corresponding to an edge in the spanning tree. Then, by the previous observation, $G_{1}^{\prime}$ is connected. Moreover, since $F\subset F_{1}^{\prime}$ and every vertex has degree $2$ in $G_{1}^{\prime}$, it follows that $G_{1}^{\prime}$ is a Hamiltonian cycle containing all edges in $F$. ∎

Note in particular that Proposition 5 implies that step 2c of Eppstein is in fact unneccessary and the algorithm still performs correctly if that step is omitted. We include that step nevertheless, since the early termination of these instances simplifies the runtime analysis in Appendix A.

The main idea of bounding the runime of Eppstein is to introduce a “problem size metric” defined as follows.

Definition 9**.**

For an FCHC instance $(G,F)$, let $s(G,F):=\max(n(G)-|F|-|C(G,F)|,0)$. We call $s(G,F)$ the size of $(G,F)$.

Proposition 6**.**

Let $(G,F)$ be an FCHC instance such that no three edges in $F$ meet at a vertex. Suppose moreover that $F$ is not a collection of cycles. Then, $n(G)-|F|-|C(G,F)|>0$.

Proof.

First of all, note that the general case can be reduced to the special case of $C(G,F)=\emptyset$ by adding one edge of each $\omega\in C(G,F)$ to $F$. Suppose now that $C(G,F)=\emptyset$, and let $G^{\prime}=(V,F)$, where $V$ is the set of vertices of $G$. Then, every vertex has degree at most $2$ in $G^{\prime}$. Moreover, since $F$ is not a collection of cycles, at least one vertex has degree $<2$ in $G^{\prime}$. Hence,

[TABLE]

and hence $n(G)-|F|>0$. ∎

It can be shown Eppstein (2007) that every application of steps 3–6 creates two FCHC instances $(G_{1},F_{1})$ and $(G_{2},F_{2})$ such that $s(G_{1},F_{1}),s(G_{2},F_{2})\leq s(G,F)-3$ or $s(G_{1},F_{1})\leq s(G,F)-2$ and $s(G_{2},F_{2})\leq s(G,F)-5$. This leads to a recursive runtime bound of $T(s(G,F))$, where $T(s)=\max(2T(s-3),T(s-2)+T(s-5))+O(\operatorname{poly}(n(G)))$, leading to $T(s)=O(2^{s/3}\operatorname{poly}(n(G)))$. In particular, $\textsc{Eppstein}(G,\emptyset)$ solves the cubic Hamiltonian cycle problem in a runtime of $O(2^{n(G)/3}\operatorname{poly}(n(G)))$. We provide the details of this runtime analysis in the Appendix A.

V.2 Quantum improvement of Eppstein using small quantum computer

Using Theorem 1, the main part of obtaining a speedup is to provide a quantum speedup of Eppstein using few qubits.

Theorem 3**.**

There exists a quantum algorithm that, for any FCHC instance $(G,F)$, decides FCHC in a runtime of $O(2^{s/4}\operatorname{poly}(n))$ using $O(s\log(n/s)+s+\log n)$ qubits, where $s=s(G,F)$ and $n=n(G)$.

We will prove this in Section V.3. Theorems 1 and 3 immediately imply an improvement to Eppstein’s algorithm.

Theorem 4**.**

Let $c>0$ be an arbitrary constant. Then, given a quantum computer with $M=cn$ qubits, there exists a hybrid quantum-classical algorithm that solves the cubic Hamiltonian cycle problem for $n$-vertex graphs in runtime $O(2^{(1/3-f(c))n}\operatorname{poly}(n))$, where $f(c)>0$.

Note that with Theorem 3, we have a quantum algorithm that satisfies all the criteria to apply Theorem 1. However, to make things fully rigorous, we also need to deal with the fact that Alg. 2 includes initial rewritings and reductions, and as such is not immediately a special case of Alg. 1. This is a minor technicality, which we resolve as follows for completeness.

Proof of Theorem 4.

Note first of all that it is sufficient to prove that one can solve the FCHC problem in a runtime of $O(\max(2^{\gamma s(G,F)-f(c)n(G)},2^{\gamma_{Q}s(G,F)})\operatorname{poly}(n(G)))$, where $\gamma=1/3$ and $\gamma_{Q}=1/4$. Next, note that it is sufficient to do this only for trivial-reduction-free FCHC instances, since the others can be reduced to the trivial-reduction-free case by one application of step 1 of Eppstein.

Thus, with the notation of Section III, let $\mathcal{P}$ be the set of all trivial-reduction-free FCHC instances. Then Alg is given as follows: $\textsc{Trivial}(P)=1$ if any of the terminal conditions in step 2 of Eppstein apply, and $f(P)$ is the value returned in step 2. Moreover, $l=2$ and $R_{1}$ and $R_{2}$ are given by first selecting an edge $yz$ according to step 3 of Eppstein, forcing and deleting it, respectively, followed by performing all possible trivial reductions (i.e., step 1 of Eppstein). Note that indeed, $R_{1}$ and $R_{2}$ map trivial-reduction-free FCHC instances to trivial-reduction-free FCHC instances. Finally, the runtime analysis of Eppstein (see Proposition 10 in Appendix A) gives $k=3$, $l_{1}=l_{2}=l_{3}=2$ and

[TABLE]

The result now follows from Theorem 1. ∎

V.3 Proof of Theorem 3

To prove Theorem 3, note first of all that we can without loss of generality assume that $(G,F)$ is trivial-reduction-free, because if it is not, $G$ and $F$ can be classically pre-processed by repeated applications of step 1 of Eppstein. Note that $s(G,F)$ is non-increasing under this step.

The recursive steps 4 and 5 in Eppstein yield a binary recursion tree, with the two branches corresponding to either step 4 or 5. More formally, consider the binary rooted tree defined as follows.

Definition 10**.**

Let $(G,F)$ be an FCHC instance. Define $\textsc{RecTree}(G,F)$ to the binary rooted tree constructed as follows: the root of the tree is a vertex labelled $(G,F)$. Then, given a vertex $(\tilde{G},\tilde{F})$, if $\textsc{Eppstein}(\tilde{G},\tilde{F})$ terminates in step 2, it becomes a leaf of the tree. Otherwise, if $\textsc{Eppstein}(\tilde{G},\tilde{F})$ calls $\textsc{Eppstein}(G_{1},F_{1})$ and $\textsc{Eppstein}(G_{2},F_{2})$ in steps 4 and 5, respectively, create two children of $(\tilde{G},\tilde{F})$ labelled $(G_{1},F_{1})$ and $(G_{2},F_{2})$, respectively.

Moreover, let $\tau(G,F)$ be the number of edges that are forced or deleted in step 1 of $\textsc{Eppstein}(G,F)$, before the algorithm moves on.

Intiutively, $\textsc{RecTree}(G,F)$ is the tree of FCHC instances explored by steps 4 and 5 of Alg. 2. Note that by Proposition 10 in Appendix A, $\textsc{RecTree}(G,F)$ has depth at most $s(G,F)/2$. We first show that in a “good” branch of the recursion tree, a total of at most $O(s(G,F))$ trivial reductions are performed.

Proposition 7**.**

Let $(G,F)$ be trivial-reduction-free and let $(G,F)=(G_{1},F_{1}),(G_{2},F_{2}),\ldots,(G_{l},F_{l})$ be a path in $\textsc{RecTree}(G,F)$, such that $\textsc{Eppstein}(G_{l},F_{l})$ returns true in step 2. Then,

[TABLE]

Proof.

First, note that no edge which is part of some $\omega\in C(G,F)$ will be forced at any point of the algorithm. On the other hand, every Hamiltonian cycle contains exactly two (opposite) edges of each $\omega\in C(G,F)$. Hence, along the path from $(G_{1},F_{1})$ to $(G_{l},F_{l})$, a total of at most $n(G)-|F|-2|C(G,F)|\leq s(G,F)$ edges will be forced. In particular, at most $s(G,F)$ edges will be forced in step 1a or 1c of $\textsc{Eppstein}(G_{j},F_{j})$ over all $j=1,\ldots,l$. As for the number of edges deleted in step 1b, note that since $(G,F)$ is trivial-reduction-free, every deletion of an edge in step 1b of $\textsc{Eppstein}(G_{j},F_{j})$ for some $j\in\{1,\ldots,l\}$ is induced by an additional edge being forced. Each such edge can induce at most two edges being deleted in step 1b. Therefore, at most $2(s(G,F)+s(G,F)/2)=3s(G,F)$ edges are deleted in step 1b of $\textsc{Eppstein}(G_{j},F_{j})$ over all $j=1,\ldots,l$. ∎

The quantum algorithm we construct is essentially a quantum version of a non-recursive variant of Eppstein which proceeds by successively forcing and deleting edges according to a given input of a suitable search space. Note that $G$ and $F$ are classical input parameters and as such, the quantum circuit may depend on $G$ and $F$. We will not actively modify $G$ or $F$ in the quantum algorithm. Instead, the removal and forcing of additional edges are done by quantumly storing encodings of a set $X\subset\{1,\ldots,3|E|\}$, where for $e\in\{1,\ldots,|E|\}$, $e\in X$ means that edge number $e$ is forced, and $e+|E|\in X$ means that edge number $e$ has been removed (we assume that all edges and vertices are enumerated in a pre-specified order, i.e., with some abuse of notation888For simplicity of notation, we will in this section not distinguish between an edge $e$ and its number in the enumeration, and simply write $e=10$ to mean that $e$ is the $10$th edge according to the enumeration. We do the same for vertices., $E=\{1,\ldots,|E|\}$ and $V=\{1,\ldots,|V|\}$). For convenience we also introduce dummy variables which correspond to the values $2|E|+1,\ldots,3|E|$.

Before moving to the quantum algorithm, we first show how to perform Eppstein non-recursively. By Proposition 7 and Proposition 10 in Appendix A, a given path leading to an accepting leaf of the recursion tree $\textsc{RecTree}(G,F)$ adds at most $r:=\lfloor s(G,F)/2\rfloor+4s(G,F)$ elements to $X$, corresponding to at most $4s(G,F)$ edges deleted or forced in step 1 (Proposition 7) of Alg. 2, and at most $s(G,F)/2$ in steps 4 or 5 (Proposition 10). Thus, a sequence of $r$ binary variables $\nu_{1},\ldots,\nu_{r}\in\{0,1\}$ suffice to enumerate all relevant leafs of $\textsc{RecTree}(G,F)$, where each variable $\nu_{i}$ corresponds to an edge deleted or forced in step 1, step 4 or step 5. More precisely, the value of $\nu_{i}$ is ignored if the $i$th element added to $X$ is through a trivial reduction (i.e., in step 1 of Eppstein), otherwise the value of $\nu_{i}$ specifies if the edge chosen in step 3 is forced (step 4) or removed (step 5). Thus, Eppstein induces a mapping from $\mathcal{I}:=\{0,1\}^{r}\rightarrow\mathcal{P}_{r}([3|E|])$, $\vec{\nu}:=(\nu_{1},\ldots,\nu_{r})\mapsto X=X(\vec{\nu})$.

Note that although the same task could be achieved by only introducing $\lfloor s(G,F)/2\rfloor$ binary variables instead of $r$, the additional $4s(G,F)$ variables ensure that at any given point of the implementation, $X$ has a pre-determined size, which would not be the case otherwise (indeed, Proposition 7 only provides an upper bound to the number of trivial reductions overall but these are generally distributed in a previously unknown way). This will be important when we later want to use the results of Section IV.

The non-recursive (classical) variant of Eppstein is given in Alg. 3. Write $X=F^{\prime}\cup D$, where $F^{\prime}=\{e\in\{1,\ldots,|E|\}:e\in X\}$ and $D=\{e\in\{1,\ldots,|E|\}:e+|E|\in X\}$ are the edges which would be forced and deleted in either of steps 1, 4 or 5 of $\textsc{Eppstein}(G,F)$, respectively. The algorithm first computes $X(\vec{\nu})$ from $\vec{\nu}$ (we call this operation Reduce), and then checks the conditions of step 2 for the FCHC instance $(G\backslash D,F\cup F^{\prime})$ and returns the corresponding value. We call the second step Check. For completeness, Check also returns false if none of the conditions of step 2 apply (note that if this is the case, Propostions 5 and 7 imply that $\vec{\nu}$ corresponds to a branch that does not find a Hamiltonian cycle). The full non-recursive version Eppstein simply goes through all $2^{r}$ values of $\vec{\nu}$, yielding a runtime of $O(2^{r}\operatorname{poly}(n(G)))$. Alternatively, by picking $\vec{\nu}\in\mathcal{I}$ uniformly at random, an expected rutnime of $O(2^{r}/2^{t}\operatorname{poly}(n(G)))=O(2^{s/2}\operatorname{poly}(n(G)))$ can be achieved.

Note that we have omitted checking the conditions of step 2c of Eppstein in the non-recursive formulation, as it does not affect the correctness of the algorithm (see also remark after Proposition 5). Indeed, for a “good” branch (i.e., a value of $\vec{\nu}$ that corresponds to finding a Hamiltonian cycle), the condition of step 2c of Eppstein is never fulfilled, whereas Proposition 5 ensures that if $F\cup F^{\prime}$ contains a non-Hamiltonian cycle, Check will return false. Instead of checking the condition of step 2c of Eppstein, the condition in line 34 of Alg. 3 has been modified to account for the case when $F$ is a collection of (non-Hamiltonian) cycles, in which case step 3b of Eppstein cannot be applied.

To turn Alg. 3 into a quantum algorithm, we first show that Reduce and Check can be performed reversibly in polynomial time, and with only $O(s\log(n/s)+s+\log n)$ bits, where $s=s(G,F)$ and $n=n(G)$, and we assume that Check simply writes the result on a single output bit. Note that throughout $\textsc{NonRecursiveEppstein}(G,F)$, $G$ and $F$ are never modified. As such, it is sufficient to write Reduce and Check as reversible circuits $\textsc{Reduce}_{G,F}$ and $\textsc{Check}_{G,F}$, which depend on $G$ and $F$, and which perform

[TABLE]

where $Z(\vec{\nu})=(x_{1},\ldots,x_{r})$, $x_{1},\ldots,x_{r}$ are the elements of $X(\vec{\nu})$ in the order in which they are added to $X$ in Reduce, $h(Z(\vec{\nu}))$ is the output bit returned by $\textsc{Check}(G,F,X(\vec{\nu}))$, and the last register comprises at most $O(s\log(n/s)+s+\log n)$ ancilla bits.

Next, we turn this into a quantum process by replacing every elementary reversible operation by its corresponding quantum operation. The final step is to use amplitude amplification Brassard et al. (2002) (or alternatively fixed point search Yoder et al. (2014)) to quantumly search for the value $\left|h(Z(\vec{\nu}))\right\rangle=\left|1\right\rangle$ on the output register. Note that since $t$ of the $r$ input bits are irrelevant, the dimension of the target space, if a Hamiltonian cycle exists, is at least $2^{t}$. Thus, fixed point search requires $O(\sqrt{2^{r}/2^{t}})=O(2^{s/4})$ repetitions of $\textsc{Reduce}_{G,F}$ and $\textsc{Check}_{G,F}$.

It thus only remains to show that for any given trivial-reduction-free FCHC instance $(G,F)$, both $\textsc{Reduce}_{G,F}$ and $\textsc{Check}_{G,F}$ can be performed reversibly in polynomial time and with only $O(s\log(n/s)+s+\log n)$ bits, where $s=s(G,F)$ and $n=n(G)$.

V.3.1 Reversible space-efficient implementation of $\textsc{Reduce}_{G,F}$

The basic idea of the $\textsc{Reduce}_{G,F}$ algorithm is to reversibly generate an efficient encoding of $X(\vec{\nu})\subset\{1,\ldots,3|E|\}$ from $\left|\vec{\nu}\right\rangle$ using Theorem 2 by specifying suitable reversible $\textsf{Calculate}_{i}$ operations. For each value of $i=1\ldots,r$, let $\textsf{Calculate}_{G,F,i}$ be the operation that finds the next edge $e_{i}$ and an action bit $a_{i}\in\{0,1\}$ following the implementation of Calculate in Alg. 3. That implementation in turn follows the implementation of Eppstein, i.e., an edge $e_{i}$ is selected according to the rules of step 1 and 3, and $a_{i}=0$ if $e_{i}$ will be forced and $a_{i}=1$ if $e_{i}$ will be removed. If no more edges are forced or deleted (i.e., one of the terminal conditions of step 2a or 2b of Eppstein apply), we set $e_{i}$ to be a dummy variable $e_{i}=2|E|+i$ and $a_{i}=0$.

The task then becomes to reversibly implement the operations

[TABLE]

and

[TABLE]

for $i=2,\ldots,r$, where $x_{i}=e_{i}+a_{i}|E|$ and $Z_{i}=(x_{1},\ldots,x_{i})$. Note that by introducing the dummy variables, we ensure that for any $i\in\{1,\ldots,r\}$, $X_{i}=\{x_{1},\ldots,x_{i}\}$ has exactly $i$ elements, even if no edges have been forced or deleted in some of the steps.

The primary challenge of the implementation is to maintain reversibility and at the same time use few ancillas. For this, it is important that any ancillas used are as soon as possible reset to $\left|0\right\rangle$ in order to avoid accumulating unnecessary junk bits.

Proposition 8**.**

Let $(G,F)$ be a trivial-reduction-free FCHC instance and $i\in\{1,\ldots,r\}$, where $r=\lfloor s(G,F)/2\rfloor+4s(G,F)$. Then, the operation $\textsf{Calculate}_{G,F,i}$ defined by Eq. (47) and (48) can be implemented reversibly using $O(\log n(G))$ ancillas and $O(\operatorname{poly}(n(G)))$ gates.

Proof.

The basic idea to maintain reversibility is to introduce a counter, initially set to [math], which is increased once suitable values for $e_{i}$ and $a_{i}$ have been found. Then, by controlling all operations on that counter being [math], we ensure that no further edges are selected once an edge and action bit has been found, and hence that only one edge and action bit is selected.

More precisely, we introduce a counter from [math] to $7$, which we call the flag counter, and denote it by $\mathcal{FC}$. We also introduce an additional ancilla bit, which we call the flag bit, and denote it by $\mathcal{FB}$. Both are initially set to zero. We denote the register of $O(\log n)$ bits containing the value of $e_{i}$ as $\mathfrak{e}$ and the register containing the value of $a_{i}$ as $\mathfrak{a}$. We assume that $\mathfrak{e}$ and $\mathfrak{a}$ are both initially set to zero.

For clarity of notation, we will only cover the case $i\geq 2$ here. The case $i=1$ is fully analogous, but without the $\left|\operatorname{EffEnc}Z_{i-1}\right\rangle$ register and ignoring any operations involving it. As before, we write $Z_{i-1}=(x_{1},\ldots,x_{i-1})$, $X_{i-1}=\{x_{1},\ldots,x_{i-1}\}$, $F^{\prime}=\{e\in\{1,\ldots,|E|\}:e\in X_{i-1}\}$ and $D=\{e\in\{1,\ldots,|E|\}:e+|E|\in X_{i-1}\}$.

The basic building block of the implementation consists of a controlled check-and-select (CCS) operation illustrated in Fig. 1. We will implement seven different check-and-select operations, each corresponding to lines 24–25, 26–27, 28–29, 30–31, 32–33, 34–35, and 36–37, of Alg. 3, respectively. For example, the check-and-select operation corresponding to lines 24–25 of Alg. 3 does the following: if $G\backslash D$ contains a vertex with degree $2$ with at least one edge in $E\backslash(F\cup F^{\prime}\cup D)$, it adds to $\mathfrak{e}$ the value of $e$ of one of the edges in $E\backslash(F\cup F^{\prime}\cup D)$ incident to such a vertex (if multiple such vertex/edge combinations exist, $e$ is taken to be the first such edge of the first such vertex), leaves $\mathfrak{a}$ invariant (such that it stays in [math]), and flips $\mathcal{FB}$.

The full reversible implementation of $\textsf{Calculate}_{G,F,i}$ is given in Fig. 2. It consists of these seven CCS operations concatenated in sequence, then adds $\mathfrak{e}+\mathfrak{a}|E|$ to the output register, and finally applies the inverses of the CCS operations. The latter ensure that all registers except for the input registers ($\left|\nu_{i}\right\rangle\left|\operatorname{EffEnc}Z_{i-1}\right\rangle$) and the ouput register are reset to $\left|0\right\rangle$.

It thus remains to show how to reversibly implement each of the seven check-and-select operations. It is easy to see, however, that each of these can be implemented using $O(\log n)$ ancilla bits. Indeed, all check-and-select operations can be formulated as a search over a set of objects that can be classically enumerated beforehand, since $G$ and $F$ are classical inputs, and the checking of each individual object can always be implemented using a constant number of ancillas and calls to $\textsf{EffContains}_{i-1}$.

For example, checking whether any given vertex $v$ has any of the properties in question (e.g., whether $v$ has degree $2$ with at least one incident edge in $E\backslash(F\cup F^{\prime}\cup D)$) reduces to checking which, if any, of its incident edges $e$ have been forced (i.e, $e\in X_{i-1}$) or deleted (i.e, $e+|E|\in X_{i-1}$). The latter can be done using a constant number of calls to $\textsf{EffContains}_{i-1}$. Controlled on the outcome, a suitable edge and action bit is added to $\mathfrak{e}_{\text{temp}}$ and $\mathfrak{a}_{\text{temp}}$, respectively, and $\mathcal{FB}_{\text{temp}}$ flipped, where $\mathfrak{e}_{\text{temp}}$, $\mathfrak{a}_{\text{temp}}$ and $\mathcal{FB}_{\text{temp}}$ are ancilla registers of the same sizes as $\mathfrak{e}$, $\mathfrak{a}$, and $\mathcal{FB}$, respectively. The full CCS operation is then implemented by introducing a counter from [math] to $n$ initially set to [math], and then, controlled on the counter being [math], performing the previous operation for all $n$ vertices in sequence, followed by incrementing that counter controlled on $\mathcal{FB_{\text{temp}}}$ (this is conceptually the same as the sequence of CCS operations in Fig. 1–2, except with $\mathcal{FC}$ replaced by a counter from [math] to $n$, and $\mathfrak{e}$, $\mathfrak{a}$, and $\mathcal{FB}$ replaced by $\mathfrak{e}_{\text{temp}}$, $\mathfrak{a}_{\text{temp}}$, and $\mathcal{FB}_{\text{temp}}$, respectively). Note that the final value of the counter is then $n+1-$ the first vertex with the property (if the counter is [math], no vertex has that property). Then, the values of $\mathfrak{e}_{\text{temp}}$, $\mathfrak{a}_{\text{temp}}$ and $\mathcal{FB}_{\text{temp}}$ are added to $\mathfrak{e}$, $\mathfrak{a}$, and $\mathcal{FB}$, respectively. After that, applying the inverse of the property checks for all vertices resets all ancillas. This covers the CCS operations corresponding to lines 24–25, 26–27, 34–35, and all but one of the subcases of lines 30–31 of Alg. 3.

A similar iteration through all edges in $E$ covers the CCS operation corresponding to lines  36–37 of Alg. 3.

One can similarly check if $G\backslash(F\cup F^{\prime}\cup D)$ contains $4$-cycles with certain properties, and select incident edges accordingly if it does. Indeed, note that $G\backslash F$ has at most $O(n)$ $4$-cycles, which can be enumerated in a pre-specified order, so a counter using $O(\log n)$ bits suffices. This covers the CCS operations corresponding to lines 28–29 and 32–33 of Alg. 3.

Finally, to check if $G\backslash(F\cup F^{\prime}\cup D)$ is a collection of disjoint $4$-cycles and isolated vertices, note that this is the case if and only if every edge in $E\backslash(F\cup F^{\prime}\cup D)$ is part of exactly one $4$-cycle in $G\backslash(F\cup F^{\prime}\cup D)$. This can thus be checked in a similar manner by sequentially going through all edges $e$, and then, for each (not necessarily unforced-isolated) $4$-cycle $\omega\ni e$ in $G\backslash F$, checking if any of its edges are in $F^{\prime}\cup D$. This covers the final subcase of the CCS operation corresponding lines 30–31 of Alg. 3. ∎

Using Theorem 2, we obtain the efficient reversible implementation of Reduce from Proposition 8.

Corollary 2**.**

Let $(G,F)$ be a trivial-reduction-free FCHC instance. Then, the operation $\textsc{Reduce}_{G,F}$ defined by Eq. (46) can be implemented reversibly with $O(s\log(n/s)+s+\log n)$ ancillas and $O(\operatorname{poly}(n))$ gates, where $s=s(G,F)$ and $n=n(G)$.

V.3.2 Reversible space-efficient implementation of $\textsc{Check}_{G,F}$

The reversible and space-efficient implementation of $\textsc{Check}_{G,F}$ follows the (non-reversible) implementation of Check in Alg. 3 by checking in turn whether the conditions in lines 44, 46, 48, and 50, respectively, apply.

It is clear that checking the first three conditions of Check, namely whether $G^{\prime}$ contains a vertex of degree $1$, whether $F\cup F^{\prime}$ contains three edges meeting at a vertex, or whether $G\backslash(F\cup F^{\prime}\cup D)$ is a collection of disjoint $4$-cycles and isolated vertices, can each be done in the same way as the check-and-select operations in the proof of Proposition 8, and thus can be implemented reversibly using $O(\log n(G))$ ancillas and $O(\operatorname{poly}(n(G)))$ gates. Hence, it only remains to check whether $G\backslash D$ is connected. We use the fact that there is a classical reversible space-efficient algorithm to check that. Indeed, Reingold (2005) shows that there is a (not necessarily reversible) classical algorithm that decides in time $O(\operatorname{poly}(n(G)))$ and space $O(\log n(G))$ if a graph $G$ is connected. Ref. Lange et al. (2000) then shows that any given (not necessarily reversible) computation requiring memory $S$ and time $T$ can be implemented reversibly using $S$ ancillas and $2^{O(S)}$ gates (see also Williams (2000); Buhrman et al. (2001)). This implies the following.

Proposition 9** (Reingold (2005); Lange et al. (2000)).**

There exists a classical deterministic algorithm that checks if a given graph $G$ is connected in time $O(\operatorname{poly}n(G))$, which can be implemented reversibly using $O(\log n(G))$ ancillas.

Note that Proposition 9 only requires oracular access to the adjacency matrix of the graph in question Reingold (2005). Moreover, we can easily access the required adjacency matrix, i.e., the map

[TABLE]

can be implemented reversibly with $O(1)$ ancillas and at most three call to $\textsf{EffContains}_{r}$ , where the last bit in (49) is $1$ if the vertices $v$ and $w$ are connected in $G^{\prime}=G\backslash D$, and [math] otherwise. This completes our space-efficient reversible implementation of $\textsc{Check}_{G,F}$.

Corollary 3**.**

Let $(G,F)$ be a trivial-reduction-free FCHC instance. Then, the operation $\textsc{Check}_{G,F}$ defined by Eq. (46) can be implemented reversibly using $O(\log n(G))$ ancillas and $O(\operatorname{poly}(n(G)))$ gates.

This concludes the proof of Theorem 3.∎

VI Conclusion and outlook

The recent progress in experimental quantum computing 201 (2017, 2018a, 2018b) increases confidence that fully scalable quantum computers will be realised at some point in the upcoming decades. However, the rate at which the number of qubits we can manipulate with relevant precision and coherence times currently grows provides significant motivation for studying potential uses of size-limited quantum computers. Complementary to research dedicated to solving small-yet-hard simulation and ground-state problems Lloyd (1996); Wecker et al. (2015); Ge et al. (2019), which are promising applications for really small quantum computers, in this work, we investigated ways to achieve speedups of classical algorithms by exploiting quantum computers significantly smaller than the problem size. Concretely, we provide a framework for designing hybrid quantum-classical algorithms, which can allow for polynomial asymptotic speedups given a quantum computer which is any constant fraction of the problem size.

Our result also implies that we can achieve a trade-off between the speedup we obtain, and the size of problem we wish to tackle. Thus, a small quantum computer can dramatically speed up the solving of small problems, but can be used to achieve more modest speedups of larger instances as well. Such trade-offs have, to our knowledge, not been explored before our works.

We provided the general formalism in the form of the so-called divide-and-conquer hybrid approach, which enables us to realise such trade-offs for a broad class of recursive classical algorithms, and we provided a characterisation of the space-efficiency of the quantum subroutines required to achieve polynomial speedups. Moreover, we provided a toolkit for the space-efficient reversible generation and manipulation of sets, which is often the bottleneck of the space requirements of many such algorithms. As an illustration, we show how this framework can be applied to speed up the algorithm of Eppstein for detecting Hamilton cycles in cubic graphs.

We also identify a number of questions that remain unresolved, both from a purely theoretical and from an applied perspective.

First, the algorithms which we so far have applied our hybridd approach to are not the absolutely best known algorithms for their respective problems. Indeed, Eppstein’s algorithm has subsequently been improved from $O(1.2599^{n}\operatorname{poly}(n))$ to $O(1.2509^{n}\operatorname{poly}(n))$ Iwama and Nakashima (2007) and $O(1.2312^{n}\operatorname{poly}(n))$ Xiao and Nagamochi (2016). It would be interesting to apply our framework to speed up the actually best classical algorithms, which would yield an asymptotic speedup over the best classical algorithms for a quantum computer the size of any constant fraction of the problem size.

Second, our approach currently focuses on Grover-based speedups; however, the quantum backtracking techniques Montanaro (2018); Moylett et al. (2017) and subsequent improvements Ambainis and Kokainis (2017) lead to better performing quantum algorithms. It remains an open question whether these methods can also be made to fit in our hybrid approach, and whether they would thus yield better speedups.

From a more applied perspective, there are two key issues which currently prevent our algorithms from being practical. First is the fact that we deal with asymptotic speedups, and focus on algorithm performance in the worst-case exponential run-times. For the issue of asymptotic statements, there has lately been increasing interest in analysing performance for finite-size settings Campbell et al. (2018), which were moderately promising, but required arbitrarily-sized quantum computers. It would be interesting to see if a similar claim could be made for size-limited quantum computers.

Second, we assume ideal noiseless settings, which is still remote Preskill (2018). Note that exponential run-times essentially require full fault tolerance to yield reliable results. It would be interesting to consider our hybrid approach for heuristic algorithms, which run for low-polynomial times, and while they may fail to find solutions for most truly hard instances, still perform very well in practice. These much more efficient algorithms would be more important for real-world solutions to NP-hard problems. Furthermore, in this case, it is more likely that intermediary efficient error mitigation schemes, as opposed to full fault tolerance, suffices to achieve quantum-enhanced and usable NP heuristics.

Acknowledgements.

We thank J.I. Cirac for helpful discussions. VD is partially funded through the Quantum Software Consortium.

Appendix A Runtime analysis of Eppstein

In this section, we prove the runtime of Eppstein (as defined in Alg. 2) of $O(2^{s(G,F)/3}\operatorname{poly}(n(G)))$. Note that since $s(G,F)\leq n(G)$, this in particular implies a runtime of $O(2^{n(G)/3}\operatorname{poly}(n(G)))$, which is the bound commonly cited in literature. The analysis is essentially the same as that in Eppstein (2007).

We first introduce a few notions for convenience.

Definition 11**.**

For any FCHC instance $(G,F)$, let $\textsc{TrivRed}(G,F)$ be the FCHC instance obtained from $(G,F)$ by applying step 1 of Eppstein to $(G,F)$.

In other words, TrivRed is the first step of Eppstein which performs all possible trivial reductions (step 1a, 1b, and 1c) until no more such reductions are possible. In particular, $\textsc{TrivRed}(G,F)$ is trivial-reduction-free for any FCHC instance $(G,F)$, and $\textsc{TrivRed}(G,F)=(G,F)$ whenever $(G,F)$ is trivial-reduction-free.

Definition 12**.**

Let $(G,F)$ be a trivial-reduction-free FCHC instance. We say that $(G,F)$ is non-terminal if

1. (i)

$G$ does not contain any vertices of degree [math] or $1$, 2. (ii)

$F$ does not contain three edges meeting at a vertex, 3. (iii)

$G\backslash F$ is not a collection of disjoint $4$-cycles and isolated vertices, and 4. (iv)

$F$ does not contain a non-Hamiltonian cycle.

Otherwise, we call $(G,F)$ terminal.

In other words, a trivial-reduction-free FCHC instance is non-terminal if and only if none of the terminal conditions in step 2 of Eppstein apply.

Definition 13**.**

For any trivial-reduction-free and non-terminal FCHC instance $(G,F)$, let $\textsc{EdgeSelect}(G,F)$ be the edge selected in step 3 of $\textsc{Eppstein}(G,F)$.

In other words, if $(G,F)$ is trivial-reduction-free and non-terminal, then steps 4 and 5 of $\textsc{Eppstein}(G,F)$ call $\textsc{Eppstein}(G,F\cup\{\textsc{EdgeSelect}(G,F)\})$ and $\textsc{Eppstein}(G\backslash\{\textsc{EdgeSelect}(G,F)\},F)$, respectively.

Eppstein’s key idea to bounding the runtime was to show that with each recursive call, $s(G,F)$ reduces by a constant larger than $1$, leading to a runtime that is polynomially better than a trivial path-search algorithm (see also Lemma 7 in Eppstein (2007)).

Proposition 10**.**

Let $(G,F)$ be a trivial-reduction-free and non-terminal FCHC instance and let $e=\textsc{EdgeSelect}(G,F)$. Suppose that $F$ is nonempty, and let $(G_{1},F_{1})=\textsc{TrivRed}(G,F\cup\{e\})$ and $(G_{2},F_{2})=\textsc{TrivRed}(G\backslash\{e\},F)$. Suppose that $(G_{1},F_{1})$ and $(G_{2},F_{2})$ are non-terminal. Then,

• •

$s(G_{1},F_{1}),s(G_{2},F_{2})\leq s(G,F)-3$, or

• •

$s(G_{1},F_{1})\leq s(G,F)-2$* and $s(G_{2},F_{2})\leq s(G,F)-5$, or vice-versa.*

Proof.

We prove the claim by going through all possible cases that can occur in $\textsc{EdgeSelect}(G,F)$.

Suppose first that $e$ is selected according to step 3a of Eppstein (see Fig. 3), i.e., $G\backslash F$ contains a $4$-cycle $\omega$ with exactly two vertices incident to edges in $F$, and $e$ is one of the other two edges adjacent to vertices in the cycle. Note that indeed, since $(G,F)$ is trivial-reduction-free, every vertex in $\omega$ is adjacent to a non-cycle edge. Note moreover that since $(G,F)$ is trivial-reduction-free, the two vertices of $\omega$ which are incident to edges in $F$ must be adjacent. Hence, $\omega$ has two opposite vertices which are incident to an edge in $F\cup\{e\}$. Thus, $\textsc{TrivRed}(G,F\cup\{e\})$ forces the last non-cycle edge adjacent to $\omega$. It follows that $|F_{1}|\geq|F|+2$ and $|C(G_{1},F_{1})|\geq|C(G,F)|+1$, and hence $s(G_{1},F_{1})\leq s(G,F)-3$. On the other hand, removing $e$ leads to two unforced edges in $\omega$, which will be forced, leading to one of the vertices in $\omega$ to have two incident forced edges. This leads to the removal of the third (cycle) edge, hence forcing the final edge in $\omega$. It follows that $|F_{2}|\geq|F|+3$, and hence $s(G_{2},F_{2})\leq s(G,F)-3$.

Next, suppose that $e=yz$ is selected according to step 3b of Eppstein. Let $w$ be the third vertex adjacent to $y$ in $G$. Note that since $(G,F)$ is trivial-reduction-free, $yw\not\in F$ and $\deg z=\deg w=3$. We distinguish two cases.

In the first case, suppose that neither $z$ nor $w$ have an incident edge in $F$ (Fig. 4). Then, $\textsc{TrivRed}(G,F\cup\{e\})$ first removes $yw$ and then adds both remaining edges incident to $w$ to $F$. Hence, $s(G_{1},F_{1})\leq s(G,F)-3$. Similarly, $s(G_{2},F_{2})\leq s(G,F)-3$.

In the second case, suppose that $z$ or $w$, have an incident edge in $F$. Note that since $xy\in F$, $yz$ and $yw$ cannot be part of a $4$-cycle of unforced edges, because otherwise $\textsc{EdgeSelect}(G,F)$ would choose $e$ according to step 3a of Eppstein. Thus, $z,y,w$ are part of an unforced, and possibly closed, chain of $k\geq 4$ vertices, with the inner vertices each having an incident edge in $F$. There are two subcases here.

In the first subcase, suppose that this chain terminates (see Fig. 5). Thus, $z,y,w$ are part of an unforced chain of $k\geq 4$ vertices such that the inner $k-2$ vertices each have an incident edge in $F$ and the outer two vertices have three unforced incident edges. Then, $\textsc{TrivRed}(G,F\cup\{e\})$ and $\textsc{TrivRed}(G\backslash\{e\},F)$ force and delete alternating edges of that chain. If $k=2l$ is even, then one of $(G_{1},F_{1})$ and $(G_{2},F_{2})$ has $l-1$ edges of that chain which are forced, and the other has $l$ (Fig. 5(a)). Assume without loss of generality that $(G_{1},F_{1})$ has $l-1$ edges of that chain forced. Then, both outer vertices of the chain will eventually have degree two, and thus TrivRed forces four additional edges. It follows that $|F_{1}|\geq|F|+4+(l-1)\geq|F|+5$ and $|F_{2}|\geq|F|+l\geq|F|+2$, and hence $s(G_{1},F_{1})\leq s(G,F)-5$ and $s(G_{2},F_{2})\leq s(G,F)-2$. On the other hand, if $k=2l+1$ is odd, then $\textsc{TrivRed}(G,F\cup\{e\})$ and $\textsc{TrivRed}(G\backslash\{e\},F)$ both force $l$ edges of the chain, and leave one of the two outer vertices with degree two, thus forcing its other two incident edges (Fig. 5(b)). It follows that $|F_{1}|,|F_{2}|\geq|F|+l+2\geq|F|+4$ and hence $s(G_{1},F_{1}),s(G_{2},F_{2})\leq s(G,F)-4$.

In the second subcase, this unforced chain is a cycle of $k$ vertices (Fig. 6), each of which is incident to an edge in $F$. Then, $\textsc{TrivRed}(G,F\cup\{e\})$ and $\textsc{TrivRed}(G\backslash\{e\},F)$ force and delete alternating edges of that chain. Clearly, by the definition of Step 3b of Eppstein, $k>4$. Moreover, if $k$ is odd, $\textsc{TrivRed}(G,F\cup\{e\})$ and $\textsc{TrivRed}(G\backslash\{e\},F)$ would both have three forced edges meeting in a vertex, and hence would be terminal. Hence, $k\geq 6$, and thus $|F_{1}|,|F_{2}|\geq|F|+3$. Hence, $s(G_{1},F_{1}),s(G_{2},F_{2})\leq s(G,F)-3$.

Finally, note that since $F$ is assumed to be non-empty and $(G,F)$ to be non-terminal, $\textsc{EdgeSelect}(G,F)$ does not choose $e$ according to step 3c of Eppstein. ∎

Corollary 4**.**

For any FCHC instance $(G,F)$, $\textsc{Eppstein}(G,F)$ decides the FCHC problem in a runtime of $O(2^{s(G,F)/3}\operatorname{poly}(n(G)))$.

Proof.

Clearly, if $(G,F)$ is trivial-reduction-free and terminal, $\textsc{Eppstein}(G,F)$ only takes $O(\operatorname{poly}(n(G)))$ time. Moreover, if $(G,F)$ is trivial-reduction-free, then by Propostion 6, $s(G,F)=0$ implies that $(G,F)$ is terminal. Hence, Proposition 10 implies that the runtime of $\textsc{Eppstein}(G,F)$ can be bounded by some function $T(s(G,F))$ depending only on $s(G,F)$, where $T(s)$ satisfies $T(s)=O(\operatorname{poly}(n(G)))$ for $s\leq 0$, and

[TABLE]

for $s>0$. Using standard techniques for solving linear recurrence relations, one obtains $T(s)=O(2^{s/3}\operatorname{poly}(n(G)))$ for $s\geq 0$. ∎