Algoritmo de Grover: um exemplo da vida real?

13

Estou bastante confuso sobre como o algoritmo de Grover poderia ser usado na prática e gostaria de pedir ajuda no esclarecimento através de um exemplo.

Vamos supor que um banco de dados de elementos $N=8$ contenha as cores Vermelho, Laranja, Amarelo, Verde, Ciano, Azul, Índigo e Violeta, e não necessariamente nessa ordem. Meu objetivo é encontrar vermelho no banco de dados.

A entrada para o algoritmo de Grover é $n = \log_2(N=8) = 3$ qubits, em que os 3 qubits codificam os índices do conjunto de dados. Minha confusão chega aqui (pode ser confuso sobre as premissas, então digamos que ocorram confusão aqui) que, como eu entendo, o oráculo realmente procura por um dos índices do conjunto de dados (representado pela superposição dos 3 qubits) e, além disso, o oráculo é "codificado" para qual índice ele deve procurar.

Minhas perguntas são:

O que eu entendi errado aqui?
Se o oracle está realmente procurando por um dos índices do banco de dados, isso significa que já sabemos qual índice estamos procurando, então por que pesquisar?
Dadas as condições acima com as cores, alguém poderia apontar se é possível com o Grover procurar por vermelho em um conjunto de dados não estruturado?

Existem implementações para o algoritmo de Grover com um oráculo para procurando por | 111>, por exemplo (ou veja uma implementação R do mesmo oráculo abaixo): /quantum//a/2205 $n=3$

Novamente, minha confusão é que, como não conheço a posição de elementos em um conjunto de dados, o algoritmo exige que eu procure uma string que codifique a posição de elementos. Como sei qual posição devo procurar quando o conjunto de dados não está estruturado? $N$ $N$

Código 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

Possível duplicata do algoritmo

— DaftWullie

também relacionado 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}}.$

Talvez o principal problema que você tenha seja entender o banco de dados e não o algoritmo de Grover. Você pode ver uma explicação mais detalhada no capítulo 6.5 Nielsen & Chuang para isso.

Eu também acho que a aplicação mais útil do algoritmo de Grover não é a aplicação de banco de dados, mas suas generalizações como amplificação de amplitude (consulte https://arxiv.org/abs/quant-ph/0005055 ) em qualquer algoritmo quântico.

$\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 24/07

\neq

$\neq$

4

Isso já foi discutido parcialmente nesta questão relacionada , mas tentarei abordar aqui mais especificamente alguns dos problemas que você surgir.

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

Nesse caso, o algoritmo não é realmente particularmente útil, pois a resposta precisa ser codificada no oráculo, mas isso não precisa ser o caso em geral.

— glS
fonte

Obrigado por sua resposta! Talvez seria possível fornecer um exemplo da vida real onde o Grover é "útil" aplicado em alguns dados reais, dado o oráculo apresentado? Por exemplo, como ele funcionaria com um banco de dados de 8 elementos com números primos e não primos?

— 01000001

1

f

$f$

f

$f$

x

$x$