Spanish
Idiomas
English
Japanese
Spanish

Nota

Esta página fue generada a partir de docs/tutorials/grover_with_sampler.ipynb.

Búsqueda en base de datos con Grover usando Sampler

En este tutorial, resolverás un pequeño problema de búsqueda en una base de datos utilizando el algoritmo de Grover con la primitiva Sampler en Qiskit Runtime.

Antes de comenzar

Este tutorial requiere una instancia del servicio Qiskit Runtime. Si aún no lo has hecho, sigue la Guía de primeros pasos para configurar uno.

Información de antecedentes

Problema de búsqueda no estructurada

En los viejos tiempos, buscabas el número de teléfono de una persona en una guía telefónica. Esa es una tarea fácil si sabes el nombre de la persona porque una guía telefónica está ordenada alfabéticamente por nombre. Sin embargo, la tarea contraria, es decir, te dan un número de teléfono y quieres saber a quién pertenece, es mucho más difícil. Esto se debe a que una guía telefónica no está ordenada por números de teléfono. Este es un ejemplo de un problema de búsqueda no estructurada. Para resolver este problema con una computadora clásica, tu mejor truco es elegir una entrada al azar. En promedio, necesitará buscar la mitad de las entradas (\(N/2\), si \(N\) es el número total de entradas) para encontrar al propietario. Sin embargo, si tienes una computadora cuántica, puedes usar el algoritmo de Grover para encontrar al propietario en \(\sqrt N\) intentos. Eso significa que para identificar al propietario en una guía telefónica que tiene 1 millón de números, ¡solo necesita hacer 1000 intentos en lugar de 500,000!

Algoritmo de Grover

En pocas palabras, el algoritmo de Grover utiliza un buen truco cuántico llamado amplificación de amplitud para aumentar drásticamente las posibilidades de encontrar la respuesta correcta, el propietario de un número de teléfono, en cada intento (iteración). Eso es todo lo que necesitas saber ahora. No tienes que entender los detalles sobre cómo funciona el algoritmo de Grover para aplicarlo, ¡porque Qiskit lo hace por ti! Sin embargo, si estás interesado, puedes leer el capítulo sobre el algoritmo de Grover en el libro de texto de Qiskit.

A continuación, veamos un ejemplo concreto.

Descripción General

En este tutorial, buscarás al propietario de una pequeña guía telefónica utilizando el algoritmo de Grover siguiendo estos pasos:

  1. Crea el circuito de Grover para el problema de búsqueda en la guía telefónica.

  2. Envía los circuitos a una computadora cuántica en la nube utilizando el servicio Qiskit Runtime y la primitiva Sampler.

  3. Analiza los resultados e identifica al propietario del número de teléfono.

Paso 1: Crear el circuito de Grover

Definir un problema de búsqueda no estructurada en Qiskit

En este ejemplo simple, se te entrega una pequeña guía telefónica que tiene 8 entradas, de la persona 0 a la persona 7, y quieres encontrar al propietario de un determinado número de teléfono. Sin embargo, no se te permite mirar la guía telefónica directamente. Solo se te permite consultar un “oráculo”: un circuito de caja negra que te dice inmediatamente si nuestra conjetura es correcta o incorrecta (como el Oráculo en «The Matrix»).

[1]:
import random
from qiskit.quantum_info import Statevector

secret = random.randint(0, 7)  # the owner is randomly picked
secret_string = format(secret, "03b")  # format the owner in 3-bit string
oracle = Statevector.from_label(secret_string)  # let the oracle know the owner

Una vez que tienes el oráculo, puedes definir el problema de búsqueda no estructurada usando la clase AmplificationProblem en Qiskit.

[2]:
from qiskit.algorithms import AmplificationProblem

problem = AmplificationProblem(oracle, is_good_state=secret_string)

Construir el circuito de Grover para el problema

Ahora estás listo para construir los circuitos cuánticos para el algoritmo de Grover para este problema. La precisión del algoritmo de Grover para encontrar la respuesta correcta aumenta con el número de iteraciones. Vamos a crear dos circuitos con una y dos iteraciones en cada uno, para ver este efecto.

[3]:
from qiskit.algorithms import Grover

grover_circuits = []
for iteration in range(1, 3):
    grover = Grover(iterations=iteration)
    circuit = grover.construct_circuit(problem)
    circuit.measure_all()
    grover_circuits.append(circuit)

Veamos los circuitos:

[4]:
# Grover's circuit with 1 iteration
grover_circuits[0].draw()
[4]:
../_images/tutorials_grover_with_sampler_11_0.png
[5]:
# Grover's circuit with 2 iterations
grover_circuits[1].draw()
[5]:
../_images/tutorials_grover_with_sampler_12_0.png

Paso 2: Enviar los circuitos a una computadora cuántica en la nube

Ahora que se crearon los circuitos de Grover, enviémoslos a una computadora cuántica en la nube usando la primitiva Sampler.

Conectarse al servicio Qiskit Runtime

First, connect to the Qiskit Runtime service instance that you created in Before you begin.

[6]:
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = "ibmq_qasm_simulator"  # use the simulator

El algoritmo de Grover determina la respuesta correcta en función de la mayor probabilidad de resultados de medición. La primitiva Sampler es perfecta para obtener probabilidades, así que la usarás. En la siguiente celda, crea una instancia de la primitiva Sampler e iniciamos una sesión de Runtime usando el administrador de contexto (with ...:), que automáticamente abre y cierra la sesión por ti.

La primitiva Sampler permite el envío por lotes de circuitos en un trabajo (job). Aquí estás pasando una lista de dos circuitos (Grover con 1 iteración y con 2 iteraciones) al Sampler, pero solo se necesita una llamada para muestrear la probabilidad de los resultados de medición de ambos circuitos.

[7]:
from qiskit_ibm_runtime import Sampler, Session

with Session(service=service, backend=backend):
    sampler = Sampler()
    job = sampler.run(circuits=grover_circuits, shots=1000)
    result = job.result()
    print(result)
SamplerResult(quasi_dists=[{1: 0.029, 2: 0.026, 5: 0.032, 3: 0.808, 0: 0.029, 7: 0.029, 6: 0.023, 4: 0.024}, {5: 0.011, 2: 0.012, 0: 0.007, 3: 0.936, 7: 0.005, 6: 0.015, 4: 0.006, 1: 0.008}], metadata=[{'header_metadata': {}, 'shots': 1000}, {'header_metadata': {}, 'shots': 1000}])

Paso 3: Analizar los resultados

Veamos los resultados:

[8]:
from qiskit.tools.visualization import plot_histogram

# Extract bit string with highest probability from results as the answer
result_dict = result.quasi_dists[1].binary_probabilities()
answer = max(result_dict, key=result_dict.get)
print(
    f"As you can see, the quantum computer returned '{answer}' as the answer with highest probability.\n"
    "And the results with 2 iterations have higher probability than the results with 1 iteration."
)

# Plot the results
plot_histogram(result.quasi_dists, legend=["1 iteration", "2 iterations"])
As you can see, the quantum computer returned `3` as the answer with highest probability.
And the results with 2 iterations have higher probability than the results with 1 iteration.
[8]:
../_images/tutorials_grover_with_sampler_19_1.png

Imprimamos el resultado cuántico, junto con la cadena secreta, para verificar que la computadora cuántica encontró la respuesta correcta.

[9]:
# Print the results and the correct answer.
print(f"Quantum answer: {answer}")
print(f"Correct answer: {secret_string}")
print("Success!" if answer == secret_string else "Failure!")
Quantum answer: 011
Correct answer: 011
Success!

¡Felicidades! Has encontrado con éxito al propietario del número de teléfono.

¡Puedes volver a ejecutar el tutorial varias veces para generar otras cadenas secretas aleatorias para comprobar que no estamos haciendo trampa! La computadora cuántica siempre encontrará la respuesta correcta.

Resumen

En este tutorial, has resuelto un pequeño problema de búsqueda en una base de datos usando una computadora cuántica. Has construido los circuitos de Grover definiendo un problema de búsqueda en la guía telefónica usando la clase AmplificationProblem en Qiskit y luego enviaste los circuitos para que se ejecuten usando la primitiva Sampler a través del servicio Qiskit Runtime.

Referencias

  1. Harkins, F., Grover’s search algorithm. In A. Abbas, et al. Learn Quantum Computation Using Qiskit. URL: https://learn.qiskit.org/course/introduction/grovers-search-algorithm (accessed 09/01/2022) (2020).

Versiones de Qiskit y derechos de autor

[10]:
import qiskit_ibm_runtime

qiskit_ibm_runtime.version.get_version_info()
[10]:
'0.7.0'
[11]:
import qiskit.tools.jupyter

%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
qiskit-terra0.21.1
qiskit-aer0.10.4
qiskit-ibmq-provider0.19.2
System information
Python version3.10.5
Python compilerClang 13.0.1
Python buildmain, Jun 14 2022 07:05:37
OSDarwin
CPUs8
Memory (Gb)16.0
Tue Aug 23 13:55:53 2022 CEST

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.