Thuật toán của Grover được sử dụng, trong số những thứ khác, để tìm kiếm một mục $\mathbf{y}$ trong danh sách các mục không có thứ tự $[\mathbf{x}_0, \mathbf{x}_1, ..., \mathbf{x}_{n-1}]$ chiều dài $n$ . Mặc dù có rất nhiều câu hỏi ở đây liên quan đến chủ đề này, tôi vẫn bỏ lỡ vấn đề.

Tìm kiếm trong một danh sách, cách cổ điển

Thông thường, tôi sẽ thiết kế một chức năng tìm kiếm theo cách này

$$\mathrm{search}([\mathbf{x}_0, \mathbf{x}_1, ..., \mathbf{x}_{n-1}], \mathbf{y}) = i \in \mathbb{N} \quad \text{such that } \mathbf{x}_i = \mathbf{y}$$ Vì vậy, tôi đưa ra danh sách và mục mong muốn làm đầu vào và tôi nhận vị trí của mục trong danh sách làm đầu ra. Tôi nghĩ rằng tôi đã hiểu rằng những thông tin về$\mathbf{y}$ được nhúng vào trong các thuật toán thông qua các cổng oracle$O$ , vì vậy chức năng của chúng tôi trở nên $$\mathrm{search}_\mathbf{y}([\mathbf{x}_1, \mathbf{x}_2, ..., \mathbf{x}_n] ) = i \in \mathbb{N} \quad \text{such that } \mathbf{x}_i = \mathbf{y}$$ Hãy làm một ví dụ thực tế. Cân nhắc tìm kiếm ace of spades$1\spadesuit$ trong chuỗi 8 thẻ từ bộ bài52 lá tiêu chuẩn:

Danh sách có độ dài $8$ là $[ \mathbf{x}_0 = J\clubsuit,$ $\mathbf{x}_1 = 10\diamondsuit,$ $\mathbf{x}_2 = 4\heartsuit,$ $\mathbf{x}_3 = Q\clubsuit,$ $\mathbf{x}_4 = 3\spadesuit,$ $\mathbf{x}_5 = 1\spadesuit,$ $\mathbf{x}_6 = 6\spadesuit,$ $\mathbf{x}_7 = 6\clubsuit]$ .

Phần tử mong muốn là $\mathbf{x}_5$ . Tôi nên lấy $\mathrm{search}_{\spadesuit}(cards) = 5$ . Mỗi thẻ có thể được mã hóa với $\lceil{\log_2 52}\rceil = 6$ bit, danh sách này có $8$ yếu tố vì vậy chúng tôi cần $6\times 8 = 48$ bit để mã hóa danh sách. Trong trường hợp này, oracle $O$ sẽ thực hiện chức năng:

$$f(\mathbf{x}) = \begin{cases} 1, & \mathbf{x} = 1\spadesuit \\ 0, & \text{otherwise} \end{cases}$$

Tuy nhiên, đầu vào của thuật toán Grover không phải là trạng thái $48$ qubit.

(NB: Hình ảnh của sàn được xáo trộn được lấy từ đây )

Grover và nhà tiên tri của nó

Một số nguồn (ví dụ ở đây - được giải thích bằng đồ họa) nói rằng đầu vào của thuật toán là khác nhau: đầu vào là trạng thái được lấy từ không gian tìm kiếm $S = \{ 0, 1, 2, ..., N \} = \{0, 1, 2, ..., 7 \}$ trong đó $N$ là số phần tử của danh sách. Mỗi số tương ứng với vị trí của một yếu tố trong danh sách.

Đầu vào của $\mathrm{search}_{\spadesuit}(\cdot)$ bây giờ là một $\lceil \log_2 8 \rceil = 3$ vector qubit $|\psi\rangle$ , mà cần phải có một sự chồng chất của tất cả các mục trong không gian tìm kiếm $S$ .

Chúng tôi biết

• $|0_{3\text{qubits}}\rangle = |000\rangle$ tương ứng với$J\clubsuit$ ;
• $|1_{3\text{qubits}}\rangle = |001\rangle$ tương ứng với$10\diamondsuit$ ;
• $|2_{3\text{qubits}}\rangle = |010\rangle$ tương ứng với$4\heartsuit$ ;
• $|5_{3\text{qubits}}\rangle = |101\rangle$ tương ứng với$1\spadesuit$ đó là yếu tố truy nã;
• và như thế...

Trong trường hợp này chúng ta có

$$\mathrm{search}_{\spadesuit}(|\psi\rangle) = |5_{3\text{qubits}}\rangle$$ Nhưng trong trường hợp này, oracle của chúng tôi sẽ phải thực hiện các chức năng $$f(|\psi\rangle) = \begin{cases} 1, & |\psi\rangle = |5_{3\text{qubits}}\rangle \\ 0, & \text{otherwise} \end{cases}$$

Xây dựng oracle đòi hỏi chúng ta phải biết rằng $\spadesuit$ là ở vị trí 5. điểm để thực hiện thuật toán nếu chúng tôi đã tìm kiếm các yếu tố để xây dựng nhà tiên tri là gì?

Nếu bạn có 8 mục trong danh sách (như trong ví dụ về thẻ của bạn), thì đầu vào của nhà tiên tri là 3 (qu) bit. Số lượng thẻ trong bộ bài (52) là không liên quan, bạn chỉ cần 3 bit để mã hóa 8 thẻ.

$$f(\mathbf{x}) = \begin{cases} 1, & \text{if x = 5, or binary '101'} \\ 0, & \text{otherwise} \end{cases}$$

PS: It is better to think about the Grover's algorithm differently: you have an oracle implementing a boolean function which outputs $1$ for a single combination of input bits, otherwise outputs zero, and your task is to find the combination. The problem has the same complexity as searching in an unsorted list or database, that is why the Grover's algorithm is usually described as searching in an unsorted database. But applying the algorithm to a real-world database search indeed raises questions that are beyond the algorithm itself. Grover's algorithm is just searching for what the oracle knows.

Mặc dù có lẽ chúng ta dễ dàng nhất để nghĩ về chức năng của nhà tiên tri vì đã tính toán tất cả các giá trị này, nhưng đó không phải là điều đang làm. Trong trường hợp bạn mô tả, nhà tiên tri có 8 đầu vào có thể (nghĩa là được mã hóa thành 3 (qu) bit) và nhà tiên tri thực hiện tất cả các tính toán mà bạn cần khi đang di chuyển . Vì vậy, thời điểm bạn cố gắng đánh giá lời tiên tri cho một số giá trị$x$, nhà tiên tri tìm kiếm (trong trường hợp này) thẻ mà giá trị của $x$tương ứng với, và sau đó kiểm tra xem thẻ đó có phải là thẻ được đánh dấu không. Ý tưởng là mỗi lần bạn gọi nhà tiên tri, nó sẽ trải qua quá trình đó một lần. Nhìn chung, bạn đánh giá chức năng một số lần bằng với số lần bạn gọi là nhà tiên tri. Mục đích của bất kỳ thuật toán tìm kiếm nào là gọi lời tiên tri đó càng ít lần càng tốt.

Trong trường hợp điều này nghe có vẻ hơi tròn (đưa ra một đầu vào $x$, tìm thẻ tương ứng với), hãy nhớ rằng bảng tra cứu của bạn để làm gì $x$tương ứng với những gì thẻ có thể được đặt hàng đó là một câu hỏi tìm kiếm khác nhau, đơn giản hơn, nhanh hơn nhiều.

Sự khác biệt chính trong ví dụ của bạn so với kịch bản sử dụng thực tế hơn là:

• Không gian tìm kiếm thường rất lớn. Không có triển vọng thực tế của việc tính toán trước tất cả các giá trị. Thật vậy, đó chính xác là những gì chúng tôi đang cố gắng tránh.

• Thông thường, chúng ta không thực sự nói 'tìm át chủ bài'. Thay vào đó, có một$f(x)$ đó là không tầm thường để đánh giá để kiểm tra nếu $x$là mục 'được đánh dấu' hay không. Thực tế là nhà tiên tri có thể mất khá nhiều thời gian để đánh giá, ngay cả đối với một mục duy nhất, là điều khiến cho nhà tiên tri trở thành phần tốn kém để thực hiện (và tất cả các cổng khác được cung cấp miễn phí) và tại sao bạn cần giảm thiểu số lượng cuộc gọi .

Vì vậy, thực sự, cách mà một tìm kiếm cổ điển sẽ giải quyết vấn đề của bạn là: chọn một $x$ngẫu nhiên. Đánh giá$y=f(x)$. Nếu$y=1$, trở về $x$, otherwise repeat. While the net effect of $f(x)$ is 'is the input $x_0$, the marked entry?', that is not the actual calculation that it does.

The question is ultimately: "What's the point to execute the algorithm if we have already searched for the element in order to build the oracle?"

Whilst somebody prebuilt the oracle, it may not have been the person using the oracle.

Grover's algorithm requires the oracle be queried no more times than $\sqrt{\text{size of list}}$. Naturally we cannot hope respective database lookups, as proposed earlier against which I cannot comment for lack of reputation, on say 5 million keys will return the content we want if our content is not addressed by any of those 5 million keys, but by saying the 9 millionth key, which happens not to be in our sample. How does Grover's algorithm do it then?

We ask the oracle: what is the answer it already has for the question it already has? Even Mateus and Omar would ask the "oracle-for-a-particular-alphabet-symbol" during runtime, what are the position(s) of its symbol in the string that it has already compiled? The oracle will give the answer to our query after only one consultation, but in this story, it cannot for example simply write out the answer as a binary string and send it to us over a classical communication channel. It will hide its answer in a superposition for us to draw it out.

I let fancy or metaphor run away in this next bit: we don't quite hear the answer the first time, and we have to ask the oracle to repeat the same answer over and over again until we are sure what the oracle has said, except we start to hallucinate from misinformation in the diffusion process if we ask too many times.

Given the oracle you have provided, the search is indeed pointless. However, that oracle misses the point of Grover's algorithm because searching for a card in a deck of cards is not an unstructured search because, as you stated, you already know the order. Ergo, your search is structured. The reason this oracle is used is that it demonstrates how Grover's may be applied without having to discuss an oracle that would make Grover's useful because such an oracle would be more complicated than valuable. Therefore, a better oracle to demonstrate the usefulness of Grover's might be something like:

$$f(x) = \begin{cases} 1, & x[0, \ldots, 3] + x[4, \ldots, 7] = 1010 \\ 0, & \text{otherwise} \end{cases}$$

What this oracle implies is that you have an 8-qubit search where you take the first four qubits and add them to the second four qubits and flip M if the addition makes 10 (1010 in binary). The difference between this oracle and the one you provided is that this oracle tests a pattern (do the operands add to 10) whereas yours tests equality (is this index 5). This oracle is much more difficult to build but it leverages the true power of Grover's, which is, in essence, a brute-force search where your oracle defines the search space.