Groverのアルゴリズムとその複雑度クラスとの関係は？

Groverのアルゴリズムと複雑度クラスへの接続について混乱しています。

グローバーのアルゴリズムの発見及び素子$k$のデータベースで$N=2^n$（例えばその$f(k)=1$）を持つ要素の

そのため、次の問題があります。

問題：データベース内でf （k ）= 1となる$k$を見つける$f(k)=1$

現在、これは意思決定の問題ではないため、複雑度クラス$\text{P}$、$\text{NP}$などの通常の定義は実際には適用されないことを認識しています。しかし、このような場合に複雑度クラスをどのように定義するかを知りたいのですが、$N$またはに関して行われ$n$ますか？

さらに、Groverのアルゴリズムはサブルーチンとして使用できます。私はいくつかの場所で、グローバーのアルゴリズムが複雑さのクラスを変更しないことを読みました。これを発見する方法はありますか。

概要

• 検索の問題（関係の問題とも呼ばれる）の複雑さの理論があります。この理論には、FP、FNP、および FBQP、さまざまな種類のリソースで検索問題を効果的に解決します。
• 検索問題から、決定問題を定義することもできます。これにより、検索問題を通常のクラスP、NP、およびBQPに関連付けることができます。
• 問題の決定バージョンの検索バージョンを検討するかどうかにかかわらず、非構造化検索問題への入力を検討する方法によって、その複雑さに置くことができる上限が決まります。

関係の問題の複雑さ

ご指摘のとおり、Groverの問題は検索の問題を解決します。これは、複雑さの文献では、関係の問題としても知られています。つまり、次のような問題です。

一般的な検索問題の構造。
入力と二項関係Rが与えられた場合、R （x 、y ）が成り立つようなyを見つけます。$x$$R$$y$$R(x,y)$

複雑度クラスFPおよびFNPは、そのような問題に関して定義されます。特に、長さが最大xの長さの多項式関数である場合、および関係R （x 、y ）がそれ自体である場合に関心があります長さのある多項式で区切られた時間で計算される$y$$x$$R(x,y)$ます。$(x,y)$

特に、Groverの検索が通常適用される「データベース検索」問題の例は、次のように説明できます。

非構造化検索。
入力オラクル所与ように O | ⟩ | B ⟩ = | ⟩ | B ⊕ F （）⟩いくつかの機能のために F ：{ 0 、1 } M → { 0 、1 }、検索 Yように Oを | Y ⟩ | 0 ⟩ = | Y ⟩ | $\mathcal O: \mathcal H_2^{\otimes m+1} \!\to \mathcal H_2^{\otimes m+1}$$\mathcal O \lvert a \rangle \lvert b \rangle = \lvert a \rangle \lvert b \oplus f(a) \rangle$$f: \{0,1\}^m \to \{0,1\}$$y$。$\mathcal O \lvert y \rangle \lvert 0 \rangle = \lvert y \rangle \lvert 1 \rangle$

ここでは、オラクル自体が問題への入力です。オラクルはの役割を果たし、計算している関係は R （O、$x$

オラクルの代わりに、関数fの計算方法を記述する特定の入力が提供され、この問題がどの複雑度クラスに属するかを検討できると仮定します。示し、我々が得る適切な複雑性クラスは、入力が提供される方法に依存します。$x$$f$pyramids

• 入力機能は、データベースへの各エントリは、いくつかの長さのあるデータベース（問題が時折記載されているように）として提供されていると。場合nは文字列の長さxを記述するために使用されるデータベース全体を、次にデータベースが持つN = N / ℓのエントリを。その後、N個のエントリのそれぞれを順番に照会することでデータベース全体を徹底的に検索し、f （y ）= 1のようなエントリyが見つかったら停止することができます。データベースへの各クエリがO ログのようなものを取ると仮定し$\ell$$n$$x$$N = n\big/\ell$$N$$y$$f(y) = 1$時、この手順が停止時間で O （N ログN ）⊆ O （N ログN ）ので、問題がであることを、FP$O(\log N) \subseteq O(\log n)$$O(N \log N) \subseteq O(n \log n)$。

  データベース検索をコヒーレントな重ね合わせで実行できると仮定すると、Groverのアルゴリズムはこの問題がFBQPにあることを許可します。しかし、としてFP  ⊆  FBQP、古典徹底的な検索も、この問題がであることを証明FBQP。取得するすべて（ログファクターまで）は、データベースクエリの数が節約されるため、2次の高速化です。
  
  

• 仕様かかる多項式時間アルゴリズムによって、入力機能を簡潔に説明されていると、引数Y ∈ { 0 、1 } Mとを計算O：HのM + 1$x \in \{0,1\}^n$$y \in \{0,1\}^m$$\mathcal O : \mathcal H_2^{m+1} \!\to \mathcal H_2^{m+1}\!$標準ベースの状態、mがよりはるかに大きくてもよいΩ （ログN ）。ここでの例は次のようになり、xは、いくつかのブール関数のCNF形指定F ：{ 0 、1 } M → { 0 、1 }のためのM ∈ O （N ）、我々は効率的に評価することができる場合には、F （yは）入力上のY $\lvert y \rangle\lvert b \rangle$$m$$\Omega(\log n)$$x$$f: \{0,1\}^m \to \{0,1\}$$m \in O(n)$$f(y)$$y \in \{0,1\}^m$ and thereby efficiently evaluate $\mathcal O$ on standard basis states. This puts the problem in FNP.

  Given a procedure to evaluate $f(y)$ from $(x,y)$ in time $O(p(n))$ for $n = \lvert x \rvert$, Grover's algorithm solves the problem of Unstructured Search for $\mathcal O$ in time $O(p(n) \sqrt{2^m})$ $\subseteq O(p(n) \sqrt{2^n})$. This is not polynomial in $n$, and so does not suffice to put this problem in FBQP: we only obtain a quadratic speedup — though this is still a potentially huge savings of computation time, assuming that the advantage provided by Grover's algorithm is not lost to the overhead required for fault-tolerant quantum computation.
  
  

In both cases, the complexity is determined in terms of the length $n$ of the string $x$ *which specifies how to compute the oracle $\mathcal O$. In the case that $x$ represents a look-up table, we have $N = n\big/\ell$, in which case the performance as a function of $N$ is similar to the performance as a function of $n$; but in the case that $x$ succinctly specifies $\mathcal O$, and $N \in O(2^{n/2})$, the big-picture message that Grover's solves the problem in $O(\sqrt N)$ queries obscures the finer-grained message that this algorithm is still exponential-time for a quantum computer.

Decision complexity from relation problems

There is a straightforward way to get decision problems from relation problems, which is well-known from the theory of NP-complete problems: to turn the search problem to a question of the existence of a valid solution.

The decision version of a general search problem.
Given an input $x$ and an binary relation $R$, determine whether $\exists y: R(x,y)$ holds.

The complexity class NP can essentially be defined in terms of such problems, when the relationship $R$ is efficiently computable: the most famous NP-complete problems (CNF-SAT, HAMCYCLE, 3-COLOURING) are about the mere existence of a valid solution to an efficiently verifiable relationship problem. This switch from producing solutions to simply asserting the existence of solutions is also what allows us to describe versions of integer factorisation which are in BQP (by asking whether there exist non-trivial factors, rather than asking for the values of non-trivial factors).

In the case of Unstructured Search, again which complexity class best describes the problem depends on how the input is structured. Determining whether there exists a solution to a relationship problem may be reduced to finding and verifying a solution to that problem. Thus in the case that the input is a string $x$ specifying the oracle as a look-up table, the problem of unstructured search is in P; and more generally if $x$ specifies an efficient means of evaluating the oracle, the problem is in NP. It is also possible that there is a way of determining whether there exists a solution to Unstructured Search which does so without actually finding a solution, though it is not clear in general how to do so in a way which would provide an advantage over actually finding a solution.

Oracle complexity

I have conspicuously been shifting from talking about the oracle $\mathcal O$, to ways that an input $x$ can be used to specify (and evaluate) the oracle $\mathcal O$. But of course, the main way in which we consider Grover's algorithm is as an oracle result in which evaluating the oracle takes a single time-step and requires no speficiation. How do we consider the complexity of the problem in this case?

In this case, we are dealing with a relativised model of computation, in which evaluating this one specific oracle $\mathcal O$ (which, remember, is the input to the problem) is a primitive operation. This oracle is defined on all input sizes: to consider the problem for searching on strings of length $n$, you must specify that you are considering how the oracle $\mathcal O$ acts on inputs of length $n$, which again would be done by considering the length of a boolean string $x$ taken as input. In this case, the way in which we would present the problem might be as follows.

$\mathcal O$
$x = 11\cdots 1$$n$

• $y \in \{0,1\}^n$

• $y \in \{0,1\}^n$

$\mathcal O \lvert y \rangle \lvert 0 \rangle = \lvert y \rangle \lvert 1 \rangle$.

This problem is in $\mathsf{NP}^{\mathcal O}$ (for the decision problem) or $\mathsf{FNP}^{\mathcal O}$ (for the relation problem), depending on which version of the problem you wish to consider. Because Grover's algorithm is not a polynomial-time algorithm, this problem is not known to be in $\mathsf{BQP}^{\mathcal O}$ or $\mathsf{FBQP}^{\mathcal O}$. In fact, we can say something stronger, as we will soon see.

The reason why I brushed over the actual, oracle-based description of Unstructured Search was in order to touch on your point of complexity, and in particular to touch on the question of input size. The complexity of problems are largely governed by how the inputs are specified: as a succinct specification (in the case of how a function is specified in CNF-SAT), as an explicit specification (in the case of a look-up table for a function), or even as an integer specified in unary, i.e. as the length of a string of 1s as above (as in "Unstructured Search relative to Oracle $\mathcal O$" above).

As we can see from the latter case, if we treat the input only as an oracle, the situation looks a bit un-intuitive, and it certainly makes it impossible to talk about the ways that the "database" can be realised. But one virtue of considering the relativised version of the problem, with an actual oracle, is that we can prove things which otherwise we have no idea how to prove. If we could prove that the decision version of the succinct unstructured search problem was in BQP, then we would stand to realise an enormous breakthrough in practical computation; and if we could prove that the decision problem was not actually in BQP, then we would have shown that P ≠ PSPACE, which would be an enormous breakthrough in computational complexity. We don't know how to do either. But for the relativised problem, we can show that there are oracles $\mathcal O$ for which the decision version of "Unstructured Search relative to $\mathcal O$" is in $\mathsf{NP}^{\mathcal O}$ but not in $\mathsf{BQP}^{\mathcal O}$. This allows us to show that while quantum computing is potentially powerful, there are reasons to expect that BQP probably doesn't contain NP, and that the relation version of Unstructured Search in particular is unlikely to be contained in FBQP without imposing strong constraints on how the input is represented.

複雑度クラスは一般に、入力のサイズに関して定義されます。ここに関連するサイズは$n$ （Groverのアルゴリズムを動作させる量子ビットの数）およびまだ言及していない数を呼び出します $m$, of bits needed to describe the subroutine generally referred to as the oracle. Typically, the oracle will be efficiently implemented in a way that scales polynomially in $n$, which is the case, for example, if you encode a typical boolean satisfiability problem in the oracle.

In any case, you do not get a gain in complexity class using Grover's algorithm: It takes exponentially many quantum operations, typically $m*2^{n/2}$, to solve a problem we could brute-force in exponentially many steps, typically $m*2^{n-1}$, on a classical computer anyways. This means that problems known (e.g. EXPTIME) or suspected (e.g. NP) to take exponential runtime will still require exponential runtime.

However, physicists like to appeal to the notion that this is still an exponential speed-up with no known (or indeed readily conceivable) classical equivalent. This is most apparent in the database example where the oracle function is a database lookup and Grover's algorithm can cause one to need many fewer lookups than there are data in the database. In this sense, there is still a significant advantage, although it is completely lost in the complexity class picture.

All counting is done in terms of $n$, the number of bits required to describe the input.

We define the class of problems $\text{NP}$ in the following way (or, this is one way to do it):

Let $f(x)$ be a function that accepts an input $x\in\{0,1\}^n$ and returns a single bit value 0 or 1. The task is that you have to find whether a given value of $x$ returns a 1. However, there is further structure to the problem: if $f(x)=1$, you are guaranteed that there exists a proof $p_x$ (of size $m\sim\text{poly}(n)$) such that a function $g(x,p_x)=1$ only if $f(x)=1$, and the function $g(x,p_x)$ is efficiently computable (i.e. it has a running time of $\text{poly}(n)$.

Let me give a few examples (perhaps these are what you were asking for here?):

• Parity: $f(x)$ answers the question 'is $x$ odd?'. This is so trivial (just take the least significant bit of $x$) that $f(x)$ is efficiently computed directly, and therefore a proof is unnecessary, $g(x,p_x)=f(x)$.

• Composite numbers: $f(x)$ answers the question 'is the decimal representation of $x$ a composite number?'. One possible proof in the yes direction (you only have to prove that direction) is to give a pair of factors. e.g. $x=72$, $p_x=(8,9)$. Then $g(x,p)$ simply involves multiplying together the factors and checking they are equal to $x$.

• Graph isomorphism: Given two graphs $G_1$ and $G_2$ (here $x$ contains the description of both graphs), $f(x)$ answers the question 'are the two graphs isomorphic?'. The proof $p_x$ is a permutation: a statement of how the vertices in $G_1$ map to those of $G_2$. The function $g(x,p_x)$ verifies that $p_x$ is a valid permutation, permutes the vertices of $G_1$ using the specified permutation, and verifies that the adjacency matrix is the same as that of $G_2$.

• Minesweeper: The old favourite game built into windows (and others) can be expressed like this. Imagine a minesweeper board that is partially uncovered, so some cells are unknown, and some cells have been uncovered to reveal how many mines are in the neighbouring cells. This is all built into the variable $x$. $f(x)$ asks the question 'is there a valid assignment of mines on the uncovered region?'. The proof, $p_x$ is simply one such assignment of mines. This is easily verified using $g(x,p_x)$ which simply ensures consistency with every known constraint.

All of these problems are in $\text{NP}$ because they fit the definition of an efficiently verifiable solution. Some of them are known to be in $\text{P}$ as well: we've already stated that odd testing is in $\text{P}$. Composite numbers also is, because it is efficient to check if a number is prime using AKS primality testing.

Graph isomorphism and minesweeper are not known to be in $\text{P}$. Indeed, minesweeper is known to be $\text{NP}$-complete, i.e. if it can be solved efficiently, every problem in $\text{NP}$ is in $\text{P}$. Many people suspect that $\text{P}\neq\text{NP}$, and hence Minesweeper would have instances which take longer than polynomial time to solve.

One possible way to solve an $\text{NP}$ problem is, for a fixed $x$, simply to test all possible proofs $p_x$ up to a maximum length $m=\text{poly}(n)$, and see if there's a satisfying solution, i.e. to search for a solution $g(x,p_x)=1$. Obviously, that takes time $O(2^m\text{poly}(m))$, as there are exponentially many items to search, each requiring a polynomial time to compute. This can be improved by implementing Grover's search: we just search for a solution $g(x,p_x)=1$ (i.e. the valid $p_x$ becomes the marked item), and this takes a time $O(2^{m/2}\text{poly}(m))$. This is massively faster, but does not change the assessment of whether the running time is polynomial or something worse; it has not become a polynomial time algorithm. For example, graph isomorphism would have to search over all possible permutations. Minesweeper would have to search over all possible assignments of mines on uncovered squares.

Of course, some of the time, additional structure in the problem permits different solutions that do not require the searching of all possible proofs. There, Grover's search is of less, or even no, use to us, but it might be that we can come up with a polynomial time algorithm in another way. For example, the case of composite testing: classically, finding the factors of a number appears to be hard: we can't do much better than testing all possible factors, so making use of that form of proof doesn't help much, but, as already mentioned, the question can be resolved efficiently via another route, AKS primality testing.

Forget about database. Grover's algorithm solves Boolean Satisfiability Problem, namely:

You have a boolean circuit with $n$ inputs and a single output. The circuit outputs $1$ for a single configuration of input bits, otherwise is outputs $0$. Find the configuration of input bits.

The problem is known to be NP-complete.