L'algoritmo di Grover: un esempio di vita reale?

13

Sono abbastanza confuso su come l'algoritmo di Grover potrebbe essere utilizzato in pratica e vorrei chiedere aiuto per chiarimenti attraverso un esempio.

Supponiamo che $N=8$ database di elementi contenga i colori Rosso, Arancione, Giallo, Verde, Ciano, Blu, Indaco e Viola, e non necessariamente in questo ordine. Il mio obiettivo è trovare Red nel database.

L'input per l'algoritmo di Grover è $n = \log_2(N=8) = 3$ qubit, in cui i 3 qubit codificano gli indici del set di dati. La mia confusione viene qui (potrebbe essere confusa sulle premesse, quindi piuttosto dire scioperi di confusione qui) che, a quanto ho capito, l'oracolo in realtà cerca uno degli indici del set di dati (rappresentato dalla sovrapposizione dei 3 qubit), e inoltre, l'oracolo è "hardcoded" per quale indice dovrebbe cercare.

Le mie domande sono:

Cosa mi sbaglio qui?
Se l'oracolo sta davvero cercando uno degli indici del database, ciò significherebbe che sappiamo già quale indice stiamo cercando, quindi perché cercare?
Date le condizioni di cui sopra con i colori, qualcuno potrebbe evidenziarlo se è possibile con Grover's cercare Red in un set di dati non strutturato?

Esistono implementazioni per l'algoritmo di Grover con un oracolo per cerca | 111>, ad esempio (o vedi un'implementazione R dello stesso oracolo di seguito): /quantum//a/2205 $n=3$

Ancora una volta, la mia confusione è che, dato che non conosco la posizione di elementi in un set di dati, l'algoritmo mi richiede di cercare una stringa che codifica la posizione di elementi. Come faccio a sapere quale posizione dovrei cercare quando il set di dati non è strutturato? $N$ $N$

Codice R:

 #START
 a = TensorProd(TensorProd(Hadamard(I2),Hadamard(I2)),Hadamard(I2))
 # 1st CNOT
 a1= CNOT3_12(a)
 # 2nd composite
 # I x I x T1Gate
 b = TensorProd(TensorProd(I2,I2),T1Gate(I2)) 
 b1 = DotProduct(b,a1)
 c = CNOT3_02(b1)
 # 3rd composite
 # I x I x TGate
 d = TensorProd(TensorProd(I2,I2),TGate(I2))
 d1 = DotProduct(d,c)
 e = CNOT3_12(d1)
 # 4th composite
 # I x I x T1Gate
 f = TensorProd(TensorProd(I2,I2),T1Gate(I2))
 f1 = DotProduct(f,e)
 g = CNOT3_02(f1)
 #5th composite
 # I x T x T
 h = TensorProd(TensorProd(I2,TGate(I2)),TGate(I2))
 h1 = DotProduct(h,g)
 i = CNOT3_01(h1)
 #6th composite
 j = TensorProd(TensorProd(I2,T1Gate(I2)),I2)
 j1 = DotProduct(j,i)
 k = CNOT3_01(j1)
 #7th composite
 l = TensorProd(TensorProd(TGate(I2),I2),I2)
 l1 = DotProduct(l,k)
 #8th composite
 n = TensorProd(TensorProd(Hadamard(I2),Hadamard(I2)),Hadamard(I2))
 n1 = DotProduct(n,l1)
 n2 = TensorProd(TensorProd(PauliX(I2),PauliX(I2)),PauliX(I2))
 a = DotProduct(n2,n1)
 #repeat the same from 2st not gate
 a1= CNOT3_12(a)
 # 2nd composite
 # I x I x T1Gate
 b = TensorProd(TensorProd(I2,I2),T1Gate(I2))
 b1 = DotProduct(b,a1)
 c = CNOT3_02(b1)
 # 3rd composite
 # I x I x TGate
 d = TensorProd(TensorProd(I2,I2),TGate(I2))
 d1 = DotProduct(d,c)
 e = CNOT3_12(d1)
 # 4th composite
 # I x I x T1Gate
 f = TensorProd(TensorProd(I2,I2),T1Gate(I2))
 f1 = DotProduct(f,e)
 g = CNOT3_02(f1)
 #5th composite
 # I x T x T
 h = TensorProd(TensorProd(I2,TGate(I2)),TGate(I2))
 h1 = DotProduct(h,g)
 i = CNOT3_01(h1)
 #6th composite
 j = TensorProd(TensorProd(I2,T1Gate(I2)),I2)
 j1 = DotProduct(j,i)
 k = CNOT3_01(j1)
 #7th composite
 l = TensorProd(TensorProd(TGate(I2),I2),I2)
 l1 = DotProduct(l,k)
 #8th composite
 n = TensorProd(TensorProd(PauliX(I2),PauliX(I2)),PauliX(I2))
 n1 = DotProduct(n,l1)
 n2 = TensorProd(TensorProd(Hadamard(I2),Hadamard(I2)),Hadamard(I2))
 n3 = DotProduct(n2,n1)
 result=measurement(n3)
 plotMeasurement(result)

grovers-algorithm

— 01000001
fonte

3

Possibile duplicato dell'algoritmo

— DaftWullie,

riferito anche a: quantumcomputing.stackexchange.com/q/175/55

— glS

5

| x ⟩_{address} | 0 ⟩_{value} \to | x ⟩_{address} | load (x) \oplus 0 ⟩_{value} = | x ⟩_{address} | load (x) ⟩_{value} .

$|x\rangle_{\text{address}}|0\rangle_{\text{value}} \rightarrow |x\rangle_{\text{address}}|\textrm{load}(x)\oplus 0\rangle_{\text{value}} = |x\rangle_{\text{address}}|\textrm{load}(x)\rangle_{\text{value}}.$

H_{address}^{\otimes n} | 0 ⟩_{address} | 0 ⟩_{value} = \frac{1}{2^{n / 2}} \sum_{x = 0}^{2^{n} - 1} | x ⟩_{address} | 0 ⟩_{value}

$H^{\otimes n}_{\text{address}} |0\rangle_{\text{address}}|\textrm0\rangle_{\text{value}}=\frac1{2^{n/2}}\sum_{x=0}^{2^n-1} |x\rangle_{\text{address}}|\textrm0\rangle_{\text{value}}$

apply load \to \frac{1}{2^{n / 2}} \sum_{x = 0}^{2^{n} - 1} | x ⟩_{address} | load (x) ⟩_{value}

$\text{apply load}\rightarrow \frac1{2^{n/2}}\sum_{x=0}^{2^n-1} |x\rangle_{\text{address}}|\textrm{load}(x)\rangle_{\text{value}}$

O (\sqrt{N})

$O(\sqrt{N})$

x^{*}

$x^*$

| x^{*} ⟩_{address} | load (x^{*}) ⟩_{value} .

$|x^*\rangle_{\text{address}}|\textrm{load}(x^*)\rangle_{\text{value}}.$

Forse il problema principale che hai è capire il database e non l'algoritmo Grover. Per questo puoi vedere una spiegazione più dettagliata nel capitolo 6.5 Nielsen & Chuang.

Penso anche che l'applicazione più utile dell'algoritmo Grover non sia l'applicazione di database, ma le sue generalizzazioni come amplificazione di ampiezza (vedi https://arxiv.org/abs/quant-ph/0005055 ) su qualsiasi algoritmo quantistico.

$\neq$

— Alex Go
fonte

\neq

$\neq$

\sum_{k} | k ⟩ \otimes | s_{k} ⟩

$\sum_k |k\rangle\otimes|s_k\rangle$

k

$k$

s_{k} = + 1

$s_k=+1$

s_{k}

$s_k$ .

— glS

Sì, questo esempio è forse più facile da capire come primo esempio. Ma penso di capire che l'algoritmo Grover è utile per un'applicazione su una classe più ampia di problemi importanti, l'idea alla base di P

\neq

$\neq$

4

Questo è già parzialmente discusso in questa domanda correlata , ma proverò qui ad affrontare più specificamente alcuni dei problemi che sollevi.

| i ⟩ \mapsto (- 1)^{f (x_{i})} | i ⟩,

$|i\rangle\mapsto(-1)^{f(x_i)}|i\rangle,$

i

$i$

x_{i}

$x_i$

i

$i$

$f(x_i)$ $x_i$ $x_i$ $x_i$ $P$ $P$

$f$ $x_i$ $i$ $x_i$

$x_i=i$ $x_i$ uguale a 3 ?".

In tal caso, l'algoritmo non è davvero particolarmente utile in quanto la risposta deve essere codificata nell'oracolo, ma non è necessario che ciò avvenga in generale.

— gls
fonte

Grazie per la risposta! Forse sarebbe possibile fornire un esempio di vita reale in cui il Grover è "utile" applicato su alcuni dati reali dato l'oracolo presentato? Ad esempio, come funzionerebbe con un database di 8 elementi con numeri primi e non primi?

— 01000001

1

@ 01000001 Credo che questa risposta su una domanda correlata su cstheory.SE potrebbe essere valida. È un bell'esempio di Grover usato per un non banale

f

$f$ . Nel suo caso,

f

$f$ codifica se una determinata formula booleana è soddisfatta dall'input. L'output dell'algoritmo è quindi un

x

$x$ soddisfare una formula booleana

— glS