Complexity-theoretic limitations on blind delegated quantum computation

TL;DR

This paper investigates the fundamental complexity-theoretic limitations of blind delegated quantum computation protocols, showing that certain secure protocols are unlikely to exist under standard conjectures and exploring their implications.

Contribution

It provides complexity-theoretic constraints on the existence of information-theoretically secure blind quantum delegation protocols, highlighting their limitations and implications for quantum computational complexity.

Findings

Classical communication protocols imply unlikely complexity class containments.

Protocols for quantum sampling problems relate to non-uniform circuit sizes.

One-round quantum-classical protocols constrain the functions that can be delegated.

Abstract

Blind delegation protocols allow a client to delegate a computation to a server so that the server learns nothing about the input to the computation apart from its size. For the specific case of quantum computation we know that blind delegation protocols can achieve information-theoretic security. In this paper we prove, provided certain complexity-theoretic conjectures are true, that the power of information-theoretically secure blind delegation protocols for quantum computation (ITS-BQC protocols) is in a number of ways constrained. In the first part of our paper we provide some indication that ITS-BQC protocols for delegating $\sf BQP$ computations in which the client and the server interact only classically are unlikely to exist. We first show that having such a protocol with $O(n^d)$ bits of classical communication implies that $\mathsf{BQP} \subset \mathsf{MA/O(n^d)}$. We conjecture that this containment is unlikely by providing an oracle relative to which $\mathsf{BQP} \not\subset \mathsf{MA/O(n^d)}$. We then show that if an ITS-BQC protocol exists with polynomial classical communication and which allows the client to delegate quantum sampling problems, then there exist non-uniform circuits of size $2^{n - \mathsf{\Omega}(n/log(n))}$, making polynomially-sized queries to an $\sf NP^{NP}$ oracle, for computing the permanent of an $n \times n$ matrix. The second part of our paper concerns ITS-BQC protocols in which the client and the server engage in one round of quantum communication and then exchange polynomially many classical messages. First, we provide a complexity-theoretic upper bound on the types of functions that could be delegated in such a protocol, namely $\mathsf{QCMA/qpoly \cap coQCMA/qpoly}$. Then, we show that having such a protocol for delegating $\mathsf{NP}$-hard functions implies $\mathsf{coNP^{NP^{NP}}} \subseteq \mathsf{NP^{NP^{PromiseQMA}}}$.

Figures

Equations

$${\rho }_1=T{r}_2({\rho }_1\otimes {\rho }_2){\rho }_2=T{r}_1({\rho }_1\otimes {\rho }_2)$$

$$\rho =\sum _{i,i^{\prime },j,j^{\prime }}{a}_{i{i}^{\prime }j{j}^{\prime }}{|i⟩}_1{⟨i^{\prime }|}_1\otimes {|j⟩}_2{⟨j^{\prime }|}_2$$

$$T{r}_2(\rho )=T{r}_2\left(\sum _{i,i^{\prime },j,j^{\prime }}{a}_{i{i}^{\prime }j{j}^{\prime }}{|i⟩}_1{⟨i^{\prime }|}_1\otimes {|j⟩}_2{⟨j^{\prime }|}_2\right)=\sum _{i,i^{\prime },j}{a}_{i{i}^{\prime }jj}{|i⟩}_1{⟨i^{\prime }|}_1$$

$$T{r}_2(|\psi ⟩⟨\psi |)=\rho$$

$$|\varphi ⟩=(I\otimes U)|\psi ⟩$$

$$\mathsf{X}=\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right]\mathsf{Z}=\left[\begin{array}{cc}1& 0\\ 0& -1\end{array}\right]\mathsf{H}=\frac{1}{\sqrt{2}}\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right]\mathsf{T}=\left[\begin{array}{cc}1& 0\\ 0& e^{i\pi /4}\end{array}\right]\mathsf{CNOT}=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\\ 0& 0& 1& 0\end{array}\right]$$

$$\frac{|0⟩|\psi ⟩|\varphi ⟩+|1⟩|\varphi ⟩|\psi ⟩}{\sqrt{2}}$$

$$|\psi ⟩=\sum _S{\alpha }_S|S⟩,\text{ with }\sum _S|{\alpha }_S{|}^2=1$$

$$Pr(S)=\frac{|Per(A_S){|}^2}{s_1!s_2!...s_m!}$$

$$Per(M)=\sum _{\sigma \in S_n}\prod _{i=1}^n{m}_{i,\sigma (i)}$$

$$p=\frac{1}{2^n}\sum _{x\in \{0,1{\}}^n}f(x)$$

$$\underset{r{\leftarrow }_R\{0,1{\}}^{p(n)}}{\mathrm{Pr}}\left(F(A,r)=S\right)=\frac{|Per(A_S){|}^2}{s_1!s_2!...s_m!}$$

$$f(A,r)=\left\{\begin{array}[]{ll}0,&\text{ if }F(A,r)\neq\ket{1_{n}}\\ 1,&\text{ if }F(A,r)=\ket{1_{n}}\\ \end{array}\right.$$

$$\underset{r{\leftarrow }_R\{0,1{\}}^{p(n)}}{\mathrm{Pr}}\left(F(A,r)=|1_n⟩\right)=\frac{1}{2^{p(n)}}\sum _{r\in \{0,1{\}}^{p(n)}}f(A,r)$$

$$Pr(z\leftarrow D({\overline{s}}_m,k,x))=Pr(z\leftarrow {\mathcal{D}}_x)$$

$$Pr(S)=\frac{|Per(A_S){|}^2}{s_1!s_2!...s_m!}$$

$$coSimon(O)=\{⟨1^n,i⟩|i\in \{0,1{\}}^n\text{ and }f(x)\equiv O(1^n,i,x)\text{ is a 1-to-1 function}\}$$

$$\{⟨1^n,i⟩|i\in \{0,1{\}}^n\text{ and }f(x)\equiv O(1^n,i,x)\text{ is a Simon function}\}$$

$${\mathcal{F}}_n=\{f_i|i\in \{0,1{\}}^n\text{ and }{f}_i\text{ is defined as }{f}_i(x)\equiv O(1^n,i,x)\}$$

$$\frac{l-1}{2^n-1-l(l-1)/2}$$

$${\sigma }_j=[(x_{1j},f(x_{1j}));(x_{2j},f(x_{2j}));...(x_{lj},f(x_{lj}))]$$

$$Z=\left[\begin{array}{cccccc}{x}_{n,n}& x_{n,n-1}& \dots & x_{n,1}& 0& 0\\ x_{n-1,n}& x_{n-1,n-1}& \dots & x_{n-1,1}& 0& 0\\ ⋮& ⋮& & ⋮& ⋮& ⋮\\ x_{1,n}& x_{1,n-1}& \dots & x_{1,1}& 1& -1\\ 0& 0& \dots & 1& 0& 1\\ 0& 0& \dots & -1& -1& 0\end{array}\right]$$

$$Per(Z)=-(Per(Z^{n+2,n+1})+Per(Z^{n+2,n}))$$

$$W=\left[\begin{array}{ccccccc}{z}_{1,1}& z_{1,2}& \dots & z_{1,m}& 0& \dots & 0\\ z_{2,1}& z_{2,2}& \dots & z_{2,m}& 0& \dots & 0\\ ⋮& ⋮& & ⋮& ⋮& & ⋮\\ z_{m-1,1}& z_{m-1,2}& \dots & z_{m-1,m}& 0& \dots & 0\\ z_{m,1}& z_{m,2}& \dots & x_{1,1}& x_{1,2}& \dots & x_{1,n}\\ 0& 0& \dots & x_{2,1}& x_{2,2}& \dots & x_{2,n}\\ ⋮& ⋮& & ⋮& ⋮& & ⋮\\ 0& 0& \dots & x_{n,1}& x_{n,2}& \dots & x_{n,n}\end{array}\right]$$

$$Per(W)=Per(Z)Per(X^{1,1})+Per(Z^{m,m})Per(X)$$

$$W=\left[\begin{array}{ccccc}{z}_{1,1}& z_{1,2}& 0& \dots & 0\\ z_{2,1}& x_{1,1}& x_{1,2}& \dots & x_{1,n}\\ 0& x_{2,1}& x_{2,2}& \dots & x_{2,n}\\ ⋮& ⋮& ⋮& & ⋮\\ 0& x_{n,1}& x_{n,2}& \dots & x_{n,n}\end{array}\right]$$

$$Per(W)=z_{1,1}Per(X)+z_{1,2}{z}_{2,1}Per(X^{1,1})$$

$$Z=\left[\begin{array}{cc}{z}_{1,1}& z_{1,2}\\ z_{2,1}& 0\end{array}\right]$$

$$Per(W)=Per(Z)Per(X^{1,1})+Per(Z^{2,2})Per(X)$$

$$Per(W)=\sum _{i=1}^{m-1}{z}_{1,i}Per(W^{1,i})+z_{1,m}Per(W^{1,m})$$

Full text

In the first part of our paper we provide some indication that ITS-BQC protocols for delegating polynomial-time quantum computations in which the client and the server interact only classically are unlikely to exist. We first show that having such a protocol in which the client and the server exchange $O(n^{d})$ bits of communication, implies that ${\sf BQP}\subset{\sf MA/O(n^{d})}$. We conjecture that this containment is unlikely by proving that there exists an oracle relative to which ${\sf BQP}\not\subset{\sf MA/O(n^{d})}$. We then show that if an ITS-BQC protocol exists in which the client and the server interact only classically and which allows the client to delegate quantum sampling problems to the server (such as BosonSampling) then there exist non-uniform circuits of size $2^{n-\mathsf{\Omega}(n/log(n))}$, making polynomially-sized queries to an ${\sf NP}^{{\sf NP}}$ oracle, for computing the permanent of an $n\times n$ matrix.

The second part of our paper concerns ITS-BQC protocols in which the client and the server engage in one round of quantum communication and then exchange polynomially many classical messages. First, we provide a complexity-theoretic upper bound on the types of functions that could be delegated in such a protocol by showing that they must be contained in ${\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$. Then, we show that having such a protocol for delegating ${\sf NP}$-hard functions implies $\mathsf{coNP^{NP^{NP}}}\subseteq{\sf NP}^{{\sf NP}^{{\sf PromiseQMA}}}$.

1 Introduction

An important area of research in modern cryptography is that of performing computations on encrypted data. The general idea is that a client wants to compute some function $f$ on some input $x$, but lacks the computational power to do this in a reasonable amount of time. Luckily, the client has access to a computationally powerful server (cloud, cluster etc) which can compute $f(x)$ quickly. However, because the computation might involve sensitive or classified information, or the server could be compromised remotely, we would like the input $x$ to be hidden from the server at all times. The client can simply encrypt $x$, but this raises the question: how can the server compute $f(x)$ if it doesn’t know $x$? The general problem of computing on encrypted data was first considered by Rivest, Adleman and Dertouzos [1]. Since then, instances of this problem have appeared in many areas of modern research including those of electronic voting, machine learning on encrypted data, program obfuscation and others [2, 3, 4, 5, 6, 7].

It was shown in 2009, when Gentry produced the first fully homomorphic encryption scheme, that performing classical computations on encrypted data is possible [8]. In homomorphic encryption the client has a pair of efficient algorithms $(Enc,Dec)$, which respectively perform encryption and decryption, and which satisfy the property $Dec(f,x,Eval(f,Enc(x)))=f(x)$, for any function $f$ from some set $\mathcal{C}$. In other words, the server evaluates $f$ on the encrypted input $Enc(x)$ using $Eval$ and returns this to the client which can then decrypt it to $f(x)$. Of course, the server should not be able to infer information about $x$ from $Enc(x)$, a condition which is typically expressed through the criterion of semantic security [9]. If the set $\mathcal{C}$ contains all polynomial-sized circuits then the scheme becomes a fully homomorphic encryption scheme, commonly abbreviated FHE. All known FHE schemes are secure under cryptographic assumptions.

Computing on encrypted data becomes particularly interesting when the server is a quantum computer. This is because efficient quantum algorithms have been found for various problems which are believed to be intractable for classical computers. In fact, it has been shown that if a classical computer and a quantum computer are both given black-box or oracle access to certain functions, then the quantum computer exponentially outperforms the classical computer [10, 11, 12, 13]. Classical clients would therefore be highly motivated to delegate problems to quantum computers. However, ensuring the privacy of their inputs is challenging. In particular, we’d have to solve the following problems:

• •

Devise an encryption scheme which is secure against quantum computers and does not leak information to the server about the client’s input.

• •

Ensure that the encryption scheme allows the client to recover the output of the computation from the result provided by the quantum server.

• •

Ensure that the protocol is efficient for the client. Ideally, the number of rounds of interaction between the client and the server as well as the client’s local computations, should scale at most polynomially with the size of the input.

In spite of these stringent requirements, protocols that achieve these properties already exist and are known collectively as delegated blind quantum computing schemes [14]. In such protocols, a probabilistic polynomial-time client is able to delegate polynomial-time quantum computations to a server in such a way that the client’s input (apart from an upper bound on its size) is kept hidden from the server in an information-theoretic sense. All of the above schemes require the client and the server to share at least one round of quantum communication. Universal Blind Quantum Computation (UBQC), shown schematically in Figure 1, is an example of such a protocol [15].

The first blind delegation protocol was devised by Childs in [16], and since then these protocols have been improved and extended in various works [17, 18, 19, 20, 21, 22, 23, 24]. UBQC and related protocols require the client and the server to exchange only one quantum message, while the rest of the communication is classical [15, 25, 26]. This quantum message (which is sent by the client to the server) consists of a tensor product of single-qubit states. As such, the only quantum capability the client needs is the ability to prepare single-qubit states.

In this paper, we explore two questions pertaining to blind delegation protocols:

• (1)

Is there a scheme for blind quantum computing that is information-theoretically secure, and that requires only classical communication between client and server?

• (2)

For schemes in which the client and the server are allowed one round of quantum communication, which functions can the client delegate to the server while maintaining information-theoretic security? In particular, could the client delegate the evaluation of ${\sf NP}$-hard functions?

We provide some indication, based on complexity-theoretic conjectures, that the answer to the first question is no. In other words, provided these complexity-theoretic conjectures hold, a classical client running in polynomial time and communicating only classically with a server cannot delegate arbitrary polynomial-time quantum computations to that server while keeping its input hidden in an information-theoretic sense. Importantly, our result does not contradict recent results on quantum fully homomorphic encryption with a classical client [27, 28], since those schemes are based on cryptographic assumptions: we are interested only in information-theoretic security.

In answer to the second question, we provide a complexity-theoretic upper bound on the types of functions that can be evaluated by UBQC-type protocols (i.e. protocols in which the client can send one quantum message to the server555In fact our result concerns protocols in which the client and the server start with one round of quantum communication, followed by polynomially-many rounds of classical communication. In other words, not only is there one quantum message from the client to the server, but the server is also allowed to respond with a quantum message.). We show that, under plausible complexity-theoretic assumptions, this upper bound prevents the client from delegating ${\sf NP}$-hard functions to the server. Thus, allowing for quantum communication between the client and the server expands the set of functions that the client can delegate to the server to include ${\sf BQP}$, but not enough so as to include ${\sf NP}$ as well.

1.1 Main results

We phrase our results formally using the concept of a generalised encryption scheme (GES) introduced by Abadi, Feigenbaum and Killian [29], which is defined in Section 2.3. Roughly speaking, a GES is a protocol between a probabilistic polynomial-time classical client and a computationally unbounded server for computing on encrypted data. The client sends the server a description of some function666Unless otherwise specified, we restrict our attention to decision problems. This is why the function $f$ has the codomain $\{0,1\}$. $f:\{0,1\}^{n}\rightarrow\{0,1\}$. Using some polynomial-time algorithm denoted $E$, the client encrypts its input $x$, and sends $E(x)$ to the server. The server and the client then interact for a number of rounds which is polynomial in the length of $x$. Finally, using a polynomial-time decryption algorithm denoted $D$, the client decrypts the server’s responses and obtains $f(x)$ with probability $1/2+1/\operatorname*{poly}(n)$. Importantly throughout the protocol, the server learns no more than the length of $x$. Because the server is computationally unbounded, the scheme requires information-theoretic security. Abadi et al. gave a complexity theoretic upper bound on the types of functions that admit such a scheme. They showed that any function $f$ that the client could delegate in a GES must be contained in the class ${\sf NP/poly}\cap{\sf coNP/poly}$. We give a simplified proof of this result in Section 2.3.

The GES framework allows us to restate the questions we address in this paper as follows:

• (1)

Can we design a GES for delegating ${\sf BQP}$ functions? Note that, by the Abadi et al. result, this is the same as asking whether ${\sf BQP}\subset{\sf NP/poly}\cap{\sf coNP/poly}$. We will consider two variants on the GES framework: one which allows the client to delegate sampling problems to the server, and one in which the total communication between client and server is bounded by $\mathsf{O(n^{d})}$, for some constant $d>0$. For the former, we show that having such a scheme for quantum sampling problems, like BosonSampling, implies that circuits exist which can compute the permanent of a matrix more efficiently than we believe is possible. For the latter, having a GES with bounded communication for polynomial-time quantum computation implies that ${\sf BQP}\subset{\sf MA/O(n^{d})}$, and we argue that this containment is unlikely by providing an oracle separation between these classes.

• (2)

If we change the GES framework to allow one round of quantum communication between the client and the server, what functions can the client delegate to the server? We answer this question by “quantising” the Abadi et al. result and showing that such functions would be contained in ${\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$ (a quantum analogue of ${\sf NP/poly}\cap{\sf coNP/poly}$). We also show that ${\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$ is unlikely to contain ${\sf NP}$-hard functions.

1.1.1 Generalised encryption scheme for BQP decision problems

As we have mentioned, for the case of decision problems, Abadi et al. showed that the class of problems that a client can delegate to a server using the GES framework is contained in ${\sf NP/poly}\cap{\sf coNP/poly}$. They also observed that if ${\sf NP}$-hard functions could be delegated by the client using a GES, then ${\sf NP}\subset{\sf NP/poly}\cap{\sf coNP/poly}$, and, in particular, ${\sf NP}\subset{\sf coNP/poly}$. Yap showed that having such a containment leads to a collapse of the polynomial hierarchy at the third level [30]. In other words, it seems unlikely that ${\sf NP}$-hard problems would admit a GES.

What about ${\sf BQP}$-hard functions? The Abadi et al. result implies that having a GES for ${\sf BQP}$-hard functions leads to ${\sf BQP}\subset{\sf NP/poly}\cap{\sf coNP/poly}$. While we would like to argue, similarly, that such a containment leads to a collapse of the polynomial hierarchy, even ${\sf BQP}={\sf P}$ isn’t known to lead to such a collapse. We instead consider a modified GES in which the total communication between the client and the server is upper bounded by a polynomial of fixed degree, $d>0$, in the size of the input777Note that we impose no such restriction on the running time of the client.. In that case, it can be shown that ${\sf BQP}\subset{\sf MA/O(n^{d})}\cap{\sf coMA/O(n^{d})}$ (see the proof of Theorem 7). We argue that this containment is unlikely based on the following result, which we prove in Section 3:

Theorem 1**.**

For each $d\in\mathbb{N}$, there exists an oracle $O_{d}$ such that ${\sf BQP}^{O_{d}}$ is not contained in $({\sf MA/O(n^{d})})^{O_{d}}$.

Essentially, the theorem shows that relative to an oracle $O_{d}$, there are problems that can be solved by a polynomial-time quantum algorithm, but which a classical client cannot delegate to a server in a GES with bounded communication. Since the oracle is parameterised by $d$, we are in fact defining a family of oracles. The specific problem on which the oracle $O_{d}$ is based is a version of Simon’s problem [11]. Simon’s problem is the following: for an input of size $n$, and given oracle access to a function $g:\{0,1\}^{n}\rightarrow\{0,1\}^{n}$ that is guaranteed to be either an injective function, or a $2$-to-$1$ and periodic function888In other words, there exists a period $s\in\{0,1\}^{n}$, $s\neq 0^{n}$, such that for all $x,y\in\{0,1\}^{n}$, $x\neq y$, it is the case that $g(x)=g(y)$ iff. $x=s\oplus y$., the task is to decide which is the case. Simon provided a polynomial-time quantum algorithm for solving this problem, thus showing that it belongs to ${\sf BQP}$ (relative to the function oracle). For the case in which one should accept when the function is $2$-to-$1$, the problem can be shown to be outside of ${\sf MA}$ (relative to the function oracle). As such, Simon’s problem provides an oracle separation between ${\sf BQP}$ and ${\sf MA}$.

In Simon’s original construction, the oracle function is the same for all inputs of size $n$. Note that, this version of the problem can be solved with one bit of advice: for all inputs of size $n$, the advice bit simply specifies whether the function is $1$-to-$1$ or $2$-to-$1$ and periodic. Therefore such a setup would not be useful in our case. For this reason, in our proof of Theorem 1, the function that the oracle provides access to is input-dependent. The problem we define, relative to this oracle, is again to decide whether the function is $1$-to-$1$ or the function is $2$-to-$1$ and periodic. However, we can show that, by considering a sufficiently large domain for these functions — in other words, by letting $g:\{0,1\}^{n^{D}}\rightarrow\{0,1\}^{n^{D}}$ for some $D>d$ — the problem is not contained in $({\sf MA/O(n^{d})})^{O_{d}}$, but is nevertheless contained in ${\sf BQP}$. The proof uses a diagonalisation argument and can be found in Section 3.

Unfortunately, the same oracle cannot be used to separate ${\sf BQP}$ from ${\sf NP/poly}$. This is because $D$ is a function of $d$; to prove a separation with respect to ${\sf NP/poly}$, where the length of the advice string can be any polynomial, we would have to find an oracle that works for all possible values of $d$. It would be interesting to see whether the oracle that Raz and Tal [31] recently used to prove a separation between ${\sf BQP}$ and ${\sf PH}$ could also be used in order to separate ${\sf BQP}$ from ${\sf NP/poly}$, or even from $\mathsf{PH/poly}$. We leave this as an open problem.

One can argue that oracle results do not constitute compelling evidence on the relationships between complexity classes. For example, it has been known for a while that there exist oracles $O_{1},O_{2}$ such that ${\sf P}^{O_{1}}\neq{\sf NP}^{O_{1}}$ but ${\sf P}^{O_{2}}={\sf NP}^{O_{2}}$, and that, while ${\sf IP}={\sf PSPACE}$, there is an oracle such that ${\sf IP}^{O}\neq{\sf PSPACE}^{O}$. Nonetheless, oracles allow us to study the query complexity of problems in different models of computation. In fact, there are situations in practice where computer programs are restricted to making black-box calls to functions in order to determine their properties [32]. Apart from this, oracle results have also inspired a number of important developments in algorithms and complexity theory999A notable example is the fact that Simon’s oracle separation between ${\sf BPP}$ and ${\sf BQP}$ led to Shor’s algorithm for factoring and computing the discrete logarithm [33]. For more arguments concerning the usefulness of oracle results, see Section 1.3 of [34].

1.1.2 Generalised encryption scheme for BQP sampling problems

We consider what would happen if we have a generalised encryption scheme which allowed a client to delegate a sampling problem, such as BosonSampling, to the server. BosonSampling, defined by Aaronson and Arkhipov in [35], is essentially the problem of simulating the statistics of photons (bosons) passing through a linear optics network. One starts with a configuration of identical photons in known locations (referred to as modes). The photons then pass through the linear optics network, which consists of optical elements (beamsplitters and phase shifters). Finally, one performs a measurement to determine the new locations of the photons in the output modes of the system. The reason this is referred to as a sampling problem is because we have a probability distribution over the different configurations of photons in the output modes. In exact BosonSampling, which is the problem we consider, the task is to produce a sample from that probability distribution. Aaronson and Arkhipov showed that the probability of observing a particular configuration of photons is proportional to the squared permanent of a matrix that can be obtained efficiently from the description of the optical network. They also showed that no polynomial-time probabilistic algorithm can sample from this distribution, unless the polynomial hierarchy collapses at the third level [35]. As such, while a quantum computer could simulate the optical network and sample from the target distribution in polynomial time, it seems unlikely that classical computers could do the same.

In a GES for exact BosonSampling, the client’s input would be a description of a linear optics network101010In principle, one could also specify the configuration of the photons in the input modes as part of the client’s input. Equivalently, however, one can always initialise the input modes to some fixed initial state, and produce whichever starting state is in fact desired by altering the linear optics network.. The client would like to delegate to the server the task of sampling from the BosonSampling distribution associated with this network, while keeping the description of the network hidden from the server. In other words, upon interacting with the server and decrypting its responses, the client should obtain a sample from the BosonSampling distribution. At the same time, the server learns at most an upper bound on the size of the network. We show the following:

Theorem 2**.**

If exact BosonSampling admits a GES, then for any matrix $X\in\{-1,0,1\}^{n\times n}$, there exist circuits of size $2^{n-\mathsf{\Omega}\left(\frac{n}{\log n}\right)}$, making polynomially-sized queries to an ${\sf NP}^{\sf NP}$ oracle, for computing the permanent of $X$.

Computing the permanent of a matrix is a problem known to be ${\sf\texttt{\#}P}$-hard. By Toda’s theorem, this means that if computing the permanent were possible at any level of the polynomial hierarchy, the hierarchy would collapse at that level [36]. Moreover, the best known algorithm for computing the permanent, by Björklund, has a run-time of $2^{\mathsf{n-\Omega\left(\sqrt{n/log(n)}\right)}}$ [37]. Prior to that, the leading algorithm for computing the permanent was Ryser’s algorithm, developed over $50$ years ago, which requires $\mathsf{O(n2^{n})}$ arithmetic operations [38]. We conjecture that the circuits of Theorem 2 do not exist and, thus, that there can be no GES for BosonSampling. The proof of this result can be found in Section 4.

1.1.3 Quantum generalised encryption scheme

While having a GES for delegating ${\sf BQP}$ computations seems unlikely, we know that giving the client some minimal quantum capabilities removes this limitation: schemes such as UBQC exist which allow for the information-theoretically secure blind delegation of quantum computations. In the spirit of the Abadi et al. result, it is natural to consider quantum generalised encryption schemes (or QGES), in which the client is no longer classical, and investigate the complexity-theoretic upper bounds on functions that admit such a protocol. For the QGES, we are still assuming information-theoretic security and that the encryption scheme leaks at most the size of the input. However, unlike the GES, the client is now assumed to be a quantum computer performing polynomial-time computations111111It should be noted that our upper bound on the power of QGES schemes also holds if the client is restricted to ${\sf BPP}$ computations (as is the case in UBQC), since ${\sf BPP}\subseteq{\sf BQP}$.. Additionally, the client and the server perform one round of quantum communication at the beginning of the protocol. The rest of the communication is classical.

We impose one other restriction on the QGES, known as offline-ness. Roughly speaking, an offline protocol is one in which the client does not need to commit to any particular input (of a given size), after having sent the quantum message to the server. The quantum message only depends on the size of the input. We note that offline-ness is a property which UBQC and all other currently known blind quantum computing protocols share. From a practical perspective, this presents the client with the option of sending the first quantum message to the server and deciding at a later time on which input the server should perform the computation. One could imagine, for instance, that the client and the server have access to a quantum channel for a limited amount of time. In practice, such a situation can occur if the communication between the parties is mediated by a satellite, as is the case with satellite-based quantum-key distribution [39]. In this case, the satellite is in the line of sight of the two parties for only a few minutes at a time. Our result is the following:

Theorem 3**.**

The class of functions that a client can delegate to a server in an offline QGES is contained in ${\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$.

Note that the class ${\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$ can be seen as a quantum analogue of the class ${\sf NP/poly}\cap{\sf coNP/poly}$ which we encounter in the GES case. We therefore view Theorem 3 as a “quantisation” of the Abadi et al. bound on the power of generalised encryption schemes.

Again, in the spirit of the Abadi et al. result, one can ask whether ${\sf NP}$-complete functions are contained in ${\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$. In other words: does giving quantum capabilities to the client increase the class of functions that it can securely delegate so that this class contains ${\sf NP}$? We give an indication that the answer is no:

Theorem 4**.**

${\sf NP}\subset{\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$* implies $\mathsf{coNP^{NP^{NP}}}\subseteq{\sf NP}^{{\sf NP}^{{\sf PromiseQMA}}}$.*

Note that if $\mathsf{PromiseQMA}$ in the above expression were replaced with ${\sf NP}$, this would imply a collapse of the polynomial hierarchy at the third level. Our result is as close to a collapse of the polynomial hierarchy as one can reasonably hope to get, given a quantum hypothesis. Hence, while a QGES does allow the client to delegate ${\sf BQP}$ computations, it seems to be no more useful than the regular GES for delegating ${\sf NP}$-hard functions.

One could ask why we would even be interested in delegating ${\sf NP}$-hard problems to a quantum computer, given that we do not expect quantum computers to be able to solve such problems in polynomial time [40]. First of all, from a theoretical perspective, note that in the QGES formalism we are not limiting the server to polynomial-time quantum computations, but instead assuming that it has unbounded computational power. Therefore, the way to view this result is not as “how can a client blindly delegate the evaluation of ${\sf NP}$-hard functions to a quantum computer?” but as “can quantum communication help in blindly delegating the evaluation of ${\sf NP}$-hard functions to an unbounded server?”.

From a practical perspective, while we do not believe that quantum computers can solve ${\sf NP}$-complete problems in polynomial time, they could, in principle, solve such problems quadratically faster than classical computers, thanks to Grover’s algorithm [41]. Even though the speedup of Grover’s algorithm is only quadratic, from (say) $2^{n}$ to $2^{n/2}$, our result is only concerned with the length of the computation performed on the client side, and therefore applies to Grover’s algorithm just as it would to a quantum algorithm achieving exponential speedup. In fact, as is mentioned in [42], there are ${\sf NP}$-complete problems for which quantum computers provide a superpolynomial speedup, at least with respect to the best known classical algorithms. Our no-go theorem indicates that clients cannot exploit such speedups by delegating the computation to the server, even when allowing some quantum communication, if we also want to keep their inputs hidden in an information-theoretic sense.

Proofs of these results can be found in Section 5.

1.2 Related work

As mentioned, the problem of computing on encrypted data was first considered by Rivest, Adleman and Dertouzos [1], which then led to the development of homomorphic encryption and eventually to fully homomorphic encryption with Gentry’s scheme [8]. Since then there have been many other FHE protocols relying on more standard cryptographic assumptions and having more practical requirements [43, 44, 45].

While FHE is similar to the GES in many respects, there are also significant differences. For starters, FHE protocols have only one round of interaction between the client and the server, whereas a GES allows for polynomially many rounds. Additionally, the GES assumes the server is computationally unbounded and hence requires information-theoretic security. In contrast, FHE relies on computational security. More precisely FHE schemes have semantic security against polynomial-time (quantum) algorithms [8].

The problem of quantum computing on encrypted data was introduced by Childs [16] and Arrighi and Salvail [46]. Further development eventually led to UBQC [15, 25] and a scheme of Broadbent [26]. The latter was followed by the construction of the first schemes for quantum fully homomorphic encryption (QFHE) [47, 48]. For a review of blind quantum computing and related protocols see [14].

In the QFHE schemes of [47, 48], the server is a polynomial-time quantum computer and the client has some quantum capabilities of its own, although it is not able to perform universal quantum computations. Both the size of the exchanged messages and the number of operations of the client are polynomial in the size of the input. More recently, QFHE schemes have been proposed in which the client is completely classical [27, 28]. Similar to FHE, these protocols rely on computational assumptions for security [49] and involve one round of back and forth interaction between the client and the server. QFHE with information-theoretic security (and a computationally unbounded server) has been considered by Yu et al. in [50], where it is shown that it is impossible to have such a scheme for arbitrary unitary operations (or even arbitrary reversible classical computations). This result was later reproved by Newmann and Shi using quantum random-access codes [51]. In relation to our work, QFHE with information-theoretic security can be viewed as a one-round QGES in which the server responds with a quantum message. The complexity-theoretic upper bound we prove for QGES computable functions would then apply to QFHE as well (provided that in QFHE we only leak the size of the input to the server), since our proof allows a quantum message from the server just as well as a classical message.

The possibility of a classical client delegating a blind computation to a quantum server was considered by Morimae and Koshiba [52]. They showed that such a protocol in which the client leaks no information about its input to the server and there is only one round of interaction leads to ${\sf BQP}\subseteq{\sf NP}$, considered an unlikely containment. We consider the more general setting of a GES for ${\sf BQP}$ functions, where the number of rounds can be polynomial in the size of the input and we allow the encryption to leak the size of the input. In fact, the question of whether a GES, as defined in Abadi et al. [29], can exist for quantum computations was raised before by Dunjko and Kashefi [53].

1.3 Future work

As we remarked in Section 1.1, in the case of decision problems, the existence of a GES with bounded communication, for polynomial-time quantum computations, leads to the inclusion ${\sf BQP}\subset{\sf MA/O(n^{d})}$. We argue that this containment is unlikely based on the existence of an oracle separating the two complexity classes. A natural extension of this result would be to prove an oracle separation between ${\sf BQP}$ and ${\sf NP/poly}$. This would provide more compelling evidence that a GES for quantum computations cannot exist.

In the case of sampling problems, we showed that a GES for BosonSampling implies the existence of circuits of size $2^{n-\mathsf{\Omega}\left(\frac{n}{\log n}\right)}$, making polynomially-sized queries to an ${\sf NP}^{\sf NP}$ oracle, for computing matrix permanents. Can this result be strengthened so as to provide circuits for computing matrix permanents that would be ruled out by the strong exponential-time hypothesis? Alternatively, could one use other quantum sampling problems (such as random circuit sampling or $\sf{IQP}$ problems [54]) to show that having a GES for such a problem leads to a collapse of the polynomial hierarchy?

We also defined the QGES, which extends the GES by allowing the client to send one quantum message to the server, and gave an upper bound for the set of functions that can be delegated using an offline version of such a scheme. The immediate question one could ask is: what upper bound can we give for an online QGES? A related question is: what upper bound can we give for a QGES that allows all of the communication between the client and the server to be quantum? The difficulty in answering both of these questions is that the offline property of the QGES is what allowed us to relate the set of functions that can be delegated to advice classes. Without this property, it seems that a different approach would be needed to provide a complexity-theoretic upper bound.

Another direction that can be explored has to do with the size of the quantum communication between the client and the server. In a QGES in which the client’s quantum message is logarithmic or poly-logarithmic in the size of the input (while the classical communication is still polynomial), is it still possible to delegate ${\sf BQP}$ functions to the server? Of course, this question only makes sense if we assume that the client is not able to perform ${\sf BQP}$ computations itself.

2 Preliminaries

2.1 Quantum information and computation basics

In this subsection we provide a few basic notions regarding quantum information and quantum computation and refer the reader to the appropriate references for a more in depth presentation [55, 56].

A quantum state (or a quantum register) is a unit vector in a complex Hilbert space, $\mathcal{H}$. We denote quantum states, using standard Dirac notation, as $\Ket{\psi}\in\mathcal{H}$, called a ‘ket’ state. The dual of this state is denoted $\Bra{\psi}$, called a ‘bra’, and is a member of the dual space $\mathcal{H}^{\perp}$. We will only be concerned with finite-dimensional Hilbert spaces. Qubits are states in two-dimensional Hilbert spaces. Traditionally, one fixes an orthonormal basis for such a space, called computational basis, and denotes the basis vectors as $\Ket{0}$ and $\Ket{1}$. Gluing together systems to express the states of multiple qubits is achieved through tensor product, denoted $\otimes$. The notation $\Ket{\psi}^{\otimes n}$ denotes a state comprising of $n$ copies of $\Ket{\psi}$. If a state $\Ket{\psi}\in\mathcal{H}_{1}\otimes\mathcal{H}_{2}$ cannot be expressed as $\ket{a}\otimes\ket{b}$, for any $\ket{a}\in\mathcal{H}_{1}$ and any $\ket{b}\in\mathcal{H}_{2}$, we say that the state is entangled.

Quantum mechanics dictates that there are two ways to change a quantum state: unitary evolution and measurement. Unitary evolution involves acting with some unitary operation $U$ (so $UU^{\dagger}=U^{\dagger}U=I$, where the $\dagger$ operation denotes the hermitian adjoint, obtained through transposing and complex conjugating) on $\Ket{\psi}$, thus producing the mapping $\Ket{\psi}\rightarrow U\Ket{\psi}$.

Measurement, in its most basic form, involves expressing a state $\ket{\psi}$ in a particular orthonormal basis, $\mathcal{B}$, and then choosing one of the basis vectors as the state of the system post-measurement. The index of that vector is the classical outcome of the measurement. The post-measurement vector is chosen at random and the probability of obtaining a vector $\ket{v}\in\mathcal{B}$ is given by $|\braket{v}{\psi}|^{2}$. There are more general types of measurement, however this is the only type that is relevant to our paper.

States denoted by kets are also referred to as pure states as they are states of maximal information for a quantum system. In other words, having a pure state for a particular quantum system means knowing all there is to know about the state of that system. When maximal information is not available, states are referred to as mixed and can be represented using density matrices. These are positive semidefinite, trace one, hermitian operators. The density matrix of a pure state $\ket{\psi}$ is $\rho=\Ket{\psi}\bra{\psi}$.

An essential operation concerning density matrices is the partial trace. This provides a way of obtaining the density matrix of a subsystem that is part of a larger system. Partial trace is linear, and is defined as follows. Given two density matrices $\rho_{1}$ and $\rho_{2}$ with Hilbert spaces $\mathcal{H}_{1}$ and $\mathcal{H}_{2}$, we have that:

[TABLE]

In the first case one is ‘tracing out’ system $2$, whereas in the second case we trace out system $1$. This property together with linearity completely defines the partial trace. For if we take any general density matrix, $\rho$, on $\mathcal{H}_{1}\otimes\mathcal{H}_{2}$, expressed as:

[TABLE]

where $\{\ket{i}\}$ ($\{\ket{i^{\prime}}\}$) and $\{\ket{j}\}$ ($\{\ket{j^{\prime}}\}$) are orthonormal bases for $\mathcal{H}_{1}$ and $\mathcal{H}_{2}$, if we would like to trace out subsystem $2$, for example, we would then have:

[TABLE]

An important result, concerning the relationship between mixed states and pure states which we use in our paper, is the fact that any mixed state can be purified. In other words, for any mixed state $\rho$ over some Hilbert space $\mathcal{H}_{1}$ one can always find a pure state $\ket{\psi}\in\mathcal{H}_{1}\otimes\mathcal{H}_{2}$ such that $dim(\mathcal{H}_{1})=dim(\mathcal{H}_{2})$121212One could allow for purifications in larger systems, but in our paper we restrict attention to same dimensions. and:

[TABLE]

Moreover, the purification $\ket{\psi}$ is not unique and so another important result is the fact that if $\ket{\phi}\in\mathcal{H}_{1}\otimes\mathcal{H}_{2}$ is another purification of $\rho$ then there exists a unitary $U$, acting only on $\mathcal{H}_{2}$ (the additional system that was added to purify $\rho$) such that:

[TABLE]

We will refer to this as the purification principle.

Quantum computation is most easily expressed in the quantum gates model. In this framework, gates are unitary operations which act on groups of qubits. As with classical computation, universal quantum computation is achieved by considering a fixed set of quantum gates which can approximate any unitary operation up to a chosen precision. The most common universal set of gates is given by:

[TABLE]

In order, the operations are known as Pauli $\mathsf{X}$ and Pauli $\mathsf{Z}$, Hadamard, the $\mathsf{T}$-gate and controlled-NOT. Note that general controlled-$U$ operations are operations performing the mapping $\Ket{0}\ket{\psi}\rightarrow\ket{0}\ket{\psi}$, $\ket{1}\ket{\psi}\rightarrow\ket{1}U\ket{\psi}$. The matrices express the action of each operator on the computational basis. A classical outcome for a particular quantum computation can be obtained by measuring the quantum state resulting from the application of a sequence of quantum gates.

The final notion which needs mentioning is the quantum SWAP test. This is a simple procedure for determining whether two quantum states $\ket{\psi},\ket{\phi}\in\mathcal{H}$ are close to each other or far apart. We express closeness in terms of the absolute value of their inner product $|\braket{\psi}{\phi}|$. The test involves preparing a qubit in the state $(\ket{0}+\ket{1})/\sqrt{2}$ and performing a controlled-SWAP operation between that qubit and the state $\ket{\psi}\ket{\phi}$. SWAP is defined by the mapping $\ket{\psi}\ket{\phi}\rightarrow\ket{\phi}\ket{\psi}$, so we obtain the state:

[TABLE]

If one then applies a Hadamard operation to the first qubit and measures it in the computational basis it can be shown that the probability of obtaining outcome $\ket{0}$ is $(1+|\braket{\psi}{\phi}|^{2})/2$.

2.2 Complexity theory

2.2.1 Decision problems

We use standard complexity theory notation and refer the reader to the Complexity Zoo [57] for the definitions of standard complexity classes. Briefly, ${\sf P}$ is the class of decision problems131313A decision problem is a problem in which for every input $x\in\{0,1\}^{*}$, the output is either “yes” or ”no”. A decision problem can be represented as either a function $f:\{0,1\}^{*}\rightarrow\{0,1\}$, or as a subset of $\{0,1\}^{*}$ representing the “yes” instances to the problem. Such a set is known as a language. that can be solved by a deterministic polynomial-time classical algorithm (or Turing machine). If the algorithm is allowed to use randomness (and we require that it outputs the correct answer with probability greater than $2/3$) the corresponding class is ${\sf BPP}$. The class of decision problems for which “yes” instances admit a polynomial-sized proof string (or witness) that can be verified by the polynomial-time algorithm is known as ${\sf NP}$141414There is an equivalent definition of ${\sf NP}$ as the set of all decision problems that can be solved by a non-deterministic polynomial-time algorithm (or Turing machine). The non-deterministic part simply means that the algorithm can guess a witness.. The analogous class for “no” instances is ${\sf coNP}$, referred to as the complement of ${\sf NP}$. Once again, if the polynomial-time algorithm also uses randomness the corresponding classes are ${\sf MA}$ and $\mathsf{coMA}$, respectively. The class of decision problems that can be decided in polynomial-time by a quantum algorithm is denoted ${\sf BQP}$. There are two quantum analogues of ${\sf MA}$. One is ${\sf QMA}$ which is the class of decision problems in which “yes” instances admit a quantum witness, of polynomially-many qubits, that can be verified by a polynomial-time quantum algorithm. The other is ${\sf QCMA}$, which is the same as ${\sf QMA}$ except the witness is a classical bit-string, rather than a quantum state. Complements of these classes are denoted $\mathsf{coQMA}$ and $\mathsf{coQCMA}$, respectively. For all classes mentioned here, we say that a problem $P$ is hard for the class $\mathcal{C}$ if for all problems $P^{\prime}\in\mathcal{C}$ there exists a deterministic polynomial-time algorithm mapping each “yes” instance of $P^{\prime}$ to a “yes” instance of $P$ and each “no” instance of $P^{\prime}$ to a “no” instance of $P$, respectively. We also say that $P$ is complete for $\mathcal{C}$ if $P$ is hard for $\mathcal{C}$ and $P\in\mathcal{C}$.

As a slight abuse of terminology, we will sometimes say “${\sf BPP}$ machine/algorithm” or “${\sf BQP}$ machine/algorithm” to mean either a probabilistic polynomial-time algorithm, or a polynomial-time quantum algorithm, respectively. Analogous terminology may be used for the other classes as well151515For instance, a “$\mathsf{QCMA}$ machine” refers to a polynomial-time quantum algorithm that also receives a classical witness string..

An important category of complexity classes that we encounter throughout the paper is that of advice classes. Let us provide a definition of this concept:

Definition 1**.**

Let $\mathcal{C}$ be a complexity class and $\mathcal{F}$ a family of functions $f:\mathbb{N}\rightarrow\{0,1\}^{*}$. The complexity class $\mathcal{C}/\mathcal{F}$, known as $\mathcal{C}$ with $\mathcal{F}$ advice, is the set of all languages $L$, for which there exists an $L^{\prime}\in\mathcal{C}$ and a function $f\in\mathcal{F}$ such that for all $x\in\{0,1\}^{*}$, $x\in L$ iff. $\braket{x,f(}{x}{)}\in L^{\prime}$.

As an example, consider the class ${\sf P/poly}$. This consists of all languages that can be decided by a deterministic polynomial-time algorithm, that receives polynomially-many bits of advice for all inputs of the same length. In other words, for all inputs $x\in\{0,1\}^{n}$, the algorithm also receives some string $a\in\{0,1\}^{poly(n)}$, aiding it in deciding whether to accept $x$ or not. Analogously ${\sf NP/poly}$ consists of languages that can be decided by a polynomial-time verifier receiving a witness for “yes” instances and a trusted advice string that only depends on the size of the input. We also encounter the class ${\sf MA/O(n^{d})}$ in which the size of the advice string is $\mathsf{O(n^{d})}$, for some fixed constant $d$.

Some of the advice classes used in the paper are not covered by Definition 1. For instance, the class $\sf{BPP/rpoly}$ denotes the set of languages that can be decided by a ${\sf BPP}$ machine that receives randomised polynomial-size advice. In other words, for all inputs $x\in\{0,1\}^{n}$, the probabilistic algorithm also receives some string $a\in\{0,1\}^{poly(n)}$, that is drawn from a distribution $\mathcal{D}_{n}$. We can see that this does not satisfy Definition 1 since the advice string is not the result of some deterministic function, but is a sample from a probability distribution. It should therefore be understood that $\mathsf{rpoly}$ corresponds to polynomial-size advice drawn from a probability distribution that only depends on the size of the input. An important result we use, concerning randomised advice, is the following:

Theorem 5** (Aaronson [58]).**

${\sf MA/rpoly}={\sf MA/poly}={\sf NP/poly}$**

It should be noted that the equalities are only known to hold for classes of decision problems.

We can similarly have quantum advice. As an example, the class $\sf{BQP/qpoly}$ denotes the set of languages that can be decided by a ${\sf BQP}$ machine that receives as advice a quantum state of polynomially-many qubits. In other words, for all inputs $x\in\{0,1\}^{n}$, the quantum algorithm also receives a quantum state $\ket{\psi_{n}}\in\mathcal{H}_{n}$, such that $dim(\mathcal{H}_{n})=2^{poly(n)}$. Hence, the suffix $\mathsf{qpoly}$ will indicate polynomially-sized quantum advice and represents a quantum state of polynomially-many qubits that only depends on the size of the input.

The concept of oracles is also used throughout the paper. Briefly, an oracle is a black box function that can be invoked by an algorithm (either classical or quantum) in order to obtain the solution to some problem in one time step. For example, the class of problems which can be solved by a deterministic polynomial-time algorithm with access to some oracle function $O:\{0,1\}^{*}\rightarrow\{0,1\}$ is denoted ${\sf P}^{O}$. If $O$ is an oracle for some ${\sf NP}$-complete problem, then the corresponding class is denoted ${\sf P}^{{\sf NP}}$. Oracles can be used to define the polynomial hierarchy. The zeroth level of the polynomial hierarchy is given by the classes $\Sigma_{0}^{\sf P}={\sf P}$, $\Pi_{0}^{\sf P}={\sf P}$. The $k$’th level of the hierarchy is then defined as $\Sigma_{k}^{\sf P}={\sf NP}^{\Sigma_{k-1}^{\sf P}}$, $\Pi_{k}^{\sf P}={\sf coNP}^{\Sigma_{k-1}^{\sf P}}$. Finally, the polynomial hierarchy is defined as ${\sf PH}=\cup_{k\geq 0}\Sigma_{k}^{\sf P}$. We say that the polynomial hierarchy collapses at level $k$ iff. $\Sigma_{k}^{\sf P}=\Pi_{k}^{\sf P}$. While not a decision class, we also mention ${\sf\texttt{\#}P}$ which is the class of all functions $f:\{0,1\}^{*}\rightarrow\mathbb{N}$ that take as input a description of a polynomial-time algorithm and output the number of inputs that the algorithm accepts (i.e. the number of “yes” instances). An important result in complexity theory is Toda’s theorem [36], which states that ${\sf PH}\subseteq{\sf P}^{{\sf\texttt{\#}P}}$.

For quantum classes, oracles are viewed as unitary operations that perform mappings of the form $U_{O}\ket{x}\ket{y}=\ket{x}\ket{y\oplus O(x)}$, where $O$ is the oracle function. Additionally, whenever a result involving complexity classes remains true when those classes are given access to an oracle, $O$, we say that the result relativises.

2.2.2 Sampling problems and BosonSampling

This section discusses sampling problems. These are problems for which the input specifies a probability distribution and the goal is to sample either exactly or approximately from that distribution. In this paper, we will only be interested in exact sampling and specifically in the BosonSampling problem, defined by Aaronson and Arkhipov [35]. As mentioned in the introduction, in BosonSampling, identical photons (bosons) are sent through a linear optics network and non-adaptive measurements are performed to count the number of photons in each mode. In more detail, for a quantum system with $m$ modes and $n$ photons, the basis states of the system are of the form $S=(s_{1},...s_{m})$, where $s_{i}$ denotes the number of photons in mode $i$ (so $s_{1}+...+s_{m}=n$). A general state, is then a state of the form:

[TABLE]

Note that the number of basis states is $M={m+n-1\choose n}$. The action of the linear optics network can be expressed as a matrix $A\in\mathcal{U}_{m,n}$, where $\mathcal{U}_{m,n}$ is the set of all $m\times n$ column-orthonormal matrices. Let $A_{S}$ be the matrix obtained by taking $s_{i}$ copies of the $i$’th row of $A$, for all $i\leq m$. If the initial state of the system consists of one photon in each of the first $n$ modes (it is assumed that $m\geq n$), a state denoted as $\ket{1_{n}}=\ket{1,...,1,0,...,0}$, then it can be shown (see [35]) that the probability of observing the state $S$, upon passing the photons through the network described by $A$ and measuring the number of photons in each mode, will be:

[TABLE]

where $Per(M)$ denotes the permanent of a matrix $M=(m_{ij})_{i,j\leq n}$, and is defined as:

[TABLE]

with $S_{n}$ the symmetric group of all permutations of the elements $1$ up to $n$.

Exact BosonSampling is then the problem of sampling from the distribution defined by Equation 7. This problem is believed to be hard for classical computers and to explain why we first need to state a result known as Stockmeyer’s approximate counting method:

Theorem 6** (Stockmeyer [59]).**

Let $f:\{0,1\}^{n}\rightarrow\{0,1\}$ be a function that can be computed by a deterministic polynomial-time algorithm and let:

[TABLE]

Then for all $g\geq 1+1/poly(n)$ there exists a ${\sf BPP}^{{\sf NP}}$ algorithm that computes $p$ to within a multiplicative factor of $g$161616In other words, the algorithm computes $\tilde{p}$ such that $p/g\leq\tilde{p}\leq gp$..

Now, suppose there existed a ${\sf BPP}$ algorithm that, given $A$ (the description of the linear optics network) as input, could sample from the distribution of Equation 7. This algorithm can be viewed as a deterministic polynomial-time computable function $F$ that, given $A$ and a string $r\in\{0,1\}^{p(n)}$, drawn from the uniform distribution, for some polynomial $p$, produces a vector $S=(s_{1},...s_{m})$ (of the form described above). The fact that this algorithm can sample from the BosonSampling distribution can be expressed mathematically as:

[TABLE]

where $r\leftarrow_{R}\{0,1\}^{p(n)}$ denotes the fact that $r$ was drawn uniformly at random from the set $\{0,1\}^{p(n)}$.

Consider now the state $\ket{1_{n}}$ (or any state in which all $s_{i}$ are either [math] or $1$). What is the probability of observing $\ket{1_{n}}$ in the output modes? Using Equation 7 we see that it is $Pr(\ket{1_{n}})=|Per(A_{\ket{1_{n}}})|^{2}$. We will define a function $f$ as follows:

[TABLE]

Note that $f$ is computable in polynomial time (since it simply involves evaluating $F$ and testing whether the output is $\ket{1_{n}}$). The probability that the ${\sf BPP}$ algorithm produces the output $\ket{1_{n}}$ can then be expressed as:

[TABLE]

But this sum can be estimated, up to multiplicative error, in ${\sf BPP}^{{\sf NP}}$ using Stockmeyer’s method. In other words, there is a ${\sf BPP}^{{\sf NP}}$ algorithm for estimating $|Per(A_{\ket{1_{n}}})|^{2}$. It is shown in [35] that one can consider any matrix $M\in\{-1,0,1\}^{n\times n}$ and embed it in $A$ (with only an added polynomial overhead) so that the probability of sampling the $\ket{1_{n}}$ state is proportional to $|Per(M)|^{2}$. By the above argument, this means that computing a multiplicative estimate for the squared permanent of a matrix over $\{-1,0,1\}$ is in ${\sf BPP}^{{\sf NP}}$. However, computing such an estimate is ${\sf\texttt{\#}P}$-hard [35]. It is also known that ${\sf BPP}^{{\sf NP}}$ is contained in the third level of the polynomial hierarchy [60], which leads us to conclude, using Toda’s theorem, that the polynomial hierarchy collapses at the third level. Such a collapse is regarded as unlikely and therefore the existence of an efficient classical algorithm for BosonSampling is also considered unlikely.

2.3 Generalised Encryption Scheme (GES)

The basis of most of the results in our paper is the generalised encryption scheme. We state its definition from [29]:

Definition 2** ([29] Generalised Encryption Scheme (GES)).**

A generalised encryption scheme (GES) is a two party protocol between a classical client $C$, and an unbounded server $S$, characterised by:

• •

A function $f:\{0,1\}^{*}\rightarrow\{0,1\}$.

• •

A cleartext input $x\in\{0,1\}^{*}$, for which the client wants to compute $f(x)$.

• •

An expected polynomial-time key generation algorithm $K$ which works as follows: for any $x\in\{0,1\}^{*}$, with probability greater than $1/2+1/poly(|x|)$ we have $(k,success)\leftarrow K(x)$, where $k\in\{0,1\}^{poly(|x|)}$. If the algorithm does not return $success$ then we have $(k^{\prime},fail)\leftarrow K(x)$, where $k^{\prime}\in\{0,1\}^{poly(|x|)}$.

• •

A polynomial-time deterministic algorithm $E$ which works as follows: for any $x\in\{0,1\}^{*}$, $k\in\{0,1\}^{poly(|x|)}$ and $s\in\{0,1\}^{poly(|x|)}$ we have that $y\leftarrow E(x,k,s)$, where $y\in\{0,1\}^{poly(|x|)}$.

• •

A polynomial-time deterministic decryption algorithm $D$, which works as follows: for any $x\in\{0,1\}^{*}$, $k\in\{0,1\}^{poly(|x|)}$ and $s\in\{0,1\}^{poly(|x|)}$ we have that $z\leftarrow D(s,k,x)$, where $z\in\{0,1\}^{poly(|x|)}$.

And satisfying the following properties:

There are $m$ rounds of communication, such that $m=poly(|x|)$. Denote the client’s message in round $i$ as $c_{i}$ and the server’s message as $s_{i}$. 2. 2.

On cleartext input $x$, $C$ runs the key generation algorithm until success to compute a key $(k,success)=K(x)$. This happens before the communication between $C$ and $S$ is initiated, and the key $k$ is used throughout the protocol. 3. 3.

In round $i$ of the protocol, $C$ computes $c_{i}=E(x,k,\overline{s}_{i-1})$, where $\overline{s}_{i-1}$ denotes the server’s responses up to and including round $i-1$, i.e. $\langle s_{0},s_{1}...s_{i-1}\rangle$. We assume that $s_{0}$ is the empty string. $C$ then sends $c_{i}$ to $S$. 4. 4.

In round $i$ of the protocol, $S$ responds with $s_{i}$, such that $s_{i}\in\{0,1\}^{poly(|x|)}$. Additionally, the server’s responses are drawn probabilistically from a distribution which is consistent with property $5$. 5. 5.

At the end of the protocol, $C$ computes $z\leftarrow D(\overline{s}_{m},k,x)$ and with probability $1/2+1/poly(|x|)$, we have that $z=f(x)$.

Let us provide some intuition for this definition. The purpose of a GES is to allow a client to compute some $f(x)$ which it cannot compute with its own resources. It does this by interacting with a computationally powerful server for a number of rounds which is polynomial in the size of the input. Importantly, the GES allows the client to hide some information about $x$ from the server. We make this statement more precise through the following definition:

Definition 3**.**

Let $X$ be a random variable denoting the input to a GES and $T(X)$ a random variable denoting the transcript of the protocol for input $X$ (in other words $T(X)$ is a collection of all the messages exchanged between the client and the server, in a run of the GES, on input $X$). We say that a GES leaks at most $L(X)$ iff. $X$ and $T(X)$ are independent given $L(X)$.

Finally, we state and give a simplified proof of the main theorem from [29], which we will use throughout the paper:

Theorem 7** ([29] GES leaking size of input).**

If a function $f$ admits a GES which leaks at most the size of the input (i.e. $L(X)=|X|$), then $f\in{\sf NP/poly}\cap{\sf coNP/poly}$.

Proof.

Suppose that $f$ admits a GES which leaks at most the size of the input. We start by first considering the simplified case of a GES with only one round of interaction between the client and the server. The protocol works as follows:

The client runs $K(x)$ until success to produce an encryption key $k$. 2. 2.

The client computes the encrypted string $y\leftarrow E(x,k,\text{`'})$ (where the last entry is the empty string) and sends it to the server. 3. 3.

The server sends a response $r$. 4. 4.

The client decrypts his response obtaining $z\leftarrow D(r,k,x)$. With probability greater than $1/2+1/poly(|x|)$ we have that $z=f(x)$.

Assuming the existence of the one-round GES, let us construct an ${\sf MA/rpoly}$ algorithm for computing $f(x)$. In other words we are going to construct a probabilistic polynomial-time algorithm that receives a checkable witness and randomised polynomial-sized advice (the distribution from which we sample the advice will be the same for inputs of the same size). The algorithm takes $x$ as input and works as follows:

• •

Denoting $|x|=n$, the algorithm receives as advice a string $x_{n}\in\{0,1\}^{n}$ as well as $r_{n}\in\{0,1\}^{poly(n)}$, where $r_{n}$ is the server’s response, in the one-round GES, when being sent $y_{n}\leftarrow E(x_{n},k_{n},\text{`'})$ from the client. Here $k_{n}$ is simply some key which can be used to encrypt $x_{n}$. The only reason we include $x_{n}$ as part of the advice is so that we can whether $x_{n}=x$. If this is the case then the algorithm simply decrypts $r_{n}$ obtaining $f(x)$ with high probability. The next steps assume that $x_{n}\neq x$.

• •

From the assumption that the GES leaks at most the size of the input, there must be some key $k$, such that $y_{n}\leftarrow E(x,k,\text{`'})$. If there did not exist such a key and the server received $y_{n}$ he would know that the input could not be $x$ and thus learn more than the size of the input, which is not allowed. More formally, it would mean that the input and the transcript of the protocol are not independent, given the length of the input, since certain transcripts (certain $y$’s) can only occur for certain inputs. The key, $k$, will be the witness that the algorithm receives. The algorithm can check whether $y_{n}\leftarrow E(x,k,\text{`'})$.

• •

The algorithm now simply computes $z\leftarrow D(r_{n},k,x)$, which by the definition of the GES, will be $f(x)$ with probability greater than $1/2+1/poly(n)$.

We have therefore given an ${\sf MA/rpoly}$ algorithm for computing $f(x)$. To recap, the ${\sf MA}$ part comes from the fact that the algorithm is probabilistic, runs in polynomial time and receives the key $k$ as a witness. The advice is $\sf{rpoly}$ because the server’s response is drawn from some probability distribution (which depends only on the length of the input). From Theorem 5, we know that ${\sf MA/rpoly}={\sf NP/poly}$ hence $f\in{\sf NP/poly}$. Since the GES frameworks requires that the key $k$ must exist irrespective of the value of $f(x)$, this means that in our algorithm both the $f(x)=1$ case and the $f(x)=0$ have a verifiable witness. Therefore it is also the case that $f\in{\sf coNP/poly}$ and so $f\in{\sf NP/poly}\cap{\sf coNP/poly}$.

We now need to generalise this to the case where the client and the server interact for a polynomial number of rounds. Because the protocol is leaking at most the size of the input, denoted $n$, any transcript of the protocol will only depend on $n$. Therefore we can make the algorithm’s advice to be a complete transcript of the protocol drawn from the distribution of all possible transcripts for inputs of length $n$. The witness would then be a key $k$ that makes the input $x$ compatible with this transcript. From the definition of the GES this again guarantees that we obtain the correct outcome with probability $1/2+1/poly(|x|)$.

Note that if the total communication between the client and the server (i.e. the size of the transcript) were bounded by $\mathsf{O(n^{d})}$, for some constant $d>0$, the above argument shows that the functions computable in this setting are contained in ${\sf MA/O(n^{d})}$171717Strictly speaking, the above argument shows that such functions would be contained in $\mathsf{MA}$ with randomised advice of size $\mathsf{O(n^{d})}$. However, the proof that $\mathsf{MA/rpoly}={\sf NP/poly}$ can be adapted to show that ${\sf MA}$ with $\mathsf{O(n^{d})}$-size randomised advice is the same as $\mathsf{MA/O(n^{d^{\prime}})}$, with $d^{\prime}\geq d$. Essentially, we can “derandomise” the advice using deterministic advice of a larger size. The same argument cannot be used, however, to derandomise the ${\sf MA}$ part of the algorithm and obtain $\mathsf{NP/O(n^{d})}$. This is because the size of the randomness used in ${\sf MA}$ is an arbitrary polynomial.. This is because, as we have seen, the transcript is given as advice and so it will also be bounded in length by $\mathsf{O(n^{d})}$. ∎

We have seen that the functions that can be delegated in a GES are contained in ${\sf NP/poly}\cap{\sf coNP/poly}$. A question we might have regarding this result is: what can we say about ${\sf BPP}^{{\sf NP/poly}\cap{\sf coNP/poly}}$? In other words, if a ${\sf BPP}$ machine uses the GES as an oracle, does that allow it to solve more problems? Intuitively, we would expect the answer to be no and indeed using a result of Brassard [61] which shows that ${\sf P}^{{\sf NP}\cap{\sf coNP}}={\sf NP}\cap{\sf coNP}$, together with Adleman’s theorem (that ${\sf BPP}\subset{\sf P/poly}$) [62] we prove the following:

Lemma 1**.**

${\sf BPP}^{{\sf NP/poly}\cap{\sf coNP/poly}}={\sf NP/poly}\cap{\sf coNP/poly}$.

Proof.

It is clear that ${\sf NP/poly}\cap{\sf coNP/poly}\subseteq{\sf BPP}^{{\sf NP/poly}\cap{\sf coNP/poly}}$, so only we need to show that ${\sf BPP}^{{\sf NP/poly}\cap{\sf coNP/poly}}\subseteq{\sf NP/poly}\cap{\sf coNP/poly}$. To do this, we first use Adleman’s theorem [62], that ${\sf BPP}\subset{\sf P/poly}$, which we know is relativising and have that ${\sf BPP}^{{\sf NP/poly}\cap{\sf coNP/poly}}\subseteq{\sf P/poly}^{{\sf NP/poly}\cap{\sf coNP/poly}}$. Next, it is easy to show that ${\sf P/poly}^{{\sf NP/poly}\cap{\sf coNP/poly}}\subseteq{\sf P}^{{\sf NP/poly}\cap{\sf coNP/poly}}$. This is because the advice received by the ${\sf P/poly}$ machine can just as easily be obtained from the ${\sf NP/poly}\cap{\sf coNP/poly}$ oracle. In other words, for any given input $x$ and advice $a$ for the ${\sf P/poly}$ machine, the ${\sf P}$ machine can simply query the ${\sf NP/poly}\cap{\sf coNP/poly}$ oracle with $x$ in order to obtain the same advice $a$181818The fact that the oracle responds with a single bit (acceptance or rejection) is not a problem, since the ${\sf P}$ machine can query the oracle for each bit of $a$.. It then simulates the ${\sf P/poly}$ machine.

We have therefore reduced our problem to showing that ${\sf P}^{{\sf NP/poly}\cap{\sf coNP/poly}}\subseteq{\sf NP/poly}\cap{\sf coNP/poly}$. This can be done by adapting Brassard’s proof [61] that ${\sf P}^{{\sf NP}\cap{\sf coNP}}={\sf NP}\cap{\sf coNP}$. The essential part of that proof is to show that ${\sf P}^{{\sf NP}\cap{\sf coNP}}\subseteq{\sf NP}$, while the containment in ${\sf coNP}$ follows by complementation. The idea is that for any ${\sf P}^{{\sf NP}\cap{\sf coNP}}$ algorithm, $A$, deciding some language, we can devise an ${\sf NP}$ algorithm, NA, which also decides that language.

The NA algorithm will simulate $A$ until it makes a query to the ${\sf NP}\cap{\sf coNP}$ oracle. At this point NA can non-deterministically guess the response to this query. To do so, note that if some language $L\in{\sf NP}\cap{\sf coNP}$ then it is the case that $L\in{\sf NP}$ and $L^{c}\in{\sf NP}$, where $L^{c}$ is the complement of $L$. In other words, there exist non-deterministic algorithms $N_{L}$ and $N_{L^{c}}$ for deciding $L$ and $L^{c}$, respectively. Assuming $A$’s query is for the language $L$, NA will simulate $N_{L}$, and for each non-deterministic branch of this simulation it will then also simulate $N_{L^{c}}$. Since $L$ and $L^{c}$ are complementary, it cannot happen that both the $N_{L}$ and the $N_{L^{c}}$ parts of the branches are accepting. We will therefore have branches in which both $N_{L}$ and $N_{L^{c}}$ were rejecting and branches in which either $N_{L}$ was accepting or $N_{L^{c}}$ was accepting. These latter branches determine the answer to the query for the ${\sf NP}\cap{\sf coNP}$ oracle. The NA algorithm will continue simulating $A$ on these branches and reject on all others.

We can see that the above reasoning would also work if the oracle was ${\sf NP/poly}\cap{\sf coNP/poly}$ and the algorithm NA were an ${\sf NP/poly}$ algorithm receiving some advice string whose length is polynomial in the size of the input. Our modified NA can continue to simulate the oracle queries if we assume that the advice it receives is the concatenation of advices received by the ${\sf NP/poly}\cap{\sf coNP/poly}$ oracle for all queries. Since the number of queries is polynomial, the concatenation will also be polynomially bounded and hence constitutes a valid advice string for an ${\sf NP/poly}$ algorithm. Therefore ${\sf P}^{{\sf NP/poly}\cap{\sf coNP/poly}}\subseteq{\sf NP/poly}$ and through complementation ${\sf P}^{{\sf NP/poly}\cap{\sf coNP/poly}}\subseteq{\sf NP/poly}\cap{\sf coNP/poly}$.

Because ${\sf BPP}^{{\sf NP/poly}\cap{\sf coNP/poly}}\subseteq{\sf P}^{{\sf NP/poly}\cap{\sf coNP/poly}}$, our result follows immediately. ∎

We end this section with an explanation of what it means to have a GES for sampling problems. The client’s input, $x$, will be a description of a probability distribution, $\mathcal{D}_{x}:\{0,1\}^{poly(|x|)}\rightarrow[0,1]$. Upon interacting with the server and applying the decryption procedure the client obtains $z\leftarrow D(\overline{s}_{m},k,x)$ such that:

[TABLE]

In other words, the output of $D(\overline{s}_{m},k,x))$ is distributed according to $\mathcal{D}_{x}$. Just as with the GES for decision problems, throughout the interaction, the server should only be able to learn $|x|$. For the specific case of BosonSampling, with $m$ modes and $n$ photons, the input will be an $m\times n$ column-orthonormal matrix $A$. The associated distribution will be the one described in Section 2.2.2, namely:

[TABLE]

where $S$ is a particular configuration of the $n$ photons in the $m$ modes.

The proof of Theorem 7 applies to the sampling case as it did to the decision case. We therefore have that if the client can delegate exact sampling from $\mathcal{D}_{x}$ to the server, using the GES, there exists an $\mathsf{MA/rpoly}$ algorithm for exactly sampling from $\mathcal{D}_{x}$. Importantly, however, the result of Theorem 5 no longer applies and we cannot equate this algorithm with a $\mathsf{NP/poly}$ sampling algorithm. That result applies to decision classes. In fact, in the sampling case, it will be simpler to consider the sampling algorithm as a $\mathsf{{BPP}^{NP}/rpoly}$ algorithm (since $\mathsf{MA/rpoly}\subseteq\mathsf{{BPP}^{NP}/rpoly}$). In other words, the existence of a GES for sampling from $\mathcal{D}_{x}$ implies the existence of a probabilistic polynomial-time algorithm, with an ${\sf NP}$ oracle, and which receives randomised polynomial-sized advice, for sampling from $\mathcal{D}_{x}$.

3 Oracle separation between BQP and MA/O(nd)

In order to prove Theorem 1 we will construct an oracle using a version of the complement of Simon’s problem [11]. Recall that Simon’s problem is the following: given a function $f:\{0,1\}^{n}\rightarrow\{0,1\}^{n}$ (for some $n\in\mathbb{N}$) which is promised to be either $1$-to-$1$ or have Simon’s property ($f$ is $2$-to-$1$ and there exists some $s\in\{0,1\}^{n}$, $s\neq 0^{n}$, such that for $x\neq y$, $f(x)=f(y)$ iff $x=s\oplus y$), decide which is the case. In particular, for Simon’s problem, the deciding algorithm should accept if the function has Simon’s property and reject if it is a $1$-to-$1$ function. The complement of this problem simply flips these two conditions. If one is not given an explicit description of $f$ but restricts access to this function through an oracle then Simon’s problem can be used to separate ${\sf BPP}$ from ${\sf BQP}$. To be precise, the oracle is some function $O:\{0,1\}^{*}\rightarrow\{0,1\}^{*}$ such that for $n\in\mathbb{N}$, if we consider $O$ restricted to the domain $\{0,1\}^{n}$, denoted $O_{n}:\{0,1\}^{n}\rightarrow\{0,1\}^{n}$, $O_{n}$ is either a $1$-to-$1$ function or a function satisfying Simon’s property. A language which is then contained in ${\sf BQP}^{O}$ but not in ${\sf BPP}^{O}$ is $L(O)=\{0^{n}|O_{n}\text{ is a function with Simon's property}\}$ as shown in [11]. In fact, as we’ve mentioned before, the complement of this language191919Note that Simon’s problem is a promise problem, so when speaking about the complement of $L(O)$ we are in fact referring to $L^{c}(O)=\{0^{n}|O_{n}\text{ is a 1-to-1 function}\}$. can be used to separate ${\sf BQP}^{O}$ and ${\sf NP}^{O}$ [34]. Lemma 2, which we prove below, is essentially a proof of this fact for a slightly different version of the oracle.

Before proving Lemma 2, let us first address a technical point. As we remarked in the introduction, an unconstrained GES for ${\sf BQP}$ would imply ${\sf BQP}\in{\sf NP/poly}\cap{\sf coNP/poly}$. Therefore, we would ideally like to construct an oracle to separate ${\sf BQP}^{O}$ and ${\sf NP/poly}^{O}$. The intuition in constructing this hypothetical oracle would be following: instead of considering a function $O_{n}$ for each input length $n$, we consider a function $O_{x}$, for each input string $x\in\{0,1\}^{n}$. In other words, for a fixed input length, $n$, there will be $2^{n}$ functions which need to be decided. But the ${\sf NP}^{O}$ machine receives only a polynomial amount of advice, which is the same for all of these $2^{n}$ functions. Therefore this advice should be insufficient to help the ${\sf NP}^{O}$ machine in deciding all of these inputs. Formalising this intuition for any polynomial is problematic, as will become clear later (see the last paragraph of the proof of Lemma 4). For this reason, we will fix the degree of the polynomial and prove that ${\sf BQP}^{O}\not\subseteq({\sf MA/O(n^{d})})^{O}$. To do this, let us first prove the separation between ${\sf BQP}^{O}$ and ${\sf NP}^{O}$, for our specific oracle.

Lemma 2**.**

There exists an oracle $O$, based on the complement of Simon’s problem, such that ${\sf BQP}^{O}\not\subseteq{\sf NP}^{O}$.

Proof.

The separation of ${\sf BQP}$ and ${\sf NP}$ with respect to an oracle has been shown a number of times before, [10, 63, 64], including with the complement of Simon’s problem. However, we prove this lemma for our particular version of Simon’s problem where instead of assigning a function to each input length, we assign different functions to different inputs.

We proceed by defining an oracle $O$ and a language which we refer to as the complement of Simon’s problem or $coSimon(O)$, such that $coSimon(O)\in{\sf BQP}^{O}$ and $coSimon(O)\not\in{\sf NP}^{O}$. We start with the latter as it also clarifies what the oracle should do:

[TABLE]

Strictly speaking, the problem we are defining is a promise problem, so the set defined above is the set of $yes$ instances to the problem, whereas the set of $no$ instances is not the complement but the set:

[TABLE]

Here, by “Simon function” we mean a function having Simon’s property.

It is clear from this definition that the oracle $O$ is the one providing the functions for which we want test whether they are $1$-to-$1$ or have Simon’s property. Of course, the whole point is to restrict access to the descriptions of those functions and force the algorithm solving the problem to perform queries to the oracle. It is also clear that for any such $O$, $coSimon(O)$ will be contained in ${\sf BQP}^{O}$ since we can just run Simon’s algorithm on the given input and flip acceptance and rejection. As is standard in quantum query complexity, we assume that the behaviour of the quantum oracle is to perform the unitary operation $\Ket{1^{n}}\Ket{i}\Ket{x}\Ket{y}\rightarrow^{O}\Ket{1^{n}}\Ket{i}\Ket{x}\Ket{O(1^{n},i,x)\oplus y}$.

The oracle $O$ can be viewed as some function taking as input the tuple $(n,i,x)$ and outputting $f_{i}(x)$, where $f_{i}:\{0,1\}^{n}\rightarrow\{0,1\}^{n}$ is a function which is either bijective or has Simon’s property. Essentially $n$, which is given in unary, specifies the domain size of our functions, $i$ is an index for a particular function and $x$ is the value on which we evaluate $f_{i}$. These last two elements of the tuple are specified in binary and the oracle should be defined for all $n\in\mathbb{N}$ and all $i,x\in\{0,1\}^{n}$. We will denote the set of functions used by the oracle for domain size $n$ as $\mathcal{F}_{n}$, in other words:

[TABLE]

Next, we construct a so-called adversarial oracle $O$. This just means defining the family of sets $\{\mathcal{F}_{n}\}_{n\in\mathbb{N}}$, in such a way that every non-deterministic Turing machine using the oracle $O$ fails to decide correctly $coSimon(O)$. The proof will use a diagonalisation argument.

Since the set of non-deterministic Turing machines is countable we consider the $k$’th machine, $M_{k}$, and check its behaviour when $n=k+n_{0}$, for some $n_{0}\geq 0$ which we define later on. Suppose we take some index $i\in\{0,1\}^{n}$, and tentatively make the $i$’th function in $\mathcal{F}_{k}$ a $1$-to-$1$ function. By simulating the behaviour of $M_{k}$ on this input we can check to see whether it accepts or rejects. If it rejects, then we are done, since $M_{k}$ will incorrectly decide this input. Conversely, if $M_{k}$ accepts, then by definition there exists a polynomial-sized path, in the non-deterministic computation tree of the machine, which leads to acceptance. We denote this path as $\pi$, and denote the length of $\pi$ as $l=poly(n)$. $M_{k}$ can make at most $l$ queries to $O$ on this path which we can represent as a list of tuples: $[(x_{1},f_{i}(x_{1})),(x_{2},f_{i}(x_{2}))...(x_{l},f_{i}(x_{l}))]$, where $x_{1},...x_{l}$ are the queried variables. An example of such a path is shown in Figure 2.

We now simply consider a Simon function $f^{\prime}$ that matched $f_{i}$ on the queried values, i.e. $f^{\prime}(x_{1})=f_{i}(x_{1}),...f^{\prime}(x_{l})=f_{i}(x_{l})$. How do we know such a function exists? The number of possible bit masks $s$ such that $f(x)=f(x\oplus s)$ is $2^{n}-1$ (since $0^{n}$ is excluded). By having $f^{\prime}$ match $f_{i}$ on the $l$ queried values it must be that $f^{\prime}$ produces different outputs for each of these values. Therefore for any $i,j\leq l$, $i\neq j$ it must be that $s\neq x_{i}\oplus x_{j}$. This means that there are $l(l-1)/2$ values of $s$ which are restricted. But $l=poly(n)$ and since $s$ can take on $2^{n}-1$ possible values, if $n$ is sufficiently large so that $2^{n}-1>l(l-1)/2$, then we can simply choose an $s$ which is not restricted. We therefore pick $n_{0}$ to be large enough so that $2^{n}-1>l(l-1)/2$ and then take $s$ to be some mask from the available $2^{n}-1-l(l-1)/2$. We thus have a Simon function which produces the same responses to the queries on path $\pi$ as the $1$-to-$1$ function $f_{i}$. If we now just take $f_{i}$ to be $f^{\prime}$, then $\pi$ will still be an accepting path and therefore $M_{k}$ will decide incorrectly on the input $\Braket{1^{n},i}$.

Through this construction, all non-deterministic Turing machines will have some input on which they decide $coSimon(O)$ incorrectly, thus $coSimon(O)\not\in{\sf NP}^{O}$ concluding the proof. ∎

Lemma 3**.**

There exists an oracle $O$, based on the complement of Simon’s problem, such that ${\sf BQP}^{O}\not\subseteq{\sf MA}^{O}$.

Proof.

The arguments from Lemma 2 can be used to show that even if the deciding machine receives a polynomial amount of randomness, it still cannot correctly input (with high probability). This corresponds to showing that the complement of Simon’s problem also lies outside of ${\sf MA}$, relative to the oracle.

The idea for this case will be to pick the oracle at random and then reduce the problem to the case without randomness. Suppose the oracle is a $1$-to-$1$ function or a Simon function with equal probability (in either case, the specific function that is picked is chosen uniformly at random). An ${\sf MA}$ algorithm is essentially a probability distribution over ${\sf NP}$ algorithms. If the complement of Simon’s problem, with respect to the random oracle, is in ${\sf MA}$, then there must be an ${\sf NP}$ machine that decides the problem correctly with probability at least $2/3$, over the random choice of the oracle.

We have therefore reduced the task of showing that the problem is not in ${\sf MA}$ to that of showing that it is not in ${\sf NP}$. Consider a non-deterministic Turing machine that accepts a particular input (of the form described in Equation 15) of length $2n$. If the machine accepts this input that means that there exists an accepting non-deterministic path, making $l$ queries, where $l=poly(n)$. Assuming the function is a Simon function, from the proof of Lemma 2, it’s clear that the probability of finding a collision after $l$ queries , (and thus distinguishing the function from a $1$-to-$1$ function), assuming one has not been found after $l-1$ queries, is:

[TABLE]

But since $l=poly(n)$, this probability is exponentially small in $n$. Since, for any given input, there is an equal chance of it being a $1$-to-$1$ function or a Simon function, it follows that the probability that the algorithm accepts correctly is at most $1/2+2^{-\Omega(n)}$, which will be smaller than $2/3$, for sufficiently large $n$. ∎

Next, we prove:

Lemma 4**.**

For each $d\in\mathbb{N}$, there exists an oracle $O$, such that ${\sf BQP}^{O}\not\subset({\sf P/O(n^{d})})^{O}$.

Proof.

To begin with, the class ${\sf P/O(n^{d})}$ is the class of problems solved by a deterministic polynomial-time Turing machine $M$, which receives an advice of length $\mathsf{O(n^{d})}$, when the input is of size $\mathsf{O(n)}$ (in our case the input size is $2n$ since we defined $n$ as being the length of inputs to the $1$-to-$1$ and Simon functions).

In contrast to the previous case, instead of having the ability to non-deterministically choose one of exponentially many paths, a polynomial-time Turing machine $M$ receives some non-uniform information to help it in deciding $coSimon(O)$. Each advice determines a new behaviour for $M$ which can even involve a different sequence of queries to the oracle. What we want to show is that irrespective of what advice $M$ might receive, it still cannot always correctly decide $coSimon(O)$. To do this, we consider functions over a larger domain than just $n$-bit strings. In other words, for each $d$ we choose $D>d$ such that the set $\mathcal{F}_{n}$ contains $2^{n}$ functions of the form $f:\{0,1\}^{n^{D}}\rightarrow\{0,1\}^{n^{D}}$. The oracle, which we now denote as $O_{d}$, still receives queries of the form $(1^{n},i,x)$, where $|i|=n$, but now $|x|=n^{D}$.

First we need to argue that the problem can still be decided in ${\sf BQP}^{O_{d}}$. This is indeed the case, since expanding the domains of the functions simply changes the running time of the quantum algorithm from $\mathsf{O(n)}$ to $\mathsf{O(n^{D})}$. But since $D$ is just a fixed constant, the algorithm still runs in polynomial time, hence $coSimon(O_{d})\in{\sf BQP}^{O_{d}}$.

The harder part is showing $coSimon(O_{d})\not\in{\sf P/O(n^{d})}$. As before, we will prove this by diagonalisation by considering the set of all (deterministic) Turing machines and showing that no matter which advice the $k$’th machine receives it cannot correctly decide $coSimon(O_{d})$. Care must be taken, as each advice induces a different behaviour and one must consider the oracle so that all possible advice strings lead to failure. This is in contrast with the previous case where we were only interested in the behaviour of one accepting path of the non-deterministic computation tree.

Suppose we take the $k$’th deterministic polynomial-time Turing machine, $M_{k}$, and examine what happens for an input of length $n=k+n_{0}$, where $n_{0}$ will be chosen later (as before). Since the advice is a binary string of length $\mathsf{O(n^{d})}$ there are $2^{\mathsf{O(n^{d})}}$ possible advice strings. Whichever one $M_{k}$ uses it will be the same for all $2^{n}$ inputs of length $n$.

Let us now consider the first index of length $n$, namely $0^{n}$ and assign a $1$-to-$1$ function $f:\{0,1\}^{n^{D}}\rightarrow\{0,1\}^{n^{D}}$ to this index. We can inspect the behaviour of $M_{k}$ for $f$ and for each possible advice string. If for more than half of the advice strings $M_{k}$ rejects, then we keep $f$ at index $0^{n}$. This means that half of all advice strings have been eliminated (there is at least one input on which those strings lead to $M_{k}$ deciding incorrectly). If, however more than half of all advice strings make $M_{k}$ accept $f$, we will attempt to turn $f$ into a Simon function while keeping acceptance for those advice strings. This will again lead to the elimination of (at least) half of all advice strings.

For each advice $a_{j}$, where $1\leq j\leq 2^{\mathsf{O(n^{d})}}$, $M_{k}$ will make a sequence of polynomially many queries to $f$. Denote that sequence of queries together with the responses as:

[TABLE]

where $l=poly(n)$. We now consider a Simon function $f^{\prime}:\{0,1\}^{n^{D}}\rightarrow\{0,1\}^{n^{D}}$ such that for all $j$ in which $M_{k}$ with advice $a_{j}$ and queries $\sigma_{j}$ accepts and for all $t\leq l$, we have that $f^{\prime}(x_{tj})=f(x_{tj})$. In other words $f^{\prime}$ will give identical responses to the queries which make $M_{k}$ accept. Since $t$ ranges from $1$ to $l=poly(n)$ and $j$ ranges from $1$ to $2^{\mathsf{O(n^{d})}}$, the maximum number of variables which are queried is of order $2^{\mathsf{O(n^{d})}}$. But unlike in the previous lemma, this number is exponential in the size of the input, so how can we be sure that such a Simon function even exists? The trick is that we can choose the domain size through $D$ and make it large enough to accommodate for a Simon function with this property.

As before, because $f$ is bijective, no two queried variables will produce the same answer. Therefore, there cannot be a bit mask $s$ ($|s|=n^{D}$) relating any pair of the $2^{\mathsf{O(n^{d})}}$ queries. These will be the restricted values of $s$. The total number of such values is also of order $2^{\mathsf{O(n^{d})}}$, however the total number of possible values is $2^{\mathsf{O(n^{D})}}$. Thus, if we simply choose $D$ such that $2^{\mathsf{O(n^{D})}}>2^{\mathsf{O(n^{d})}}$ then we can find a Simon function $f^{\prime}$ which matches the responses of $f$ on the $2^{\mathsf{O(n^{d})}}$ queries.

Hence, for this case if we use $f^{\prime}$ as the function for index $0^{n}$ we will eliminate half of the possible advice strings. Thus, no matter how $M_{k}$ behaves we are able to eliminate half of all possible advice strings with our first input of length $2n$. Clearly this process can be repeated for the next index and so on until the last index. We are effectively halving the number of potentially useful advice strings with each index. Since we are doing this $2^{n}$ times, to eliminate all possible advice strings we just need to ensure that $2^{\mathsf{O(n^{d})}}/2^{2^{n}}<1$ or $2^{\mathsf{O(n^{d})}}<2^{2^{n}}$. To achieve this, simply choose $n_{0}$ (recall that $n=k+n_{0}$) large enough so that the inequality holds.

We therefore have that for all $k$, and for all possible advice strings, there will always be an input to $coSimon(O_{d})$ which is decided incorrectly, hence $coSimon(O_{d})\not\in{\sf P/O(n^{d})}$.

Note that the same proof would not work for ${\sf P/poly}$. A crucial element in our proof was the fact that we can make $D$ (which determines the size of the domain of each function) to be much larger than $d$ (which determines the length of the advice). But this is only possible because $d$ is fixed from the very beginning. If the advice length could be any arbitrary polynomial then no matter what constant value of $D$ we decided upon for our oracle, there would always be some $d>D$ and hence some polynomial length of the advice string for which the proof does not work. A possible “fix” would be to make $D$ part of the input in some form, so that it too can increase. So if, say, $D$ was included in the input as a $g(n)$ unary string, where $g$ is some monotonically increasing function, then for sufficiently large $n$, $g(n)>d$. But we immediately notice the problem with this approach. While it is true that in this case the problem cannot be decided in ${\sf P/poly}^{O}$ it would also no longer be decidable in ${\sf BQP}^{O}$ either. This is because the query complexity of the quantum algorithm becomes $\mathsf{O(n^{g(n)})}$ which is no longer polynomial unless $g$ is the constant function. Hence, proving separation from ${\sf P/poly}$ seems to require some non-trivial modification of this proof or a totally different technique. ∎

Finally, we can prove Theorem 1 by combining the previous results.

Proof of Theorem 1.

Let us first show that, relative to an oracle, the complement of Simon’s problem is not contained in $\mathsf{NP/O(n^{d})}$. The oracle $O_{d}$ will be defined in the exact same way as for the ${\sf P/O(n^{d})}$ case. The same reasoning as before applies here. Take the $k$’th non-deterministic Turing machine and examine its behaviour for some input $\Braket{1^{n},i}$, where $n=k+n_{0}$ and $n_{0}$ is chosen as before. For each index, we tentatively pick a $1$-to-$1$ function and examine what the machine does for each advice of length $\mathsf{O(n^{d})}$. If more than half of the advice strings lead to rejection then we keep the bijective function and proceed to the next index. Otherwise we replace it with a Simon function. In this case, for each advice in which the machine accepts, there will be some polynomial-sized path leading to acceptance. We will pick one accepting path for each advice on which the machine accepts and ensure that the Simon function produces the same responses to the queries on those paths. This reduces the problem to the previous case. We know that for sufficiently large $D$ such a function exists and therefore each index will render half of the possible advice strings useless. By also choosing $n_{0}$ large enough we can make sure that all advice strings are eliminated and thus that the problem is incorrectly decided by all non-deterministic Turing machines irrespective of the advice (of length $\mathsf{O(n^{d})}$).

For the ${\sf MA/O(n^{d})}$ case, one can use the same proof as in Lemma 3 to reduce to the $\mathsf{NP/O(n^{d})}$ case. It follows that $coSimon(O_{d})\not\in{\sf MA/O(n^{d})}$. ∎

4 GES for exact BosonSampling and circuits for the permanent

To prove Theorem 2, we first need to show a number of results concerning permanents of matrices. The purpose of these results is to eventually show that having an oracle for estimating the squared permanent of a matrix taking values in $\{-1,0,1\}$, yields a polynomial-time algorithm, with random access to $n^{\sf{O}(n)}$ bits of advice, for exactly computing the permanent. This result together with the assumption that a GES allows the client to sample exactly from the BosonSampling distribution and a result of Björklund, from [37], will allow us to prove Theorem 2.

Let us first introduce some helpful notation: for a matrix, $A$, we will denote $A^{i,j}$ as the matrix obtained by deleting row $i$ and column $j$ from $A$.

Lemma 5**.**

Let $X=(x_{i,j})\in\{-1,0,1\}^{n\times n}$. There exists a matrix $Z=(z_{i,j})\in\{-1,0,1\}^{(n+2)\times(n+2)}$ such that:

• •

$z_{n+2,n+2}=0$**

• •

$Per(Z)=-Per(X)$**

• •

$Per(Z^{n+2,n+2})=Per(X^{1,1})$**

Proof.

Let $Z$ be the following matrix:

[TABLE]

We can see that $z_{n+2,n+2}=0$. It is also not difficult to see that $Per(Z^{n+2,n+2})=Per(X^{1,1})$, through a Laplace expansion. We now perform a Laplace expansion along the last row of $Z$, to compute its permanent:

[TABLE]

But $Per(Z^{n+2,n})=Per(X^{1,1})$ and $Per(Z^{n+2,n+1})=Per(X)-Per(X^{1,1})$ hence $Per(Z)=-Per(X)$. ∎

Lemma 6**.**

Let $X=(x_{ij})\in\{-1,0,1\}^{n\times n}$, $Z=(z_{ij})\in\{-1,0,1\}^{m\times m}$, $m\geq 2$, such that $z_{m,m}=0$ and $W=(w_{ij})\in\{-1,0,1\}^{(m+n-1)\times(m+n-1)}$ defined as follows:

[TABLE]

Then, it is the case that:

[TABLE]

Proof.

We will prove this by induction over $m$. For the $m=2$ case we have:

[TABLE]

By doing a Laplace expansion along the first row of $W$, we get:

[TABLE]

Now note that:

[TABLE]

So $Per(Z)=z_{1,2}z_{2,1}$ and $Per(Z^{2,2})=z_{1,1}$, therefore:

[TABLE]

We now assume the relation is true for $m-1$ and prove it for $m$. To do this, we will first Laplace expand the permanent of $W$ along the first row:

[TABLE]

The reason for separating the terms this way, is because $W^{1,i}$, with $i<m$, is of the same form as $W$ and we can therefore apply the induction hypothesis. Doing so yields:

[TABLE]

Where $Z^{(1,m),(i,m)}$ is obtained from $Z$ by deleting rows $1$ and $m$ and columns $i$ and $m$. Taking common factors we get:

[TABLE]

But notice that:

[TABLE]

since it is a Laplace expansion along the first row of $Z^{m,m}$. This leads to:

[TABLE]

The matrix $W^{1,m}$ is of the same form as $W$:

[TABLE]

We can see this by taking:

[TABLE]

Together with the induction hypothesis this gives us:

[TABLE]

Now note that $Per(X_{W^{1,m}})=z_{m,m-1}Per(X_{W^{1,m}}^{1,1})$ and $Per(X_{W^{1,m}}^{1,1})=Per(X^{1,1})$, hence:

[TABLE]

But the term in parenthesis is $Per(Z^{1,m})$ so:

[TABLE]

By substituting this into Equation 27, we get:

[TABLE]

After grouping terms:

[TABLE]

But:

[TABLE]

Thus:

[TABLE]

This concludes the proof. ∎

Using the above lemmas, we can now show the following:

Theorem 8**.**

Let $\mathcal{O}$ be an oracle that, given a matrix $X\in\{-1,0,1\}^{n\times n}$, outputs a number $\mathcal{O}(X)$ such that:

[TABLE]

where $g\in[1,poly(n)]$. Then, for any $X\in\{-1,0,1\}^{n\times n}$ there exists a polynomial time algorithm for computing $Per(X)$, which has random access to $n^{\mathsf{O}(n)}$ bits of advice and making $poly(n)$ queries to $\mathcal{O}$.

Proof.

The theorem shows that having an oracle for computing a multiplicative approximation for the squared permanent of a matrix, implies the existence of a polynomial time algorithm, with $n^{\sf{O}(n)}$ bits of advice, that can compute the permanent exactly.

The proof of this theorem is inspired from a similar result of Aaronson and Arkhipov (see Theorem 4.3 from [35]). In that case, the oracle was outputting a multiplicative approximation of the squared permanent of an arbitrary real matrix. In our case, however, the matrices are restricted to entries from $\{-1,0,1\}$, which means that we cannot directly use that result.

We prove the theorem by induction. For the case of $n=1$ the algorithm simply outputs $X$. Suppose now that we have an algorithm for computing the permanents of $(n-1)\times(n-1)$ matrices with entries from $\{-1,0,1\}$. We will use this algorithm to compute the permanent of $X$. Firstly, if $\mathcal{O}(X)=0$, then $Per(X)=0$ and we are done. Additionally, we are going to use the oracle to check if any of the $(n-1)\times(n-1)$ minors of $X$ are non-zero. If all of them are zero, then $Per(X)=0$ again and we are done. So let’s assume that $Per(X)\neq 0$ and $Per(X^{1,1})\neq 0$202020The permanent is invariant under permutations of rows and columns. Thus, if $X$ has a non-zero minor, we can simply permute the columns of $X$, so that $X^{1,1}$ is that minor..

We know from Lemma 6, that if we take a matrix $Z=(z_{ij})\in\{-1,0,1\}^{m\times m}$, $m\geq 2$, such that $z_{m,m}=0$ and then construct:

[TABLE]

we have that:

[TABLE]

If $Per(W)=0$ and $Per(Z^{m,m})\neq 0$, then:

[TABLE]

From Lemma 5, we know that for any $n\times n$ matrix $X$, there exists an $(n+2)\times(n+2)$ matrix $Z$, such that $z_{n+2,n+2}=0$, $Per(Z)=-Per(X)$ and $Per(Z^{n+2,n+2})=Per(X^{1,1})$. If one used such a $Z$ in the construction of $W$, then it is immediate that $Per(W)=0$ and that $Per(Z^{n+2,n+2})\neq 0$. The algorithm will search for such a $Z$, construct the corresponding $W$ and use the oracle to test if $Per(W)=0$. If the permanent of $W$ is zero, then one can compute the permanent of $X$ using Equation 37.

But how do we search for $Z$ and, furthermore, how do we compute $Per(Z)/Per(Z^{n+2,n+2})$? This is where we make use of advice. Note that since $Z\in\{-1,0,1\}^{(n+2)\times(n+2)}$, we have that:

[TABLE]

hence, there are at most $n^{\mathsf{O}(n)}$ possible values for the permanents of $Z$ matrices. Similarly, there are at most $n^{\mathsf{O}(n)}$ possible values for the permanents of the $Z^{n+2,n+2}$ minors of $Z$ matrices.

The advice, to our algorithm, will consist of tuples $(Z_{i},Per(Z_{i}^{n+2,n+2}),f_{i}=Per(Z_{i})/Per(Z_{i}^{n+2,n+2}))$, comprising of a matrix $Z_{i}$ together with the permanent of its top left $(n+1)\times(n+1)$ minor and the ratio between that matrix’s permanent and the permanent of its top left minor, with $i\leq n^{cn}$, for some constant $c>0$. Here $Z_{i}\in\{-1,0,1\}^{(n+2)\times(n+2)}$, with the bottom right entry being [math] and $Per(Z_{i}^{n+2,n+2})\neq 0$. The matrices in the tuples are such that all possible values for the fraction $f_{i}=Per(Z_{i})/Per(Z_{i}^{n+2,n+2})$ are covered. From the above discussion, it’s clear that there will be at most $n^{\mathsf{O}(n)}$ such tuples. Furthermore, the tuples are sorted in ascending order with respect to those fractions.

For a given matrix $X$, our algorithm should search through this advice in order to find a matrix $Z_{i}$ such that $\mathcal{O}(W_{i})=0$, where $W_{i}$ is constructed from $X$ and $Z_{i}$ as in Lemma 6. When such a matrix is found, we have that:

[TABLE]

But $f_{i}$ is given in the advice tuple and $Per(X^{1,1})$ is computed recursively by our algorithm, hence we have computed the permanent of $X$.

To find the matrix $Z_{i}$ we will perform a binary search over the advice. Suppose that $i$ ranges from $1$ to $l=n^{\mathsf{O}(n)}$. Additionally, let $\alpha_{i}=Per(Z_{i}^{n+2,n+2})$, so that:

[TABLE]

This means that computing $\sqrt{\mathcal{O}(W_{i})}/|\alpha_{i}|$ gives us a multiplicative approximation for $|Per(X)+f_{i}Per(X^{1,1})|$. Because the $f_{i}$ values are sorted in ascending order, this means that the function:

[TABLE]

is monotonically increasing as a function of $i$ and furthermore that there is a unique value $i$ such that $h(i)=0$. In our case, however, we have a multiplicative approximation for $|h(i)|$, which we denote as $t(i)=\sqrt{\mathcal{O}(W_{i})}/|\alpha_{i}|$. This function will be monotonically decreasing between $1$ and $i$ and increasing between $i$ and $l$. We look for $i$ using binary search as follows: compute $t(v)$ and $t(w)$ for the middle two points, $v$ and $w$ of the interval $[1,l]$. If either of them is [math], then we are done. Otherwise, if $t(v)<t(w)$, then search the interval $[2,v]$, otherwise the interval $[w,l]$. Repeat this recursively until the minimum is found.

Given that the advice is of length $n^{\mathsf{O}(n)}$, the algorithm will query it (and consequently $\mathcal{O}$ as well) at most $\mathsf{O}(n\log n)$ times. Additionally, the construction of each $W_{i}$ takes time $\mathsf{O}(n^{2})$ and since this is done at most $\mathsf{O}(n\log n)$ times, the complexity of this step is $\mathsf{O}(n^{3}\log n)$. Finally, the algorithm performs recursive calls to itself (in order to compute $Per(X^{1,1})$) and if we add up the running times of each step we find that the total runtime will be $\mathsf{O}(n^{4}\log n)$. ∎

Theorem 9**.**

If a ${\sf BPP/rpoly}$ algorithm can sample exactly from the BosonSampling distribution then for any matrix $X\in\{-1,0,1\}^{n\times n}$, there exist circuits of size $2^{n-\mathsf{\Omega}\left(\frac{n}{\log n}\right)}$, making polynomially-sized queries to an ${\sf NP}$ oracle, for computing $Per(X)$.

Proof.

The starting point for our proof is a result by Björklund [37]. He showed that, for $k\leq n$, the permanent of an $n\times n$ matrix, $X$, can be expressed as a linear combination of $poly(n)2^{n-k}$ permanents of $k\times k$ matrices. It should be noted that these matrices are not necessarily minors of the original matrix. Nevertheless, each $k\times k$ matrix can be computed efficiently given the input matrix, $X$.

Our task will be to compute all of these $poly(n)2^{n-k}$ permanents and then perform the linear combination so as to arrive at the permanent of $X$. We will use the result of Theorem 8 together with the fact that there exists a ${\sf BPP/rpoly}$ algorithm for exact BosonSampling, to show that the permanent of a $k\times k$ matrix can be computed in polynomial time, using random access to $k^{\mathsf{O}(k)}$ bits of advice and polynomially-sized queries to an ${\sf NP}$ oracle. Crucially, the $k^{\mathsf{O}(k)}$-sized advice will be the same for all $k\times k$ matrices. This means that all permanents can be computed in $poly(n)2^{n-k}$ time with access to $k^{\mathsf{O}(k)}$ bits of advice. The explicit value of $k$, as a function of $n$, will be chosen later.

Consider a $k\times k$ matrix, $M$, and a value $\epsilon>0$, to be chosen later. We embed $\epsilon M$, a scaled version of $M$, as a submatrix of a BosonSampling matrix $A_{M}$. In other words, $A_{M}\in\mathbb{C}^{m\times k}$, with $m=poly(k)$ (see [35] for more details). We then have that the probability of detecting one photon in each output mode, a state which we denote as $\ket{1}$, is:

[TABLE]

Since $Per(M)\leq k!$, to ensure that $p\leq 1$, it suffices to set $\epsilon=1/k$.

If a ${\sf BPP/rpoly}$ machine can simulate the output distribution of a BosonSampling instance, $A_{M}$, that means that:

[TABLE]

where $\mathcal{A}$ is a ${\sf BPP}$ algorithm and $y$ is the $\mathsf{rpoly}$ advice string, of size polynomial in $k$, drawn from the distribution $\mathcal{D}_{k}=\{q_{y}\}_{y}$. Note that $\mathcal{D}_{k}$ only depends on $k$. If we can estimate $p$ up to multiplicative error in polynomial time (potentially with the help of an ${\sf NP}$ oracle and $k^{\mathsf{O}(k)}$ bits of advice) then we will effectively be simulating the oracle $\mathcal{O}$ from Theorem 8.

To do this, first note that if $Per(M)\neq 0$, the smallest possible value of $p$ is $1/k^{\mathsf{O}(k)}$. We will therefore consider our advice string to consist of $k^{\mathsf{O}(k)}$ samples from $\mathcal{D}_{k}$, along with their associated probabilities212121The fact that the advice has size $k^{\mathsf{O}(k)}$ will ensure that, if $p$ is non-zero, then a $y$ such that $Pr(\mathcal{A}(A_{M},y)\text{ outputs }\ket{1})>0$ is overwhelmingly likely to be sampled when we generate the advice.. Denote the set of these samples as $S$. This allows us to define:

[TABLE]

as a multiplicative estimate for $p$. But $\mathcal{A}$ is a ${\sf BPP}$ algorithm, which means that we can view it as a polynomial-time function, $f_{\mathcal{A}}(A_{M},y,r)$ which receives as input (apart from $A_{M}$ and $y$) a random string $r\in\{0,1\}^{l(k)}$, for some polynomial $l$. The function will output either $1$, corresponding to the cases where $\mathcal{A}$ outputs $\ket{1}$, or [math], corresponding to the cases where $\mathcal{A}$ produces some other output. We therefore have that:

[TABLE]

and this leads to our estimate of $p$ being:

[TABLE]

Computing $p_{est}$ exactly would require summing exponentially many terms. However notice that $p_{est}$ is a sum of exponentially many positive numbers, each of which can be evaluated in polynomial time (given access to the $k^{\mathsf{O}(k)}$ advice). For this reason, we can use Stockmeyer’s approximate counting method to compute a multiplicative estimate of $p_{est}$ [59]. This will, of course, also yield a multiplicative estimate for $p$ itself.

We have thus given an algorithm for computing a multiplicative estimate of a $k\times k$ matrix $M$ that works in time polynomial in $k$, performs queries to an ${\sf NP}$ oracle and has random access to $k^{\mathsf{O}(k)}$ bits of advice. This algorithm can now be viewed as an implementation of the oracle $\mathcal{O}$ from Theorem 8. Using that theorem, leads to a polynomial-time algorithm, with access to an ${\sf NP}$ oracle and $k^{\mathsf{O}(k)}$-size advice, for computing $Per(M)$ exactly. However, since the advice is the same for all $k\times k$ matrices, by repeating this procedure for all $poly(n)2^{n-k}$ $k\times k$ matrices and combining the results we obtain an algorithm for computing $Per(X)$ that runs in time $poly(n)2^{n-k}$, uses $k^{\mathsf{O}(k)}$ bits of advice and makes polynomially-sized queries to an ${\sf NP}$ oracle.

The last step is to convert this algorithm into a circuit. Since the algorithm has a running time of $poly(n)2^{n-k}$, by choosing $k=c\;n/\log n$, for some suitable constant $c>0$, we will have circuits of size at most $2^{n-\Omega\left(\frac{n}{log(n)}\right)}$. These circuits, must also operate on the $k^{\mathsf{O}(k)}$ bits of advice. Note that $k^{\mathsf{O}(k)}\ll 2^{n-\Omega\left(\frac{n}{log(n)}\right)}$. To reproduce the random access to these bits, we will assume that the gates have unbounded fan-in. The advice bits are therefore hardcoded into the circuit and “fed” into each part of the algorithm that makes use of them. Since only polynomially-many bits of the advice are used at any given point, this can only increase the size of our circuit by a polynomial factor. This concludes the proof. ∎

With the above result, the proof of Theorem 2 is immediate:

Proof of Theorem 2.

Recall from the end of Section 2.3 that the existence of a GES for sampling from a distribution, $\mathcal{D}_{x}$, implies the existence of a probabilistic polynomial-time algorithm, with an ${\sf NP}$ oracle, and which receives randomised polynomial-sized advice, for sampling from $\mathcal{D}_{x}$. In other words, having a GES for BosonSampling means having a $\sf{BPP^{NP}/rpoly}$ algorithm that can sample from the exact BosonSampling distribution. We now notice that the result of Theorem 9 relativises. In particular, this means that if a $\sf{BPP^{NP}/rpoly}$ algorithm can sample from the exact BosonSampling distribution, then for any matrix $X\in\{-1,0,1\}^{n\times n}$, there exist circuits of size $2^{n-\mathsf{\Omega}\left(\frac{n}{\log n}\right)}$, making polynomially-sized queries to an ${\sf NP}^{\sf NP}$ oracle, for computing $Per(X)$. ∎

5 Quantum GES

5.1 An upper bound for QGES functions

This section is, in a certain sense, dedicated to ‘quantising’ the Abadi et al. result. First of all, we need to define the quantum generalised encryption scheme. Since we’re defining this in analogy to UBQC and other blind quantum computing protocols, our QGES considers a single quantum message from the client to the server, rather than allowing the entire interaction between client and server to be quantum. More formally, we have the following:

Definition 4** (Quantum Generalised Encryption Scheme (QGES)).**

A quantum generalised encryption scheme (QGES) is a two party protocol between a quantum polynomial-time client $C$, and an unbounded server $S$, characterised by:

• •

A function $f:\{0,1\}^{*}\rightarrow\{0,1\}$.

• •

A cleartext input $x\in\{0,1\}^{*}$, for which the client wants to compute $f(x)$.

• •

An expected polynomial-time key generation algorithm $K$ which works as follows: for any $x\in\{0,1\}^{*}$, with probability greater than $1/2+1/poly(|x|)$ we have $(k,success)\leftarrow K(x)$, where $k\in\{0,1\}^{poly(|x|)}$. If the algorithm does not return $success$ then we have $(k^{\prime},fail)\leftarrow K(x)$, where $k^{\prime}\in\{0,1\}^{poly(|x|)}$.

• •

A quantum polynomial-time algorithm $QE$, that takes as input classical bit strings and produces as output a quantum state, which works as follows: for any $x\in\{0,1\}^{*}$, $k\in\{0,1\}^{poly(|x|)}$ we have that $\Ket{y}\leftarrow QE(x,k)$, where $\Ket{y}\in\mathcal{H}$ and $dim(\mathcal{H})=2^{poly(|x|)}$.

• •

A polynomial-time deterministic algorithm $E$ which works as follows: for any $x\in\{0,1\}^{*}$, $k\in\{0,1\}^{poly(|x|)}$ and $s\in\{0,1\}^{poly(|x|)}$ we have that $w\leftarrow E(x,k,s)$, where $w\in\{0,1\}^{poly(|x|)}$.

• •

A polynomial-time deterministic decryption algorithm $D$, which works as follows: for any $x\in\{0,1\}^{*}$, $k\in\{0,1\}^{poly(|x|)}$ and $s\in\{0,1\}^{poly(|x|)}$ we have that $z\leftarrow D(s,k,x)$, where $z\in\{0,1\}^{poly(|x|)}$.

And satisfying the following properties:

There are $m$ rounds of communication, such that $m=poly(|x|)$. Denote the client’s message in round $i$ as $c_{i}$ and the server’s message as $s_{i}$. 2. 2.

On cleartext input $x$, $C$ runs the key generation algorithm until success to compute a key $(k,success)=K(x)$. This happens before the communication between $C$ and $S$ is initiated, and the key $k$ is used throughout the protocol. $C$ then runs $QE(x,k)$ to obtain a quantum encryption of the input, $\Ket{y}$ and sends it to $S$222222It should be noted that it makes no difference for our definition if the client sends the whole state $\ket{y}$ to the server or part of it. The state received by the server will be mixed and the only important property we require is that the client has a purification of this state.. 3. 3.

In round $i$ of the protocol, $C$ computes $c_{i}=E(x,k,\overline{s}_{i-1})$, where $\overline{s}_{i-1}$ denotes the server’s responses up to and including round $i-1$, i.e. $\langle s_{0},s_{1}...s_{i-1}\rangle$. We assume that $s_{0}$ is the empty string. $C$ then sends $c_{i}$ to $S$. 4. 4.

In round $i$ of the protocol, $S$ responds with $s_{i}$, such that $s_{i}\in\{0,1\}^{poly(|x|)}$. 5. 5.

At the end of the protocol, $C$ computes $z\leftarrow D(\overline{s}_{m},k,x)$ and with probability $1/2+1/poly(|x|)$, it must be that $z=f(x)$.

As mentioned in the introduction, we add an additional requirement to our QGES known as offline-ness. What this means is that the client can send a quantum state to the server, representing an encryption of the input, and decide afterwards which input it intends to use. Essentially the client is free to change its mind about the input and not commit to a particular input when the protocol commences. More formally, we define the offline condition as follows:

Definition 5** (Offline QGES).**

In a QGES, let:

[TABLE]

be the state of the client’s system on input $x$ in a superposition over possible keys and encryptions. Here, $\mathcal{K}_{C}(x)$ is the set of encryption keys which are compatible with $x$ (i.e. could have resulted from the key generation algorithm acting on $x$, $K(x)$) and $\Ket{y^{x}_{i}}_{E}\leftarrow QE(x,k^{x}_{i})$ is the quantum encryption of $x$ using the key $k^{x}_{i}$. The subscripts $K$ and $E$ indicate the key register and the encrypted input register, respectively.

For $n>0$, let $x_{1},x_{2}\in\{0,1\}^{n}$ be two different inputs for $f$ such that $x_{1}\neq x_{2}$. We say that the QGES is offline if there exists a polynomial-sized quantum circuit, $V$, acting only on the key register, $K$, such that $V\ket{\psi_{x_{1}}}=\ket{\psi_{x_{1}}}$.

The definition essentially says that there exists an efficient procedure that the client can apply on her local system in order to map from one input of size $n$, to a different input of the same size. One might ask whether this property is not immediately satisfied by a QGES leaking only the size of the input. Indeed, leaking only the size of the input is equivalent to saying that the density matrix corresponding to the quantum encryption, which the server receives, is the same for all inputs of the same size. In other words, it is the case that:

[TABLE]

for any $x_{1},x_{2}\in\{0,1\}^{n}$. Since the density matrix is the same, that means that there exists a unitary (acting on the client’s system) which can map one purification of this state, corresponding to one input, to another, corresponding to a different input. This unitary must be verifiable in the sense that the client can check (using a quantum SWAP test) whether the unitary maps to the correct purification. However, this unitary need not have a polynomial-sized quantum circuit representation. The offline condition simply imposes that such a circuit always exists. As we’ve mentioned before, UBQC and all other existing delegated blind quantum computation protocols satisfy this property.

We are now ready to prove Theorem 3, showing that functions that can be delegated by the client to the server in an offline QGES are contained in ${\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$:

Proof of Theorem 3.

For an input $x$ for which the client wants to compute $f(x)$, consider the state:

[TABLE]

where the notation is the same as in Definition 5. If we trace out the key register, $K$, the resulting density matrix is the mixed state of possible encrypted states which the server will receive:

[TABLE]

The assumption that the protocol only leaks the size of the input $x$ to the server implies that for any two inputs $x_{1}$, $x_{2}$ it is the case that $\rho_{x_{1}}=\rho_{x_{2}}$. In fact, something stronger is true. The server’s ‘view’ of the protocol should be the same in both cases. By this we mean that the server’s system as well as the distribution of his classical messages must be independent of $x$, given the size of $x$. Therefore, we should consider a state comprising of his system and his response after receiving the quantum encryption, for a particular input, $x$:

[TABLE]

Here, $U_{ERS}$ is the unitary performed by the server in order to produce his response, which will be stored in the response register, initially set to $\Ket{0}^{\otimes t}_{R}$, where $t=poly(|x|)$. This unitary will of course involve the encrypted state provided by the client and the server’s private ancilla, denoted as $\Ket{anc}_{S}$ (but will not involve the key register). Note that the server’s response is a classical bit string. Hence, the state in the response register, obtained through the application of the unitary $U_{ERS}$, will be a probabilistic mixture over computational basis states. This, however, makes no difference in our proof and we can just as well assume that his response is a general quantum state.

If we again trace out the register $K$ we obtain some state $\sigma_{x}=Tr_{K}(\Ket{\phi_{x}}\Bra{\phi_{x}})$. This state encodes the distribution of possible messages exchanged by the client and the server in one round of interaction, as well as the server’s private system. Since $\rho_{x_{1}}=\rho_{x_{2}}$, it is also the case that $\sigma_{x_{1}}=\sigma_{x_{2}}$. By the purification principle, this means that if we consider the states:

[TABLE]

[TABLE]

there exists a local unitary, $V_{K}$, acting only on the key register which can map $\Ket{\phi_{x_{1}}}$ to $\Ket{\phi_{x_{2}}}$, for any two inputs $x_{1}$ and $x_{2}$. In fact, let us examine the states of the system for inputs $x_{1}$ and $x_{2}$ before $U_{ERS}$ is applied:

[TABLE]

[TABLE]

These states are also related by $V_{K}$. This can be inferred from the following relations. First, we know that:

[TABLE]

And also that:

[TABLE]

Therefore:

[TABLE]

But $(I_{K}\otimes U^{\dagger}_{ERS})$ and $V_{K}\otimes I_{ERS}$ commute because they act on different systems and therefore $(I_{K}\otimes U^{\dagger}_{ERS})$ and $(I_{K}\otimes U_{ERS})$ will cancel out, leaving:

[TABLE]

This is also illustrated in the following diagram:

\textstyle{\ket{\chi_{x_{1}}}\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{V_{K}\otimes I_{ERS}}$$\scriptstyle{I_{K}\otimes U_{ERS}}$$\textstyle{\ket{\chi_{x_{2}}}}$$\textstyle{\ket{\phi_{x_{1}}}\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{V_{K}\otimes I_{ERS}}$$\textstyle{\ket{\phi_{x_{2}}}\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{I_{K}\otimes U^{\dagger}_{ERS}}

Since the protocol is offline, we know that $V_{K}$ must be a polynomial-sized quantum circuit. Note that even if we trace out the server’s ancilla from the states $\Ket{\phi_{x_{1}}}$ and $\Ket{\phi_{x_{2}}}$, the resulting states are still related by $V_{K}$ on the key register. This allows us to define a ${\sf QCMA/qpoly}$ algorithm computing any function which admits a QGES. To do so we first introduce some notation. We will consider the following states:

[TABLE]

[TABLE]

which are simply superpositions over the valid keys for two different inputs $x$ and $x^{\prime}$. Next we consider:

[TABLE]

[TABLE]

which include the encrypted states and the server’s response. Lastly, we trace out the server’s ancilla from both these states resulting in:

[TABLE]

[TABLE]

From the above argument the two states $\Ket{\kappa_{x}}$ and $\Ket{\kappa_{x^{\prime}}}$ and the two states $\omega_{x}$ and $\omega_{x^{\prime}}$ are related through the same polynomial-sized quantum circuit $V_{K}$ acting only on the key register.

We can now present the algorithm. Let us first consider the one round case. The algorithm would work as follows:

The input to the algorithm is some string $x$ for which we want to compute $f(x)$. 2. 2.

The algorithm receives as advice the string $x^{\prime}$ which is simply some string of the same length as $x$. Additionally, it receives the state $\omega_{x^{\prime}}$. It is clear that both of these only depend on $|x|$ and have a length which is polynomial in $|x|$ hence constituting a valid advice. 3. 3.

From the definition of the key generating function, the algorithm can efficiently produce the states $\Ket{\kappa_{x}}$ and $\Ket{\kappa_{x^{\prime}}}$. 4. 4.

The classical witness is a description of the quantum circuit $V^{\dagger}_{K}$. 5. 5.

The algorithm tests that $V^{\dagger}_{K}$ maps $\Ket{\kappa_{x^{\prime}}}$ to $\Ket{\kappa_{x}}$. This can be done through a quantum SWAP test. 6. 6.

Use $V^{\dagger}_{K}$ to map $\omega_{x^{\prime}}$ to $\omega_{x}$. 7. 7.

By measuring the response register of $\omega_{x}$, the algorithm obtains the response that the server would have produced in an interaction with the client in the QGES protocol. Applying the decryption algorithm to this response will yield the correct result $f(x)$ with high probability.

The probability of success of the algorithm can be boosted by providing polynomially many copies of $\omega_{x^{\prime}}$ as advice and performing multiple SWAP tests. Additionally this algorithm can be made to compute the complement of $f(x)$ as well which would gives us a ${\sf coQCMA/qpoly}$ containment.

Let us now consider the case of polynomially many rounds of interaction, of which the first round involves quantum interaction. We’ve shown that for that first round, we can design a polynomial-time quantum algorithm, receiving quantum advice and a classical witness, to emulate the client in the QGES. For the rounds after the quantum interaction, we essentially have a classical GES. Our algorithm would then operate as in the proof of Theorem 7. In other words, apart from the quantum advice and the witness providing the circuit $V_{K}$, the algorithm will also receive classical (randomised) advice corresponding to a transcript of the classical interaction in the protocol, and a key $k$ to decrypt this transcript. It follows that $f$ will be contained in ${\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$. ∎

A question we might ask is: why can’t we adapt this proof to the case of full quantum communication between the client and the server? For this case, we would need a stronger version of the offline-ness condition that imposes the existence of a polynomial-size quantum circuit for mapping the entire transcript of the protocol, corresponding to some input $x_{1}$ to that of some input $x_{2}$ (where $|x_{1}|=|x_{2}|$). Another question is whether the class of interest should in fact be ${\sf BQP}^{{\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}}$ since a ${\sf BQP}$ client could use the QGES as an oracle. Just as we showed that ${\sf BPP}^{{\sf NP/poly}\cap{\sf coNP/poly}}={\sf NP/poly}\cap{\sf coNP/poly}$ we can show that:

Lemma 7**.**

${\sf BQP}^{{\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}}={\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}$**

Proof.

This proof is similar to the one showing that ${\sf BPP}^{{\sf NP/poly}\cap{\sf coNP/poly}}={\sf NP/poly}\cap{\sf coNP/poly}$. Just like in that case, the inclusion ${\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}\subseteq{\sf BQP}^{{\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}}$ is immediate and we need only show that ${\sf BQP}^{{\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}}\subseteq{\sf QCMA/qpoly}$. The containment in ${\sf coQCMA/qpoly}$ follows by complementation.

Consider a quantum algorithm QA for deciding problems in ${\sf BQP}^{{\sf QCMA/qpoly}\cap{\sf coQCMA/qpoly}}$. We will show that this algorithm can be simulated by a ${\sf QCMA/qpoly}$ algorithm, denoted NQA. Since ${\sf BQP}$, ${\sf QCMA}$ and ${\sf coQCMA}$ have bounded error in deciding problems, we can assume, from standard amplification techniques, that this error is of order $2^{-poly(n)}$, where $n$ is the size of the input. We will also assume that for all quantum algorithms measurements are postponed until the end of the circuit.

We will treat the case without advice first, and then explain how to deal with the quantum advice at the end. To start with, NQA will simulate QA until it makes a query to the oracle. In the standard definition of oracles the oracle is just a classical function that solves a decision problem. However, when dealing with quantum algorithms such as QA it is also possible to speak of quantum oracles, where the oracle can be viewed as some unitary operation (technically a sequence of unitary operations for each possible input length, see [65] for more details) which QA can query even in superposition. Our result will cover this more general case of quantum oracles. We would therefore like the NQA algorithm to be able to simulate this quantum oracle.

Firstly, just like in the classical case we have that if some language $L\in{\sf QCMA}\cap{\sf coQCMA}$ then $L\in{\sf QCMA}$ and $L^{c}\in{\sf coQCMA}$, where $L^{c}$ is the complement of $L$. This means that there exist polynomial-sized quantum circuits $Q_{L}$ and $Q_{L^{c}}$ which take some input $x$ along with classical witnesses $w_{1}$ and $w_{2}$, respectively, and decide correctly, when the output is measured, with probability at least, $1-2^{-poly(|x|)}$. In other words, $Q_{L}$ receives as input $\Ket{x}\Ket{w_{1}}\ket{0^{m}}$ and $Q_{L^{c}}$ receives as input $\ket{x}\ket{w_{2}}\ket{0^{m}}$, respectively, where $m=poly(|x|)$. If we were to run both $Q_{L}$ and $Q_{L^{c}}$ on $x$, because $L$ and $L^{c}$ are complementary, the output qubits, when measured, will also be complementary with high probability.

Assume that $Q_{L}$ and $Q_{L^{c}}$ are circuits which act on $t=poly(|x|)$ qubits. We define a new quantum circuit called $SimQuery$ which operates on $2t+1$ qubits. $SimQuery$ applies $Q_{L}$ to the first $t$ qubits and $Q_{L^{c}}$ to the next $t$ qubits. It then applies a Pauli $\mathsf{X}$ to the output qubit of $Q_{L^{c}}$ and a CCNOT operation from the output qubits of $Q_{L}$ and $Q_{L^{c}}$ onto the the $2t+1$’th qubit. It then applies $\mathsf{X}$ again to the output qubit of $Q_{L^{c}}$ and then $Q_{L}^{\dagger}$ and $Q_{L^{c}}^{\dagger}$ on the first $2m$ qubits. An illustration of this circuit (acting on the $\ket{00...0}$ input) is given in Figure LABEL:fig:simquery.