L'algoritmo di Grover viene utilizzato, tra le altre cose, per cercare un elemento in un elenco non ordinato di elementi di lunghezza . Anche se ci sono molte domande qui su questo argomento, mi manca ancora il punto. $\mathbf{y}$ $[\mathbf{x}_0, \mathbf{x}_1, ..., \mathbf{x}_{n-1}]$ $n$

Ricerca in un elenco, in modo classico

Normalmente, progetterei una funzione di ricerca in questo modo Quindi do l'elenco e l'elemento desiderato come input e ricevo la posizione dell'elemento nell'elenco come output. Penso di aver compreso che le informazioni su sono incorporate nell'algoritmo attraverso l'oracolo gate , quindi la nostra funzione diventa Facciamo un esempio pratico. Prova a cercare l'asso di picche

s e a r c h ([x_{0}, x_{1}, . . ., x_{n - 1}], y) = i \in N such that x_{i} = 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}$

y

$\mathbf{y}$

O

$O$

{S e un' r c h}_{y} ([X_{1}, X_{2}, . . ., X_{n}]) = io \in N tale che X_{io} = y

$\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}$

1 ♠

$1\spadesuit$ in una sequenza di 8 carte da un mazzo standard da 52 carte :

L'elenco della lunghezza $8$ è $[ \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]$ .

L'elemento desiderato è $\mathbf{x}_5$ . Dovrei ottenere $\mathrm{search}_{\spadesuit}(cards) = 5$ . Ogni scheda può essere codificata con $\lceil{\log_2 52}\rceil = 6$ bit, la lista ha $8$ elementi quindi abbiamo bisogno di $6\times 8 = 48$ bit per codificare la lista. In questo caso, l'oracolo $O$ implementerà la funzione:

f (x) = {\begin{cases} 1, & x = 1 ♠ \\ 0, & otherwise \end{cases}

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

Tuttavia, l'input dell'algoritmo di Grover non è uno stato di $48$ qubit.

(NB: l'immagine del mazzo mischiato è presa da qui )

Grover e il suo oracolo

Diverse fonti (ad es. Qui - spiegate graficamente) affermano che l'input dell'algoritmo è diverso: l'input è uno stato preso dallo spazio di ricerca dove è il numero di elementi dell'elenco. Ogni numero corrisponde alla posizione di un elemento nell'elenco. $S = \{ 0, 1, 2, ..., N \} = \{0, 1, 2, ..., 7 \}$ $N$

L'input di ora è un qubit vector , che deve essere una sovrapposizione di tutti gli elementi nello spazio di ricerca . $\mathrm{search}_{\spadesuit}(\cdot)$ $\lceil \log_2 8 \rceil = 3$ $|\psi\rangle$ $S$

Sappiamo

$|0_{3\text{qubits}}\rangle = |000\rangle$ corrisponde a ; $J\clubsuit$
$|1_{3\text{qubits}}\rangle = |001\rangle$ corrisponde a ; $10\diamondsuit$
$|2_{3\text{qubits}}\rangle = |010\rangle$ corrisponde a ; $4\heartsuit$
$|5_{3\text{qubits}}\rangle = |101\rangle$ corrisponde a che è l'elemento desiderato; $1\spadesuit$
e così via...

In questo caso abbiamo Ma in questo caso, il nostro oracolo dovrebbe implementare la funzione

{s e a r c h}_{♠} (| ψ ⟩) = | 5_{3 qubits} ⟩

$\mathrm{search}_{\spadesuit}(|\psi\rangle) = |5_{3\text{qubits}}\rangle$

f (| ψ ⟩) = {\begin{cases} 1, & | ψ ⟩ = | 5_{3 qubits} ⟩ \\ 0, & otherwise \end{cases}

$f(|\psi\rangle) = \begin{cases} 1, & |\psi\rangle = |5_{3\text{qubits}}\rangle \\ 0, & \text{otherwise} \end{cases}$

Costruire l'oracolo ci richiede di sapere che è in posizione 5. Qual è il punto di eseguire l'algoritmo se abbiamo già cercato l'elemento per costruire l'oracolo? $\spadesuit$

grovers-algorithm

— incud
fonte

Ho anche difficoltà a comprendere il vantaggio dell'algoritmo di Grover. Supponiamo che io abbia N elementi nell'elenco. Ad ogni chiamata all'oracolo, ha valutato tutte le N possibilità? Anche se la valutazione è molto veloce ma se dobbiamo ancora iterare su tutte le configurazioni, la complessità della valutazione Oracle è O (N). Quindi l'algoritmo di Grover non sembra essere più veloce della ricerca stupida. È corretto?

— Sanparith Marukatat,

@SanparithMarukatat Non è corretto. Le voci del tuo elenco sono i termini della sovrapposizione dello stato coinvolto nella ricerca. Quando Oracle opera su questo stato, conta come una singola operazione. La capacità dell'Oracolo di segnare il termine ricercato della tua sovrapposizione è una parte fondamentale dell'intuizione di Grover. Per comprendere l'algoritmo di Grover, ti consiglio innanzitutto di capire come si verifica questa marcatura dello stato desiderato. Successivamente, assicurati di comprendere il ruolo dello stato nell'oracolo.

| - ⟩

$|- \rangle$

— R. Chopin,

Se lo capisci, dovresti studiare l'operatore che è in grado di aumentare l'ampiezza del termine desiderato nella sovrapposizione, riducendo allo stesso tempo l'ampiezza dei termini indesiderati della sovrapposizione. Per me il modo più semplice di avvicinarsi a quello di Grover è guardare l'operatore inverso-medio-medio. (Alcune persone considerano la vista geometrica, ma non la trovo così chiara.)

— R. Chopin

10

Se hai 8 elementi nell'elenco (come nell'esempio della tua carta), allora l'ingresso dell'oracolo è 3 (qu) bit. Il numero di carte nel mazzo (52) è irrilevante, sono necessari solo 3 bit per codificare 8 carte.

Puoi pensare che 3 bit codifichino la posizione nell'elenco della scheda che stai cercando; allora non conosci la posizione, ma l'oracolo lo sa. Quindi, se stai cercando l'asso di picche, l'oracolo sa che l'asso di picche è la sesta carta (o il 5o conteggio da zero) e implementa la funzione

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

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

PS: è meglio pensare all'algoritmo di Grover in modo diverso: hai un oracolo che implementa una funzione booleana che emette per una singola combinazione di bit di input, altrimenti output zero, e il tuo compito è trovare la combinazione. Il problema ha la stessa complessità della ricerca in un elenco o database non ordinati, per questo motivo l'algoritmo di Grover viene generalmente descritto come ricerca in un database non ordinato. Ma applicare l'algoritmo a una ricerca nel database del mondo reale solleva effettivamente domande che vanno oltre l'algoritmo stesso. L'algoritmo di Grover sta solo cercando ciò che l'oracolo sa. $1$

— kludg
fonte

Sì, scusa, quel 6 era di una precedente modifica

— incluso

2

La ringrazio per la risposta. Ho corretto l'errore di scrittura. A che serve eseguire l'algoritmo se per costruire l'oracolo ho bisogno di conoscere la posizione dell'elemento cercato?

— include

1

@incud In effetti non ha senso. Ho aggiornato la risposta.

— kludg,

" L'algoritmo di Grover sta solo cercando ciò che l'oracolo sa ": non necessariamente. L'oracolo può controllare solo alcune proprietà specifiche dell'input, in modo che il risultato che si ottiene alla fine contenga più informazioni di quelle codificate nell'oracle stesso. Un esempio tipico è la ricerca in una rubrica. L'oracolo "chiede" un record allegato a un nome specifico, ma una volta trovato il record corretto, si ottengono anche le informazioni aggiuntive del numero di telefono allegato a quel record, che non è stato affatto codificato nell'oracolo

— glS

4

Mentre forse è più facile per noi pensare alla funzione dell'oracolo come aver già calcolato tutti questi valori, non è quello che sta facendo. Nel caso che hai descritto, l'oracolo ha 8 possibili ingressi (cioè codificati in 3 (qu) bit) e l'oracolo esegue tutti i calcoli di cui hai bisogno al volo . Quindi, nel momento in cui provi a valutare l'oracolo per un valore , l'oracolo cerca (in questo caso) la carta che il valore di $x$ $x$ corrisponde a, quindi controlla se quella carta è la carta contrassegnata. L'idea è che ogni volta che chiami l'oracolo, passa attraverso quel processo una volta. Nel complesso, si valuta la funzione un numero di volte uguale al numero di volte che si chiama l'oracolo. Lo scopo di qualsiasi algoritmo di ricerca è di chiamare quell'oracolo il minor numero di volte possibile.

Nel caso in cui suona un po 'circolare (dato un input , trova a quale scheda corrisponde), ricorda che la tua tabella di ricerca per quale corrisponde a quale scheda può essere ordinata che è una domanda di ricerca diversa, più semplice, molto più veloce. $x$ $x$

Le differenze chiave nel tuo esempio rispetto a uno scenario di utilizzo più realistico sono:

Lo spazio di ricerca è generalmente enorme. Non esiste una prospettiva realistica di precomputare tutti i valori. In effetti, questo è esattamente ciò che stiamo cercando di evitare.
Di solito, in realtà non diciamo "trova l'asso di picche". Invece, c'è una che non è banale da valutare per verificare se è l'elemento 'contrassegnato' o meno. Il fatto che l'oracolo possa richiedere parecchio tempo per essere valutato, anche per una singola voce, è ciò che rende l'oracolo la parte costosa da implementare (e tutte le altre porte sono fornite gratuitamente) e perché è necessario ridurre al minimo il numero di chiamate . $f(x)$ $x$

Quindi, davvero, il modo in cui una ricerca classica funzionerebbe sul tuo problema è: scegli una a caso. Valuta . Se , restituisce , altrimenti ripeti. Mentre l' effetto netto di è 'è l'input , la voce contrassegnata?', Non è il calcolo effettivo che fa. $x$ $y=f(x)$ $y=1$ $x$ $f(x)$ $x_0$

— DaftWullie
fonte

2

Alla fine la domanda è: "Qual è il punto di eseguire l'algoritmo se abbiamo già cercato l'elemento per costruire l'oracolo?"

Mentre qualcuno ha precostruito l'oracolo, potrebbe non essere stata la persona che utilizza l'oracolo.

$\sqrt{\text{size of list}}$

Chiediamo all'oracolo: qual è la risposta che ha già per la domanda che già ha? Anche Mateus e Omar chiederebbero "l'oracolo-per-un-particolare-simbolo-alfabeto" durante il runtime, quali sono le posizioni del suo simbolo nella stringa che ha già compilato? L'oracolo darà la risposta alla nostra domanda dopo una sola consultazione, ma in questa storia, ad esempio, non può semplicemente scrivere la risposta come una stringa binaria e inviarcela su un canale di comunicazione classico. Nasconderà la sua risposta in una sovrapposizione per noi per tirarla fuori.

Lascio che la fantasia o la metafora scappino nel prossimo momento: non sentiamo la risposta per la prima volta e dobbiamo chiedere all'oracolo di ripetere più volte la stessa risposta finché non siamo sicuri di ciò che l'oracolo ha detto, salvo che iniziamo ad allucinare dalla disinformazione nel processo di diffusione se chiediamo troppe volte.

— Brendan M
fonte

2

Dato l'oracolo che hai fornito, la ricerca è davvero inutile. Tuttavia, quell'oracolo manca il punto dell'algoritmo di Grover perché la ricerca di una carta in un mazzo di carte non è una ricerca non strutturata perché, come hai affermato, conosci già l'ordine. Ergo, la tua ricerca è strutturata. Il motivo per cui questo oracolo viene utilizzato è che dimostra come potrebbero essere applicati i Grover senza dover discutere di un oracolo che renderebbe Grover utile perché un tale oracolo sarebbe più complicato che prezioso. Pertanto, un oracolo migliore per dimostrare l'utilità di Grover potrebbe essere qualcosa del tipo:

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

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

Ciò che questo oracolo implica è che hai una ricerca a 8 qubit in cui prendi i primi quattro qubit e li aggiungi ai secondi quattro qubit e capovolgi M se l'aggiunta fa 10 (1010 in binario). La differenza tra questo oracolo e quello che hai fornito è che questo oracolo verifica un modello (aggiungono gli operandi a 10) mentre il tuo verifica l'uguaglianza (è questo indice 5). Questo oracolo è molto più difficile da costruire ma sfrutta il vero potere di Grover, che è, in sostanza, una ricerca di forza bruta in cui l'oracolo definisce lo spazio di ricerca.

— Woody1193
fonte

Algoritmo di Grover: dov'è la lista?

Ricerca in un elenco, in modo classico

Grover e il suo oracolo