L'algoritmo di Grover e la sua relazione con le classi di complessità?

Mi sto confondendo con l'algoritmo di Grover e la sua connessione con le classi di complessità.

L'algoritmo di Grover trova ed elemento in un database di N = 2 n (tale che f ( k ) = 1 ) di elementi con ∼ $k$$N=2^n$$f(k)=1$ chiamate all'oracolo.

Quindi abbiamo il seguente problema:

Problema: trovare una nel database in modo tale che f ( k ) = $k$$f(k)=1$

Ora sono consapevole che questo non è un problema di decisione e quindi le nostre normali definizioni di classe di complessità , NP ecc. Non si applicano davvero. Ma sono curioso di sapere come definiremmo la classe di complessità in questo caso - e che tempo fa rispetto a N o n ?$\text{P}$$\text{NP}$$N$$n$

Inoltre, l'algoritmo di Grover può essere utilizzato come subroutine. Ho letto in diversi punti che l'algoritmo di Grover non cambia la classe di complessità un problema: esiste un modo euristico di vederlo.

Sommario

• Esiste una teoria della complessità dei problemi di ricerca (nota anche come problemi di relazione). Questa teoria include classi chiamate FP , FNP e FBQP che si occupano effettivamente di risolvere i problemi di ricerca con diversi tipi di risorse.
• Da problemi di ricerca, è anche possibile definire problemi di decisione, che consente di mettere in relazione i problemi di ricerca con le normali classi P , NP e BQP .
• Indipendentemente dal fatto che si consideri la versione di ricerca della versione decisionale del problema, il modo in cui si considera l'input per il problema di Ricerca non strutturata determinerà quali limiti superiori è possibile applicare alla sua complessità.

La complessità dei problemi relazionali

Come notate, il problema di Grover risolve un problema di ricerca , che nella letteratura sulla complessità è talvolta noto anche come problema di relazione . Cioè, è un problema del seguente tipo:

La struttura di un problema di ricerca generale.
Dato un input e una relazione binaria R , trova una y tale che R ( x , y ) vale.$x$$R$$y$$R(x,y)$

Le classi di complessità FP e FNP sono definite in termini di tali problemi, dove in particolare uno è interessato al caso in cui ha una lunghezza al massimo di una funzione polinomiale della lunghezza di x , e dove la relazione R ( x , y ) può essa stessa essere calcolato in un periodo di tempo limitato da un polinomio nella lunghezza di ( x , y ) .$y$$x$$R(x,y)$$(x,y)$

In particolare: l'esempio del problema di "ricerca nel database" per il quale viene generalmente applicata la ricerca di Grover può essere descritto come segue.

Ricerca non strutturata.
Dato un oracolo di input tale che O | un ⟩ | b ⟩ = | un ⟩ | b ⊕ f ( a ) ⟩ per alcune funzioni f : { 0 , 1 } m → { 0 , 1 } , trova una y tale che 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$

Qui, l'oracolo stesso è l'input al problema: gioca il ruolo di , e la relazione che stiamo calcolando è R ( O , y $x$

Supponiamo che, anziché un oracolo, ci venga fornito un input specifico che descriva come calcolare la funzione f , possiamo quindi considerare a quale classe di complessità appartiene questo problema. Come indicato , la classe di complessità appropriata che otteniamo dipende da come viene fornito l'input.$x$$f$pyramids

• Supponiamo che la funzione di input sia fornita come database (poiché il problema è talvolta descritto), in cui ciascuna voce del database ha una certa lunghezza . Se n è la lunghezza della stringa x utilizzata per descrivere l'intero database , il database ha voci N = n / ℓ . È quindi possibile effettuare una ricerca esaustiva dell'intero database interrogando ciascuna delle N voci in sequenza e fermarsi se troviamo una voce y tale che f ( y ) = 1 . Supponendo che ogni query nel database richieda qualcosa come O $\ell$$n$$x$$N = n\big/\ell$$N$$y$$f(y) = 1$ time, questa procedura si interrompe nel tempo O ( N log N ) ⊆ O ( n log n ) , quindi il problema è inFP.$O(\log N) \subseteq O(\log n)$$O(N \log N) \subseteq O(n \log n)$

  Supponendo che la ricerca del database possa essere eseguita in una sovrapposizione coerente, l'algoritmo di Grover consente che questo problema si trovi in FBQP . Tuttavia, come FP  ⊆  FBQP , la classica ricerca esaustiva dimostra anche che questo problema si trova in FBQP . Tutto ciò che otteniamo (fino a registrare i fattori) è un quadratico accelerato a causa di un risparmio nel numero di query del database.
  
  

• Supponiamo che la funzione di input sia descritta in modo succinto, da un algoritmo del tempo polinomiale che prende una specifica e un argomento y ∈ { 0 , 1 } me calcola 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}\!$su base standard , dove m può essere molto più grande di Ω ( log n ) . Un esempio potrebbe essere dove x specifica la forma CNF di una funzione booleana f : { 0 , 1 } m → { 0 , 1 } per m ∈ O ( n ) , nel qual caso possiamo valutare in modo efficiente f ( y ) su un input 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)$ quindi valutare in modo efficiente O su stati di base standard. Questo pone il problema inFNP.$y \in \{0,1\}^m$$\mathcal O$

  Data una procedura per valutare da ( x , y ) nel tempo O ( p ( n ) ) per n = | x | , L'algoritmo di Grover risolve il problema della ricerca non strutturata di O nel tempo O ( p ( n ) $f(y)$$(x,y)$$O(p(n))$$n = \lvert x \rvert$$\mathcal O$⊆O(p(n)$O(p(n) \sqrt{2^m})$ . Questo non è polinomiale inn, e quindi non è sufficiente per mettere questo problema inFBQP: otteniamo solo unquadruplo divelocità - anche se questo è ancora un potenziale risparmio enorme di tempo di calcolo, supponendo che il vantaggio fornito dall'algoritmo di Grover non sia perso a l'overhead richiesto per il calcolo quantico a tolleranza d'errore.$\subseteq O(p(n) \sqrt{2^n})$$n$
  
  

$n$$x$$\mathcal O$$x$$N = n\big/\ell$$N$$n$$x$$\mathcal O$$N \in O(2^{n/2})$$O(\sqrt N)$

Complessità decisionale da problemi di relazione

Esiste un modo semplice per ottenere problemi di decisione da problemi di relazione, che è ben noto dalla teoria dei problemi NP completi : trasformare il problema di ricerca in una domanda sull'esistenza di una soluzione valida.

$x$$R$$\exists y: R(x,y)$

$R$

$x$$x$ una soluzione per la ricerca non strutturata che lo fa senza trovare effettivamente una soluzione, sebbene non sia chiaro in generale come farlo in un modo che fornirebbe un vantaggio rispetto alla ricerca effettiva di una soluzione.

Complessità Oracle

$\mathcal O$$x$$\mathcal O$

$\mathcal O$$n$$\mathcal O$$n$$x$

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

$\mathsf{NP}^{\mathcal O}$$\mathsf{FNP}^{\mathcal O}$$\mathsf{BQP}^{\mathcal O}$$\mathsf{FBQP}^{\mathcal O}$

$\mathcal O$

Come possiamo vedere da quest'ultimo caso, se trattiamo l'input solo come un oracolo, la situazione sembra un po 'non intuitiva e certamente rende impossibile parlare dei modi in cui il "database" può essere realizzato. Ma una virtù di considerare la versione relativizzata del problema, con un vero oracolo, è che possiamo provare cose che altrimenti non abbiamo idea di come provare. Se potessimo provare che la versione decisionale del problema di ricerca non strutturato conciso era in BQP , allora potremmo realizzare un enorme passo avanti nel calcolo pratico; e se potessimo dimostrare che il problema decisionale non era effettivamente in BQP , allora avremmo dimostrato che P ≠ PSPACE$\mathcal O$$\mathcal O$$\mathsf{NP}^{\mathcal O}$$\mathsf{BQP}^{\mathcal O}$

$n$$m$$n$

$m*2^{n/2}$$m*2^{n-1}$

Tuttavia, ai fisici piace fare appello all'idea che si tratti ancora di una accelerazione esponenziale senza equivalenti classici noti (o addirittura facilmente concepibili). Ciò è più evidente nell'esempio del database in cui la funzione oracle è una ricerca nel database e l'algoritmo di Grover può far sì che uno abbia bisogno di molte meno ricerche rispetto ai dati nel database. In questo senso, c'è ancora un vantaggio significativo, sebbene sia completamente perso nel quadro della classe di complessità.

$n$

$\text{NP}$

$f(x)$$x\in\{0,1\}^n$$x$$f(x)=1$$p_x$$m\sim\text{poly}(n)$$g(x,p_x)=1$$f(x)=1$$g(x,p_x)$$\text{poly}(n)$

Lasciami fare alcuni esempi (forse questi sono quelli che stavi chiedendo qui ?):

• $f(x)$$x$$x$$f(x)$$g(x,p_x)=f(x)$

• $f(x)$$x$$x=72$$p_x=(8,9)$$g(x,p)$$x$

• $G_1$$G_2$$x$$f(x)$$p_x$$G_1$$G_2$$g(x,p_x)$$p_x$$G_1$$G_2$

• $x$$f(x)$$p_x$$g(x,p_x)$

$\text{NP}$$\text{P}$$\text{P}$

$\text{P}$$\text{NP}$$\text{NP}$$\text{P}$$\text{P}\neq\text{NP}$

$\text{NP}$$x$$p_x$$m=\text{poly}(n)$$g(x,p_x)=1$$O(2^m\text{poly}(m))$$g(x,p_x)=1$$p_x$$O(2^{m/2}\text{poly}(m))$. Questo è enormemente più veloce, ma non cambia la valutazione se il tempo di esecuzione è polinomiale o qualcosa di peggio; non è diventato un algoritmo temporale polinomiale. Ad esempio, l'isomorfismo grafico dovrebbe cercare tutte le possibili permutazioni. Il dragamine avrebbe dovuto cercare tutte le possibili assegnazioni di mine su quadrati scoperti.

Naturalmente, in alcuni casi, la struttura aggiuntiva del problema consente soluzioni diverse che non richiedono la ricerca di tutte le prove possibili. Lì, la ricerca di Grover è di scarsa utilità, o addirittura no, per noi, ma potrebbe essere che possiamo elaborare un algoritmo temporale polinomiale in un altro modo. Ad esempio, il caso del test composito: classicamente, trovare i fattori di un numero sembra essere difficile: non possiamo fare molto meglio del test di tutti i possibili fattori, quindi fare uso di quella forma di prova non aiuta molto, ma , come già accennato, la domanda può essere risolta in modo efficiente tramite un'altra strada, il test di primalità di AKS.

Dimentica il database. L'algoritmo di Grover risolve il problema della soddisfazione booleana , vale a dire:

$n$$1$$0$

È noto che il problema è NP-completo.