Algoritmo de Grover: ¿un ejemplo de la vida real?

Estoy bastante confundido acerca de cómo se podría usar el algoritmo de Grover en la práctica y me gustaría pedir ayuda sobre la aclaración a través de un ejemplo.

Supongamos una base de datos de elementos que contiene colores Rojo, Naranja, Amarillo, Verde, Cian, Azul, Indigo y Violeta, y no necesariamente en este orden. Mi objetivo es encontrar Red en la base de datos.$N=8$

La entrada para el algoritmo de Grover es qubits, donde los 3 qubits codifican los índices del conjunto de datos. Mi confusión viene aquí (podría estar confundido acerca de las premisas, así que más bien decir que la confusión ataca aquí) que, según tengo entendido, el oráculo realmente busca uno de los índices del conjunto de datos (representado por la superposición de los 3 qubits), y además, el oráculo está "codificado" para el índice que debe buscar.$n = \log_2(N=8) = 3$

Mis preguntas son:

• ¿Qué me equivoco aquí?
• Si el oráculo realmente está buscando uno de los índices de la base de datos, eso significaría que ya sabemos qué índice estamos buscando, entonces, ¿por qué buscar?
• Dadas las condiciones anteriores con los colores, ¿alguien podría señalarlo si es posible con Grover buscar Rojo en un conjunto de datos no estructurado?

Hay implementaciones para el algoritmo de Grover con un oráculo para buscando | 111>, por ejemplo (o vea una implementación R del mismo oráculo a continuación): /quantum//a/2205$n=3$

Nuevamente, mi confusión es que, dado que no conozco la posición de elementos en un conjunto de datos, el algoritmo requiere que busque una cadena que codifique la posición de N elementos. ¿Cómo sé qué posición debo buscar cuando el conjunto de datos no está estructurado?$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)

$$|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^{\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}}$$ $$\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})$$x^*$ $$|x^*\rangle_{\text{address}}|\textrm{load}(x^*)\rangle_{\text{value}}.$$

Quizás el principal problema que tiene es comprender la base de datos, no el algoritmo de Grover. Puede ver una explicación más detallada en el capítulo 6.5 Nielsen & Chuang para esto.

También creo que la aplicación más útil del algoritmo de Grover no es la aplicación de la base de datos, sino sus generalizaciones como amplificación de amplitud (consulte https://arxiv.org/abs/quant-ph/0005055 ) en cualquier algoritmo cuántico.

$\neq$

Esto ya se discutió parcialmente en esta pregunta relacionada , pero trataré aquí para abordar más específicamente algunos de los problemas que plantea.

En términos generales, el algoritmo de Grover se basa en el supuesto de que uno puede realizar una operación de consulta del formulario

$$|i\rangle\mapsto(-1)^{f(x_i)}|i\rangle,$$ dónde $i$ es el índice en la base de datos y $x_i$ cualquier información que la base de datos adjunte a $i$.

Tu puedes pensar en $f(x_i)$como " hacer una pregunta sobre$x_i$". Por ejemplo," es$x_i$un numero primo? "o" hace$x_i$ tener propiedad $P$?", dónde $P$ podría significar "ser rojo".

Es importante observar que $f$ podría estar haciendo una pregunta que no caracteriza completamente $x_i$. Esto significa que después de ejecutar el algoritmo y recuperar$i$, y por lo tanto $x_i$ con él, también obtengo conocimiento que no se usó para construir el oráculo.

Sin embargo, en muchas implementaciones de prueba de principio del algoritmo de Grover, como la que muestra, este no es el caso. De hecho, en estas demostraciones la pregunta que se hace es "trivial", en el sentido de que$x_i=i$, y la pregunta es de la forma " es$x_i$igual a 3 ?

En tal caso, el algoritmo no es particularmente útil ya que la respuesta tiene que estar codificada en el oráculo, pero este no tiene que ser el caso en general.