Expansion Testing using Quantum Fast-Forwarding and Seed Sets

Expansion testing aims to decide whether an $n$-node graph has expansion at least $\Phi$, or is far from any such graph. We propose a quantum expansion tester with complexity $\widetilde{O}(n^{1/3}\Phi^{-1})$. This accelerates the $\widetilde{O}(n^{1/2}\Phi^{-2})$ classical tester by Goldreich and Ron [Algorithmica '02], and combines the $\widetilde{O}(n^{1/3}\Phi^{-2})$ and $\widetilde{O}(n^{1/2}\Phi^{-1})$ quantum speedups by Ambainis, Childs and Liu [RANDOM '11] and Apers and Sarlette [QIC '19], respectively. The latter approach builds on a quantum fast-forwarding scheme, which we improve upon by initially growing a seed set in the graph. To grow this seed set we borrow a so-called evolving set process from the graph clustering literature, which allows to grow an appropriately local seed set.


Introduction and Summary
The (vertex) expansion of a graph is a measure for how well connected the graph is. For an undirected graph G = (V, E), with |V| = n and |E| = m, it is defined as where ∂S is the set of nodes in V\S that have an edge going to S. See [LR99] for a discussion on the relevance of expansion for a range of graph approximation algorithms, and [HLW06] for a survey on expander graphs and their applications. Since exactly determining Φ(G) is an NP-hard problem [LRV13], we consider the relaxed objective of testing the expansion. Goldreich and Ron [GR02,GR11] initially studied this problem in the bounded-degree model, where they proposed the following question: given query acces to G, does it have expansion at least some Φ, or is it far from any graph having expansion Ω(Φ 2 )? In this model, given graphs G and G with degree bound d, G is -far from G if at least nd edges have to be added or removed from G to obtain G . They proved an Ω(n 1/2 ) lower bound on the query complexity of this problem, and proposed an elegant tester based on random walk collision counting with complexity 1 O(n 1/2 Φ −2 ).
In rough strokes, the algorithm picks a uniformly random node, and counts collisions between O(n 1/2 ) independent random walks of length O(Φ −2 ) all starting from this node. If the graph is far from being an expander, then the random walk will get stuck in certain low-expansion subsets, leading to an increased number of collisions. The graph is hence rejected if the number of collisions exceeds some constant.
? Figure 1: The GR tester counts collisions between independent random walks starting from some seed node. Low expansion of the graph results in an increased number of collisions.
Goldreich and Ron had to base the correctness of their tester on a certain unproven combinatorial conjecture. However, in later works by Czumaj and Sohler [CS10], Kale and Seshadhri [KS11] and Nachmias and Shapira [NS10] the correctness was unconditionally established. The ideas underlying this tester and its analysis were more recently extended towards testing the k-clusterability of a graph [CPS15, CKK + 18], which is a multipartite generalization of the expansion testing problem.
In this work we consider the expansion testing problem in the quantum setting, where we allow to perform queries in superposition. We refer to the nice survey by Montanaro and de Wolf [MdW16] for a general overview of quantum property testing. Ambainis, Childs and Liu [ACL11] were the first to describe a quantum algorithm for expansion testing. The gist of their algorithm is to combine an appropriate derandomization of the GR tester with Ambainis' quantum algorithm for element distinctness [Amb07]. The latter allows to count collisions among the set of O(n 1/2 ) random walk endpoints using only O(n 1/3 ) quantum queries. The improved complexity of their quantum expansion tester is In addition they proved an Ω(n 1/4 ) lower bound on the quantum query complexity.
In later work of the current author together with Sarlette [AS19], as well as in the current work, a very different approach is taken. Quantum walks, which form the quantum counterpart of random walks, are used to explore the graph. Rather than picking random neighbors, a quantum walk explores a graph through quantum queries to its neighborhood. In particular, this allows to create a "quantum sample" that appropriately encodes the random walk distribution. As we detail in Section 1.1 below, we can then use standard tools from quantum algorithms to estimate the random walk collision probability. In [AS19] we introduced a new quantum walk technique called "quantum fast-forwarding" (QFF) that allows to approximately prepare these quantum samples in the square root of the random walk runtime. This yielded a new quantum expansion tester with complexity quadratically improving the dependency of the GR tester on Φ, which corresponds to the random walk runtime. Up to this work, this left the problem of quantum expansion testing with two different testers with a complementary speedup. In this work, however, we present a new quantum tester which closes this gap. Essentially we improve the QFF tester from [AS19] by initially doing some classical work in the graph: from the initial node v, we first grow a local node subset or "seed set" of size n 1/3 . In earlier work by the author [A19] it was already shown that such seed sets allow to more efficiently create quantum samples, essentially by improving the projection of the initial state on the final quantum sample. Indeed, starting from this seed set, rather than directly from v, we can run the  QFF tester with an improved complexity O(n 1/3 Φ −1 ). To prove correctness of the tester, we must ensure that if the initial node v is inside some low-expansion set, then the seed set largely remains inside that set. Thereto we borrow a so-called "evolving set process" from the local graph clustering literature [AGPT16], allowing to grow such a set in complexity O(n 1/3 Φ −1 ). This allows to prove our main result: Theorem 1. There exists a quantum expansion tester with complexity O(n 1/3 Φ −1 ).
The resulting speedup combines the quantum speedups of [ACL11] and [AS19]. To summarize, we gather the different algorithms and approaches in Table 1.

QFF Tester
Our tester builds on the QFF tester from [AS19], hence we describe this tester first. Let P denote the random walk (RW) transition matrix, and P t |v the t-step RW probability distribution 2 starting from a node v. The tester builds on the observation that the squared 2-norm P t |v 2 exactly equals the collision probability of a pair of random walks: where we let X t denote the random walk position at time step t. Hence, we can estimate the collision probability between the t-step RW endpoints simply by estimating P t |v 2 . This we can do rather straightforwardly using quantum algorithms, in particular making use of quantum walks (QWs). Starting from an initial node v of the graph, a QW allows to generate the quantum sample which encodes the RW probability distribution P t |v as one of its component, with |Γ some auxiliary garbage component that is orthogonal to the RW component, and which we will not care about. Given the ability to generate such quantum samples, we can then use a standard quantum routine called quantum amplitude estimation to estimate the norm P t |v 2 of the RW component. Now, similarly to the GR tester, if we set t ∈ O(Φ −2 ) then we can reject the graph if P t |v 2 , and hence the collision probability, is larger than some threshold.
The amplitude estimation routine requires O( P t |v −1 ) quantum samples, so that the complexity of this quantum expansion tester is O( P t |v −1 QS t ), where QS t denotes the quantum complexity of creating the quantum sample |ψ t . If the graph is regular 3 then P has a uniform stationary distribution, i.e., the vector |π = n −1/2 u∈V |u is the unique eigenvalue-1 eigenvector of P . This allows to bound In order to bound QS t , we can use an existing QW approach by Watrous [Wat01] which gives QS t ∈ O(t). Since we choose t ∈ O(Φ −2 ), this yields a complexity O(n 1/2 Φ −2 ), thus giving no speedup with respect to the GR tester.
In [AS19] however, we introduced a more involved QW technique called quantum fastforwarding (QFF). Building on a Chebyshev truncation of the P t operator, this technique allows to quadratically improve the complexity to QS t ∈ O(t 1/2 ), resulting in a complexity Given that the GR tester has complexity O(n 1/2 Φ −2 ), this yields a complementary speedup to the O(n 1/3 Φ −2 ) expansion tester in [ACL11]. Whereas their speedup follows from a quantum routine for accelerating the collision counting procedure, the speedup in the QFF tester follows from accelerating the random walk runtime.

QFF Tester with Seed Sets
In this paper we refine the QFF tester, improving its complexity to O(n 1/3 Φ −1 ). We improve its suboptimal n 1/2 -dependency by initially constructing or "growing" a seed set around the initial node, from which we then run the QFF tester. This idea is derived from earlier work of the author [A19], where seed sets are used to create a superposition over the edges of a graph, leading to a similar speedup. The main insight is derived from the bound in (1), showing that the suboptimal n 1/2 -dependency stems from a small projection of the initial state |v onto the uniform superposition |π . Growing a seed set allows to improve this dependency: if we grow a set S ⊆ V from v, and we use the quantum superposition |S = |S| −1/2 u∈S |u as an initial state, this bound becomes This suggests the following new tester: (i) pick a uniformly random node v, (ii) grow a seed set S from v of appropriate size, and (iii) create O(n 1/2 |S| −1/2 ) QW samples |ψ t = P t |S +|Γ , allowing to estimate P t |S . Assuming that the construction of S requires |S| queries, and momentarily ignoring the Φ-dependency, this tester has a combined complexity of O(|S|+ P t |S −1 ) ∈ O(|S|+n 1/2 |S| −1/2 ). If we choose |S| = n 1/3 , this becomes O(n 1/3 ) as we aimed for. Using a similar reasoning as before, we again wish to reject the graph if our estimate is larger than some threshold. Indeed, as depicted in Figure 2, if the seed set is localized in some low-expansion set, then the 2-norm P t |S will be larger than when the graph has no low-expansion sets. The difficulty however is to ensure that the seed set S, when grown from some initial node v in a low-expansion set, effectively remains inside that set. If this is not the case, then a RW from S will no longer be stuck in the low-expansion set, thus no longer giving rise to an increased 2-norm. As a consequence, we cannot simply use a breadth-first search from v, as we did in [A19]: a BFS might exit a low-expansion set more easily than a random walk. Luckily, however, the problem of locally exploring a low-expansion set (or "cluster") turns out to be well-studied under the name "local graph clustering" [ST13, ACL06, AGPT16, OSV12].
? Figure 2: The new tester classically grows an appropriately local seed set around the initial node. From this set a quantum sample can be generated more efficiently. We use an evolving set process to ensure that the seed set mostly remains inside the initial low-expansion set.
In particular, we can use a so-called "evolving set process" (ESP) as used by Andersen, Oveis-Gharan, Peres and Trevisan in [AGPT16]. An ESP is a Markov chain on subsets of the nodes, which evolves by expanding or contracting its boundary based on the RW behavior on the graph. Given an initial node v inside a low-expansion set, they simulate an ESP to explicitly retrieve this set. Since we are interested in growing a potentially much smaller seed set S inside the cluster, we slightly adapt their algorithm, leading to the following result. The algorithm either returns a low-expansion set, allowing to immediately reject the graph, or it returns an appropriate seed set.
Building on this tool, we can now sketch our new quantum tester, summarized in Algorithm 1. Since the ESP process requires O(n 1/3 Φ −1 ) steps by the above proposition, and estimating P t |S requires O( P t |S Φ −1 ) ∈ O(n 1/3 Φ −1 ) steps, we retrieve the promised tester complexity O(n 1/3 Φ −1 ).

Algorithm 1 Quantum Expansion Tester
1: select a uniformly random starting node v 2: grow a seed set S from v using an ESP 3: if Φ(S) < Φ then reject 4: use quantum amplitude estimation to estimate P t |S for t ∈ O(Φ −1 ) 5: if P t |S too large then reject else accept

Open Questions
We finish this section by discussing some open questions related to this work.
• In [A19] a breadth-first search is used to grow a seed set S, requiring a number of steps O(|S|). In the current work we use a more refined ESP algorithm to grow S, which in particular ensures that the set remains inside some low-expansion subset (say with expansion at most Φ). This procedure however requires an increased number of steps O(|S|Φ −1 ). We leave it as an open question whether such an appropriate set can be grown in O(|S|) steps. The complexity of the tester then becomes O(|S| + n 1/2 |S| −1/2 Φ −1 ). Setting |S| = n 1/3 Φ −2/3 this would lead to an improved complexity O(n 1/3 Φ −2/3 ).
• The use of an ESP for the expansion testing problem could also be useful for improving the Φ-dependency of the classical GR tester. If we could for instance grow a pair of seed sets, both of size n 1/2 , that behave to some extent as "random subsets" of a local cluster, then we could simply count collisions between these sets, thus avoiding the use of random walks. A higher number of collisions would then again signal a low expansion of the graph. Ideally an ESP-like procedure would allow to grow these sets in O(n 1/2 Φ −1 ) steps, improving on the O(n 1/2 Φ −2 ) complexity of the GR tester.
• Clusterability testing, as recently studied in [CPS15, CKK + 18], uses very similar techniques to the GR expansion tester. It seems feasible that we can use the techniques from this paper to similarly improve on these testers.
• Goldreich and Ron [GR02] proved a classical lower bound Ω(n 1/2 ) for expansion testing, suggesting that their tester has an optimal dependency on n. In the quantum setting however, the only known lower bound is Ω(n 1/4 ) as proven by Ambainis, Childs and Liu [ACL11], thus leaving a large gap to all current quantum testers, which have a O(n 1/3 )-dependency. While our work does not provide any new insights towards closing this gap, we do feel that this is an interesting question to resolve.

Preliminaries
In this section we formalize the computational model, the query model and the definition of an expansion tester. We also describe some necessary random walk properties, and define the notion of a quantum walk.

Complexity, Computational Model and QRAM
The quantum query complexity of an algorithm simply denotes the number of quantum queries that the algorithm makes to the input (see Section 2.2 for details).
In contrast, the actual runtime or complexity of the algorithm is defined with respect to a computational model. We specify our computation model as a system that 1. can run quantum routines on O(log n) qubits, where n is the number of nodes in the input graph, 2. can make quantum queries to the input (see Section 2.2), and 3. has access to a quantum-read/classical-write RAM (QRAM) of O(n 1/3 ) classical bits. A single QRAM operation corresponds to either (i) classically writing a bit to the QRAM, or (ii) making a quantum query to bits stored in the QRAM.
By the complexity of an algorithm we denote the total number of (i) queries, (ii) elementary classical and quantum operations (gates), and (iii) QRAM operations. By definition, the complexity of an algorithm forms an upper bound on the query complexity of an algorithm, irrespective of the computational model or QRAM assumptions. Let S ⊂ V be a subset of nodes. As in [A19], we can use the QRAM to efficiently create, and reflect around, the quantum state |S = |S| −1/2 v∈S |v . To this end, we rely on the following theorem by Kerenidis and Prakash [KP17]. We make two final comments on our QRAM assumption, as it is often subject of debate. First, such an assumption is native to any quantum algorithm that makes use of quantum-accessible classical input or memory. We note that the actual qubits that a QRAM query acts on (i.e., the superposition of queried addresses plus the target register) is only logarithmic in the number of stored bits. In that sense our memory requirement is weaker than for instance that of Ambainis's element distinctness algorithm [Amb07] and its application in the quantum expansion tester of [ACL11], which effectively require a polynomial-sized memory of qubits. Second, as already pointed out above, the complexity is an upper bound on the query complexity, irrespective of the computational model or QRAM assumptions. In that sense, our work improves on the query complexity of the former works [ACL11, AS19], also without these assumptions.

Query Model and Property Testing
We are given query access to some undirected graph In the context of property testing of bounded-degree graphs [GR02], the following queries are allowed: • uniform node query: return uniformly random node v ∈ V • degree query: given v ∈ V, return degree d(v) • neighbor query: Throughout the paper we will assume that G is regular. If this is not the case, then we can always modify the graph to ensure this: to any node i with degree d(i) < d we add d − d(i) parallel self loops. This effectively renders the graph regular, ensuring that a random walk converges to the uniform distribution, as we will require later. Notably this does not change the expansion of the graph. Goldreich and Ron [GR11] achieve the same effect by modifying the random walk rather than the graph, but modifying the graph will prove more elegant for our purpose.
Since we wish to study quantum algorithms, we will allow to perform degree and neighbor queries in superposition. To illustrate this, assume that a neighbor query, given v ∈ V and k ∈ [d(v)], returns a node u. Using quantum notation, this is described as a unitary transformation |v |k |x → |v |k |x + u , where x is some arbitrary log n -bit string, and "+" denotes addition modulo log n . We can now imagine the first register being in a superposition d(v) −1/2 k∈[d(v)] |v |k |x , so that the query operation now becomes where we let u (k) denote the k-th neighbor of v. We will call a single such query a "quantum query". We refer the interested reader to the survey by Montanaro and de Wolf [MdW16] for more details on the quantum query model.
We will follow the property testing model for bounded-degree graphs by Goldreich and Ron [GR02]. Given two n-node graphs G = ([n], E) and G = ([n], E ) with degree bound d, they define the relative distance between G and G as the number of edges that needs to be added or removed to turn G into G , divided by the maximum number of edges nd. This is equal to |E E |/(nd), with the symmetric difference between E and E . G is then said to be -far from G if |E E |/(nd) ≥ . When studying a certain property P of graphs, G is said to be " -far from having property P " if G is -far from any graph G having property P .

Expansion Testing
We define the (vertex) expansion of a subset S ⊂ V as Φ(S) = |∂S|/|S|. Here ∂S = {u ∈ S c | ∃v ∈ S s.t. (u, v) ∈ E} is the set of nodes in S c that have an edge going to S. The expansion of a graph G is then defined as We consider the following definition of an expansion tester due to Czumaj and Sohler [CS10]. • if the graph has expansion at least Φ, then the algorithm outputs "accept" with probability at least 2/3, • if the graph is -far from any graph having expansion at least cΦ 2 log −1 (dn), then the algorithm outputs "reject" with probability at least 2/3.
We note that this is a slightly more constrained definition than the one in e.g. [KS11, ACL11, AS19]. In these works the log-factor in the reject case is actually left as an additional free parameter µ, which is compensated in the runtime. While our algorithm might also work in that more general setting, we believe that the corresponding technicalities would go beyond the scope and main ideas of this paper, and we leave it as a minor open question. We also mention that in the traditional setting of property testing, the expression "cΦ 2 log −1 (dn)" in the second bullet should be replaced by "Φ". Although unproven, the relaxation in this definition seems necessary to allow for efficient (sublinear) testing using random walks. This is a consequence of the fact that the expansion only characterizes the random walk mixing behavior up to a quadratic factor. We stress that this quadratic gap is present in all works on expansion testing. Apart from the vertex expansion, we also define the conductance. When studying random walks, this is often a slightly more appropriate measure. For a subset S ⊂ V it is defined as φ(S) = |E(S, S c )|/d(S), where E(S, S c ) = {(u, v) ∈ E | u ∈ S, v ∈ S c } denotes the set of edges between S to S c . The conductance of a graph G with m edges is then defined as φ(G) = min S⊂V:d(S)≤m/2 φ(S). If G is d-regular, as we will assume throughout the paper, this simplifies to φ(G) = min S⊂V:|S|≤n/2 |E(S, S c )|/(d|S|). Since |∂S| ≤ |E(S, S c )| ≤ d|∂S|, this allows to relate vertex expansion and conductance as follows:

Random Walks
We will consider lazy random walks (RWs), described by a Markov chain on the node set. From any node the RW jumps with probability 1/2 to any of its neighbors uniformly at random, and otherwise stands still. If we let P (u, v) denote the RW transition probability from node v to node u, then P (u, v) = 1/(2d(v)) for (v, u) ∈ E, P (u, v) = 1/2 if u = v and P (u, v) = 0 elsewhere. If the underlying graph is connected, then the RW converges to a unique limit distribution in which every node has a probability proportional to its degree. On a regular graph, this corresponds to a uniform distribution.

Diffusion Core
Central to the study of expansion testers is the so-called "diffusion core" of a set S ⊆ V. The diffusion core allows to lower bound the probability that a RW of given length stays entirely inside S, as a function of its conductance φ(S). Let τ v (S c ) denote the escape time of S from v, i.e., the hitting time of a RW from v ∈ S to the complement S c . We then define the diffusion core of S as follows: Definition 2. For α, β > 0, the (α, β)-diffusion core of S is defined as Throughout we define the "canonical" diffusion core S d = S 1/40,3/4 . Using a reasoning similar to Spielman and Teng [ST13], we can lower bound the size of the diffusion core.
Proof. Let Y v denote the event that τ v (S c ) > αφ(S) −1 , let π denote the stationary distribution of the RW, and let π S denote the distribution π conditioned on being in the set S: π S (v) = I(v ∈ S)π(v)/π(S). From [ST13, Proposition 2.5] we know that Combined with the former inequality, and the fact that π S (S α,β ) = d(S α,β )/d(S), this proves the claimed statement.
This lemma implies that d(S d )/d(S) > 19/20. As we will require this later, we also wish to prove something slightly stronger: there exists a subset S of the diffusion core S d , from which we can bound the probability that a random walk stays inside the diffusion core, rather than only inside S.
We will also use the following lemma, which in essence was already present in [CS10,NS10,KS11]. It argues that a graph which is -far from having a certain expansion must have a large subset with low expansion.
Lemma 3. Let G be an undirected n-node graph with degree bound d that is -far from having expansion ≥ β, with β ≤ 1/10. Then the following holds: • There exists a subset A ⊂ V, with n/12 ≤ |A| ≤ (1 + )n/2, such that Φ(A) < r d β, with r d a constant dependent on d.
• For any t ≤ 1/(2r d β) and distribution v having a γ-overlap with the diffusion core of A, with γ > 2(1 + )/3, it holds that Proof. The first bullet is proven in [CS10,Corollary 4.6]. To prove the second bullet, we use the fact that for a general probability distribution w it holds that with u the uniform distribution. This bound can be found in the proof of [CS10, Lemma 4.3]. To lower bound the right hand side, we will use that If w = P t v, we can lower bound (P t v)(A) since this represents the probability that a t-step RW from v end in A. By definition of the diffusion core, we know that a (t ≤ 1/(40Φ(A)))step RW, starting anywhere in the diffusion core A d of A, remains inside A with probability at least 3/4. Since v has a γ-overlap with A d , this proves that a (t ≤ 1/(40r d β))-step RW from v remains inside A with probability at least 3γ/4. This implies that (P t v)(A) ≥ 3γ/4 and hence P t v − u 1 ≥ 2|3γ/4 − u(A)|. By our assumption that γ > 2(1 + )/3, and since u(A) = |A|/n ≤ (1 + )/2, this implies that P t v − u 1 ≥ 2(3γ/4 − (1 + )/2). Combining this with the above inequality proves the claimed bound.

Quantum Walks
Quantum walks (QWs) form an elegant quantum counterpart to random walks on graphs.
They similarly explore a graph in a local manner, by performing queries in superposition to the neighbors of certain nodes, as illustrated in (2) in Section 2.2. In the following, let P be a symmetric random walk transition matrix (as will be the case for us), and let S ⊆ V be the initial seed set. We denote by |S = |S| −1/2 v∈S |v the quantum state that is a uniform superposition over nodes in S. Starting from |S , QWs allow to create a quantum state or "quantum sample" of the form Here the first component forms a quantum encoding of the RW probability distribution started from a uniformly random node in S. The second component denotes some auxiliary garbage state in which we will not be interested. In our earlier work on quantum expansion testing, we introduced a QW technique called "quantum fast-forwarding" (QFF) that allows to approximate the above quantum sample in the square root of the classical runtime. The following lemmas follow from [AS19], recalling that d M denotes the maximum degree of the graph.
Lemma 4 (QFF). Starting from the state |S , there exists a QW algorithm that outputs a state -close to the quantum sample |ψ t in complexity O(t 1/2 d 1/2 M log 1/2 (1/ )).
Proof. We first note that, starting from |S , the state |ψ t can be -approximated using a number of QW steps that scales as O(t 1/2 log 1/2 (1/ )) (hiding polylog-dependencies on t, n, ). An explicit statement of this fact can be found as Theorem 7 in [AGJK20]. Second we note that a single QW step can be implemented in complexity O(d For clarity of exposition, we will ignore the approximation error of QFF in the rest of the paper. By linearity it suffices to set inverse polynomially small in n, and so the approximation error will only add a log-factor to the overall complexity (this in contrast to the approximation error in the lemma below, which in fact is important).
Given access to such quantum samples, we can use a standard quantum routine called "quantum amplitude estimation" to estimate P t |S . This leads to the following lemma, which is an immediate corollary from [AS19, Theorem 5] and Lemma 4.
As discussed in Section 2.1 (and equal to the approach in [A19]), we can use a QRAM data structure to prepare and reflect around the quantum state |S . The effective complexity of these operations in our computation model is then O(1) (i.e., polylogarithmic in n).

Evolving Set Processes
Evolving Set Processes (ESPs) have been used for analyzing the mixing time of Markov chains [MP05], and as an algorithmic tool for performing local graph clustering [AP09,AGPT16]. Derived from some original Markov chain over a node set V, an ESP is a Markov chain over subsets of the node set. For our particular case we will assume that the original Markov chain corresponds to the (lazy) RW. Given that the current state of the ESP is S ⊆ V, its next state is then determined by the following rule: draw a variable U uniformly at random from the interval [0, 1], and set the next state Here P (S, v) denotes the probability that a single RW step from v ends up in S, and is given by P (v, S) = |E(v, S)|/(2d(v)) + I(v ∈ S)/2. This gives rise to an ESP transition matrix K : 2 V × 2 V → [0, 1]. Notice that only states in the inner or outer boundary of S can be added or removed: |E(v, S)| = d(v) and I(v ∈ S) = 1 if y and all of its neighbors lie in S, whereas |E(v, S)| = I(v ∈ S) = 0 if v nor any of its neighbors lie in S. This process has absorbing states S = ∅ and S = V, both of which have no boundary. For algorithmic purposes, it is desirable to prevent the ESP from being absorbed in the empty set. To this end, the transition probabilities can be slightly altered: Clearly the transition probability to the empty set is now equal to zero.K is again a stochastic transition matrix, and the resulting process is called the volume-biased ESP (yet for brevity we will simply refer to it as the ESP). We refer the reader to [AGPT16,LPW17] for more details on the ESP and its volume-biased variant. Starting inside some low-expansion set S, ESPs are used as a means of locally constructing or exploring S. In our case, we only wish to retrieve a smaller subset, typically of size |S| 1/3 . This subset however should be sufficiently localized "inside" S, i.e., have a sufficient overlap with the smaller diffusion core of S. To this end we refine the ESP analysis: we use our Lemma 2 to show that also the ESP will remain in the diffusion core with large probability. The following Section 3.1 introduces some useful properties of the ESP, and in Section 3.2 we prove the main tool.

ESP Complexity and Properties
As we wish to use an ESP as an algorithmic means, it is desirable to quantify the resources needed to simulate it. Thereto we define the cost of a sample path with d(S) the total degree of a subset S and S S the symmetric difference between S and S . We also define a stopping time τ (T, B, θ) for the ESP:

ESP for Growing Seed Set
Using known results on ESPs, combined with our new Lemma 2, we can derive the following theorem. This constitutes the main tool that we will use to grow seed sets. We defer the proof technicalities to Appendix A.

Quantum Expansion Tester
We are now ready to construct our new quantum expansion tester, yielding the main contribution of this paper.
Proof. First we prove that if Φ(G) ≥ Φ, then the algorithm accepts with probability at least 2/3. Thereto note that by definition of the vertex expansion, necessarily Φ(S) ≥ Φ(G) ≥ Φ if |S| ≤ n/2. Hence the algorithm cannot falsely reject in step 5. To exclude rejection in step 7, we use the result in [NS10, Proof of Theorem 2.1] showing that if Φ(G) ≥ Φ then for all nodes v ∈ V and time t ≥ 16d 2 Φ −2 log n it holds that P t |v ≤ n −1 (1 + n −1 ). This allows to bound P t |S ≤ |S| −1/2 s∈S P t |s ≤ |S|n −1 (1 + n −1 ). Using the 2-norm estimator from Lemma 5, the estimate a will with probability 1 − δ be such that a ≤ |S|n −1 (1 + n −1 ) + .
Step 7 will therefore reject falsely only with probability at most δ. The total probability of a faulty rejection can then be bounded by Kδ < 1/3. Since the algorithm accepts if it never rejects, it will correctly accept the graph with probability at least 2/3.
From A, we can define the diffusion core A d and the subset A ⊆ A d as in Lemma 2, which states that d(A ) > d(A)/3 and hence |A | ≥ |A|/3. The initial node v will hence be in A with probability at least |A|/(3n) ≥ /36. Conditioning on v ∈ A , we can analyze the ESP output set S using Theorem 4. We choose M = n 1/3 d . Using the bound (4), which by (3) implies the same upper bound for φ(A), S will with probability at least 1/5 be such that (i) d(S ∩ A d ) ≥ 3d(S)/4, and therefore |S ∩ A d | ≥ 3|S|/4, and (ii) either φ(S) ≤ Φ/(2d) or d(S) ≥ M . If φ(S) ≤ Φ/(2d) and |S| ≤ n/2, then we have a proof that G has vertex expansion Φ(G) ≤ Φ/2, and hence we reject the graph in step 5. To see this, simply note that φ(S) ≤ Φ/(2d) implies that Φ(S) ≤ Φ/2 (again by (3)). In any other case, we know that d(S) ≥ M and hence |S| ≥ M/d. Given such a set S, consider the uniform distribution π S over S. Since |S ∩ A d | ≥ 3|S|/4, we know that π S has a 3/4-overlap with A d . By the second bullet of Lemma 3 this implies that for all t ≤ log(dn)/(2r d cΦ 2 ) = 1200(2d) 2 log(dn)Φ −2 , using that γ = 3/4 and ≤ 1/16. By Lemma 5, the estimate a will then with probability 1 − δ be such that a ≥ |S|n −1 1 + 1/256 − . If ≤ |S|n −1 ( 1 + 1/256 − 1)/4, then this is strictly larger than |S|n −1 (1 + n −1 ) + for sufficiently large n, allowing to correctly reject the graph with probability at least 1 − δ. Now we can bound the total probability of correctly rejecting the graph in a single iteration. Thereto we multiply the probability that v ∈ A (≥ /36), the ESP process succeeds (≥ 1/5) and the 2-norm estimator succeeds (≥ 1 − δ), yielding a total rejection probability of at least p = (1−δ)/180. The total probability of correctly rejecting at least once in K iterations is therefore at least 1 − (1 − p) K . Using the elementary inequality (1 − p) 1/p < 1/e for any 0 < p ≤ 1, we can lower bound the rejection probability as provided that K ≥ ln(3)/p = 180 ln(3)/( (1 − δ)), which is ensured by our choice of K. This concludes the proof that Algorithm 2 is a (Φ, )-expansion tester. Towards bounding the complexity of the algorithm, we consider a single iteration of the for-loop. By Theorem 4, the complexity of simulating the ESP in step 4 is O(M θ −1 log 2 (dn)), which is O(n 1/3 d 2 Φ −1 log 2 (dn)). By Lemma 5, the ( , δ) 2-norm estimator in step 6 has complexity Since we iterate the for-loop K ∈ O( −1 ) times, this gives the claimed complexity.
Lemma 6 ([AGPT16, Theorem 5.4]). For any starting set S 0 and any stopping time τ that is upper bounded by T , it holds that E[cost τ /d(S τ )] ≤ 1 + 4 T log m.
Now if both cost τ > B andZ α hold, then using the bound B > 5αM . As a consequence, if both cost τ > B and Z α hold, then also Y holds, and so P(Y | cost τ > B) ≥ P(Z α cost τ > B). This gives the desired bound Finally we will upper bound P(τ = T ) using Lemma 8. For c = α this states that P min t<T φ(S t ) ≤ γ ≥ 1 − α −1 .