Span Programs and Quantum Space Complexity

TL;DR

This paper establishes a fundamental link between quantum space complexity and span program size, introducing approximate span programs and providing the first non-trivial lower bounds for explicit functions.

Contribution

It connects quantum space complexity to classical span program measures, introduces approximate span programs, and provides the first non-trivial lower bounds for explicit functions.

Findings

Quantum space complexity relates to the logarithm of span program size.

Approximate span programs generalize span program size for bounded error models.

First non-trivial lower bound established for an explicit function's approximate span program size.

Abstract

While quantum computers hold the promise of significant computational speedups, the limited size of early quantum machines motivates the study of space-bounded quantum computation. We relate the quantum space complexity of computing a function f with one-sided error to the logarithm of its span program size, a classical quantity that is well-studied in attempts to prove formula size lower bounds. In the more natural bounded error model, we show that the amount of space needed for a unitary quantum algorithm to compute f with bounded (two-sided) error is lower bounded by the logarithm of its approximate span program size. Approximate span programs were introduced in the field of quantum algorithms but not studied classically. However, the approximate span program size of a function is a natural generalization of its span program size. While no non-trivial lower bound is known on the span program size (or approximate span program size) of any concrete function, a number of lower bounds are known on the monotone span program size. We show that the approximate monotone span program size of f is a lower bound on the space needed by quantum algorithms of a particular form, called monotone phase estimation algorithms, to compute f. We then give the first non-trivial lower bound on the approximate span program size of an explicit function.

Equations

$${\mathsf{S}}_U(f)\ge \log \widetilde{\mathsf{SP}}(f).$$

$${\mathsf{S}}_U^1(f)\ge \log \mathsf{SP}(f).$$

$${\mathsf{S}}_U(f)\ge \Omega \left(\log \left(\frac{\frac{1}{2}\text{mbox}-\mathrm{rank}(M)}{{\max }_{i\in [n]}\mathrm{rank}(M\circ {\Delta }_i)}\right)\right),$$

$${\Vert A\Vert }_{\infty }=\underset{i,j}{\max }|A_{i,j}|,\text{mbox}and\Vert A\Vert =\max \{\Vert A|v⟩\Vert :\Vert |v⟩\Vert =1\}.$$

$$\mathrm{col}(A)=\mathrm{span}\{|v_k⟩{\}}_k,\mathrm{row}(A)=\mathrm{span}\{|u_k⟩{\}}_k,\ker (A)=\mathrm{row}(A{)}^{\perp },A^{+}=\sum _k\frac{1}{{\sigma }_k}|u_k⟩⟨v_k|.$$

$$U_T{\mathcal{O}}_x{U}_{T-1}\dots {\mathcal{O}}_x{\mathcal{U}}_1|0⟩$$

$$\frac{1}{\sqrt{T}}\sum _{t=0}^{T-1}|t⟩U^t|\psi ⟩,$$

$$U(2|\psi ⟩⟨\psi |-I)U^{†}(2\Pi -I)$$

$$w_{+}(x,P)=w_{+}(x)=\min \{{\Vert |w⟩\Vert }^2:|w⟩\in H(x),A|w⟩=|\tau ⟩\}.$$

$$W_{+}(P,D)=W_{+}=\underset{x\in P_1\cap D}{\max }{w}_{+}(x,P).$$

$$w_{-}(x,P)=w_{-}(x)=\min \{{\Vert ⟨\omega |A\Vert }^2:⟨\omega |\in \mathcal{L}(V,\mathbb{R}),⟨\omega |\tau ⟩=1,⟨\omega |A{\Pi }_{H(x)}=0\}.$$

$$W_{-}(P,D)=W_{-}=\underset{x\in P_0\cap D}{\max }{w}_{-}(x,P).$$

$$s^{\prime }(P)=\sum _{j,b}\dim (\mathrm{col}(A{\Pi }_{H_{j,b}}))=\sum _{j,b}\dim (\mathrm{row}(A{\Pi }_{H_{j,b}})).$$

$${\hat{W}}_{+}={\hat{W}}_{+}^{\kappa }(P,D)=\underset{x\in f^{-1}(1)}{\max }\min \left\{{\Vert |\hat{w}⟩\Vert }^2:A|\hat{w}⟩=|\tau ⟩,{\Vert {\Pi }_{H(x{)}^{\perp }}|\hat{w}⟩\Vert }^2\le \frac{\kappa }{W_{-}}\right\}.$$

$$\min \left\{{\Vert {\Pi }_{H(x{)}^{\perp }}|\hat{w}⟩\Vert }^2:A|\hat{w}⟩=|\tau ⟩\right\}=\frac{1}{w_{-}(x)}.$$

$${\widetilde{\mathsf{SP}}}_{\kappa }(f)\ge {\widetilde{\mathsf{SP}}}_{{\kappa }^{\prime }}(f{)}^{\frac{1}{2}\frac{\log \frac{1}{\kappa }}{\log \frac{1}{{\kappa }^{\prime }}}}-2.$$

$$\mathsf{m}{\widetilde{\mathsf{SP}}}_{\kappa }(f)\ge \mathsf{m}{\widetilde{\mathsf{SP}}}_{{\kappa }^{\prime }}(f{)}^{\frac{1}{2}\frac{\log \frac{1}{\kappa }}{\log \frac{1}{{\kappa }^{\prime }}}}-2.$$

$${\widetilde{\mathsf{SP}}}_{{\kappa }^{\prime }}(f)\le s(P^{\prime })={\left({\widetilde{\mathsf{SP}}}_{\kappa }(f)+2\right)}^{2\frac{\log \frac{1}{{\kappa }^{\prime }}}{\log \frac{1}{\kappa }}}.$$

$$A^{\prime }|j,b,k,0⟩=\mathrm{Re}\left(A|j,b,k⟩\right)|0⟩+\mathrm{Im}\left(A|j,b,k⟩\right)|1⟩$$

$$A^{\prime }|j,b,k,1⟩=\mathrm{Re}\left(A|j,b,k⟩\right)|1⟩-\mathrm{Im}\left(A|j,b,k⟩\right)|0⟩.$$

$$|\tau ⟩$$

$$=\mathrm{Re}(A\mathrm{Re}(|w⟩))+i\mathrm{Im}(A\mathrm{Re}(|w⟩))+i\mathrm{Re}(A\mathrm{Im}(|w⟩))-\mathrm{Im}(A\mathrm{Im}(|w⟩)).$$

$$|\tau ⟩=\mathrm{Re}(A\mathrm{Re}(|w⟩))-\mathrm{Im}(A\mathrm{Im}(|w⟩))\text{mbox}\text{and}\mathrm{Im}(A\mathrm{Re}(|w⟩))+\mathrm{Re}(A\mathrm{Im}(|w⟩))=0.$$

$$A^{\prime }|w^{\prime }⟩=\mathrm{Re}(A\mathrm{Re}(|w⟩))|0⟩+\mathrm{Im}(A\mathrm{Re}(|w⟩))|1⟩+\mathrm{Re}(A\mathrm{Im}(|w⟩))|1⟩-\mathrm{Im}(A\mathrm{Im}(|w⟩))|0⟩=|\tau ⟩|0⟩=|{\tau }^{\prime }⟩.$$

$$U(P,x)=(2{\Pi }_{\ker (A)}-I)(2{\Pi }_{H(x)}-I),$$

$${\Vert {\Pi }_{\Theta }|w_0⟩\Vert }^2\le {\Theta }^2{\hat{W}}_{+}+\frac{4\kappa }{W_{-}}.$$

$${\Pi }_{\mathrm{row}(A)}{\Pi }_{H(x)}|{\hat{w}}_x⟩+{\Pi }_{\mathrm{row}(A)}{\Pi }_{H(x{)}^{\perp }}|{\hat{w}}_x⟩=|w_0⟩.$$

$${\Vert {\Pi }_{\Theta }{\Pi }_{\mathrm{row}(A)}{\Pi }_{H(x)}|{\hat{w}}_x⟩\Vert }^2$$

$${\Vert {\Pi }_{\Theta }\left(|w_0⟩-{\Pi }_{\mathrm{row}(A)}{\Pi }_{H(x{)}^{\perp }}|{\hat{w}}_x⟩\right)\Vert }^2$$

$${\Vert {\Pi }_{\Theta }|w_0⟩\Vert }^2+{\Vert {\Pi }_{\Theta }{\Pi }_{\mathrm{row}(A)}{\Pi }_{H(x{)}^{\perp }}|{\hat{w}}_x⟩\Vert }^2-2⟨w_0|{\Pi }_{\Theta }{\Pi }_{\mathrm{row}(A)}{\Pi }_{H(x{)}^{\perp }}|{\hat{w}}_x⟩$$

$${\Vert {\Pi }_{\Theta }|w_0⟩\Vert }^2-2\Vert {\Pi }_{\Theta }|w_0⟩\Vert \Vert {\Pi }_{H(x{)}^{\perp }}|{\hat{w}}_x⟩\Vert$$

$${\Vert {\Pi }_{\Theta }|w_0⟩\Vert }^2-2\Vert {\Pi }_{\Theta }|w_0⟩\Vert \sqrt{\frac{\kappa }{W_{-}}}$$

$$\Vert {\Pi }_{\Theta }|w_0⟩\Vert$$

Full text

In the more natural bounded error model, we show that the amount of space needed for a unitary quantum algorithm to compute $f$ with bounded (two-sided) error is lower bounded by the logarithm of its approximate span program size. Approximate span programs were introduced in the field of quantum algorithms but not studied classically. However, the approximate span program size of a function is a natural generalization of its span program size.

While no non-trivial lower bound is known on the span program size (or approximate span program size) of any concrete function, a number of lower bounds are known on the monotone span program size. We show that the approximate monotone span program size of $f$ is a lower bound on the space needed by quantum algorithms of a particular form, called monotone phase estimation algorithms, to compute $f$. We then give the first non-trivial lower bound on the approximate span program size of an explicit function.

1 Introduction

While quantum computers hold the promise of significant speedups for a number of problems, building them is a serious technological challenge, and it is expected that early quantum computers will have quantum memories of very limited size. This motivates the theoretical question: what problems could we solve faster on a quantum computer with limited space? Or similarly, what is the minimum number of qubits needed to solve a given problem (and hopefully still get a speedup).

We take a modest step towards answering such questions, by relating the space complexity of a function $f$ to its span program size (see Definition 3.3), which is a measure that has received significant attention in theoretical computer science over the past few decades. Span programs are a model of computation introduced by Karchmer and Wigderson [KW93] in an entirely classical setting; they defined the span program size of a function in order to lower bound the size of counting branching programs. Some time later, Reichardt and Špalek [RŠ12] related span programs to quantum algorithms, and introduced the new measure of span program complexity (see Definition 3.4). The importance of span programs in quantum algorithms stems from the ability to compile any span program for a function $f$ into a bounded error quantum algorithm for $f$ [Rei09]. In particular, there is a tight correspondence between the span program complexity of $f$, and its quantum query complexity – a rather surprising and beautiful connection for a model originally introduced outside the realm of quantum computing. In contrast, the classical notion of span program size had received no attention in the quantum computing literature before now.

Ref. [IJ19] defined the notion of an approximate span program for a function $f$, and showed that even an approximate span program for $f$ can be compiled into a bounded error quantum algorithm for $f$. In this work, we further relax the definition of an approximate span program for $f$, making analysis of such algorithms significantly easier (see Definition 3.6).

Let $\mathsf{S}_{U}(f)$ denote the bounded error unitary space complexity of $f$, or the minimum space needed by a unitary quantum algorithm that computes $f$ with bounded error (see Definition 2.2). For a function $f:\{0,1\}^{n}\rightarrow\{0,1\}$, we can assume that the input is accessed by queries, so that we do not need to store the full $n$-bit input in working memory, but we need at least $\log n$ bits of memory to store an index into the input. Thus, a lower bound of $\omega(\log n)$ on $\mathsf{S}_{U}(f)$ for some $f$ would be non-trivial.

Letting $\mathsf{SP}(f)$ denote the minimum size of a span program deciding $f$, and $\widetilde{\mathsf{SP}}(f)$ the minimum size of a span program approximating $f$ (see Definition 3.7), we have the following (see Theorem 4.1):

Theorem 1.1** (Informal).**

For any Boolean function $f$, if $\mathsf{S}_{U}(f)$ denotes its bounded error unitary space complexity, and $\widetilde{\mathsf{SP}}(f)$ its approximate span program size, then

[TABLE]

Similarly, if $\mathsf{S}_{U}^{1}(f)$ denotes its one-sided error unitary space complexity, and $\mathsf{SP}(f)$ its span program size, then

[TABLE]

The relationship between span program size and unitary quantum space complexity is rather natural, as the span program size of $f$ is known to lower bound the minimum size of a symmetric branching program for $f$, and the logarithm of the branching program size of a function $f$ characterizes its classical deterministic space complexity.

The inequality $\mathsf{S}_{U}^{1}(f)\geq\log\mathsf{SP}(f)$ follows from a construction of [Rei09] for converting a one-sided error quantum algorithm for $f$ into a span program for $f$. We adapt this construction to show how to convert a bounded (two-sided) error quantum algorithm for $f$ with query complexity $T$ and space complexity $S\geq\log T$ into an approximate span program for $f$ with complexity $\Theta(T)$ and size $2^{\Theta(S)}$, proving $\mathsf{S}_{U}(f)\geq\Omega(\log\widetilde{\mathsf{SP}}(f))$. The connection between $\mathsf{S}_{U}(f)$ and $\log\widetilde{\mathsf{SP}}(f)$ is tight up to an additive term of the logarithm of the minimum complexity of any span program for $f$ with optimal size. This follows from the fact that an approximate span program can be compiled into a quantum algorithm in a way that similarly preserves the correspondence between space complexity and (logarithm of) span program size, as well as the correspondence between query complexity and span program complexity (see Theorem 3.1). While the preservation of the correspondence between query complexity and span program complexity (in both directions) is not necessary for our results, it may be useful in future work for studying lower bounds on time and space simultaneously.

The significance of Theorem 1.1 is that span program size has received extensive attention in theoretical computer science. Using results from [BGW99], the connection in Theorem 1.1 immediately implies the following (Theorem 4.2):

Theorem 1.2**.**

For almost all Boolean functions $f$ on $n$ bits, $\mathsf{S}_{U}^{1}(f)=\Omega({n})$.

If we make a uniformity assumption that the quantum space complexity of an algorithm is at least the logarithm of its time complexity, then Theorem 1.2 would follow from a lower bound of $\Omega(2^{n})$ on the quantum time complexity of almost all $n$-bit Boolean functions. Notwithstanding, the proof via span program size is evidence of the power of the technique.

In the pursuit of lower bounds on span program size of concrete functions, several nice expressions lower bounding $\mathsf{SP}(f)$ have been derived. By adapting one such lower bound on $\mathsf{SP}(f)$ to $\widetilde{\mathsf{SP}}(f)$, we get the following (see Lemma 4.6):

Theorem 1.3** (Informal).**

For any Boolean function $f$, and partial matrix $M\in(\mathbb{R}\cup\{\star\})^{f^{-1}(0)\times f^{-1}(1)}$ with $\left\|M\right\|_{\infty}\leq 1$:

[TABLE]

where $\circ$ denotes the entrywise product, and $\Delta_{i}[x,y]=1$ if $x_{i}\neq y_{i}$ and 0 else.

Above, $\frac{1}{2}$-rank denotes the approximate rank, or the minimum rank of any matrix $\widetilde{M}$ such that $|M[{x,y}]-\widetilde{M}[{x,y}]|\leq\frac{1}{2}$ for each $x,y$ such that $M[x,y]\neq\star$. If we replace $\frac{1}{2}$-rank$(M)$ with rank$(M)$, we get the logarithm of an expression called the rank measure, introduced by Razborov [Raz90]. The rank measure was shown by Gàl to be a lower bound on span program size, $\mathsf{SP}$ [Gàl01], and thus, our results imply that the log of the rank measure is a lower bound on $\mathsf{S}_{U}^{1}$. It is straightforward to extend this proof to the approximate case to get Theorem 1.3.

Theorem 1.3 seems to give some hope of proving a non-trivial – that is, $\omega(\log n)$ – lower bound on the unitary space complexity of some explicit $f$, by exhibiting a matrix $M$ for which the (approximate) rank measure is $2^{\omega(\log n)}$. In [Raz90], Razborov showed that the rank measure is a lower bound on the Boolean formula size of $f$, motivating significant attempts to prove lower bounds on the rank measure of explicit functions. The bad news is, circuit lower bounds have been described as “Complexity theory’s Waterloo” [AB09]. Despite significant effort, no non-trivial lower bound on span program size for any $f$ is known.

Due to the difficulty of proving explicit lower bounds on span program size, earlier work has considered the easier problem of lower bounding monotone span program size, $\mathsf{mSP}(f)$. For a monotone function $f$, the monotone span program size of $f$, $\mathsf{mSP}(f)$ is the minimum size of any monotone span program for $f$ (see Definition 5.1). We can similarly define the approximate monotone span program size of $f$, $\mathsf{m}\widetilde{\mathsf{SP}}(f)$ (see Definition 5.1). Although $\log\mathsf{m}\widetilde{\mathsf{SP}}(f)$ is not a lower bound on $\mathsf{S}_{U}(f)$, even for monotone $f$, it is a lower bound on the space complexity of any algorithm obtained by compiling a monotone span program. We show that such algorithms are equivalent to a more natural class of algorithms called monotone phase estimation algorithms. Informally, a phase estimation algorithm is an algorithm that works by performing phase estimation of some unitary that makes one query to the input, and estimating the amplitude on a 0 in the phase register (see Definition 5.12). A monotone phase estimation algorithm is a phase estimation algorithm where, loosely speaking, adding 0s to the input can only make the algorithm more likely to reject (see Definition 5.13). We can then prove the following (see Theorem 5.14):

Theorem 1.4** (Informal).**

For any Boolean function $f$, any bounded error monotone phase estimation algorithm for $f$ has space complexity at least $\log\mathsf{m}\widetilde{\mathsf{SP}}(f)$, and any one-sided error monotone phase estimation algorithm for $f$ has space complexity at least $\log\mathsf{mSP}(f)$.

Fortunately, non-trivial lower bounds for the monotone span program complexity are known for explicit functions. In Ref. [BGW99], Babai, Gàl and Wigderson showed a lower bound of $\mathsf{mSP}(f)\geq 2^{\Omega\left(\log^{2}(n)/\log\log(n)\right)}$ for some explicit function $f$, which was later improved to $\mathsf{mSP}(f)\geq 2^{\Omega(\log^{2}(n))}$ by Gàl [Gàl01]. In Ref. [RPRC16], a function $f$ was exhibited with $\mathsf{mSP}(f)\geq 2^{n^{\epsilon}}$ for some constant $\epsilon\in(0,1)$, and in the strongest known result, Pitassi and Robere exhibited a function $f$ with $\mathsf{mSP}(f)\geq 2^{\Omega(n)}$ [PR17]. Combined with our results, each of these implies a lower bound on the space complexity of one-sided error monotone phase estimation algorithms. For example, the result of [PR17] implies a lower bound of $\Omega(n)$ on the space complexity of one-sided error monotone phase estimation algorithms for a certain satisfiability problem $f$. This lower bound, and also the one in [RPRC16], are proven by choosing $f$ based on a constraint satisfaction problem with high refutation width, which is a measure related to the space complexity of certain classes of SAT solvers, so it is intuitively not surprising that these problems should require a large amount of space to solve with one-sided error.

For the case of bounded error space complexity, we also prove the following (see Theorem 5.3, Corollary 5.15):

Theorem 1.5** (Informal).**

There exists a function $f:\{0,1\}^{n}\rightarrow\{0,1\}$ such that any bounded error monotone phase estimation algorithm for $f$ has space complexity $(\log n)^{2-o(1)}$.

This lower bound is non-trivial, although much less so than the best known lower bound of $\Omega(n)$ for the one-sided case. Our result also implies a new lower bound of $2^{(\log n)^{2-o(1)}}$ on the monotone span program complexity of the function $f$ in Theorem 1.5.

To prove the lower bound in Theorem 1.5, we apply a new technique that leverages the best possible gap between the certificate complexity and approximate polynomial degree of a function, employing a function $g:\{0,1\}^{m^{2+o(1)}}\rightarrow\{0,1\}$ from [BT17]111An earlier version of this work used a function described in [ABK16] with a $7/6$-separation between certificate complexity and approximate degree. We thank Robin Kothari for pointing us to the improved result of [BT17]., whose certificate complexity is $m^{1+o(1)}$, and whose approximate degree is $m^{2-o(1)}$. Following a strategy of [RPRC16], we use this $g$ to construct a pattern matrix [She09] (see Definition 5.8) and use this matrix in a monotone version of Theorem 1.3 (see Theorem 5.4). The fact that certificate complexity and approximate degree of total functions are related by $\widetilde{\deg}_{1/3}(g)\leq C(g)^{2}$ for all $g$ is a barrier to proving a lower bound better than $(\log n)^{2}$ using this technique, but we also give a generalization that has the potential to prove significantly better lower bounds (see Lemma 5.11).

Discussion and open problems

The most conspicuous open problem of this work is to prove a lower bound of $\omega(\log n)$ on $\mathsf{S}_{U}(f)$ or even $\mathsf{S}_{U}^{1}(f)$ for some explicit decision function $f$. It is known that any space $S$ quantum Turing machine can be simulated by a deterministic classical algorithm in space $S^{2}$ [Wat99] so a lower bound of $\omega(\log^{2}n)$ on classical space complexity would also give a non-trivial lower bound on quantum space complexity. If anything, the relationship to span program size is evidence that this task is extremely difficult.

We have shown a lower bound of $2^{(\log n)^{2-o(1)}}$ on the approximate monotone span program complexity of an explicit monotone function $f$, which gives a lower bound of $(\log n)^{2-o(1)}$ on the bounded error space complexity needed by a quantum algorithm of a very specific form: a monotone phase estimation algorithm. This is much worse than the best bound we can get in the one-sided case: a lower bound of $\Omega(n)$ for some explicit function. An obvious open problem is to try to get a better lower bound on the approximate monotone span program complexity of some explicit function.

Our lower bound of $(\log n)^{2-o(1)}$ only applies to the space complexity of monotone phase estimation algorithms and does not preclude the existence of a more space-efficient algorithm for $f$ of a different form. We do know that phase estimation algorithms are fully general, in the sense that every problem has a space-optimal phase estimation algorithm. Does something similar hold for monotone phase estimation algorithms? This would imply that $\log\mathsf{m}\widetilde{\mathsf{SP}}(f)$ is a lower bound on $\mathsf{S}_{U}(f)$ for all monotone functions $f$.

In this work, we define an approximate version of the rank method, and monotone rank method, and in case of the monotone rank method, give an explicit non-trivial lower bound. The rank method is known to give lower bounds on formula size, and the monotone rank method on monotone formula size. An interesting question is whether the approximate rank method also gives lower bounds on some complexity theoretic quantity related to formulas.

Our results are a modest first step towards understanding unitary quantum space complexity, but even if we could lower bound the unitary quantum space complexity of an explicit function, there are several obstacles limiting the practical consequences of such a result. First, while an early quantum computer will have a small quantum memory, it is simple to augment it with a much larger classical memory. Thus, in order to achieve results with practical implications, we would need to study computational models that make a distinction between quantum and classical memories. We leave this as an important challenge for future work.

Second, we are generally only interested in running quantum algorithms when we get an advantage over classical computers in the time complexity, so results that give a lower bound on the quantum space required if we wish to keep the time complexity small, such as time-space lower bounds, are especially interesting. While we do not address time-space lower bounds in this paper, one advantage of the proposed quantum space lower bound technique, via span programs, is that span programs are also known to characterize quantum query complexity, which is a lower bound on time complexity. We leave exploration of this connection for future work.

We mention two previous characterizations of $\mathsf{S}_{U}(f)$. Ref. [JKMW09] showed that $\mathsf{S}_{U}(f)$ is equal to the logarithm of the minimum width of a matchgate circuit computing $f$, and thus our results imply that this minimum matchgate width is approximately equal to the approximate span program size of $f$. Separately, in Ref. [FL18], Fefferman and Lin showed that for every function $k$, inverting $2^{k(n)}\times 2^{k(n)}$ matrices is complete for the class of problems $f$ such that $\mathsf{S}_{U}(f)\leq k(n)$. Our results imply that evaluating an approximate span program of size $2^{k(n)}$ (for some suitable definition of the problem) is similarly complete for this class. Evaluating an approximate span program boils down to deciding if $\left\|A(x)^{+}{\lvert}w_{0}\rangle\right\|$, for some matrix $A(x)$ partially determined by the input $x$, and some initial state ${\lvert}w_{0}\rangle$, is below a certain threshold, so these results are not unrelated222Here, $A(x)=A\Pi_{H(x)}$, where $A$ is as in Definition 3.3, ${\lvert}w_{0}\rangle=A^{+}{\lvert}\tau\rangle$ for ${\lvert}\tau\rangle$ as in Definition 3.3, and $H(x)$ is as in Definition 3.4. Then one can verify that $w_{+}(x)=\left\|A(x)^{+}{\lvert}w_{0}\rangle\right\|^{2}$ (see Definition 3.4).. We leave exploring these connections as future work.

Organization

The remainder of this paper is organized as follows. In Section 2, we present the necessary notation and quantum algorithmic preliminaries, and define quantum space complexity. In Section 3, we define span programs, and describe how they correspond to quantum algorithms. In particular, we describe how a span program can be “compiled” into a quantum algorithm (Section 3.2), and how a quantum algorithm can be turned into a span program (Section 3.3), with both transformations moreorless preserving the relationships between span program size and algorithmic space, and between span program complexity and query complexity. From this correspondence, we obtain, in Section 4, expressions that lower bound the quantum space complexity of a function. While we do not know how to instantiate any of these expressions to get a non-trivial lower bound for a concrete function, in Section 5, we consider to what extent monotone span program lower bounds are meaningful lower bounds on quantum space complexity, and give the first non-trivial lower bound on the approximate monotone span program size of a function.

2 Preliminaries

We begin with some miscellaneous notation. For a vector ${\lvert}v\rangle$, we let $\left\|{\lvert}v\rangle\right\|$ denote its $\ell_{2}$-norm. In the following, let $A$ be a matrix with $i$ and $j$ indexing its rows and columns. Define:

[TABLE]

Following [ALSV13], define the $\varepsilon$-rank of a matrix $A$ as the minimum rank of any matrix $B$ such that $\left\|A-B\right\|_{\infty}\leq\varepsilon$. For a matrix $A$ with singular value decomposition $A=\sum_{k}\sigma_{k}{\lvert}v_{k}\rangle{\langle}u_{k}\rvert$, define:

[TABLE]

The following lemma, from [LMR*+*11], is useful in the analysis of quantum algorithms.

Lemma 2.1** (Effective spectral gap lemma).**

Fix orthogonal projectors $\Pi_{A}$ and $\Pi_{B}$. Let $U=(2\Pi_{A}-I)(2\Pi_{B}-I)$, and let $\Pi_{\Theta}$ be the orthogonal projector onto the $e^{i\theta}$-eigenspaces of $U$ such that $|\theta|\leq\Theta$. Then if $\Pi_{A}{\lvert}u\rangle=0$, $\left\|\Pi_{\Theta}\Pi_{B}{\lvert}u\rangle\right\|\leq\frac{\Theta}{2}\left\|{\lvert}u\rangle\right\|$.

In general, we will let $\Pi_{V}$ denote the orthogonal projector onto $V$, for a subspace $V$.

Unitary quantum algorithms and space complexity

A unitary quantum algorithm ${\cal A}=\{{\cal A}_{n}\}_{n\in\mathbb{N}}$ is a family (parametrized by $n$) of sequences of $2^{s(n)}$-dimensional unitaries $U_{1}^{(n)},\dots,U_{T(n)}^{(n)}$, for some $s(n)\geq\log n$ and $T(n)$. (We will generally dispense with the explicit parametrization by $n$). For $x\in\{0,1\}^{n}$, let ${\cal O}_{x}$ be the unitary that acts as ${\cal O}_{x}{\lvert}j\rangle=(-1)^{x_{j}}{\lvert}j\rangle$ for $j\in[n]$, and ${\cal O}_{x}{\lvert}0\rangle={\lvert}0\rangle$. We let ${\cal A}(x)$ denote the random variable obtained from measuring

[TABLE]

with some two-outcome measurement that should be clear from context. We call $T(n)$ the query complexity of the algorithm, and $S(n)=s(n)+\log T(n)$ the space complexity. By including a $\log T(n)$ term in the space complexity, we are implicitly assuming that the algorithm must maintain a counter to know which unitary to apply next. This is a fairly mild uniformity assumption (that is, any uniformly generated algorithm uses $\Omega(\log T)$ space), and it will make the statement of our results much simpler. The requirement that $s(n)\geq\log n$ is to ensure that the algorithm has enough space to store an index $i\in[n]$ into the input.

For a (partial) function $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$, we say that ${\cal A}$ computes $f$ with bounded error if for all $x\in D$, ${\cal A}(x)=f(x)$ with probability at least $2/3$. We say that ${\cal A}$ computes $f$ with one-sided error if in addition, for all $x$ such that $f(x)=1$, ${\cal A}(x)=f(x)$ with probability 1.

Definition 2.2** (Unitary Quantum Space).**

For a family of functions $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$, the unitary space complexity of $f$, $\mathsf{S}_{U}(f)$, is the minimum $S(n)$ such that there is a family of unitary quantum algorithms with space complexity $S(n)$ that computes $f$ with bounded error. Similarly, $\mathsf{S}_{U}^{1}(f)$ is the minimum $S(n)$ such that there is a family of unitary quantum algorithms with space complexity $S(n)$ that computes $f$ with one-sided error.

Remark 2.3**.**

Since $T$ is the number of queries made by the algorithm, we may be tempted to assume that it is at most $n$, however, while every $n$-bit function can be computed in $n$ queries, this may not be the case when space is restricted. For example, it is difficult to imagine an algorithm that uses $O(\log n)$ space and $o(n^{3/2})$ quantum queries to solve the following problem on $[q]^{n}\equiv\{0,1\}^{n\log q}$: Decide whether there exist distinct $i,j,k\in[n]$ such that $x_{i}+x_{j}+x_{k}=0\mod q$.

Phase estimation

For a unitary $U$ acting on $H$ and a state ${\lvert}\psi\rangle\in H$, we will say we perform $T$ steps of phase estimation of $U$ on ${\lvert}\psi\rangle$ when we compute:

[TABLE]

and then perform a quantum Fourier transform over $\mathbb{Z}/T\mathbb{Z}$ on the first register, called the phase register. This procedure was introduced in [Kit95]. It is easy to see that the complexity (either query or time) of phase estimation is $O(T)$ times the complexity of implementing a controlled call to $U$. The space complexity of phase estimation is $\log T+\log\mathrm{dim}(H)$. We will use the following properties:

Lemma 2.4** (Phase Estimation).**

If $U{\lvert}\psi\rangle={\lvert}\psi\rangle$, then performing $T$ steps of phase estimation of $U$ on ${\lvert}\psi\rangle$ and measuring the phase register results in outcome 0 with probability 1. If $U{\lvert}\psi\rangle=e^{i\theta}{\lvert}\psi\rangle$ for $|\theta|\in(\pi/T,\pi]$, then performing $T$ steps of phase estimation of $U$ on ${\lvert}\psi\rangle$ results in outcome 0 with probability at most $\frac{\pi}{T\theta}$.

We note that we can increase the success probability to any constant by adding some constant number $k$ of phase registers, and doing phase estimation $k$ times in parallel, still using a single register for $U$, and taking the majority. This still has space complexity $\log\dim H+O(\log T)$.

Amplitude estimation

For a unitary $U$ acting on $H$, a state ${\lvert}\psi_{0}\rangle\in H$, and an orthogonal projector $\Pi$ on $H$, we will say we perform $M$ steps of amplitude estimation of $U$ on ${\lvert}\psi\rangle$ with respect to $\Pi$ when we perform $M$ steps of phase estimation of

[TABLE]

on $U{\lvert}\psi\rangle$, then, if the phase register contains some $t\in\{0,\dots,M-1\}$, compute $\tilde{p}=\sin^{2}\frac{\pi t}{2M}$, which is an estimate of $\left\|\Pi U{\lvert}\psi\rangle\right\|^{2}$ in a new register. The (time or query) complexity of this is $O(M)$ times the complexity of implementing a controlled call to $U$, implementing a controlled call to $2\Pi-I$, and generating ${\lvert}\psi\rangle$. The space complexity is $\log T+\log\dim H+O(1)$. We have the following guarantee [BHMT02]:

Lemma 2.5**.**

Let $p=\left\|\Pi U{\lvert}\psi\rangle\right\|^{2}$. There exists $\Delta=\Theta(1/M)$ such that when $\tilde{p}$ is obtained as above from $M$ steps of amplitude estimation, with probability at least $1/2$, $\left|\tilde{p}-p\right|\leq\Delta$.

We will thus also refer to $M$ steps of amplitude estimation as amplitude estimation to precision $1/M$.

3 Span Programs and Quantum Algorithms

In Section 3.1, we will define a span program, its size and complexity, and what it means for a span program to approximate a function $f$. In Section 3.2, we will prove the following, which implies that the first part of Theorem 1.1 is essentially tight.

Theorem 3.1**.**

Let $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$, and let $P$ be a span program that $\kappa$-approximates $f$ with size $K$ and complexity $C$, for some constant $\kappa\in(0,1)$. Then there exists a unitary quantum algorithm ${\cal A}_{P}$ that decides $f$ with bounded error in space $S=O(\log K+\log C)$ using $T=O(C)$ queries to $x$.

Finally, in Section 3.3, we prove the following theorem, which implies Theorem 1.1:

Theorem 3.2**.**

Let $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$ and let ${\cal A}$ be a unitary quantum algorithm using $T$ queries, and space $S$ to compute $f$ with bounded error. Then for any constant $\kappa\in(0,1)$, there is a span program $P_{\cal A}$ with size $s(P_{\cal A})\leq 2^{O(S)}$ that $\kappa$-approximates $f$ with complexity $C_{\kappa}\leq O(T)$. If $\cal A$ decides $f$ with one-sided error, then $P_{\cal A}$ decides $f$.

3.1 Span Programs

Span programs were first introduced in the context of classical complexity theory in [KW93], where they were used to study counting classes for nondeterministic logspace machines. While span programs can be defined with respect to any field, we will consider span programs over $\mathbb{R}$ (or equivalently, $\mathbb{C}$, when convenient, see Remark 3.10). We use the following definition, slightly modified from [KW93]:

Definition 3.3** (Span Program and Size).**

A span program on $\{0,1\}^{n}$ consists of:

• •

Finite inner product spaces $\{H_{j,b}\}_{j\in[n],b\in\{0,1\}}\cup\{H_{\mathrm{true}},H_{\mathrm{false}}\}$. We define $H=\bigoplus_{j,b}H_{j,b}\oplus H_{\mathrm{true}}\oplus H_{\mathrm{false}}$, and for every $x\in\{0,1\}^{n}$, $H(x)=H_{1,x_{1}}\oplus\dots\oplus H_{n,x_{n}}\oplus H_{\mathrm{true}}$.333We remark that while $H_{\mathrm{true}}$ and $H_{\mathrm{false}}$ may be convenient in constructing a span program, they are not necessary. We can always consider a partial function $f^{\prime}$ defined on $(n+1)$-bit strings of the form $(x,1)$ for $x$ in the domain of $f$, as $f(x)$, and let $H_{n+1,1}=H_{\mathrm{true}}$ and $H_{n+1,0}=H_{\mathrm{false}}$.

• •

A vector space $V$.

• •

A target vector ${\lvert}\tau\rangle\in V$.444Although $V$ has no meaningful inner product, we use Dirac notation, such as ${\lvert}\tau\rangle$ and ${\langle}\omega\rvert$ for the sake of our fellow quantum computing researchers.

• •

A linear map $A:H\rightarrow V$.

We specify this span program by $P=(H,V,{\lvert}\tau\rangle,A)$, and leave the decomposition of $H$ implicit. The size of the span program is $s(P)=\dim H$.

To recover the classical definition from [KW93], we can view $A$ as a matrix, with each of its columns labelled by some $(j,b)\in[n]\times\{0,1\}$ (or “true” or “false”).

Span programs were introduced to the study of quantum query complexity in [RŠ12]. In the context of quantum query complexity, $s(P)$ is no longer the relevant measure of the complexity of a span program. Instead, [RŠ12] introduce the following measures:

Definition 3.4** (Span Program Complexity and Witnesses).**

For a span program $P=(H,V,{\lvert}\tau\rangle,A)$ on $\{0,1\}^{n}$ and input $x\in\{0,1\}^{n}$, we say $x$ is accepted by the span program if there exists ${\lvert}w\rangle\in H(x)$ such that $A{\lvert}w\rangle={\lvert}\tau\rangle$, and otherwise we say $x$ is rejected by the span program. Let $P_{0}$ and $P_{1}$ be respectively the set of rejected and accepted inputs to $P$. For $x\in P_{1}$, define the positive witness complexity of $x$ as:

[TABLE]

Such a ${\lvert}w\rangle$ is called a positive witness for $x$. For a domain $D\subseteq\{0,1\}^{n}$, we define the positive complexity of $P$ (with respect to $D$) as:

[TABLE]

For $x\in P_{0}$, define the negative witness complexity of $x$ as:

[TABLE]

Above, ${\cal L}(V,\mathbb{R})$ denotes the set of linear functions from $V$ to $\mathbb{R}$. Such an ${\langle}\omega\rvert$ is called a negative witness for $x$. We define the negative complexity of $P$ (with respect to $D$) as:

[TABLE]

Finally, we define the complexity of $P$ (with respect to $D$) by $C(P,D)=\sqrt{W_{+}W_{-}}$.

For $f:D\rightarrow\{0,1\}$, we say a span program $P$ decides $f$ if $f^{-1}(0)\subseteq P_{0}$ and $f^{-1}(1)\subseteq P_{1}$.

Definition 3.5**.**

We define the span program size of a function $f$, denoted $\mathsf{SP}(f)$, as the minimum $s(P)$ over families of span programs that decide $f$.

We note that originally, in [KW93], span program size was defined

[TABLE]

This could differ from $s(P)=\mathrm{dim}(H)=\sum_{j,b}\mathrm{dim}(H_{j,b})$, because $\mathrm{dim}(H_{j,b})$ might be much larger than $\mathrm{dim}(\mathrm{row}(A\Pi_{H_{j,b}}))$. However, if a span program has $\dim(H_{j,b})>\dim(\mathrm{row}(A\Pi_{H_{j,b}}))$ for some $j,b$, then it is a simple exercise to show that the dimension of $\dim(H_{j,b})$ can be reduced without altering the witness size of any $x\in\{0,1\}^{n}$, so the definition of $\mathsf{SP}(f)$ is the same as if we’d used $s^{\prime}(P)$ instead of $s(P)$. In any case, we will not be relying on previous results about the span program size as a black-box, and will rather prove all required statements, so this difference has no impact on our results.

While span program size has only previously been relevant outside the realm of quantum algorithms, the complexity of a span program deciding $f$ has a fundamental correspondence with the quantum query complexity of $f$. Specifically, a span program $P$ can be turned into a quantum algorithm for $f$ with query complexity $C(P,D)$, and moreover, for every $f$, there exists a span program such that the algorithm constructed in this way is optimal [Rei09]. This second direction is not constructive: there is no known method for converting a quantum algorithm with query complexity $T$ to a span program with complexity $C(P,D)=\Theta(T)$. However, if we relax the definition of which functions are decided by a span program, then this situation can be improved. The following is a slight relaxation of [IJ19, Definition 2.6]555Which was already a relaxation of the notion of a span program deciding a function..

Definition 3.6** (A Span Program that Approximately Decides a Function).**

Let $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$ and $\kappa\in(0,1)$. We say that a span program $P$ on $\{0,1\}^{n}$ $\kappa$-approximates $f$ if $f^{-1}(0)\subseteq P_{0}$, and for every $x\in f^{-1}(1)$, there exists an approximate positive witness ${\lvert}\hat{w}\rangle$ such that $A{\lvert}\hat{w}\rangle={\lvert}\tau\rangle$, and $\left\|\Pi_{H(x)^{\bot}}{\lvert}\hat{w}\rangle\right\|^{2}\leq\frac{\kappa}{W_{-}}$. We define the approximate positive complexity as

[TABLE]

If $P$ $\kappa$-approximates $f$, we define the complexity of $P$ (wrt. $D$ and $\kappa$) as $C_{\kappa}(P,D)=\sqrt{\widehat{W}_{+}W_{-}}$.

If $\kappa=0$, the span program in Definition 3.6 decides $f$ (exactly), and $\widehat{W}_{+}=W_{+}$. By [IJ19], for any $x$,

[TABLE]

Thus, since $W_{-}=\max_{x\in f^{-1}(0)}w_{-}(x)$, for every $x\in f^{-1}(0)$, there does not exist an approximate positive witness with $\left\|\Pi_{H(x)^{\bot}}{\lvert}\hat{w}\rangle\right\|^{2}<\frac{1}{W_{-}}$. Thus, when a span program $\kappa$-approximates $f$, there is a gap of size $\frac{1-\kappa}{W_{-}}$ between the smallest positive witness error $\left\|\Pi_{H(x)^{\bot}}{\lvert}\hat{w}\rangle\right\|^{2}$ of $x\in f^{-1}(1)$, the smallest positive witness error of $x\in f^{-1}(0)$.

Definition 3.7**.**

We define the $\kappa$-approximate span program size of a function $f$, denoted $\widetilde{\mathsf{SP}}_{\kappa}(f)$, as the minimum $s(P)$ over families of span programs that $\kappa$-approximate $f$. We let $\widetilde{\mathsf{SP}}(f)=\widetilde{\mathsf{SP}}_{1/4}(f)$.

We note that the choice of $\kappa=1/4$ in $\widetilde{\mathsf{SP}}(f)$ is arbitrary, as it is possible to modify a span program to reduce any constant $\kappa$ to any other constant without changing the size or complexity asymptotically. This convenient observation is formalized in the following claim.

Claim 3.8**.**

Let $P$ be a span program that $\kappa$-approximates $f:D\rightarrow\{0,1\}$ for some constant $\kappa$. For any constant $\kappa^{\prime}\leq\kappa$, there exists a span program $P^{\prime}$ that $\kappa^{\prime}$-approximates $f$ with $s(P^{\prime})=(s(P)+2)^{2\frac{\log\frac{1}{\kappa^{\prime}}}{\log\frac{1}{\kappa}}}$, and $C_{\kappa^{\prime}}(P^{\prime},D)\leq O\left(C_{\kappa}(P,D)\right)$.

We prove Claim 3.8 in Appendix A. We have the following corollary that will be useful later, where $\mathsf{m}\widetilde{\mathsf{SP}}_{\kappa}$ is the monotone approximate span program size, defined in Definition 5.1:

Corollary 3.9**.**

For any $\kappa,\kappa^{\prime}\in(0,1)$ with $\kappa^{\prime}<\kappa$, and any Boolean function $f$,

[TABLE]

If $f$ is monotone, we also have

[TABLE]

Proof.

Let $P$ $\kappa$-approximate $f$ with optimal size, so $s(P)=\widetilde{\mathsf{SP}}_{\kappa}(f)$. Then by Claim 3.8, there is a span program $P^{\prime}$ that $\kappa^{\prime}$-approximates $f$ with size

[TABLE]

The first result follows. The second is similar, but also includes the observation that if $P$ is monotone, so is $P^{\prime}$. ∎

Remark 3.10**.**

It can sometimes be useful to construct a span program over $\mathbb{C}$. However, for any span program over $\mathbb{C}$, $P$, there is a span program over $\mathbb{R}$, $P^{\prime}$, such that for all $x\in P_{0}$, $w_{-}(x,P^{\prime})\leq w_{-}(x,P)$, for all $x\in P_{1}$, $w_{+}(x,P^{\prime})\leq w_{+}(x,P)$, and $s(P^{\prime})\leq 2s(P)$. We define $P^{\prime}$ as follows. Without loss of generality, suppose $H_{j,b}=\mathrm{span}_{\mathbb{C}}\{{\lvert}j,b,k\rangle:k\in S_{j,b}\}$. Define $H^{\prime}_{j,b}=\mathrm{span}_{\mathbb{R}}\{{\lvert}j,b,k,a\rangle:k\in S_{j,b},a\in\{0,1\}\}$. Define

[TABLE]

[TABLE]

Finally, let ${\lvert}\tau^{\prime}\rangle={\lvert}\tau\rangle{\lvert}0\rangle$.

Suppose ${\lvert}w\rangle$ is a witness in $P$. Then

[TABLE]

Since we can assume ${\lvert}\tau\rangle$ is real, we have

[TABLE]

Define ${\lvert}w^{\prime}\rangle=\mathrm{Re}({\lvert}w\rangle){\lvert}0\rangle+\mathrm{Im}({\lvert}w\rangle){\lvert}1\rangle.$ Then

[TABLE]

Note that we have $\left\|{\lvert}w\rangle\right\|=\left\|{\lvert}w^{\prime}\rangle\right\|$. A similar argument holds for negative witnesses.

Thus, we will restrict our attention to real span programs, but still allow constructions of span programs over $\mathbb{C}$ (in particular, in Section 3.3 and Section 5.2.1).

3.2 From Span Programs to Quantum Algorithms

In this section, we will prove Theorem 3.1, which states that if a span program approximately decides a function $f$, then we can compile it to a quantum algorithm for $f$. While we hope that Theorem 3.1 will have applications in designing span program algorithms, its only relevance to the contents of this paper are its implications with respect to the tightness of the first lower bound expression in Theorem 4.1, and so this section can be safely skipped.

Theorem 3.1 is similar to [IJ19, Lemma 3.6], the difference here is we let an approximate positive witness for $x$ be any witness with error, $\left\|\Pi_{H(x)^{\bot}}{\lvert}w\rangle\right\|^{2}$, at most $\kappa/W_{-}$, whereas in [IJ19], it is required to have error as small as possible. This relaxation could potentially decrease the positive complexity $\widehat{W}_{+}$, since we now have more freedom in selecting positive witnesses, but more importantly, it makes it easier to analyze a span program, because we needn’t find the approximate positive witness with the smallest possible error. Importantly, this change in how we define a span program that approximates $f$ does not change the most important property of such a span program: that it can be compiled into a quantum algorithm for $f$. To show this, we now modify the proof of [IJ19, Lemma 3.6] to fit the new definition. We will restrict to span programs on binary strings $\{0,1\}^{n}$, but the proof also works for span programs on $[q]^{n}$ for $q>2$.

Proof of Theorem 3.1.

For a span program $P$ on $\{0,1\}^{n}$ and $x\in\{0,1\}^{n}$, define

[TABLE]

which acts on $H$. To prove Theorem 3.1, we will show that by performing phase estimation of $U(P,x)$ on initial state ${\lvert}w_{0}\rangle=A^{+}{\lvert}\tau\rangle$, and estimating the amplitude on having ${\lvert}0\rangle$ in the phase register, we can distinguish 1- and 0-inputs of $f$ with bounded error.

By Corollary A.2 and Claim 3.8, we can assume without loss of generality that $P$ has been scaled so that it $\kappa$-approximates $f$ for some $\kappa<1/4$, ${\lvert}w_{0}\rangle=A^{+}{\lvert}\tau\rangle$ is a unit vector, and $W_{-}\leq 2$. The scaled span program still has size $K^{O(1)}$ and complexity $O(C)$.

We first modify the proof of [IJ19, Lemma 3.2] to get the following lemma:

Lemma 3.11**.**

Let $P$ be a span program that $\kappa$-approximates $f$, with $\left\|{\lvert}w_{0}\rangle\right\|^{2}=1$. Fix any $\Theta\in(0,\pi)$, and let $\Pi_{\Theta}$ be the projector onto the $e^{i\theta}$-eigenspaces of $U(P,x)$ with $|\theta|\leq\Theta$. For any $x\in f^{-1}(1)$,

[TABLE]

Proof.

Suppose $x\in f^{-1}(1)$ and let ${\lvert}\hat{w}_{x}\rangle$ be an approximate positive witness with $\left\|\Pi_{H(x)^{\bot}}{\lvert}\hat{w}_{x}\rangle\right\|^{2}\leq\frac{\kappa}{W_{-}}$ and $\left\|{\lvert}\hat{w}_{x}\rangle\right\|^{2}\leq\widehat{W}_{+}$. Note that since $A{\lvert}\hat{w}_{x}\rangle={\lvert}\tau\rangle$, $\Pi_{\mathrm{row}(A)}{\lvert}\hat{w}_{x}\rangle=A^{+}A{\lvert}\hat{w}_{x}\rangle=A^{+}{\lvert}\tau\rangle={\lvert}w_{0}\rangle$, so

[TABLE]

Since $\Pi_{H(x)^{\bot}}\Pi_{H(x)}{\lvert}\hat{w}_{x}\rangle=0$, we have, by the effective spectral gap lemma (Lemma 2.1):

[TABLE]

This is satisfied only when

[TABLE]

We will let $\Theta^{2}=\frac{1-4\kappa}{2\widehat{W}_{+}W_{-}}$. Then when $f(x)=0$, we have

[TABLE]

by [IJ19, Lemma 3.3]. On the other hand, when $f(x)=1$, we have:

[TABLE]

We want to distinguish these two cases using $1/\Theta$ steps of phase estimation, and then estimating the amplitude on having an estimate of 0 in the phase register to precision:

[TABLE]

This will allow us to distinguish between amplitude $\geq q_{0}$ and amplitude $\leq q_{1}$. Since $\kappa<\frac{1}{4}$ is a constant, $\Delta=\Omega(1/W_{-})$, and thus we use $O(1/\Delta)=O(W_{-})=O(1)$ (recall that we are assuming the span program has been scaled) calls to phase estimation, each of which requires $O(1/\Theta)=O\left(\sqrt{\widehat{W}_{+}W_{-}}\right)=O(C)$ controlled calls to $U$ (for more details, see the nearly identical proof of [IJ19, Lemma 3.2]). Since $U(P,x)$ can be implemented in cost one query, the query complexity of this algorithm is $O(C)$.

The algorithm needs a single register of dimension $\dim H=K^{O(1)}$ to apply $U(P,x)$, $O(1)$ registers of dimension $1/\Theta$ to act as phase registers in phase estimation, and $O(1)$ registers of dimension $O(1/\Delta)$ to act as phase registers in the amplitude estimation, for a total space requirement of

[TABLE]

To complete the proof, we note that the algorithm is unitary, since it consists of phase estimation, composed unitarily with amplitude estimation. ∎

3.3 From Quantum Algorithms to Span Programs

In this section, we will show how to turn a unitary quantum algorithm into a span program, proving Theorem 3.2, which implies Theorem 1.1. The construction we use to prove Theorem 3.2 is based on a construction of Reichardt for turning any one-sided error quantum algorithm into a span program whose complexity matches the algorithm’s query complexity [Rei09, arXiv version]. We observe that a similar construction also works for two-sided error algorithms,666A preliminary version of this result appeared in [Jef14], but there was an error in the proof, which is fixed by our new definition of approximate span programs. but the resulting span program only approximately decides $f$.

The algorithm

Fix a function $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$, and a unitary quantum algorithm ${\cal A}$ such that on input $x\in f^{-1}(0)$, $\Pr[{\cal A}(x)=1]\leq\frac{1}{3}$, and on input $x\in f^{-1}(1)$, $\Pr[{\cal A}(x)=1]\geq 1-\varepsilon$, for $\varepsilon\in\{0,\frac{1}{3}\}$, depending on whether we want to consider a one-sided error or a bounded error algorithm. Let $p_{0}(x)=\Pr[{\cal A}(x)=0]$, so if $f(x)=0$, $p_{0}(x)\geq 2/3$, and if $f(x)=1$, $p_{0}(x)\leq\varepsilon$.

We can suppose ${\cal A}$ acts on three registers: a query register $\mathrm{span}\{{\lvert}j\rangle:j\in[n]\cup\{0\}\}$; a workspace register $\mathrm{span}\{{\lvert}z\rangle:z\in{\cal Z}\}$ for some finite set of symbols ${\cal Z}$ that contains 0; and an answer register $\mathrm{span}\{{\lvert}a\rangle:a\in\{0,1\}\}$. The query operator ${\cal O}_{x}$ acts on the query register as ${\cal O}_{x}{\lvert}j\rangle=(-1)^{x_{j}}{\lvert}j\rangle$ if $j\geq 1$, and ${\cal O}_{x}{\lvert}0\rangle={\lvert}0\rangle$. If ${\cal A}$ makes $T$ queries, the final state of ${\cal A}$ is:

[TABLE]

for some unitaries $U_{2T+1},\dots,U_{1}$. The output bit of the algorithm, ${\cal A}(x)$, is obtained by measuring the answer register of ${\lvert}\Psi_{2T+1}(x)\rangle$. We have given the input-independent unitaries odd indicies so that we may refer to the $t$-th query as $U_{2t}$.

Let ${\lvert}\Psi_{0}(x)\rangle={\lvert}\Psi_{0}\rangle={\lvert}0,0,0\rangle$ denote the starting state, and for $t\in\{1,\dots,2T+1\}$, let ${\lvert}\Psi_{t}(x)\rangle=U_{t}\dots U_{1}{\lvert}\Psi_{0}\rangle$ denote the state after $t$ steps.

The span program

We now define a span program $P_{\cal A}$ from ${\cal A}$. The space $H$ will represent all three registers of the algorithm, with an additional time counter register, and an additional register to represent a query value $b$.

[TABLE]

We define $V$ and $A$ as follows, where $c$ is some constant to be chosen later:

[TABLE]

For $t\leq 2T$, $A{\lvert}t,b,j,z,a\rangle$ should be intuitively understood as applying $U_{t+1}$ to ${\lvert}j,z,a\rangle$, and incrementing the counter register from ${\lvert}t\rangle$ to ${\lvert}t+1\rangle$. When $t$ is even, this correspondence is clear (in that case, the value of $b$ is ignored). When $t$ is odd, so $U_{t+1}={\cal O}_{x}$, then as long as $b=x_{j}$, $(-1)^{b}{\lvert}t+1,j,z,a\rangle={\lvert}t+1\rangle U_{t+1}{\lvert}j,z,a\rangle$. We thus define

[TABLE]

For even $t$, applying $U_{t+1}$ is independent of the input, so we make the corresponding states available to every input; along with states where the query register is set to $j=0$, meaning ${\cal O}_{x}$ acts input-independently; and accepting states, whose answer register is set to 1 at time $2T+1$:

[TABLE]

The remaining part of $H$ will be assigned to $H_{\mathrm{false}}$:

[TABLE]

Note that in defining $A$, we have put a large factor of $\sqrt{cT}$ in front of $A{\lvert}2T+1,0,j,z,0\rangle$, making the vectors in $H_{\mathrm{false}}$ very “cheap” to use. These vectors are never in $H(x)$, but will be used as the error part of approximate positive witnesses, and the $\sqrt{cT}$ ensures they only contribute relatively small error.

Finally, we define:

[TABLE]

Intuitively, we can construct ${\lvert}\tau\rangle$, the initial state, using a final state that has 1 in the answer register, and using the transitions ${\lvert}t,j,z,a\rangle-{\lvert}t+1\rangle U_{t+1}{\lvert}j,z,a\rangle$ to move from the final state to the initial state. In the following analysis, we make this idea precise.

Analysis of $P_{\cal A}$

We will first show that for every $x$ there is an approximate positive witness with error depending on its probability of being rejected by $\cal A$, $p_{0}(x)$.

Lemma 3.12**.**

For any $x\in\{0,1\}^{n}$, there exists an approximate positive witness ${\lvert}w\rangle$ for $x$ in $P_{\cal A}$ such that:

[TABLE]

In particular, if $f(x)=1$,

[TABLE]

Proof.

Let $Q_{x}$ be the linear isometry that acts as

[TABLE]

where we interpret $x_{0}$ as 0. Note that for all ${\lvert}j,z,a\rangle$, and $t\in\{0,\dots,2T\}$, we have

[TABLE]

Let $\Pi_{a}=\sum_{j\in[n]\cup\{0\},z\in{\cal Z}}{\lvert}j,z,a\rangle{\langle}j,z,a\rvert$ be the orthogonal projector onto states of the algorithm with answer register set to $a$. We will construct a positive witness for $x$ from the states of the algorithm on input $x$, as follows:

[TABLE]

To see that this is a positive witness, we compute $A{\lvert}w\rangle$, using the fact that $U_{t+1}{\lvert}\Psi_{t}(x)\rangle={\lvert}\Psi_{t+1}(x)\rangle$:

[TABLE]

We next consider the error of ${\lvert}w\rangle$ for $x$, given by $\left\|\Pi_{H(x)^{\bot}}{\lvert}w\rangle\right\|^{2}$. Since $Q_{x}{\lvert}j,z,a\rangle\in H(x)$ for all $j,z,a$, and ${\lvert}2T+1,0\rangle\Pi_{1}{\lvert}\Psi_{2T+1}(x)\rangle\in H_{\mathrm{true}}\subset H(x)$, $\Pi_{H(x)^{\bot}}{\lvert}w\rangle=\frac{1}{\sqrt{cT}}{\lvert}2T+1\rangle{\lvert}0\rangle\Pi_{0}{\lvert}\Psi_{2T+1}(x)\rangle$, so

[TABLE]

Finally, we compute the positive witness complexity of ${\lvert}w\rangle$:

[TABLE]

Next, we upper bound $w_{-}(x)$ whenever $f(x)=0$:

Lemma 3.13**.**

For any $x$ that is rejected by $\cal A$ with probability $p_{0}(x)>0$,

[TABLE]

In particular, if $f(x)=0$, $w_{-}(x)\leq\frac{c+4}{2/3}T$, so $W_{-}\leq\frac{c+4}{2/3}T$.

Proof.

We will define a negative witness for $x$ as follows. First, define

[TABLE]

the rejecting part of the final state. This is non-zero whenever $p_{0}(x)>0$. Then for $t\in\{0,\dots,2T\}$, define

[TABLE]

From this we can define

[TABLE]

We first observe that

[TABLE]

Thus

[TABLE]

is a negative witness. Next, we show that ${\langle}{\omega}\rvert A\Pi_{H(x)}=0$. First, for ${\lvert}t,x_{j},j,z,a\rangle\in H_{j,x_{j}}$ (so $t<2T$ is odd), we have

[TABLE]

The same argument holds for ${\lvert}t,0,0,j,z,a\rangle\in H_{\mathrm{true}}$. Similarly, for any ${\lvert}t,b,j,z,a\rangle\in H_{\mathrm{true}}$ with $t\leq 2T$ even, we have

[TABLE]

Finally, for any ${\lvert}2T+1,b,j,z,1\rangle\in H_{\mathrm{true}}$, we have

[TABLE]

Thus ${\langle}\omega\rvert A\Pi_{H(x)}=0$ and so ${\langle}\bar{\omega}\rvert A\Pi_{H(x)}=0$, and ${\langle}\bar{\omega}\rvert$ is a negative witness for $x$ in $P$. To compute its witness complexity, first observe that ${\langle}\omega\rvert A={\langle}\omega\rvert A\Pi_{H(x)^{\bot}}$, and

[TABLE]

so, using ${{\langle}\Psi_{2s-1}^{0}(x)|}j,z,a\rangle={\langle}\Psi_{2s}^{0}(x)\rvert U_{2s}{\lvert}j,z,a\rangle=(-1)^{x_{j}}{{\langle}\Psi_{2s}^{0}(x)|}j,z,a\rangle$, we have:

[TABLE]

Thus, the complexity of ${\langle}\bar{\omega}\rvert$ is:

[TABLE]

Because each $U_{t}$ is unitary, we have $\left\|{\lvert}\Psi_{2s}^{0}(x)\rangle\right\|^{2}=\left\|{\lvert}\Psi_{2T+1}^{0}(x)\rangle\right\|^{2}=p_{0}(x)$, thus:

[TABLE]

We conclude the proof of Theorem 3.2 with the following corollary, from which Theorem 3.2 follows immediately, by appealing to Claim 3.8 with $\kappa=\frac{9}{10}$ and $\kappa^{\prime}$ any constant in $(0,1)$.

Corollary 3.14**.**

Let $c=5$, in the definition of $P_{\cal A}$. Then:

• •

$s(P_{\cal A})=2^{S+O(1)}$**

• •

If $\cal A$ decides $f$ with one-sided error, then $P_{\cal A}$ decides $f$ with complexity $C\leq O(T)$.

• •

If $\cal A$ decides $f$ with bounded error, then $P_{\cal A}$ $\frac{9}{10}$-approximates $f$ with complexity $C_{\kappa}\leq O(T)$.

Proof.

We first compute $s(P_{\cal A})=\dim H$ using the fact that the algorithm uses space $S=\log\dim\mathrm{span}\{{\lvert}j,z,a\rangle:j\in[n]\cup\{0\},z\in{\cal Z},a\in\{0,1\}\}+\log T$:

[TABLE]

We prove the third statement, as the second is similar. By Lemma 3.13, using $c=5$, we have

[TABLE]

By Lemma 3.12, we can see that for every $x$ such that $f(x)=1$, there is an approximate positive witness ${\lvert}w\rangle$ for $x$ with error at most:

[TABLE]

Furthermore, $\left\|{\lvert}w\rangle\right\|^{2}\leq 2T+2$, so $\widehat{W}_{+}\leq 2T+2$. Observing $C_{\kappa}=\sqrt{W_{-}\widehat{W}_{+}}\leq\sqrt{27T(T+1)}$ completes the proof. ∎

4 Span Programs and Space Complexity

Using the transformation from algorithms to span programs from Section 3.3, we immediately have the following connections between span program size and space complexity.

Theorem 4.1**.**

For any $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$, we have

[TABLE]

Theorem 4.1 is a corollary of Theorem 3.2. Theorem 3.1 shows that the lower bound for $\mathsf{S}_{U}(f)$ in Theorem 4.1 is part of a tight correspondence between space complexity and $\log s(P)+\log C(P)$.

Theorem 2.9 of [BGW99] gives a lower bound of $\mathsf{SP}(f)\geq\Omega(2^{n/3}/(n\log n)^{1/3})$ for almost all $n$-bit Boolean functions. Combined with Theorem 4.1, we immediately have:

Theorem 4.2**.**

For almost all Boolean functions $f:\{0,1\}^{n}\rightarrow\{0,1\}$, $\mathsf{S}_{U}^{1}(f)=\Omega(n)$.

Ideally, we would like to use the lower bound in Theorem 4.1 to prove a non-trivial lower bound for ${\mathsf{S}_{U}}(f)$ or $\mathsf{S}_{U}^{1}(f)$ for some concrete $f$. Fortunately, there are somewhat nice expressions lower bounding $\mathsf{SP}(f)$ [Raz90, Gàl01], which we extend to lower bounds of $\widetilde{\mathsf{SP}}(f)$ in the remainder of this section. However, on the unfortunate side, there has already been significant motivation to instantiate these expressions to non-trivial lower bounds for concrete $f$, with no success. There has been some success in monotone versions of these lower bounds, which we discuss more in Section 5.

For a function $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$, and an index $j\in[n]$, we let $\Delta_{f,j}\in\{0,1\}^{f^{-1}(0)\times f^{-1}(1)}$ be defined by $\Delta_{f,j}[y,x]=1$ if and only if $x_{j}\neq y_{j}$. When $f$ is clear from context, we simply denote this by $\Delta_{j}$. The following tight characterization of $\mathsf{SP}(f)$ may be found in, for example, [Lok09].

Lemma 4.3**.**

For any $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$,

[TABLE]

where $J$ is the $f^{-1}(0)\times f^{-1}(1)$ all-ones matrix.

By Theorem 4.1, the logarithm of the above is a lower bound on $\mathsf{S}_{U}^{1}(f)$. We modify Lemma 4.3 to get the following approximate version, whose logarithm lower bounds $\mathsf{S}_{U}(f)$ when $\kappa=\frac{1}{4}$.

Lemma 4.4**.**

For any $\kappa\in[0,1)$, and $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$,

[TABLE]

Proof.

Fix a span program that $\kappa$-approximates $f$ with $s(P)=\widetilde{\mathsf{SP}}_{\kappa}(f)$, and let $\{{\langle}\omega_{y}\rvert:y\in f^{-1}(0)\}$ be optimal negative witnesses, and $\{{\lvert}w_{x}\rangle:x\in f^{-1}(1)\}$ be approximate positive witnesses with $\left\|\Pi_{H(x)}{\lvert}w_{x}\rangle\right\|^{2}\leq\frac{\kappa}{W_{-}}$. Letting $\Pi_{j,b}$ denote the projector onto $H_{j,b}$, define

[TABLE]

so $\Lambda_{j}$ has rank at most $\dim H_{j}$, and so $\sum_{j\in[n]}\mathrm{rank}(\Lambda_{j})\leq s(P)=\widetilde{\mathsf{SP}}_{\kappa}(f)$.

We now show that $\{\Lambda_{j}\}_{j}$ is a feasible solution. Let ${\lvert}\mathsf{err}(x)\rangle$ be the positive witness error of ${\lvert}w_{x}\rangle$, ${\lvert}\mathsf{err}(x)\rangle=\Pi_{H(x)^{\bot}}{\lvert}w_{x}\rangle=\sum_{j=1}^{n}\Pi_{j,\bar{x}_{j}}{\lvert}w_{x}\rangle$. Then we have:

[TABLE]

Above we used the fact that ${\langle}\omega_{y}\rvert A\Pi_{H(y)}=0$. Thus, $\{\Lambda_{j}\}_{j}$ is a feasible solution with objective value $\leq\widetilde{\mathsf{SP}}_{\kappa}(f)$, so the result follows. ∎

As a corollary of the above, and the connection between span program size and unitary quantum space complexity stated in Theorem 4.1, the logarithm of the expression in (1) with $\kappa=\frac{1}{4}$ is a lower bound on $\mathsf{S}_{U}(f)$, and with $\kappa=0$, it is a lower bound on $\mathsf{S}_{U}^{1}(f)$. However, as stated, it is difficult to use this expression to prove an explicit lower bound, because it is a minimization problem. We will shortly give a lower bound in terms of a maximization problem, making it possible to obtain explicit lower bounds by exhibiting a feasible solution.

A partial matrix is a matrix $M\in(\mathbb{R}\cup\{\star\})^{f^{-1}(0)\times f^{-1}(1)}$. A completion of $M$ is any $\overline{M}\in\mathbb{R}^{f^{-1}(0)\times f^{-1}(1)}$ such that $\overline{M}[y,x]=M[y,x]$ whenever $M[y,x]\neq\star$. For a partial matrix $M$, define rank$(M)$ to be the smallest rank of any completion of $M$, and $\varepsilon\mbox{-rank}(M)$ to be the smallest rank of any $\tilde{M}$ such that $|M[y,x]-\tilde{M}[y,x]|\leq\varepsilon$ for all $y,x$ such that $M[y,x]\neq\star$. Let $M\circ\Delta_{i}$ to be the partial matrix defined:

[TABLE]

Then we have the following:

Lemma 4.5**.**

For all Boolean functions $f:D\rightarrow\{0,1\}$, with $D\subseteq\{0,1\}^{n}$, and all partial matrices $M\in(\mathbb{R}\cup\{\star\})^{f^{-1}(0)\times f^{-1}(1)}$ such that $\max\{|M[y,x]|:M[y,x]\neq\star\}\leq 1$:

[TABLE]

In [Raz90], Razborov showed that the expression on the right-hand side in Lemma 4.5 is a lower bound on the logarithm of the formula size of $f$ (Ref. [Gàl01] related this to $\mathsf{SP}(f)$). Later, in [Raz92], Razborov noted that when restricted to non-partial matrices, this can never give a better bound than $n$. Thus, to prove a non-trivial lower bound on $\mathsf{S}_{U}^{1}(f)$ using this method, one would need to use a partial matrix. We prove the following generalization to the approximate case.

Lemma 4.6**.**

For all Boolean functions $f:D\rightarrow\{0,1\}$, with $D\subseteq\{0,1\}^{n}$, and all partial matrices $M\in(\mathbb{R}\cup\{\star\})^{f^{-1}(0)\times f^{-1}(1)}$ such that $\max\{|M[y,x]|:M[y,x]\neq\star\}\leq 1$:

[TABLE]

Proof.

Let $\{\Lambda_{j}\}_{j}$ be an optimal feasible solution for the expression from Lemma 4.4, so

[TABLE]

Let $\overline{M}_{j}$ be a completion of $M\circ\Delta_{j}$ with $\mbox{rank}(M\circ\Delta_{j})=\mbox{rank}(\overline{M}_{j})$. Then for any $x,y$ such that $M[y,x]\neq\star$:

[TABLE]

Thus

[TABLE]

Using the fact that for any matrices $B$ and $C$, $\mathrm{rank}(B\circ C)\leq\mathrm{rank}(B)\mathrm{rank}(C)$, we have

[TABLE]

Setting $\kappa=\frac{1}{4}$, and noting that by Theorem 4.1, $\mathsf{S}_{U}(f)\geq\log\widetilde{\mathsf{SP}}(f)=\log\widetilde{\mathsf{SP}}_{1/4}(f)$ completes the proof. ∎

Unfortunately, as far as we are aware, nobody has used this lower bound to successfully prove any concrete formula size lower bound of $2^{\omega(\log n)}$, so it seems to be quite difficult. However, there has been some success proving lower bounds in the monotone span program case, even without resorting to partial matrices, which we discuss in the next section.

5 Monotone Span Programs and Monotone Algorithms

A monotone function is a Boolean function in which $y\leq x$ implies $f(y)\leq f(x)$, where $y\leq x$ should be interpreted bitwise. In other words, flipping 0s to 1s either keeps the function value the same, or changes it from 0 to 1. A monotone span program is a span program in which $H_{i,0}=\{0\}$ for all $i$, so only 1-valued queries contribute to $H(x)$, and $H(y)\subseteq H(x)$ whenever $y\leq x$. A monotone span program can only decide or approximate a monotone function.

Definition 5.1**.**

For a monotone function $f$, define the monotone span program size, denoted $\mathsf{mSP}(f)$, as the minimum $s(P)$ over (families of) monotone span programs $P$ such that $P$ decides $f$; and the approximate monotone span program size, denoted $\mathsf{m}\widetilde{\mathsf{SP}}_{\kappa}(f)$, as the minimum $s(P)$ over (families of) monotone span programs $P$ such that $P$ $\kappa$-approximates $f$. We let $\mathsf{m}\widetilde{\mathsf{SP}}(f)=\mathsf{m}\widetilde{\mathsf{SP}}_{1/4}(f)$.

In contrast to $\mathsf{SP}(f)$, there are non-trivial lower bounds for $\mathsf{mSP}(f)$ for explicit monotone functions $f$. However, this does not necessarily give a lower bound on $\mathsf{SP}(f)$, and in particular, may not be a lower bound on the one-sided error quantum space complexity of $f$. However, lower bounds on $\log\mathsf{mSP}(f)$ or $\log\mathsf{m}\widetilde{\mathsf{SP}}(f)$ do give lower bounds on the space complexity of quantum algorithms obtained from monotone span programs, and as we will soon see, $\log\mathsf{mSP}(f)$ and $\log\mathsf{m}\widetilde{\mathsf{SP}}(f)$ are lower bounds on the space complexity of monotone phase estimation algorithms, described in Section 5.2. The strongest known lower bound on $\mathsf{mSP}(f)$ is the following:

Theorem 5.2** ([PR17]).**

There is an explicit Boolean function $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$ such that

[TABLE]

We will adapt some of the techniques used in existing lower bounds on $\mathsf{mSP}$ to show a lower bound on $\mathsf{m}\widetilde{\mathsf{SP}}(f)$ for some explicit $f$:

Theorem 5.3**.**

There is an explicit Boolean function $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$ such that for any constant $\kappa$,

[TABLE]

In particular, this implies a lower bound of $2^{(\log n)^{2-o(1)}}$ on $\mathsf{mSP}(f)$ for the function $f$ in Theorem 5.3. We prove Theorem 5.3 in Section 5.1. Theorem 5.3 implies that any quantum algorithm for $f$ obtained from a monotone span program must have space complexity $(\log n)^{2-o(1)}$, which is slightly better than the trivial lower bound of $\Omega(\log n)$. In Section 5.2, we describe a more natural class of algorithms called monotone phase estimation algorithms such that $\log\mathsf{m}\widetilde{\mathsf{SP}}(f)$ is a lower bound on the quantum space complexity of any such algorithm computing $f$ with bounded error. Then for the specific function $f$ from Theorem 5.3, any monotone phase estimation algorithm for $f$ must use space $(\log n)^{2-o(1)}$.

5.1 Monotone Span Program Lower Bounds

Our main tool in proving Theorem 5.3 will be the following.

Theorem 5.4**.**

For any Boolean function $f:D\rightarrow\{0,1\}$, $D\subseteq\{0,1\}^{n}$, and any constant $\kappa\in[0,1)$:

[TABLE]

where $\Delta_{j,1}[y,x]=1$ if $y_{i}=0$ and $x_{i}=1$, and 0 else.

When, $\kappa=0$, the right-hand side of the equation in Theorem 5.4 is the (monotone) rank measure, defined in [Raz90], and shown in [Gàl01] to lower bound monotone span program size. We extend the proof for the $\kappa=0$ case to get a lower bound on approximate span program size. We could also allow for partial matrices $M$, as in the non-monotone case (Lemma 4.6) but unlike the non-monotone case, it is not necessary to consider partial matrices to get non-trivial lower bounds.

Proof.

Fix a monotone span program that $\kappa$-approximates $f$ with size $\mathsf{m}\widetilde{\mathsf{SP}}_{\kappa}(f)$. Let $\{{\langle}\omega_{y}\rvert:y\in f^{-1}(0)\}$ be optimal negative witnesses, and let $\{{\lvert}w_{x}\rangle:x\in f^{-1}(1)\}$ be approximate positive witnesses with $\left\|\Pi_{H(x)^{\bot}}{\lvert}w_{x}\rangle\right\|^{2}\leq\frac{\kappa}{W_{-}}$. Letting $\Pi_{j,b}$ denote the projector onto $H_{j,b}$, define

[TABLE]

so $\Lambda_{j}$ has rank at most $\mathrm{dim}H_{j}$, and so $\sum_{j\in[n]}\mathrm{rank}(\Lambda_{j})\leq s(P)=\mathsf{m}\widetilde{\mathsf{SP}}_{\kappa}(f)$. Furthermore, $\Lambda_{j}$ is only supported on $(y,x)$ such that $y_{j}=0$ and $x_{j}=1$, so $\Lambda_{j}\circ\Delta_{j,1}=\Lambda_{j}$. Denoting the error of ${\lvert}w_{x}\rangle$ as ${\lvert}\mathsf{err}(x)\rangle=\Pi_{H(x)^{\bot}}{\lvert}w_{x}\rangle=\sum_{j:x_{j}=0}\Pi_{j,1}{\lvert}w_{x}\rangle$, we have

[TABLE]

Then for any $M\in\mathbb{R}^{f^{-1}(0)\times f^{-1}(1)}$ with $\left\|M\right\|_{\infty}\leq 1$, we have:

[TABLE]

Thus

[TABLE]

To show a lower bound on $\mathsf{m}\widetilde{\mathsf{SP}}(f)$ for some explicit $f:\{0,1\}^{n}\rightarrow\{0,1\}$, it turns out to be sufficient to find some high approximate rank matrix $M\in\mathbb{R}^{Y\times X}$ for finite sets $X$ and $Y$, and a rectangle cover of $M$, $\Delta_{1},\dots,\Delta_{n}$, where each $\Delta_{i}\circ M$ has low rank. Specifically, we have the following lemma, which, with rank in place of approximate rank, has been used extensively in previous monotone span program lower bounds.

Lemma 5.5**.**

Let $M\in\mathbb{R}^{Y\times X}$ with $\left\|M\right\|_{\infty}\leq 1$, for some finite sets $X$ and $Y$ and $X_{1},\dots,X_{n}\subseteq X$, $Y_{1},\dots,Y_{n}\subseteq Y$ be such that for all $(x,y)\in X\times Y$, there exists $j\in[n]$ such that $(x,y)\in X_{j}\times Y_{j}$. Define $\Delta_{j}\in\{0,1\}^{Y\times X}$ by $\Delta_{j}[y,x]=1$ if and only if $(y,x)\in Y_{j}\times X_{j}$. There exists a monotone function $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$ such that for any constant $\kappa\in[0,1)$:

[TABLE]

Proof.

For each $y\in Y$, define $t^{y}\in\{0,1\}^{n}$ by:

[TABLE]

Similarly, for each $x\in X$, define $s^{x}\in\{0,1\}^{n}$ by:

[TABLE]

For every $(y,x)\in Y\times X$, there is some $j$ such that $y_{j}\in Y_{j}$ and $x_{j}\in X_{j}$, so it can’t be the case that $s^{x}\leq t^{y}$. Thus, we can define $f$ as the unique monotone function such that $f(s)=1$ for every $s\in\{0,1\}^{n}$ such that $s^{x}\leq s$ for some $x\in X$, and $f(t)=0$ for all $t\in\{0,1\}^{n}$ such that $t\leq t^{y}$ for some $y\in Y$. Then we can define a matrix $M^{\prime}\in\mathbb{R}^{f^{-1}(0)\times f^{-1}(1)}$ by $M^{\prime}[t^{y},s^{x}]=M[y,x]$ for all $(y,x)\in Y\times X$, and 0 elsewhere. We have $\varepsilon\mbox{-rank}(M^{\prime})=\varepsilon\mbox{-rank}(M)$ for all $\varepsilon$, and $\mathrm{rank}(M^{\prime}\circ\Delta_{j,1})=\mathrm{rank}(M\circ\Delta_{j})$ for all $j$. The result then follows from Theorem 5.4. ∎

We will prove Theorem 5.3 by constructing an $M$ with high approximate rank, and a good rectangle cover. Following [RPRC16] and [PR17], we will make use of a technique due to Sherstov for proving communication lower bounds, called the pattern matrix method [She09]. We begin with some definitions.

Definition 5.6** (Fourier spectrum).**

For a real-valued function $p:\{0,1\}^{m}\rightarrow\mathbb{R}$, its Fourier coefficients are defined, for each $S\subseteq[m]$:

[TABLE]

where $\chi_{S}(z)=(-1)^{\sum_{i\in S}z_{i}}$. It is easily verified that $p=\sum_{S\subseteq[m]}\hat{p}(S)\chi_{S}$.

Definition 5.7** (Degree and approximate degree).**

The degree of a function $p:\{0,1\}^{m}\rightarrow\mathbb{R}$ is defined $\deg(p)=\max\{|S|:\hat{p}(S)\neq 0\}$. For any $\varepsilon\geq 0$, $\widetilde{\deg}_{\varepsilon}(p)=\min\{\deg(\tilde{p}):\left\|p-\tilde{p}\right\|_{\infty}\leq\varepsilon\}$.

Pattern matrices, defined by Sherstov in [She09], are useful for proving lower bounds in communication complexity, because their rank and approximate rank are relatively easy to lower bound. In [RPRC16], Robere, Pitassi, Rossman and Cook first used this analysis to give lower bounds on $\mathsf{mSP}(f)$ for some $f$. We now state the definition, using the notation from [PR17], which differs slightly from [She09].

Definition 5.8** (Pattern matrix).**

For a real-valued function $p:\{0,1\}^{m}\rightarrow\mathbb{R}$, and a positive integer $\lambda$, the $(m,\lambda,p)$-pattern matrix is defined as $F\in\mathbb{R}^{\{0,1\}^{\lambda m}\times([\lambda]^{m}\times\{0,1\}^{m})}$ where for $y\in\{0,1\}^{\lambda m}$, $x\in[\lambda]^{m}$, and $w\in\{0,1\}^{m}$,

[TABLE]

where by $y|_{x}$, we mean the $m$-bit string containing one bit from each $\lambda$-sized block of $y$ as specified by the entries of $x$: $(y^{(1)}_{x_{1}},y^{(2)}_{x_{2}},\dots,y^{(m)}_{x_{m}})$, where $y^{(i)}\in\{0,1\}^{\lambda}$ is the $i$-th block of $y$.

For comparison, what [She09] calls an $(n,t,p)$-pattern matrix would be a $(t,n/t,p)$-pattern matrix in our notation. As previously mentioned, a pattern matrix has the nice property that its rank (or even approximate rank) can be lower bounded in terms of properties of the Fourier spectrum of $p$. In particular, the following is proven in [She09]:

Lemma 5.9**.**

Let $F$ be the $(m,\lambda,p)$-pattern matrix for $p:\{0,1\}^{m}\rightarrow\{-1,+1\}$. Then for any $\varepsilon\in[0,1]$ and $\delta\in[0,\varepsilon]$, we have:

[TABLE]

This shows that we can use functions $p$ of high approximate degree to construct pattern matrices $F\in\mathbb{R}^{\{0,1\}^{\lambda m}\times([\lambda]^{m}\times\{0,1\}^{m})}$ of high approximate rank. To apply Lemma 5.5, we also need to find a good rectangle cover of some $F$.

A $b$-certificate for a function $p$ on $\{0,1\}^{m}$ is an assignment $\alpha:S\rightarrow\{0,1\}$ for some $S\subseteq[m]$ such that for any $x\in\{0,1\}^{m}$ such that $x_{j}=\alpha(j)$ for all $j\in S$, $f(x)=b$. The size of a certificate is $|S|$. The following shows how to use the certificates of $p$ to construct a rectangle cover of its pattern matrix.

Lemma 5.10**.**

Let $p:\{0,1\}^{m}\rightarrow\{-1,+1\}$, and suppose there is a set of $\ell$ certificates for $p$ of size at most $C$ such that every input satisfies at least one certificate. Then for any positive integer $\lambda$, there exists a function $f:\{0,1\}^{n}\rightarrow\{0,1\}$ for $n=\ell(2\lambda)^{C}$ such that for any $\kappa\in(0,1)$ and $\varepsilon\in[\sqrt{\kappa},1]$:

[TABLE]

Proof.

For $i=1,\dots,\ell$, let $\alpha_{i}:S_{i}\rightarrow\{0,1\}$ for $S_{i}\subset[m]$ of size $|S_{i}|\leq C$ be one of the $\ell$ certificates. That is, for each $i$, there is some $v_{i}\in\{-1,+1\}$ such that for any $x\in\{0,1\}^{m}$, if $x_{j}=\alpha_{i}(j)$ for all $j\in S_{i}$, then $p(x)=v_{i}$ (so $\alpha_{i}$ is a $v_{i}$-certificate).

We let $F$ be the $(m,\lambda,p)$-pattern matrix, which has $\left\|F\right\|_{\infty}=1$ since $p$ has range $\{-1,+1\}$. We will define a rectangle cover as follows. For every $i\in[\ell]$, $k\in[\lambda]^{S_{i}}$, and $b\in\{0,1\}^{S_{i}}$, define:

[TABLE]

We first note that this is a rectangle cover. Fix any $y\in\{0,1\}^{\lambda m}$, $x\in[\lambda]^{m}$ and $w\in\{0,1\}^{m}$. First note that for any $i$, if we let $b$ be the restriction of $w$ to $S_{i}$, and $k$ the restriction of $x$ to $S_{i}$, we have $(x,w)\in X_{i,k,b}$. This holds in particular for $i$ such that $\alpha_{i}$ is a certificate for $y|_{x}\oplus w$, and by assumption there is at least one such $i$. For such an $i$, we have $y^{(j)}_{x_{j}}\oplus w_{j}=\alpha(j)$ for all $j\in S_{i}$, so $y\in Y_{i,k,b}$. Thus, we can apply Lemma 5.5.

Note that if $(x,w)\in X_{i,k,b}$, and $y\in Y_{i,k,b}$, then $(y|_{x}\oplus w)[j]=y^{(j)}_{x_{j}}\oplus w_{j}=\alpha_{i}(j)$ for all $j\in S_{i}$, so $p(y|_{x}\oplus w)=v_{i}$. Letting $\Delta_{i,k,b}[y,(x,w)]=1$ if $y\in Y_{i,k,b}$ and $(x,w)\in X_{i,k,b}$, and 0 else, we have that if $y\in Y_{i,k,b}$ and $(x,w)\in X_{i,k,b}$, $(F\circ\Delta_{i,k,b})[y,(x,w)]=p(y|_{x}\oplus w)=v_{i}$, and otherwise, $(F\circ\Delta_{i,k,b})[y,(x,w)]=0$. Thus $\mathrm{rank}(F\circ\Delta_{i,k,b})=\mathrm{rank}(v_{i}\Delta_{i,k,b})=1$. Then by Lemma 5.5, there exists $f:\{0,1\}^{n}\rightarrow\{0,1\}$ where $n=\sum_{i=1}^{\ell}(2\lambda)^{|S_{i}|}\leq\ell(2\lambda)^{C}$ such that:

[TABLE]

We now prove Theorem 5.3, restated below:

Theorem 5.3.

There is an explicit Boolean function $f:D\rightarrow\{0,1\}$ for $D\subseteq\{0,1\}^{n}$ such that for any constant $\kappa$,

[TABLE]

Proof.

By [BT17, Theorem 38], there is a function $p$ with $\widetilde{\deg}_{1/3}(p)\geq C(p)^{2-o(1)}$, which is, up to the $o(1)$ in the exponent, the best possible separation between these two quantities. In particular, this function has $\widetilde{\deg}_{1/3}(p)\geq M^{2-o(1)}$, and $C(p)\leq M^{1+o(1)}$, where $C(p)$ is the certificate complexity of $p$, for some parameter $M$ (see [BT17] equations (64) and (65), where $p$ is referred to as $F$), and $p$ is a function on $M^{2+o(1)}$ variables (see [BT17], discussion above equation (64)). Thus, there are at most $\binom{M^{2+o(1)}}{M^{1+o(1)}}$ possible certificates of size $M^{1+o(1)}$ such that each input satisfies at least one of them.

Then by Lemma 5.10 there exists a function $f:\{0,1\}^{n}\rightarrow\{0,1\}$ for $n\leq\binom{M^{2+o(1)}}{M^{1+o(1)}}(2\lambda)^{M^{1+o(1)}}$ such that for constant $\kappa<1/36$ and constant $\lambda$:

[TABLE]

Then we have:

[TABLE]

Thus, $\log\mathsf{m}\widetilde{\mathsf{SP}}_{\kappa}(f)\geq(\log n)^{2-o(1)}$, and the result for any $\kappa$ follows using Corollary 3.9. ∎

Since for all total functions $p$, $\widetilde{\deg}_{1/3}(p)\leq C(p)^{2}$, where $C(p)$ is the certificate complexity of $p$, Lemma 5.10 can’t prove a lower bound better than $\log\mathsf{m}\widetilde{\mathsf{SP}}(p)\geq(\log n)^{2}$ for any $n$-bit function. We state a more general version of Lemma 5.10 that might have the potential to prove a better bound, but we leave this as future work.

Lemma 5.11**.**

Fix $p:\{0,1\}^{m}\rightarrow\{-1,+1\}$. For $i=1,\dots,\ell$, let $\alpha_{i}:S_{i}\rightarrow\{0,1\}$ for $S_{i}\subseteq[m]$ be a partial assignment such that every $z\in\{0,1\}^{m}$ satisfies at least one of the assignments. Let $p_{i}$ denote the restriction of $p$ to strings $z$ satisfying the assignment $\alpha_{i}$. Then for every positive integer $\lambda$, there exists a function $f:\{0,1\}^{n}\rightarrow\{0,1\}$, where $n=\sum_{i=1}^{\ell}(2\lambda)^{|S_{i}|}$ such that for any $\kappa\in(0,1)$ and $\varepsilon\in[\sqrt{\kappa},1]$:

[TABLE]

To make use of this lemma, one needs a function $p$ of high approximate degree, such that for every input, there is a small assignment that lowers the degree to something small. This generalizes Lemma 5.10 because a certificate is an assignment that lowers the degree of the remaining sub-function to constant. However, we note that a $p$ with these conditions is necessary but may not be sufficient for proving a non-trivial lower bound, because while $\sum_{S:\hat{p}_{i}(S)\neq 0}\lambda^{|S|}\geq\lambda^{\deg(p_{i})}$, it may also be much larger if $p_{i}$ has a dense Fourier spectrum.

Proof.

Let $F$ be the $(m,\lambda,p)$-pattern matrix. Let $\{X_{i,k,b}\times Y_{i,k,b}\}_{i,k,b}$ be the same rectangle covered defined in the proof of Lemma 5.10, with the difference that since the $\alpha_{i}$ are no longer certificates, the resulting submatrices of $F$ may not have constant rank.

Let $\Delta_{i,k,b}=\sum_{y\in Y_{i,k,b}}{\lvert}y\rangle\sum_{(x,w)\in X_{i,k,b}}{\langle}x,w\rvert$. Then

[TABLE]

Note that when $y\in Y_{i,k,b}$ and $(x,w)\in X_{i,b,k}$, $y|_{x}\oplus w$ satisfies $\alpha_{i}$, so $p(y|_{x}\oplus w)=p_{i}(y^{\prime}|_{x^{\prime}}\oplus w^{\prime})$, where $y^{\prime}$, $x^{\prime}$ and $w^{\prime}$ are restrictions of $y\in(\{0,1\}^{\lambda})^{m}$, $x\in[\lambda]^{m}$ and $w\in\{0,1\}^{m}$ to $[m]\setminus S_{i}$. Thus, continuing from above, and rearranging registers, we have:

[TABLE]

where $F_{i}$ is the $(m,\lambda,p_{i})$-pattern matrix, and $J_{a,b}$ is the all-ones matrix of dimension $a$ by $b$, which always has rank 1 for $a,b>0$. Thus

[TABLE]

by [She09]. This part of the proof follows [RPRC16, Lemma IV.6].

Then by Lemma 5.5 and Lemma 5.9, we have:

[TABLE]

5.2 Monotone Algorithms

In Theorem 5.3, we showed a non-trivial lower bound on $\log\mathsf{m}\widetilde{\mathsf{SP}}(f)$ for some explicit monotone function $f$. Unlike lower bounds on $\log\widetilde{\mathsf{SP}}(f)$, this does not give us a lower bound on the quantum space complexity of $f$, however, at the very least it gives us a lower bound on the quantum space complexity of a certain type of quantum algorithm. Of course, this is naturally the case, since a lower bound on $\mathsf{m}\widetilde{\mathsf{SP}}(f)$ gives us a lower bound on the quantum space complexity of any algorithm for $f$ that is obtained from a monotone span program. However, this is not the most satisfying characterization, as it is difficult to imagine what this class of algorithms looks like.

In this section, we will consider a more natural class of algorithms whose space complexity is lower bounded by $\mathsf{m}\widetilde{\mathsf{SP}}(f)$, and in some cases $\mathsf{mSP}(f)$. We will call a quantum query algorithm a phase estimation algorithm if it works by estimating the amplitude on ${\lvert}0\rangle$ in the phase register after running phase estimation of a unitary that makes one query. We assume that the unitary for which we perform phase estimation is of the form $U{\cal O}_{x}$. This is without loss of generality, because the most general form is a unitary $U_{2}{\cal O}_{x}U_{1}$, but we have $(U_{2}{\cal O}_{x}U_{1})^{t}{\lvert}\psi_{0}\rangle=U_{1}^{\dagger}(U{\cal O}_{x})^{t}{\lvert}\psi_{0}^{\prime}\rangle$ where ${\lvert}\psi_{0}^{\prime}\rangle=U_{1}{\lvert}\psi_{0}\rangle$, and $U=U_{1}U_{2}$. The weight on a phase of ${\lvert}0\rangle$ is not affected by this global ($t$-independent) $U_{1}^{\dagger}$. Thus, we define a phase estimation algorithm as follows:

Definition 5.12**.**

A phase estimation algorithm ${\cal A}=(U,{\lvert}\psi_{0}\rangle,\delta,T,M)$ for $f:D\rightarrow\{0,1\}$, $D\subseteq\{0,1\}^{n}$, is defined by (families of):

• •

a unitary $U$ acting on ${\cal H}=\mathrm{span}\{{\lvert}j,z\rangle:j\in[n],z\in{\cal Z}\}$ for some finite set ${\cal Z}$;

• •

an initial state ${\lvert}\psi_{0}\rangle\in{\cal H}$;

• •

a bound $\delta\in[0,1/2)$;

• •

positive integers $T$ and $M\leq\frac{1}{\sqrt{\delta}}$;

such that for any $M^{\prime}\geq M$ and $T^{\prime}\geq T$, the following procedure computes $f$ with bounded error:

Let $\Phi(x)$ be the algorithm that runs phase estimation of $U{\cal O}_{x}$ on ${\lvert}\psi_{0}\rangle$ for $T^{\prime}$ steps, and then computes a bit ${\lvert}b\rangle_{A}$ in a new register $A$, such that $b=0$ if and only if the phase estimate is [math]. 2. 2.

Run $M^{\prime}$ steps of amplitude estimation to estimate the amplitude on ${\lvert}0\rangle_{A}$ after application of $\Phi(x)$. Output [math] if the amplitude is $>{\delta}$.

The query complexity of the algorithm is $O(MT)$, and, the space complexity of the algorithm is $\log\dim{\cal H}+\log T+\log M+1$.

We insist that the algorithm work not only for $M$ and $T$ but for any larger integers as well, because we want to ensure that the algorithm is successful because $M$ and $T$ are large enough, and not by some quirk of the particular chosen values. When $\delta=0$, the algorithm has one-sided error (see Lemma 5.17).

We remark on the generality of this form of algorithm. Any algorithm can be put into this form by first converting it to a span program, and then compiling that into an algorithm, preserving both the time and space complexity, asymptotically. However, we will consider a special case of this type of algorithm that is not fully general.

Definition 5.13**.**

A monotone phase estimation algorithm is a phase estimation algorithm such that if $\Pi_{0}(x)$ denotes the orthogonal projector onto the $(+1)$-eigenspace of $U{\cal O}_{x}$, then for any $x\in\{0,1\}^{n}$, $\Pi_{0}(x){\lvert}\psi_{0}\rangle$ is in the $(+1)$-eigenspace of ${\cal O}_{x}$.

Let us consider what is “monotone” about this definition. The algorithm rejects if ${\lvert}\psi_{0}\rangle$ has high overlap with the $(+1)$-eigenspace of $U{\cal O}_{x}$, i.e., $\Pi_{0}(x){\lvert}\psi_{0}\rangle$ is large. In a monotone phase estimation algorithm, we know that the only contribution to $\Pi_{0}(x){\lvert}\psi_{0}\rangle$ is in the $(+1)$-eigenspace of ${\cal O}_{x}$, which is exactly the span of ${\lvert}j,z\rangle$ such that $x_{j}=0$. Thus, only 0-queries can contribute to the algorithm rejecting.

As a simple example, Grover’s algorithm is a monotone phase estimation algorithm. Specifically, let ${\lvert}\psi_{0}\rangle=\frac{1}{\sqrt{n}}\sum_{j=1}^{n}{\lvert}j\rangle$ and $U=(2{\lvert}\psi_{0}\rangle{\langle}\psi_{0}\rvert-I)$. Then $U{\cal O}_{x}$ is the standard Grover iterate, and ${\lvert}\psi_{0}\rangle$ is in the span of $e^{i\theta}$-eigenvectors of $U{\cal O}_{x}$ with $\sin|\theta|=\sqrt{|x|/n}$, so phase estimation can be used to distinguish the case $|x|=0$ from $|x|\geq 1$. So $\Pi_{0}(x){\lvert}\psi_{0}\rangle$ is either 0, when $|x|\neq 0$, or ${\lvert}\psi_{0}\rangle$, when $|x|=0$. In both cases, it is in the $(+1)$-eigenspace of ${\cal O}_{x}$.

It is clear that a monotone phase estimation algorithm can only decide a monotone function. However, while any quantum algorithm can be converted to a phase estimation algorithm, it is not necessarily the case that any quantum algorithm for a monotone function can be turned into a monotone phase estimation algorithm. Thus lower bounds on the quantum space complexity of any monotone phase estimation algorithm for $f$ do not imply lower bounds on $\mathsf{S}_{U}(f)$. Nevertheless, if we let $\mathsf{mS}_{U}(f)$ represent the minimum quantum space complexity of any monotone phase estimation algorithm for $f$, then a lower bound on $\mathsf{mS}_{U}(f)$ at least tells us that if we want to compute $f$ with space less than said bound, we must use a non-monotone phase estimation algorithm.

Similarly, we let $\mathsf{mS}_{U}^{1}(f)$ denote the minimum quantum space complexity of any monotone phase estimation algorithm with $\delta=0$ that computes $f$ (with one-sided error).

The main theorem of this section states that any monotone phase estimation algorithm for $f$ with space $S$ can be converted to a monotone span program of size $2^{\Theta(S)}$ that approximates $f$, so that lower bounds on $\mathsf{m}\widetilde{\mathsf{SP}}(f)$ imply lower bounds on $\mathsf{mS}_{U}(f)$; and that any monotone phase estimation algorithm with $\delta=0$ and space $S$ can be converted to a monotone span program of size $2^{\Theta(S)}$ that decides $f$ (exactly) so that lower bounds on $\mathsf{mSP}(f)$ imply lower bounds on $\mathsf{mS}_{U}^{1}(f)$. These conversions also preserve the query complexity. We now formally state this main result.

Theorem 5.14**.**

Let ${\cal A}=(U,{\lvert}\psi_{0}\rangle,\delta,T,M)$ be a monotone phase estimation algorithm for $f$ with space complexity $S=\log\dim{\cal H}+\log T+\log M+1$ and query complexity $O(TM)$. Then there is a monotone span program with complexity $O(TM)$ and size $2\dim{\cal H}\leq 2^{S}$ that approximates $f$. If $\delta=0$, then this span program decides $f$ (exactly). Thus

[TABLE]

We prove this theorem in Section 5.2.1. As a corollary, lower bounds on $\mathsf{mSP}(f)$, such as the one from [PR17], imply lower bounds on $\mathsf{mS}_{U}^{1}(f)$; and lower bounds on $\mathsf{m}\widetilde{\mathsf{SP}}(f)$ such as the one in Theorem 5.3, imply lower bounds on $\mathsf{mS}_{U}(f)$. In particular:

Corollary 5.15**.**

Let $f:\{0,1\}^{n}\rightarrow\{0,1\}$ be the function described in Theorem 5.3. Then $\mathsf{mS}_{U}(f)\geq(\log n)^{2-o(1)}$. Let $g:\{0,1\}^{n}\rightarrow\{0,1\}$ be the function described in Theorem 5.2. Then $\mathsf{mS}_{U}^{1}(g)\geq\Omega(n)$.

We emphasize that while this does not give a lower bound on the quantum space complexity of $f$, or the one-sided quantum space complexity of $g$, it does show that any algorithm that uses $(\log n)^{c}$ space to solve $f$ with bounded error, for $c<2$, or $o(n)$ space to solve $g$ with one-sided error, must be of a different form than that described in Definition 5.12 and Definition 5.13.

In a certain sense, monotone phase estimation algorithms completely characterize those that can be derived from monotone span programs, because the algorithm we obtain from compiling a monotone span program is a monotone phase estimation algorithm, as stated below in Lemma 5.16. However, not all monotone phase estimation algorithms can be obtained by compiling monotone span programs, and similarly, we might hope to show that an even larger class of algorithms can be converted to monotone span programs, in order to give more strength to lower bounds on $\mathsf{mS}_{U}(f)$.

Lemma 5.16**.**

Let $P$ be an approximate monotone span program for $f$ with size $S$ and complexity $C$. Then there is a monotone algorithm for $f$ with query complexity $O(C)$ and space complexity $O(\log S+\log C)$.

Proof.

Fix a monotone span program, and assume it has been appropriately scaled. Without loss of generality, we can let $H_{j}=H_{j,1}=\mathrm{span}\{{\lvert}j,z\rangle:z\in{\cal Z}_{j}\}$ for some finite set ${\cal Z}_{j}$. Then, ${\cal O}_{x}=I-2\Pi_{H(x)}$, which is only true because the span program is monotone. Let $U=2\Pi_{\mathrm{row}(A)}-I$. Then $U{\cal O}_{x}=(2\Pi_{\ker(A)}-I)(2\Pi_{H(x)}-I)$ is the span program unitary, described in Section 3.2. Then it is simple to verify that the algorithm described in [IJ19, Lemma 3.6] (and referred to in Section 3.2) is a phase estimation algorithm for $f$ with query complexity $O(C)$ and space complexity $O(\log S+\log C)$.

The algorithm is a monotone phase estimation algorithm because $U=2\Pi_{\mathrm{row}(A)}-I$ is a reflection, and ${\lvert}\psi_{0}\rangle={\lvert}w_{0}\rangle=A^{+}{\lvert}\tau\rangle$ is in the $(+1)$-eigenspace of $U$, $\mathrm{row}(A)$. Since $U$ is a reflection, the $(+1)$-eigenspace of $U{\cal O}_{x}$ is exactly $(\ker(A)\cap H(x))\oplus(\mathrm{row}(A)\cap H(x)^{\bot})$, and so $\Pi_{0}(x){\lvert}w_{0}\rangle\in\mathrm{row}(A)\cap H(x)^{\bot}\subset H(x)^{\bot}$. ∎

5.2.1 Monotone Algorithms to (Approximate) Monotone Span Programs

In this section, we prove Theorem 5.14. Throughout this section, we fix a phase estimation algorithm ${\cal A}=(U,{\lvert}\psi_{0}\rangle,\delta,T,M)$ that computes $f$, with $U$ acting on ${\cal H}$. For any $x\in\{0,1\}^{n}$ and $\Theta\in[0,\pi]$, we let $\Pi_{\Theta}(x)$ denote the orthogonal projector onto the span of $e^{i\theta}$-eigenvectors of $U{\cal O}_{x}$ for $|\theta|\leq\Theta$. We will let $\Pi_{x}=\sum_{j\in[n],z\in{\cal Z}:x_{j}=1}{\lvert}j,z\rangle{\langle}j,z\rvert$.

We begin by drawing some conclusions about the necessary relationship between the eigenspaces of $U{\cal O}_{x}$ and a function $f$ whenever a monotone phase estimation computes $f$. The proofs are somewhat dry and are relegated to Appendix B.

Lemma 5.17**.**

Fix a phase estimation algorithm with $\delta=0$ that solves $f$ with bounded error. Then if $f(x)=0$,

[TABLE]

and for any $d<\sqrt{8}/\pi$, if $f(x)=1$, then

[TABLE]

and the algorithm always outputs 1, so it has one-sided error.

Lemma 5.18**.**

Fix a phase estimation algorithm with $\delta\neq 0$ that solves $f$ with bounded error. Then there is some constant $c>0$ such that if $f(x)=0$,

[TABLE]

and if $f(x)=1$, for any $d<\sqrt{8}/\pi$,

[TABLE]

To prove Theorem 5.14, we will define a monotone span program $P_{\cal A}$ as follows:

[TABLE]

We first show that $\Pi_{0}(x){\lvert}\psi_{0}\rangle$ is (up to scaling) a negative witness for $x$, whenever it is nonzero:

Lemma 5.19**.**

For any $x\in\{0,1\}^{n}$, we have

[TABLE]

In particular, $\Pi_{0}(x){\lvert}\psi_{0}\rangle/\left\|\Pi_{0}(x){\lvert}\psi_{0}\rangle\right\|^{2}$ is an optimal negative witness for $x$ when $\Pi_{0}(x){\lvert}\psi_{0}\rangle\neq 0$.

Proof.

Suppose $\Pi_{0}(x){\lvert}\psi_{0}\rangle\neq 0$, and let ${\lvert}\omega\rangle=\Pi_{0}(x){\lvert}\psi_{0}\rangle/\left\|\Pi_{0}(x){\lvert}\psi_{0}\rangle\right\|^{2}$. We will first show that this is a negative witness, and then show that no negative witness can have better complexity. First, we notice that

[TABLE]

Next, we will see that ${\langle}\omega\rvert A\Pi_{H(x)}=0$. By the monotone phase estimation property, ${\cal O}_{x}\Pi_{0}(x){\lvert}\psi_{0}\rangle=\Pi_{0}(x){\lvert}\psi_{0}\rangle$, and so ${\cal O}_{x}{\lvert}\omega\rangle={\lvert}\omega\rangle$, and thus $\Pi_{x}{\lvert}\omega\rangle=0$, where $\Pi_{x}$ is the projector onto ${\lvert}j,z\rangle$ such that $x_{j}=1$. Note that $H(x)=\mathrm{span}\{{\lvert}j,z,1\rangle:x_{j}=1,z\in{\cal Z}\}\oplus\mathrm{span}\{{\lvert}j,z\rangle:j\in[n],z\in{\cal Z}\}$. Thus $\Pi_{H(x)}=\Pi_{H_{\mathrm{true}}}+\Pi_{x}\otimes{\lvert}1\rangle{\langle}1\rvert$. We have:

[TABLE]

Since ${\lvert}\omega\rangle$ is in the $(+1)$-eigenspace of $U{\cal O}_{x}$, we have $U{\cal O}_{x}{\lvert}\omega\rangle={\lvert}\omega\rangle$ so since ${\cal O}_{x}{\lvert}\omega\rangle={\lvert}\omega\rangle$, $U{\lvert}\omega\rangle={\lvert}\omega\rangle$. Thus

[TABLE]

Thus ${\lvert}\omega\rangle$ is a zero-error negative witness for $x$. Next, we argue that it is optimal.

Suppose ${\lvert}\omega\rangle$ is any optimal negative witness for $x$, with size $w_{-}(x)$. Then since ${\langle}\omega\rvert\Pi_{x}={\langle}\omega\rvert A(\Pi_{x}\otimes{\lvert}1\rangle{\langle}1\rvert)$ must be 0, ${\cal O}_{x}{\lvert}\omega\rangle=(I-2\Pi_{x}){\lvert}\omega\rangle={\lvert}\omega\rangle$, and since ${\langle}\omega\rvert A\Pi_{H_{\mathrm{true}}}={\langle}\omega\rvert(I-U^{\dagger})$ must be 0, $U{\lvert}\omega\rangle={\lvert}\omega\rangle$. Thus ${\lvert}\omega\rangle$ is a 1-eigenvector of $U{\cal O}_{x}$, so

[TABLE]

We complete the proof by noticing that since ${\langle}\omega\rvert A\Pi_{H_{\mathrm{true}}}=0$, we have ${\langle}\omega\rvert A={\langle}\omega\rvert{\langle}1\rvert$, and $w_{-}(x)=\left\|{\langle}\omega\rvert A\right\|^{2}=\left\|{\lvert}\omega\rangle\right\|^{2}$. ∎

Next we find approximate positive witnesses.

Lemma 5.20**.**

For any $\Theta\geq 0$, the span program $P_{\cal A}$ has approximate positive witnesses for any $x$ with error at most $\left\|\Pi_{\Theta}(x){\lvert}\psi_{0}\rangle\right\|^{2}$ and complexity at most $\frac{5\pi^{2}}{4\Theta^{2}}$.

Proof.

We first define a vector ${\lvert}v\rangle$ by:

[TABLE]

Note that $I-(U{\cal O}_{x})^{\dagger}$ is supported everywhere except the $(+1)$-eigenvectors of $(U{\cal O}_{x})^{\dagger}$, which are exactly the $(+1)$-eigenvectors of $U{\cal O}_{x}$. Thus, $(I-\Pi_{\Theta}(x)){\lvert}\psi_{0}\rangle$ is contained in this support.

Next we define

[TABLE]

Then we have:

[TABLE]

So ${\lvert}w\rangle$ is a positive witness, and we next compute its error for $x$:

[TABLE]

Above, $\Pi_{\bar{x}}=I-\Pi_{x}$. We now observe that

[TABLE]

Thus, continuing from above, we have:

[TABLE]

Now we compute the complexity of ${\lvert}w\rangle$. First, let $U{\cal O}_{x}=\sum_{j}e^{i\theta_{j}}{\lvert}\lambda_{j}\rangle{\langle}\lambda_{j}\rvert$ be the eigenvalue decomposition of $U{\cal O}_{x}$. Then

[TABLE]

We can thus bound $\left\|{\lvert}v\rangle\right\|^{2}$:

[TABLE]

Next, using ${\cal O}_{x}+2\Pi_{x}=I-2\Pi_{x}+2\Pi_{x}=I$, we compute:

[TABLE]

Then we have the complexity of ${\lvert}w\rangle$:

[TABLE]

We conclude with the following two corollaries, whose combination gives Theorem 5.14.

Corollary 5.21**.**

Let ${\cal A}=(U,{\lvert}\psi_{0}\rangle,0,T,M)$ be a monotone phase estimation algorithm for $f$ with space complexity $S=\log\dim{\cal H}+\log T+\log M+1$ and query complexity $O(TM)$. Then there is a monotone span program that decides $f$ (exactly) whose size is $2\dim{\cal H}\leq 2^{S}$ and whose complexity is $O(TM)$.

Proof.

If $f(x)=0$, then by Lemma 5.17, we have $\left\|\Pi_{0}(x){\lvert}\psi_{0}\rangle\right\|^{2}\geq\frac{1}{M^{2}}$, so by Lemma 5.19, $w_{-}(x)\leq M^{2}$. Thus $W_{-}\leq M^{2}$.

If $f(x)=1$, then by Lemma 5.17, we have $\left\|\Pi_{2/T}(x){\lvert}\psi_{0}\rangle\right\|^{2}=0$, so by Lemma 5.20, there’s an exact positive witness for $x$ with complexity $O(T^{2})$. Thus $W_{+}\leq O(T^{2})$, and so the span program $P_{\cal A}$ from (2) has complexity $O(TM)$. The size of the span program $P_{\cal A}$ is $\dim H=2\dim{\cal H}$. ∎

Corollary 5.22**.**

Let ${\cal A}=(U,{\lvert}\psi_{0}\rangle,\delta,T,M)$ be a monotone phase estimation algorithm for $f$ with space complexity $S=\log\dim{\cal H}+\log T+\log M+1$ and query complexity $O(TM)$. Then there is a constant $\kappa\in(0,1)$ such that there exists a monotone span program that $\kappa$-approximates $f$ whose size is $2\dim{\cal H}\leq 2^{S}$ and whose complexity is $O(TM)$.

Proof.

If $f(x)=0$, then by Lemma 5.18, we have $\left\|\Pi_{0}(x){\lvert}\psi_{0}\rangle\right\|^{2}>\delta(1+c)$ for some constant $c>0$. Thus, by Lemma 5.19, $W_{-}\leq\frac{1}{(1+c)\delta}$.

If $f(x)=1$, then by Lemma 5.20, setting $\Theta=d\pi/T$ for $d=\frac{2}{\pi}\sqrt{\frac{c}{1+c}}$, (where $c$ is the constant from above), by Lemma 5.20 there is an approximate positive witness for $x$ with error

[TABLE]

and complexity $O(T^{2})$. By Lemma 5.18, we have

[TABLE]

Thus, letting $\kappa=\frac{1}{1+c/2}<1$, we have that $P_{\cal A}$ $\kappa$-approximates $f$. Since the positive witness complexity is $O(T^{2})$, and by Lemma 5.18, we also have $W_{-}\leq O(M^{2})$, the complexity of $P_{\cal A}$ is $O(TM)$. The size of $P_{\cal A}$ is $\dim H=2\dim{\cal H}$. ∎

Acknowledgements

I am grateful to Tsuyoshi Ito for discussions that led to the construction of approximate span programs from two-sided error quantum algorithms presented in Section 3.3, and to Alex B. Grilo and Mario Szegedy for insightful comments. I am grateful to Robin Kothari for pointing out the improved separation between certificate complexity and approximate degree in [BT17], which led to an improvement in from $(\log n)^{7/6}$ (using [ABK16]) to $(\log n)^{2-o(1)}$ in Theorem 5.3.

Appendix A Proof of Claim 3.8

In this section, we prove Claim 3.8, restated below:

Claim 3.8.

Let $P$ be a span program that $\kappa$-approximates $f:D\rightarrow\{0,1\}$ for some constant $\kappa$. For any constant $\kappa^{\prime}\leq\kappa$, there exists a span program $P^{\prime}$ that $\kappa^{\prime}$-approximates $f$ with $s(P^{\prime})=(s(P)+2)^{2\frac{\log\frac{1}{\kappa^{\prime}}}{\log\frac{1}{\kappa}}}$, and $C_{\kappa^{\prime}}(P^{\prime},D)\leq O\left(C_{\kappa}(P,D)\right)$.

Let ${\lvert}w_{0}\rangle=A^{+}{\lvert}\tau\rangle$. We say a span program is normalized if $\left\|{\lvert}w_{0}\rangle\right\|=1$. A span program can easily be normalized by scaling ${\lvert}\tau\rangle$, which also scales all positive witnesses and inverse scales all negative witnesses. However, we sometimes want to normalize a span program, while also keeping all negative witness sizes bounded by a constant. We can accomplish this using the following construction, from [IJ19].

Theorem A.1**.**

Let $P=(H,V,{\lvert}\tau\rangle,A)$ be a span program on $\{0,1\}^{n}$, and let $N=\left\|{\lvert}w_{0}\rangle\right\|^{2}$. For a positive real number $\beta$, define a span program $P^{\beta}=(H^{\beta},V^{\beta},{\lvert}\tau^{\beta}\rangle,A^{\beta})$ as follows, where ${\lvert}\hat{0}\rangle$ and ${\lvert}\hat{1}\rangle$ are not in $H$ or $V$:

[TABLE]

[TABLE]

Then we have the following:

• •

$\left\|(A^{\beta})^{+}{\lvert}\tau^{\beta}\rangle\right\|=1$;

• •

for all $x\in P_{1}$, ${w}_{+}(x,P^{\beta})=\frac{1}{\beta^{2}}w_{+}(x,P)+2$;

• •

for all $x\in P_{0}$, $w_{-}(x,P^{\beta})=\beta^{2}w_{-}(x,P)+1$.

Corollary A.2**.**

Let $P$ be a span program on $\{0,1\}^{n}$, and $P^{\beta}$ be defined as above for $\beta=\frac{1}{\sqrt{W_{-}(P)}}$. If $P$ $\kappa$-approximates $f$, then $P^{\beta}$ $\sqrt{\kappa}$-approximates $f$, with $W_{-}(P^{\beta})\leq 2$, $\widehat{W}_{+}(P^{\beta})\leq W_{-}(P)\widehat{W}_{+}(P)+2$ and $s(P^{\beta})\leq s(P)+2$.

Proof.

First note that by Theorem A.1, $W_{-}(P^{\beta})\leq 2$. Let ${\lvert}w\rangle$ be an approximate positive witness for $x$ in $P$, with $\left\|\Pi_{H(x)^{\bot}}{\lvert}w\rangle\right\|^{2}\leq\frac{\kappa}{W_{-}(P)}$ and $\left\|{\lvert}w\rangle\right\|^{2}\leq\widehat{W}_{+}(P)$. Define

[TABLE]

One can check that $A^{\beta}{\lvert}w^{\prime}\rangle={\lvert}\tau^{\beta}\rangle$.

[TABLE]

where we have used $W_{-}(P^{\beta})\leq 2$. We upper bound $\widehat{W}_{+}(P^{\beta})$ by noting that:

[TABLE]

Finally, $s(P^{\beta})=s(P)+2$ because of the two extra degrees of freedom ${\lvert}\hat{0}\rangle$ and ${\lvert}\hat{1}\rangle$. ∎

Proof of Claim 3.8.

We will first show how, given a span program $P$ such that $\left\|{\lvert}w_{0}\rangle\right\|^{2}\leq 1$, and $P$ $\kappa$-approximates $f$, we can get a span program $P^{\prime}$ such that $\left\|{\lvert}w_{0}^{\prime}\rangle\right\|^{2}\leq 1$, $W_{-}(P^{\prime})\leq W_{-}(P)^{2}$, $P^{\prime}$ $\kappa^{2}$-approximates $f$, $\widehat{W}_{+}(P^{\prime})\leq 4\widehat{W}_{+}(P)$, and $s(P^{\prime})=s(P)^{2}$.

Define $P^{\prime}$ as follows, where $S$ is a swap operator, which acts as $S({\lvert}u\rangle{\lvert}v\rangle)={\lvert}v\rangle{\lvert}u\rangle$ for all ${\lvert}u\rangle,{\lvert}v\rangle\in H$:

[TABLE]

Observe that for any ${\lvert}u\rangle,{\lvert}v\rangle\in H$, we have

[TABLE]

Note that $A^{\prime}({\lvert}w_{0}\rangle{\lvert}w_{0}\rangle)={\lvert}\tau^{\prime}\rangle$, so $\left\|{A^{\prime}}^{+}{\lvert}\tau^{\prime}\rangle\right\|\leq\left\|{\lvert}w_{0}\rangle{\lvert}w_{0}\rangle\right\|\leq 1.$

If ${\langle}\omega\rvert$ is a negative witness for $x$ in $P$, it is easily verified that ${\langle}\omega^{\prime}\rvert={\langle}\omega\rvert\otimes{\langle}\omega\rvert$ is a negative witness in $P^{\prime}$, and

[TABLE]

so $w_{-}(x,P^{\prime})\leq w_{-}(x,P)^{2}$, and $W_{-}(P^{\prime})\leq W_{-}(P)^{2}$.

If ${\lvert}w\rangle$ is an approximate positive witness for $x$ in $P$, then define

[TABLE]

We have

[TABLE]

We can bound the error as:

[TABLE]

Next, observe that

[TABLE]

Thus, using the assumption $\left\|{\lvert}w_{0}\rangle\right\|\leq 1$, and the fact that $\Pi_{\mathrm{row}(A)}{\lvert}w\rangle={\lvert}w_{0}\rangle$:

[TABLE]

Note that we could assume that $\widehat{W}_{-}(P)\geq 1$ because $\left\|w_{0}\right\|\leq 1$.

We complete the proof by extending to the general case. Let $P$ be any span program that $\kappa$-approximates $f$. By applying Theorem A.1 and Corollary A.2, we can get a span program, $P_{0}$, with $\left\|{\lvert}w_{0}\rangle\right\|=1$, ${W_{-}(P_{0})}\leq 2$, $\widehat{W}_{+}(P_{0})\leq C(P)^{2}+2$, and $s(P_{0})=s(P)+2$, that $\sqrt{\kappa}$-approximates $f$. We can then apply the construction described above, iteratively, $d$ times, to get a span program $P_{d}$ that $\sqrt{\kappa}^{2^{d}}=\kappa^{2^{d-1}}$-approximates $f$, with

[TABLE]

[TABLE]

Setting $d=\log\left(\frac{\log\frac{1}{\kappa^{\prime}}}{\log\frac{1}{\kappa}}\right)+1$ gives the desired $\kappa^{\prime}$. ∎

Appendix B Proofs of Lemma 5.17 and Lemma 5.18

We will prove the lemmas as a collection of claims. Fix $T^{\prime}\geq T$ and $M^{\prime}\geq M$ with which to run the algorithm. Suppose $\Phi(x)$ outputs ${\lvert}\psi(x)\rangle=\sqrt{p_{x}}{\lvert}0\rangle_{A}{\lvert}\Phi_{0}(x)\rangle+\sqrt{1-p_{x}}{\lvert}1\rangle_{A}{\lvert}\Phi_{1}(x)\rangle$, and let $\tilde{p}$ denote the estimate output by the algorithm. We will let $U{\cal O}_{x}=\sum_{j}e^{i\sigma_{j}(x)}{\lvert}\lambda_{j}^{x}\rangle{\langle}\lambda_{j}^{x}\rvert$ be an eigenvalue decomposition.

Claim B.1**.**

If $f(x)=0$ then $\left\|\Pi_{0}(x){\lvert}\psi_{0}\rangle\right\|^{2}\geq\frac{1}{M^{2}}$.

Proof.

Since the algorithm computes $f$ with bounded error, the probability of accepting $x$ is at most $1/3$, so $\tilde{p}\leq\delta$ with probability at most $1/3$.

Amplitude estimation is just phase estimation of a unitary $W_{\Phi}$ such that ${\lvert}\psi(x)\rangle$ is in the span of $e^{\pm 2i\theta_{x}}$-eigenvectors of $W_{\Phi}$, where $p_{x}=\sin^{2}\theta_{x}$, $\theta_{x}\in[0,\pi/2)$ [BHMT02]. One can show that the probability of outputting an estimate $\tilde{p}=0$ is $\sin^{2}(M^{\prime}\theta_{x})/({M^{\prime}}^{2}\sin^{2}(\theta_{x}))$, so

[TABLE]

If $M^{\prime}\theta_{x}\leq\frac{\pi}{2}$, then this would give:

[TABLE]

which is a contradiction. Thus, we have:

[TABLE]

Since $\Phi(x)$ is the result of running phase estimation, we have

[TABLE]

for any $\Theta$. In particular, if $\Delta$ is less than the spectral gap of $U{\cal O}_{x}$, we have $\left\|\Pi_{\Delta}(x){\lvert}\psi_{0}\rangle\right\|=\left\|\Pi_{0}(x){\lvert}\psi_{0}\rangle\right\|$, so

[TABLE]

This is true for any choices $T^{\prime}\geq T$ and $M^{\prime}\geq M$, so we must have:

[TABLE]

Claim B.2**.**

If $f(x)=1$ and $\delta=0$, then for any $d<\frac{\sqrt{8}}{\pi}$, $\left\|\Pi_{d\pi/T}(x){\lvert}\psi_{0}\rangle\right\|^{2}=0$.

Proof.

Suppose towards a contradiction that $\left\|\Pi_{d\pi/T}(x){\lvert}\psi_{0}\rangle\right\|^{2}>0$. Then $p_{x}>0$, and some sufficiently large $M^{\prime}\geq M$ would detect this and cause the algorithm to output 0, so we must actually have $\left\|\Pi_{d\pi/T}(x){\lvert}\psi_{0}\rangle\right\|^{2}=0$. In fact, in order to sure that no large enough value $M^{\prime}$ detects amplitude $>0$ on ${\lvert}0\rangle_{A}$, we must have $p_{x}=0$ whenever $f(x)=1$. That means that when $f(x)=1$, the algorithm never outputs 0, so the algorithm has one-sided error. ∎

Claim B.3**.**

There is some constant $c$ such that if $f(x)=0$ and $\delta>0$ then $\left\|\Pi_{0}(x){\lvert}\psi_{0}\rangle\right\|^{2}>\delta(1+c)$.

Proof.

Recall that $\tilde{p}\in\{\sin^{2}(\pi m/M^{\prime}):m=0,\dots,M^{\prime}-1\}$. We will restrict our attention to choices $M^{\prime}$ such that for some integer $d$,

[TABLE]

To see that such a choice exists, let ${\tau}$ be such that $\delta=\sin^{2}\tau$, and note that the condition holds as long as $d\leq\frac{\tau M^{\prime}}{\pi}<d+1/3$ for some $d$, which is equivalent to saying that ${\lfloor}\frac{3\tau M^{\prime}}{\pi}\rfloor=0\mod 3$. If $K={\lfloor}\frac{1}{2}\frac{\pi}{3\tau}\rfloor$, then for any $M^{\prime}\geq M$, and $\ell\geq 0$, define:

[TABLE]

Then for any $\ell>0$,

[TABLE]

so there must be one $\ell\in\{0,\dots,6\}$ such that $\lfloor\frac{3\tau}{\pi}M_{\ell}\rceil=0\mod 3$. In particular, there is some choice $M_{\ell}$ satisfying the condition such that (using some $M^{\prime}\leq\frac{1}{\sqrt{\delta}}$):

[TABLE]

We will use this value as our $M^{\prime}$ for the remainder of this proof.

Let $p_{x}=\sin^{2}\theta_{x}$ for $\theta_{x}\in[0,\pi/2]$. Let $z$ be an integer such that $\Delta=\theta_{x}-\pi z/M^{\prime}$ has $|\Delta|\leq\frac{\pi}{2M^{\prime}}$. Then the outcome $\tilde{p}=\sin^{2}\frac{\pi z}{M^{\prime}}$ has probability:

[TABLE]

since $|M^{\prime}\Delta|\leq\frac{\pi}{2}$. Thus, by correctness, we must have $\sin^{2}(\pi z/M^{\prime})>\delta\geq\sin^{2}\frac{d\pi}{M^{\prime}}$. Thus $z>d$, so

[TABLE]

Thus:

[TABLE]

When $\sin^{2}\frac{\pi}{6M^{\prime}}\leq 1-\delta$, which we can assume, the above expression is minimized when $\sin^{2}\frac{\pi}{6M^{\prime}}$ is as small as possible. We have, using $M^{\prime}\leq\frac{1+\pi}{\sqrt{\delta}}$, from (3):

[TABLE]

Thus, continuing from above, letting $k=\frac{1}{9(1+\pi)^{2}}$, we have:

[TABLE]

Next, notice that $(1-k\delta)(1-\delta)$ is minimized when $\delta=\frac{1+k}{2k}$, but $\delta\leq\frac{1}{2}<\frac{1+k}{2k}$, so we have, using $k<1$ and $\delta\leq 1/2$:

[TABLE]

Since $\Phi(x)$ is the result of running phase estimation of $U{\cal O}_{x}$ for $T^{\prime}\geq T$ steps, we have:

[TABLE]

so in particular, for any $\Theta\in[0,\pi)$, we have

[TABLE]

In particular, for any $\Theta<\Delta$ where $\Delta$ is the spectral gap of $U{\cal O}_{x}$, we have $\left\|\Pi_{\Theta}(x){\lvert}\psi_{0}\rangle\right\|=\left\|\Pi_{0}(x){\lvert}\psi_{0}\rangle\right\|$, so for any $T^{\prime}\geq T$, we have

[TABLE]

Since this holds for any $T^{\prime}\geq T$, we get

[TABLE]

The proof is completed by letting $c=\sqrt{k}$. ∎

Claim B.4**.**

If $f(x)=1$ and $\delta>0$ then $\left\|\Pi_{d\pi/T}(x){\lvert}\psi_{0}\rangle\right\|^{2}(1-d^{2}\pi^{2}/8)\leq\delta$.

Proof.

If ${\lvert}\lambda\rangle$ is an $e^{i\theta}$-eigenvector of $U{\cal O}_{x}$ for some $|\theta|\leq d\pi/T<\sqrt{8}/T$, then the probability of measuring 0 in the phase register upon performing $T$ steps of phase estimation is:

[TABLE]

Let $\varepsilon(x)=1-\frac{\sin^{2}x}{x^{2}}$ for any $x$. It is simple to verify that $\varepsilon(x)\leq x^{2}/2$ for any $x$, and $\varepsilon(x)\in[0,1]$ for any $x$. So we have:

[TABLE]

Thus, we conclude that

[TABLE]

If this is $>\delta$, then with some sufficiently large $M^{\prime}\geq M$, amplitude estimation would detect this and cause the algorithm to output 0 with high probability. ∎