Applications of the quantum algorithm for st-connectivity

TL;DR

This paper introduces quantum algorithms for graph connectivity problems, including cycle detection and bipartiteness, with optimal query complexity and improved performance under specific graph conditions.

Contribution

It presents new quantum algorithms for multiple graph connectivity problems, optimizing query complexity and extending capabilities to estimate circuit rank.

Findings

Query-optimal algorithms for cycle detection and bipartiteness

Improved performance with large circuit rank or few edges

Algorithms operate with logarithmic space complexity

Abstract

We present quantum algorithms for various problems related to graph connectivity. We give simple and query-optimal algorithms for cycle detection and odd-length cycle detection (bipartiteness) using a reduction to st-connectivity. Furthermore, we show that our algorithm for cycle detection has improved performance under the promise of large circuit rank or a small number of edges. We also provide algorithms for detecting even-length cycles and for estimating the circuit rank of a graph. All of our algorithms have logarithmic space complexity.

Equations

$$O\left(\sqrt{\underset{\begin{array}{c}x\in X\\ R_{s,t}(G(x))\ne \infty \end{array}}{\max }{R}_{s,t}(G(x))\times \underset{\begin{array}{c}x\in X\\ C_{s,t}(G(x))\ne \infty \end{array}}{\max }{C}_{s,t}(G(x))}\right).$$

$$O(\max \{\log (|E|),\log (|V|)\}),$$

$${\tilde{R}}_{-}(x,G)=\underset{\mathcal{V}\in \mathcal{L}(V,\mathbb{R}):\mathcal{V}(u)={\mathcal{V}}_x(u)\text{ if }u\in V_x}{\min }\sum _{\{u,v\}\in E}{\left(\mathcal{V}(u)-\mathcal{V}(v)\right)}^2.$$

$$R_{s,t}(G_{\text{cyc}}(x))=\frac{1}{r}.$$

$$R_{u,v}(G)$$

$$R_{s,t}(G_{\text{cyc}}(x))={\left(\sum _{(u,v)\in E(G(x))}1-R_{u,v}(G(x))\right)}^{-1}.$$

$$t(g_i(x))(n_i-1)=\sum _{\ell \in E(g_i(x))}{t}_{\ell }(g_i(x)).$$

$$n_i-1$$

$$n-\kappa =\sum _{\{u,v\}\in E(G)}{R}_{u,v}(G(x)),$$

$$\sum _{\{u,v\}\in E(G(x))}1=m,$$

$$\sum _{\{u,v\}\in E(G(x))}1-R_{u,v}(G(x))=r.$$

$$\frac{1}{R_{u,v}(G)}=1+\frac{1}{R_{s,t}(G_{\ell }^{-})}.$$

$$R_{s,t}(G_{\ell }^{-})=\frac{R_{u,v}(G)}{1-R_{u,v}(G)}$$

$$R_{s,t}(G_{\ell })$$

$$=\frac{R_{u,v}(G)}{1-R_{u,v}(G)}+1$$

$$=\frac{1}{1-R_{u,v}(G)}.$$

$$\frac{1}{R_{s,t}(G_{\text{cyc}})}=\sum _{\{u,v,\}\in E(G)}1-R_{u,v}(G).$$

Full text

1 Introduction

Quantum query algorithms are remarkably described by span programs [15, 16], a linear algebraic object originally created to study classical logspace complexity [12]. However, finding optimal span program algorithms can be challenging; while they can be obtained using a semidefinite program, the size of the program grows exponentially with the size of the input to the algorithm. Moreover, span programs are designed to characterize the query complexity of an algorithm, while in practice we also care about the time and space complexity.

One of the nicest span programs is for the problem of undirected $st$-connectivity, in which one must decide whether two vertices $s$ and $t$ are connected in a given graph. It is “nice” for several reasons:

• •

It is easy to describe and understand why it is correct.

• •

It corresponds to a quantum algorithm that uses logarithmic (in the number of vertices and edges of the graph) space [4, 11].

• •

The time complexity of the corresponding algorithm is the product of the query complexity, and the time required to implement a unitary that applies one step of a quantum walk on the underlying graph [4, 11]. On the complete graph, for example, the quantum walk step introduces only an additional logarithmic factor to the complexity [4].

• •

The query complexity of the algorithm is determined by two well known graph functions, the effective resistance and effective capacitance [10].

Thus one strategy for designing other “nice” quantum algorithms is to reduce a given problem to $st$-connectivity, and then use the span program $st$-connectivity algorithm. This strategy has proven to be quite successful, and in fact has produced several optimal or nearly optimal algorithms. There is a reduction from Boolean formula evaluation to $st$-connectivity [14] that produces an optimal quantum algorithm for read-once formulas [11]. There is an optimal reduction from graph connectivity to $st$-connectivity [10]. Cade et al. use an $st$-connectivity subroutine to create nearly query-optimal algorithms for cycle detection and bipartiteness [7]111In Ref. [2], Āriņš designed algorithms for connectivity and bipartiteness which, while not strictly reductions to $st$-connectivity, are very closely related.. Finally, the $st$-connectivity span program algorithm underlies the learning graph framework [3], one of the most successful heuristics for span program algorithm design.

In this work, we follow precisely this strategy for creating “nice” quantum algorithms: we reduce the graph problems of cycle detection, odd-length path detection, bipartiteness, and even-length cycle detection to $st$-connectivity. In our reductions, solving the related $st$-connectivity problem comprises the whole algorithm; in other words, we create a new graph that has an $st$-path if and only if the original graph has the property in question.

Additionally, there is an an estimation algorithm closely related to the $st$-connectivity algorithm that determines the size of the effective resistance or effective capacitance of the graph [9, 10]. Not only is it often useful to estimate the effective resistance or effective capacitance of a graph, as these quantities bound the shortest path length and smallest cut size respectively, but sometimes one can encode quantities of interest as either the effective capacitance or effective resistance. For example, given a graph $G$, it is possible to create a new graph whose effective resistance is the average effective resistance (Kirchoff index) of the original graph [10]. Using this strategy of reduction to effective resistance estimation, we also create an algorithm to estimate the circuit rank of a graph.

1.1 Contributions and Comparison to Previous Work

All of our algorithms are in the adjacency matrix model (see Section 2), in which one can query elements of the adjacency matrix of the input graph. This contrasts with work such as [7] which study similar problems in the adjacency list model.

We note all of our algorithms are space efficient, in that the number of qubits required are logarithmic in the number of edges and vertices of the graph. (This property is inherited directly from the basic $st$-connectivity span program.) We do not analyze time complexity, but, as mentioned above, it is the product of the query complexity, which we analyze, and the time required to implement certain quantum walk unitaries. (We leave this analysis for future work.)

We next discuss the context of each of our results in turn. In this section, we assume the underlying graph is the complete graph on $n$ vertices to more easily compare to previous work, although in the main body of the paper, we show our results apply more to generic underlying graphs with $n$ vertices and $m$ edges.

Cycle Detection

Cade et al. [7] describe a nearly optimal $\tilde{O}(n^{3/2})$ quantum query algorithm for cycle detection via reduction to $st$-connectivity, almost matching the lower bound of $\Omega(n^{3/2})$ [8]. In this work, we find an algorithm that removes the log-factors of the previous result, giving an algorithm with optimal $O(n^{3/2})$ query complexity. Moreover, our algorithm is simpler than that in Ref. [7]: their approach requires solving an $st$-connectivity problem within a Grover search, while our approach is entirely based on solving an $st$-connectivity problem.

We furthermore prove that if promised that (in the case of a cycle) the circuit rank of the graph is at least $r$ or (in the case of no cycles) there are at most $\mu$ edges, then the query complexity of cycle detection is $O(\mu\sqrt{n/r})$.

Bipartiteness

An optimal quantum query algorithm for bipartiteness was created by Āriņš [2], matching the lower bound of $\Omega(n^{3/2})$ [19]. However, this algorithm was not known to be time efficient (and did not use a reduction to $st$-connectivity, although the ideas are quite similar to the approach here and in [7]). In Ref. [7], Cade et al., using similar ideas as in their cycle detection algorithm, create a bipartiteness checking algorithm using a reduction to $st$-connectivity that is again embedded in a search loop, which is optimal up to logarithmic factors in query complexity. Our algorithm for bipartiteness removes the logarithmic factors of [7], and so recovers the optimal query complexity of [2], while retaining the simplicity of the reduction to $st$-connectivity.

Even-length Cycle Detection

The problem of detecting an even-length cycle can provide insight into the structure of the graph. For example, it is straightforward to see that in a graph with no even cycles, no edge can be involved in more than one cycle. Classically this problem requires $\Theta(n^{2})$ queries [17]. We are not aware of an existing quantum algorithm for this problem; we provide an $O(n^{3/2})$ query algorithm.

Estimation of Circuit Rank

Circuit rank parameterizes the number of cycles in a graph: it is the number of edges that must be removed before there are no cycles left in a graph. It has also been used to describe the complexity of computer programs [13]. We give an algorithm to estimate the circuit rank $r$ to multiplicative error $\epsilon$ with query complexity $\widetilde{O}\left(\epsilon^{-3/2}\sqrt{n^{4}/r}\right)$ in the generic case and query complexity $\widetilde{O}\left(\epsilon^{-3/2}\sqrt{n^{3}/r}\right)$ when promised that the graph is a cactus graph. When additionally promised that the circuit rank is large, these algorithms can have non-trivial query complexity. We are aware of no other classical or quantum query algorithms that determine or estimate this quantity.

Odd-length Path

We provide an algorithm to determine whether there is an odd-length path between two specified vertices that uses $O(n^{3/2})$ queries. While perhaps not the most interesting problem on its own, we effectively leverage this algorithm as a subroutine in several of our other constructions.

1.2 Open Problems

Throughout this paper, our strategy is to take a graph $G$, use it to create a new graph $G^{\prime}$, such that there is an $st$-path through $G^{\prime}$ if and only if $G$ has a certain property. We analyze the query complexity of the algorithms we create in detail, but not the time complexity. The time complexities of our algorithms depend on the time required to implement one step of a quantum walk on the graph $G^{\prime}$ (see $\mathsf{U}$ from Theorem 4 and Ref. [11]) 222In Ref. [7], they claim that their algorithms are time efficient, but their time analysis only considers the case of the underlying graph being the complete graph, while the actual graph used in their algorithms is not the complete graph. We expect that their algorithms can be implemented efficiently, but more work is needed to show this.. We strongly suspect that the highly structured nature of the graphs $G^{\prime}$ we consider would yield time-efficient algorithms, but we have not done a full analysis.

In the case of our algorithm for cycle detection, we create a graph $G^{\prime}$ whose effective resistance is the circuit rank of the original graph $G$. For the graphs we design for the other algorithms in this paper, do the effective resistance or effective capacitance have relevant meanings?

The query complexity of our algorithm for estimating the circuit rank of a graph depends on bounding a quantity called the approximate negative witness. While the best bound we currently have is $O(n^{4})$, we believe this is not tight. Obtaining a better bound would not only be interesting for these results, but could provide insight into more general quantum estimation algorithms.

Several of our results rely on a graph that tests for paths of odd length, i.e. those whose length modulo 2 is 1. Is there a way to adapt our algorithm to test for paths of arbitrary modulus?

Ref. [1] provides a list of complete problems for symmetric logarithmic space (SL), of which $st$-connectivity is one such problem. It would be interesting to study the query complexity of these problems to see if reducing to $st$-connectivity always gives an optimal approach.

Finally, it would be nice to improve the quantum lower bounds and classical bounds for several of these problems. In particular, we would like to obtain better quantum lower bounds for the even-length cycle detection and odd-length path detection problems. (For the later, the best quantum lower bound is $\Omega(n)$ [4].) We expect that the promise of large circuit rank also aids a classical algorithm for cycle detection, and it would be interesting to know by how much, in order to compare to our quantum algorithm.

2 Preliminaries

We consider undirected graphs $G=(V,E)$ where $V$ is a set of vertices and $E$ a set of edges; we often use $E(G)$ and $V(G)$ to denote the sets of edges and vertices of a graph $G$ when there are multiple graphs involved. If clear which graph we are referring to, we will use $n$ for the number of vertices in the graph, and $m$ for the number of edges. For ease of notation, we associate each edge with a unique label $\ell$. For example, we refer to an edge between vertices $u$ and $v$ labeled by $\ell$ as $\{u,v\}$, or simply as $\ell$. In general, we could consider a weighting function on the edges or consider graphs with multi-edges (see [10] for more details on how these modifications are implemented) but for our purposes, we will always consider all edges to have weight $1$, and we will only consider graphs with a at most a single edge between any two vertices.

We will use the following notation regarding spanning trees: if $G$ is a connected graph and $\ell\in E(G)$, then we use $t_{\ell}(G)$ to denote the number of unique spanning trees of $G$ that include edge $\ell$, and we use $t(G)$ to denote the total number of unique spanning trees of $G.$

In Section 3 we describe a quantum algorithm for estimating the circuit rank of a graph, which is a quantity that is relevant for a number of applications, like determining the robustness of a network, analyzing chemical structure [18], or parameterizing the complexity of a program [13].

Definition 1** (Circuit Rank).**

The circuit rank of a graph with $m$ edges and $n$ vertices is $m-n+\kappa$ where $\kappa$ is the number of connected components. Alternatively, the circuit rank of a graph is the minimum number of edges that must be removed to break all cycles and turn the graph into a tree or forest.

We also consider a special class of graphs called cactus graphs:

Definition 2**.**

A cactus graph is a connected graph in which any two simple cycles share at most one common vertex.

We will in particular use cactus forests, in which all components of the graph are cacti. For cactus forests, the circuit rank is simply the total number of cycles in the graph.

The final type of graph we need is the bipartite double graph:

Definition 3**.**

Given a graph $G$, the bipartite double of $G$, denoted $K^{G}$, is the graph that consists of two copies of the vertices of $G$ (with vertex $v\in V(G)$ labeled as $v_{0}$ in the first copy and $v_{1}$ in the second), with all original edges removed, and edges $\{u_{0},v_{1}\}$ and $\{v_{0},u_{1}\}$ created for each edge $\{u,v\}\in E(G).$ This graph is also known as the Kronecker cover of $G$, or $G\times K_{2}$, and its adjacency matrix is given by $G\otimes X$ (where $X$ is the Pauli $X$ operator.)

We associate edges of $G$ with literals of a string $x\in\{0,1\}^{N}$, where $N\leq|E|$, and a literal is either $x_{i}$ or $\overline{x}_{i}$ for $i\in[N]$. The subgraph $G(x)$ of $G$ contains an edge $\ell$ if $\ell$ is associated with $x_{i}$ and $x_{i}=1$, or if $\ell$ is associated with $\overline{x}_{i}$ and $x_{i}=0$. (See [10] for more details on this association.)

We assume that we have complete knowledge of $G$, and access to $x\in\{0,1\}^{N}$ via a black box unitary (oracle) $O_{x}$. This oracle acts as $O_{x}|i\rangle|b\rangle=|i\rangle|b\oplus x_{i}\rangle$, where $x_{i}$ is the $i\textsuperscript{th}$ bit of $x$. Then our goal is to use $O_{x}$ as few times as possible to determine a property of the graph $G(x).$ The number of uses of $O_{x}$ required for a given application is called the query complexity.

We will be applying and analyzing an algorithm for $st$-connectivity, which is the problem of deciding whether two nodes $s,t\in V(G)$ are connected in a graph $G(x)$, where $G$ is initially known, but $x$ must be determined using the oracle, and we are promised $x\in X$, where $X\subseteq\{0,1\}^{N}$. An $st$-path is a series of edges connecting $s$ to $t$.

Given two instances of $st$-connectivity, they can be combined in parallel, where the two $s$ vertices are identified and labeled as the new $s$, and the two $t$ vertices are identified and labeled as the new $t$. This new $st$-connectivity problem encodes the logical or of the original connectivity problems, in that the new graph is connected if and only if at least one of the original graphs was connected. Two instances of $st$-connectivity can also be combined in series, where the $s$ vertex of one graph is identified with the $t$ vertex of the other graph, and relabeled using a label not previously used for a vertex in either graph. This new $st$-connectivity encodes the logical and of the original connectivity problems, in that the new graph is connected if and only if both of the original graphs were connected. This correspondence was noted in [14] and applied to quantum query algorithms for Boolean formulas in [11] and for determining total connectivity in [10].

The key figures of merit for determining the query complexity of the span-program-based $st$-connectivity quantum algorithm are effective resistance and effective capacitance [10]. We use $R_{s,t}(G(x))$ to denote the effective resistance between vertices $s$ and $t$ in a graph $G(x)$, and we use $C_{s,t}(G(x))$ to denote the effective capacitance between vertices $s$ and $t$ in $G(x)$. These two functions were originally formulated to characterize electrical circuits, but are also important functions in graph theory. For example, effective resistance is related to the hitting time of a random walk on a graph. (See [6] for more information on effective resistance and capacitance in the context of graph theory.) For this paper, we don’t require a formal definition of these functions, but can instead use a few of their well known and easily derived properties (see [10] for formal definitions):

Effective Resistance

1. 1

If $G$ consists of a single edge between $s$ and $t$, and $G(x)=G$, then $R_{s,t}(G(x))=1$. 2. 2

If $s$ and $t$ are not connected in $G(x)$, then $R_{s,t}(G(x))=\infty$. 3. 3

If $G$ consists of subgraphs $G_{1}$ and $G_{2}$ connected in series as described above, then

$R_{s,t}(G(x))=R_{s,t}(G_{1}(x))+R_{s,t}(G_{2}(x))$. 4. 4

If $G$ consists of subgraphs $G_{1}$ and $G_{2}$ connected in parallel as described above, then

$\left(R_{s,t}(G(x))\right)^{-1}=\left(R_{s,t}(G_{1}(x))\right)^{-1}+\left(R_{s,t}(G_{2}(x))\right)^{-1}$. 5. 5

If $G(x)$ is a subgraph of $G(y)$, then $R_{s,t}(G(x))\geq R_{s,t}(G(y))$. 6. 6

If $s$ and $t$ are connected in $G(x)$, then $R_{s,t}(G(x))\leq d$, where $d$ is the length of the shortest path from $s$ to $t.$

Effective Capacitance

1. i

If $G$ consists of a single edge between $s$ and $t$, and $G(x)$ does not include the edge $\{s,t\}$, then $C_{s,t}(G(x))=1$. 2. ii

If $s$ and $t$ are connected in $G(x)$, then $C_{s,t}(G(x)=\infty$. 3. iii

If $G$ consists of subgraphs $G_{1}$ and $G_{2}$ connected in series as described above, then

$\left(R_{s,t}(G(x))\right)^{-1}=\left(R_{s,t}(G_{1}(x))\right)^{-1}+\left(R_{s,t}(G_{2}(x))\right)^{-1}$. 4. iv

If $G$ consists of subgraphs $G_{1}$ and $G_{2}$ connected in parallel, then

$R_{s,t}(G(x))=R_{s,t}(G_{1}(x))+R_{s,t}(G_{2}(x))$. 5. v

If $G(x)$ is a subgraph of $G(y)$, then $C_{s,t}(G(x))\leq C_{s,t}(G(y))$. 6. vi

If $s$ and $t$ are not connected in $G(x)$, $C_{s,t}(G(x))$ is less than the size of the smallest cut in $G$ between $s$ and $t$.

We analyze our algorithms using these properties rather than first principles to demonstrate the relative ease of bounding the query complexity of span program algorithms for $st$-connectivity problems.

Now we can describe the performance of the span program algorithm for deciding $st$-connectivity:

Theorem 4**.**

[10]** Let $G=(V,E)$ be a graph with $s,t\in V(G)$. Then there is a span program algorithm whose bounded-error quantum query complexity of evaluating whether $s$ and $t$ are connected in $G(x)$ promised $x\in X$ and $X\subseteq\{0,1\}^{N}$ is

[TABLE]

Furthermore, the space complexity is

[TABLE]

and the time complexity is $\mathsf{U}$ times the query complexity, where $\mathsf{U}$ is the time required to perform one step of a quantum walk on $G$ (see [11]).

Ito and Jeffery describe an algorithm that can be used to estimate $R_{s,t}(G(x))$. It depends on a quantity called the negative witness size, which we denote $\widetilde{R}_{-}(x,G)$ (this is the quantity $\widetilde{w}_{-}(x)$ of [9] tailored to the case of the $st$-connectivity span program). Let ${\mathcal{L}}(U,\mathbb{R})$ be the set of linear maps from a set $U$ to $\mathbb{R}$. Then we have the following definition

Definition 5** (See Theorem 4.2, [9]).**

Let $G=(V,E)$ with $s,t\in V$. If $G(x)$ is connected from $s$ to $t$, let $V_{x}\subseteq V$ be the set of vertices connected to both $s$ and $t$. Then there is a unique map ${\mathcal{V}}_{x}\in{\mathcal{L}}(V_{x},\mathbb{R})$ such that ${\mathcal{V}}_{x}(s)=1$, ${\mathcal{V}}_{x}(t)=0$, and $\sum_{\{u,v\}\in E(G(x))}\left({\mathcal{V}}_{x}(u)-{\mathcal{V}}_{x}(v)\right)^{2}$ is minimized. Then the negative approximate witness size of input $x$ on the graph $G$ is

[TABLE]

Theorem 6**.**

Let $G$ be a graph with $s,t\in V(G)$. Then the bounded-error quantum query complexity of estimating $R_{s,t}(G(x))$ to multiplicative error $\epsilon$ promised $s$ and $t$ are connected in $G(x)$ and $x\in X$ for $X\subseteq\{0,1\}^{N}$ is $\widetilde{O}\left(\epsilon^{-3/2}\sqrt{R_{s,t}(G(x))\widetilde{R}_{-}}\right)$, where $\widetilde{R}_{-}=\max_{x\in X}\widetilde{R}_{-}(x,G).$

3 Quantum Algorithms for Detecting and Characterizing Cycles

In this section, we prove the following results on detecting and characterizing cycles:

Theorem 7**.**

Let $G$ be the complete graph on $n$ vertices. If we are promised that either $G(x)$ is connected with circuit rank at least $r$, or $G(x)$ is not connected and contains at most $\mu$ edges, then the bounded-error quantum query complexity of detecting a cycle in $G(x)$ is $O(\mu\sqrt{n/r})$.

Theorem 8**.**

Given a generic graph $G$ with $m$ edges, and a parameter $\epsilon\ll 1$ (here $\epsilon$ can be a constant or can depend on the input) there is a quantum algorithm that estimates the circuit rank $r$ of $G(x)$ to multiplicative error $\epsilon$ using $\widetilde{O}\left(\epsilon^{-3/2}\sqrt{m\mu/r}\right)$ applications of $O_{x}$, under the promise that $G(x)$ has at most $\mu$ edges.

A few notes on these theorems:

• •

Theorem 7 has a worst case upper bound of $O(n^{3/2})$, which matches the optimal lower bound. This is because $r\geq 1$ ($r$ takes value $1$ in the case of a single cycle) and $\mu\leq n-1$ (since a graph without cycles must be a forest).

• •

In Theorem 8, if $r$ and $\epsilon$ are $O(1)$ and if nothing is known about $\mu$ (in which case it could be as large as $m$), one would need to query all edges of the graph. However, given a promise that $r$ is large, for example if $r=\Omega(m^{\beta})$ for a positive constant $\beta$, or a promise on $\mu$, we can do better than the trivial classical algorithm of querying all edges.

We prove both of these results using a reduction from cycle detection to $st$-connectivity. Specifically we construct a graph ${G_{\textrm{cyc}}}$ such that ${G_{\textrm{cyc}}}(x)$ has an $st$-path if and only if $G(x)$ has a cycle. We note that there is a cycle in $G(x)$ if and only if an edge $\{u,v\}$ is present in $G(x)$ and there is a path from $u$ to $v$ in $G(x)$ that does not use the edge $\{u,v\}.$ Thus, our reduction tests every edge in $G$ to determine whether these two conditions are satisfied. We use the encoding of logical and and or into $st$-connectivity using serial and parallel composition, as described in Section 2 and in Refs. [14, 11].

We now describe how to build up ${G_{\textrm{cyc}}}$ from simpler graphs. For an edge $\ell=\{u,v\}\in E(G)$ let $G^{-}_{\ell}$ be the graph that is the same as $G$, except with the edge $\ell$ removed, and the vertex $u$ labeled as $s$, and the vertex $v$ labeled as $t$. (The choice of which endpoint of $\ell$ is $s$ and which is $t$ is arbitrary - either choice is acceptable). Each edge in $G^{-}_{\ell}$ is associated with the same literal of $x$ as the corresponding edge in $G$. Thus there is an $st$-path in $G^{-}_{\ell}(x)$ if and only if there is a path between $u$ and $v$ in $G(x)$ that does not go through $\{u,v\}$.

Next, for an edge $\ell\in E(G)$ let $G^{1}_{\ell}$ be the graph with exactly two vertices labeled $s$ and $t$, and one edge between them. The one edge in $G^{1}_{\ell}$ is associated with the same literal bit of $x$ as $\ell$. Thus there is an $st$-path in $G^{1}_{\ell}(x)$ if and only if $\ell\in E(G(x))$.

Next, we create the graph $G_{\ell}$ by connecting $G^{1}_{\ell}$ and $G^{-}_{\ell}$ in series, while leaving the associations between edges and literals the same. Then because connecting $st$-connectivity graphs in series is equivalent to logical and, there is an $st$-path through $G_{\ell}(x)$ if and only if there is a cycle in $G(x)$ passing through $\ell$.

Finally, we create the graph ${G_{\textrm{cyc}}}$ by connecting all of the graphs $G_{\ell}$ (for each $\ell\in E(G)$) in parallel, again retaining the association between edges and literals. Since attaching graphs in parallel is equivalent to logical or, ${G_{\textrm{cyc}}}(x)$ has an $st$-path if and only if there is a cycle through some edge of $G(x)$. See Fig. 1 for an example of the construction of ${G_{\textrm{cyc}}}.$

In order to use Theorem 4 to determine the query complexity of deciding $st$-connectivity on ${G_{\textrm{cyc}}}(x)$, we next analyze the effective resistance (respectively capacitance) of ${G_{\textrm{cyc}}}(x)$ in the presence (resp. absence) of cycles in $G(x)$. We first show the following relationship between effective resistance and circuit rank:

Lemma 9**.**

Let $r$ be the circuit rank of $G(x)$. Then

[TABLE]

The proof of Lemma 9 uses the following result from Ref. [5] relating effective resistance and spanning trees:

Theorem 10**.**

[5]** Let $\{u,v\}=\ell$ be an edge in a connected graph $G$. Then the effective resistance between vertices $u$ and $v$ is equal to the number of spanning trees that include an edge $\ell$, divided by the total number of spanning trees:

[TABLE]

Proof of Lemma 9.

Using the rules that the effective resistance of graphs in series adds, (Effective Resistance Property 3), and the inverse effective resistance of graphs in parallel adds, (Effective Resistance Property 4), we have:

[TABLE]

(We include this relatively straightforward calculation in Appendix A.)

We next relate the righthand side of Eq. 6 to the circuit rank. Let $G(x)$ be a graph with $\kappa$ connected components. Let $g_{i}(x)$ be a subgraph consisting of the $i\textsuperscript{th}$ connected component of $G$, with $n_{i}$ vertices. We count the number of times edges are used in all spanning trees of $g_{i}(x)$ in two ways. First, we multiply the number of spanning trees by the number of edges in each spanning tree. Second, for each edge we add the number of spanning trees that include that edge. Setting these two terms equal, we have,

[TABLE]

Rearranging, and using Theorem 10 we have

[TABLE]

where if the sum has no terms (i.e. $E(g_{i}(x))=\varnothing$), we define it to be zero.

Summing over all $\kappa$ components of $G(x)$, we have

[TABLE]

Finally, using the fact that

[TABLE]

where $m$ is the number of edges in $G(x)$, and combining with Eq. 9, and Definition 1, we have

[TABLE]

Finally Eq. 11 and Eq. 6 give the result.

∎

We next analyze the effective capacitance of ${G_{\textrm{cyc}}}(x)$ in the case of no cycles in $G(x)$:

Lemma 11**.**

If $G$ is the complete graph on $n$ vertices and $G(x)$ has no cycles and at most $\mu$ edges, then, $C_{s,t}({G_{\textrm{cyc}}}(x))=O(n\mu^{2})$.

Proof.

We first analyze the effective capacitance of the subgraph $G_{\ell}(x)$ in two cases, when $\ell\in E(G(x))$ and when $\ell\notin E(G(x)).$

When $\ell\in E(G(x))$, then using Effective Capacitance Properties ii and iii, we have $C_{s,t}(G_{\ell}(x))=C_{s,t}(G^{-}_{\ell}(x))$. Then using Effective Capacitance Property vi, we have that $C_{s,t}(G^{-}_{\ell}(x))$ is less than the size of the cut between vertices $s$ and $t$ in $G^{-}_{\ell}(x)$. Since there are $\mu$ edges and $n$ vertices in $G(x)$, this quantity is bounded by $O(n\mu)$. (The worst case is when there are $\Omega(\mu)$ vertices connected to $s$, e.g.)

When $\ell\notin E(G(x))$, then using Effective Capacitance Properties i and iii, $C_{s,t}(G_{\ell}(x))=O(1)$.

Since there are $n-\mu$ graphs $G_{\ell}(x)$ with $\ell\notin E(G(x))$ and $\mu$ graphs $G_{\ell}(x)$ with $\ell\in E(G(x))$, using Effective Capacitance Property iv for graphs connected in parallel, we have that $C_{s,t}({G_{\textrm{cyc}}}(x))=O(\mu^{2}n).$ ∎

In order to prove Theorem 8, we need to analyze $\widetilde{R}_{-}(x,{G_{\textrm{cyc}}})$:

Lemma 12**.**

For a graph $G$ with $m$ edges, let $X=\{x:G(x)\textrm{ contains a cycle and }|E(G(x))|\leq\mu\}$ and let $\widetilde{R}_{-}=\max_{x\in X}\widetilde{R}_{-}(x,{G_{\textrm{cyc}}})$. Then $\widetilde{R}_{-}=O(m\mu).$

Proof.

Looking at Eq. 3, for $\ell\notin E(G(x))$, we have that all $v\in V(G_{\ell})$ (except $s$ and $t$) are not in $V_{x}$, so any choice of ${\mathcal{V}}$ on these vertices will give an upper bound on the minimizing map. We choose ${\mathcal{V}}(v)=0$ for these vertices to give us our bound, which contributes $1$ to the sum for each such subgraph. Thus edges in these subgraphs contribute $m-\mu$ to the total.

For $\ell\in E(G(x))$, for vertices in these subgraphs which are also part of $V_{x}$, they will get mapped by ${\mathcal{V}}_{x}$ to values between [math] and $1$ inclusive (since ${\mathcal{V}}_{x}$ can be seen as the voltage induced at each point by a unit potential difference between $s$ and $t$). If we choose the remaining vertices to also get mapped to values between [math] and $1$ by ${\mathcal{V}}$, we will again have an upper bound on the minimum. Then $\left({\mathcal{V}}(u)-{\mathcal{V}}(v)\right)^{2}\leq 1$ across all edges in these subgraphs. Since there are $m$ edges in each subgraph, and $\mu$ such subgraphs, edges in these subgraphs contributes $m\mu$ to the total.

Combining the two terms, we have that $\widetilde{R}_{-}(x,{G_{\textrm{cyc}}})\leq m-\mu+m\mu=O(m\mu).$ ∎

Now we can put these results together to prove Theorem 8:

Proof of Theorem 8.

Using Theorem 6, Lemma 9, and Lemma 12, we can estimate one over the circuit rank (i.e. $1/r$) to multiplicative error $\epsilon$. That is, we get an estimate of $1/r$ within $(1\pm\epsilon)/r$. Now if we take the inverse of this estimate, we get an estimate of of $r$ within $r/(1\pm\epsilon)$. But since $\epsilon\ll 1$, taking the Taylor expansion, we have $1/(1\pm\epsilon)\approx(1\pm\epsilon)$ to first order in $\epsilon$. ∎

4 Algorithms for Detecting Odd Paths, Bipartiteness, and Even Cycles

In this section, we note that a slight variation on one of the st-connectivity problems considered by Cade et al. in Ref. [7] can be used to detect odd paths and bipartiteness; furthermore the bipartiteness testing algorithm we describe is optimal in query complexity, and far simpler than the bipartiteness algorithm in [7]. We then use a similar construction to create a reduction from even-length cycle detection to $st$-connectivity.

All of these algorithms involve the bipartite double graph of the original graph. Given a graph $G$ with vertices $u$ and $v$, let ${K^{G}_{u,v}}$ be the bipartite double graph of $G$, with vertex $u_{0}$ relabeled as $s$, and vertex $v_{1}$ relabeled as $t$. To define ${K^{G}_{u,v}}(x)$, if $\{x,y\}\in E(G)$ is associated with a literal, then $\{x_{0},y_{1}\}$ and $\{x_{1},y_{0}\}$ in $E({K^{G}_{u,v}})$ are associated with the same literal.

We first show a reduction from detecting an odd-length path to $st$-connectivty on $K^{G}$:

Lemma 13**.**

Let $G$ be a graph with vertices $u$ and $v$. There is an odd-length path from $u$ to $v$ in $G(x)$ if and only if there is an $st$-path in ${K^{G}_{u,v}}(x)$

Proof.

Suppose there is an odd-length path from $u$ to $v$ in $G(x)$. Let the path be $u,\eta^{1},\eta^{2},\dots,\eta^{k},v$ where $k$ is an even integer greater than or equal to 0. Then there is a path $s,\eta^{1}_{1},\eta^{2}_{0},\dots,\eta^{k}_{0},t$, in ${K^{G}_{u,v}}(x)$ (where the path goes through $\eta^{i}_{i\mod 2}$). For the other direction, if there is a path from $s$ to $t$ in ${K^{G}_{u,v}}(x)$, there is an odd-length path from $u$ to $v$ in $G$. Note that any path in ${K^{G}_{u,v}}(x)$ must alternate between [math]- and $1$-labeled vertices. If there is a path that starts at a [math]-labeled vertex and ends at a $1$-labeled vertex, it must be an odd-length path. Then there must be the equivalent path in $G(x)$, but without the labeling. See Fig. 2 for an example of this reduction. ∎

Theorem 14**.**

Let $G$ be a graph with $n$ vertices and $m$ edges, with vertices $u$ and $v$. Then there is a bounded-error quantum query algorithm that detects an odd length path from $u$ to $v$ in $G$ using $O(\sqrt{nm})$ queries.

Proof.

Using Lemma 13 we reduce the problem to $st$-connectivity on ${K^{G}_{u,v}}$. Then using Theorem 4, we need to bound the largest effective resistance and effective capacitance of ${K^{G}_{u,v}}(x)$ for any string $x$. The longest possible path from $s$ to $t$ in ${K^{G}_{u,v}}(x)$ is $O(n)$ so by Effective Resistance Property 6, $R_{s,t}({K^{G}_{u,v}}(x))=O(n).$ The longest possible cut between $s$ and $t$ is $O(m)$, so by Effective Capacitance Property vi, $C_{s,t}({K^{G}_{s,t}}(x))=O(m).$ This gives the claimed query complexity. ∎

Note $u_{0}$ is connected to $u_{1}$ in $K^{G}(x)$ if and only if there is an odd-length path from $u$ to itself in $G(x),$ where this path is allowed to double back on itself, as in Fig. 3. This odd-length path in turn occurs if and only if the connected component of $G(x)$ that includes $u$ is not bipartite (has an odd cycle)! Thus if we are promised that $G(x)$ is connected, we can pick any vertex in $G$, run the algorithm of Theorem 14 on ${K^{G}_{u,u}}(x)$, and determine if the graph is bipartite, which requires $O(\sqrt{nm})$ queries.

On the other hand, if we are not promised that $G(x)$ is connected, we simply need to check whether there is an odd path from any of the $n$ vertices of $G$ to itself, and we now show that doing this check does not increase the query complexity. We use a similar strategy as with cycle detection:

Theorem 15**.**

Let $G$ be a graph with $n$ vertices and $m$ edges. Then there is a bounded-error quantum query algorithm that detects an odd cycle (in effect, non-bipartiteness) in $O(\sqrt{nm})$ queries.

Proof Sketch.

Let ${G_{\textrm{bip}}}$ be the graph that consists of the the graphs ${K^{G}_{u,u}}$ composed in parallel for all $u\in V(G)$. This amounts to evaluating the logical or of there being an odd cycle connected to any vertex in $G$.

A similar analysis as in cycle detection shows that the effective resistance of ${G_{\textrm{bip}}}$ is $O(1)$, if there is an odd cycle. On the other hand, since there are $n$ copies of $K^{G}$ in this new graph, and each copy has $m$ edges, the largest possible cut is $O(nm)$. Applying Theorem 4 gives the result. ∎

Finally, we show how to detect even cycles:

Theorem 16**.**

Let $G$ be a graph with $n$ vertices and $m$ edges. Then there is a bounded-error quantum query algorithm that detects an even-length cycle in $O(\sqrt{nm})$ queries.

Proof.

For an edge $\ell=\{u,v\}\in E(G)$, note that there is an $st$-path in $K^{G^{-}_{\ell}}_{u,v}$ if and only if there is an odd-length path from $u$ to $v$ that does not use the edge $\ell$ itself. Thus if we consider the graph composed of $G^{1}_{\ell}$ and $K^{G^{-}_{\ell}}_{u,v}$ in series, which we denote $G^{E}_{\ell}$, there is an $st$-path if and only if there is an even-length cycle through $\ell$. Finally, if we compose the graphs $G^{E}_{\ell}$ in parallel for all $\ell\in E(G)$, we obtain a graph that has an $st$-path if and only if there is an even cycle passing through some edge in $G$, as in Fig. 4.

As in our previous analyses of cycle detection and bipartiteness, if there is an even cycle, the effective resistance will be $O(1).$ On the other hand, if there is no even-length cycle, then it is a fairly well known fact that the number of edges in $G$ is $O(n)$. Then similar to previous analyses, for each graph $G^{E}_{\ell}$ such that $\ell\in E(G)$, we have that the cut is $O(m)$. Otherwise, for each graph $G^{E}_{\ell}$ such that $\ell\in E(G)$, we have that the cut is $O(1)$. Thus a bound on the size of the total cut is $O(n^{2}+nm)=O(nm)$ (assuming that $n=O(m)$.) Applying Theorem 4 gives the result. ∎

5 Acknowledgments

This research was sponsored by the Army Research Office and was accomplished under Grant Number W911NF-18-1-0286. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Army Research Office or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein.

Appendix A Effective Resistance of ${G_{\textrm{cyc}}}$

We relate the effective resistance across edges in $G$ to the effective resistance between $s$ and $t$ in ${G_{\textrm{cyc}}}$. (The proof also applies to $G(x)$ and ${G_{\textrm{cyc}}}(x)$.) We will write $R_{s,t}({G_{\textrm{cyc}}})$ in terms of a sum of $R_{u,v}(G)$ where $(u,v,\ell)$ is an edge on a cycle in $G$.

Consider an edge $\{u,v\}\in E(G)$. Then using Effective Resistance Property 4 (for graphs composed in parallel), we have

[TABLE]

Rearranging, we have

[TABLE]

Then using Effective Resistance Property 3 (for graphs composed in series), we have that

[TABLE]

Finally, using Effective Resistance Property 4 (graphs composed in parallel) again, we have

[TABLE]