Primeros pasos en la computación cuántica

Dificultad: Principiante
Uso de tiempo de QPU: 11 s

¡Bienvenido/a, hacker! Estamos muy contentos de tenerte en el workshop. El objetivo principal de esta práctica introductoria es prepararte para tu viaje cuántico: 1) guiándote en cómo instalar qiskit, 2) cómo crear una cuenta de IBM Cloud y preparar api_key y crn para usar un computador cuántico real, 3) crear tu primer Circuit cuántico, 4) resolver un cuestionario sobre estados cuánticos y 5) ejecutar tus Circuits en el computador cuántico real y representar los resultados.

1. Lo primero es lo primero: Qiskit

¿Qué es Qiskit?

El SDK de Qiskit es una pila de software de alto rendimiento creada para ayudar a desarrolladores e investigadores a aprovechar toda la potencia de los computadores cuánticos a escala de utilidad y más allá. En su núcleo se encuentra el SDK de Qiskit, un kit de desarrollo de software de código abierto para trabajar con computadores cuánticos a nivel de Circuits cuánticos extendidos, Operadores y primitivas. El SDK de Qiskit permite a cualquier persona obtener un rendimiento óptimo de los computadores cuánticos reales usando su entorno de computación preferido.

Más allá del SDK, Qiskit también incluye un conjunto de herramientas y servicios de alto rendimiento como Qiskit Runtime Service, que permite cálculos optimizados en los computadores cuánticos de IBM a través de la nube usando primitivas que gestionan la mitigación de errores. El servicio Qiskit Transpiler, que proporciona métodos heurísticos e impulsados por IA de vanguardia que mejoran el rendimiento para tareas comunes de optimización de Circuits cuánticos.

Qiskit functions, un catálogo de servicios de IBM y de terceros que facilita la optimización de cargas de trabajo y el uso de Qiskit para casos de uso industriales. Tanto si eres un desarrollador de software cuántico, un experimentalista cuántico, un científico computacional o simplemente quieres comenzar, el marco modular y flexible de Qiskit te permite trabajar en el nivel de abstracción que mejor se adapta a tus necesidades.

Qiskit está diseñado para la extensibilidad y la personalización, de modo que puedas extraer un rendimiento líder en la industria y abordar nuevos tipos de problemas. Una base de código de alto rendimiento significa que el SDK de Qiskit trabaja más rápido, usa menos memoria y ofrece mejores resultados que nunca. Y Qiskit también te introduce en una vasta comunidad de usuarios y desarrolladores que están ansiosos por darte la bienvenida y ayudarte a responder tus preguntas. Lanzado por primera vez en 2019, el programa de defensores de Qiskit es una iniciativa global centrada en la comunidad que recluta profesionales y entusiastas de la computación cuántica de todo el mundo. Con el paso de los años, los defensores se han convertido en líderes reconocidos en la comunidad cuántica. ¿Quieres ser el próximo líder cuántico? No dudes en postularte - aquí

Instalar Qiskit

Primero, verifica que la versión de Python que estás usando en tu entorno sea python>=3.10, para asegurarte de que sea compatible con la última versión de Qiskit que usaremos.

from platform import python_version

print(python_version())

Si no es el caso, puedes actualizarlo usando tu herramienta preferida. Si no sabes cómo hacerlo, algunas opciones recomendadas son:

MacOS: Homebrew
Linux: sudo apt-get update

Una guía detallada sobre cómo actualizar Python dependiendo de tu sistema operativo se detalla aquí: How to update Python

Para obtener más información, echa un vistazo al wiki del QGSS (Qiskit Global Summer School) 2025: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

Puedes verificar tu instalación ejecutando la celda a continuación. Si la instalaste correctamente, devolverá la versión de qiskit.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

Solución de problemas

Si la celda anterior generó un error, puedes optar por instalar Qiskit en un entorno virtual (se sugieren dos métodos a continuación). Si no tienes errores, puedes ignorar esta celda y pasar a la siguiente.

Aquí proponemos dos métodos diferentes para configurar un entorno virtual para instalar Qiskit.

Usando venv, como se explica en la guía de instalación de Qiskit.
Usando conda, como se explica en este vídeo de Coding with Qiskit.

2. Configura tu cuenta de IBM Cloud

Para usar un computador cuántico real, necesitas una api key — un ticket de entrada principal a la nube — y un crn — un token que pondrá tus recursos a tu disposición configurando tu cuenta.

Configura tu cuenta de la siguiente manera:

Ve a la Plataforma IBM Quantum®.
Ve a la esquina superior derecha (como se muestra en la imagen anterior), crea tu token de API y cópialo en un lugar seguro.
En la siguiente celda, reemplaza deleteThisAndPasteYourAPIKeyHere con tu clave de API.
Ve a la esquina inferior izquierda (como se muestra en la imagen anterior) y crea tu instancia. Asegúrate de elegir el plan abierto.
Después de que se cree la instancia, copia su código CRN asociado. Es posible que necesites actualizar para ver la instancia.
En la celda a continuación, reemplaza deleteThisAndPasteYourCRNHere con tu código CRN.

Consulta esta guía para obtener más detalles sobre cómo configurar tu cuenta de IBM Cloud®.

⚠️ Nota: Trata tu clave de API como si fuera una contraseña segura. Consulta la guía de configuración de la nube para obtener más información sobre el uso de tu clave de API tanto en entornos seguros como no confiables.

Además, si eres miembro de la red universitaria de socios de IBM, utiliza la dirección de correo electrónico de tu institución para tu IBM ID para recibir el beneficio de socio.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

3. Tu primer circuito cuántico

Circuitos cuánticos

La unidad fundamental de Qiskit es el circuito cuántico, que es una serie de instrucciones que un computador cuántico puede usar para trabajar con bits cuánticos de información, también conocidos como qubits. Estos qubits tienen propiedades especiales que permiten a los computadores cuánticos abordar los problemas de manera diferente a cómo lo haría tu portátil o iPhone. Qiskit avanza rápidamente como tecnología — aunque todavía puedes diseñar manualmente tus Circuits cuánticos y decidir cómo quieres ejecutarlos (y hay muchas buenas razones para hacerlo), IBM Quantum también te proporciona herramientas que simplifican el proceso. En aras del aprendizaje, vamos a diseñar un Circuit muy simple y ejecutarlo en un simulador.

Nos estamos acelerando en este resumen porque, honestamente, podríamos pasar horas solo explicando los conceptos básicos de la información y la computación cuántica. De hecho, IBM Quantum ya ha hecho esto, produciendo un curso escrito y una serie de clases en vídeo dedicados al tema. ¡Si necesitas un repaso, échales un vistazo!

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

Operaciones básicas sobre qubits y mediciones

Descripción de estados de un solo qubit

Comencemos observando un qubit único. La principal diferencia entre un bit clásico, que solo puede tomar los valores 0 y 1, es que un bit cuántico, o qubit, puede estar en los estados $\vert0\rangle$ , $\vert1\rangle$ , así como en una combinación lineal de estos dos estados. Esta característica se conoce como superposición, y nos permite escribir el estado más general de un Qubit como:

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

Si midiéramos el estado de este qubit, encontraríamos el resultado $1$ con probabilidad $p$ , y el resultado $0$ con probabilidad $1-p$ . Como puedes ver, la probabilidad total es $1$ , lo que significa que efectivamente mediremos $0$ o $1$ , y no existe ningún otro resultado.

Además de $p$ , es posible que hayas notado otro parámetro arriba. La variable $\phi$ indica la fase cuántica relativa entre los dos estados $\vert0\rangle$ y $\vert1\rangle$ . Como descubriremos más adelante, esta fase relativa es bastante importante. Por ahora, basta señalar que la fase cuántica es lo que permite la interferencia entre estados cuánticos, lo que nos da la capacidad de escribir algoritmos cuánticos para resolver tareas específicas.

Visualización de estados cuánticos

A lo largo de este ejercicio visualizamos estados cuánticos usando lo que se conoce como qsphere. Aquí se muestra cómo se ve el qsphere para los estados $\vert0\rangle$ y $\vert1\rangle$ , respectivamente. Ten en cuenta que la parte más alta de la esfera representa el estado $\vert0\rangle$ , mientras que la parte inferior representa $\vert1\rangle$ .

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

Puedes crear exactamente el mismo QSphere usando un Circuit cuántico. El statevector que se usa aquí es del estado $|0\rangle$ . En Qiskit, el Qubit se inicializa en el estado $|0\rangle$ . Intenta ejecutar el Circuit a continuación y comprueba si puedes obtener el mismo QSphere.

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

Ahora visualicemos el estado $|1\rangle$ . No debería sorprenderte que el estado de superposición con fase cuántica $\phi = 0$ y probabilidad $p = 1/2$ (lo que significa una probabilidad igual de medir tanto 0 como 1) se muestre en el qsphere con dos puntos. Sin embargo, observa también que el tamaño de los círculos en los dos puntos es más pequeño que cuando simplemente teníamos $\vert0\rangle$ y $\vert1\rangle$ anteriormente. Esto se debe a que el tamaño de los círculos es proporcional a la probabilidad de medir cada uno, que ahora se ha reducido a la mitad.

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

En el caso de estados de superposición, donde la fase cuántica es distinta de cero, el qsphere nos permite visualizar esa fase cambiando el color del blob respectivo. Por ejemplo, el estado con $\phi = 90^\circ$ (grados) y probabilidad $p = 1/2$ se muestra en el qsphere a continuación.

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

Manipulación de qubits

Los qubits se manipulan aplicando puertas cuánticas. Repasemos una descripción general de las diferentes puertas que consideraremos en los siguientes ejercicios.

Primero, describamos cómo podemos cambiar el valor de $p$ para nuestro estado cuántico general. Para hacer esto, usaremos dos puertas:

Puerta $X$ : Esta puerta cambia entre los dos estados $\vert0\rangle$ y $\vert1\rangle$ . Esta operación es la misma que la puerta NOT clásica. Como resultado, la puerta $X$ a veces se denomina puerta de inversión de bit o NOT. Matemáticamente, la puerta $X$ cambia $p$ a $1-p$ , por lo que en particular de 0 a 1, y viceversa.
Puerta $H$ : Esta puerta nos permite pasar del estado $\vert0\rangle$ al estado $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ . Este estado también se conoce como $\vert+\rangle$ . Matemáticamente, esto significa pasar de $p=0, \phi=0$ a $p=1/2, \phi=0$ . Como el estado final del Qubit es una superposición de $\vert0\rangle$ y $\vert1\rangle$ , el Gate de Hadamard representa una verdadera operación cuántica.

Observa que ambas puertas cambiaron el valor de $p$ , pero no $\phi$ . Afortunadamente para nosotros, es bastante fácil visualizar la acción de estas puertas mirando la figura a continuación.

Una vez que tenemos el estado $\vert+\rangle$ , podemos cambiar la fase cuántica aplicando varias otras puertas. Por ejemplo, una puerta $S$ añade una fase de $90$ grados a $\phi$ , mientras que el Gate $Z$ añade una fase de $180$ grados a $\phi$ . Para restar una fase de $90$ grados, podemos aplicar el Gate $S^\dagger$ , que se lee S-dagger y comúnmente se escribe como sdg. Finalmente, existe un Gate $Y$ que aplica una secuencia de Gates $Z$ y $X$ .

Puedes experimentar con las puertas $X$ , $Y$ , $Z$ , $H$ , $S$ y $S^\dagger$ para familiarizarte con las diferentes operaciones y cómo afectan al estado de un qubit. Para hacerlo, puedes visitar Circuit Composer e iniciar nuestro widget de Circuit. Después de visitar el Circuit Composer, elige un Gate para aplicar a un Qubit y luego elige el Qubit (en los primeros ejemplos, el único Qubit para elegir es el qubit 0). Observa cómo cambia el estado correspondiente con cada Gate, así como la descripción de ese estado. También te proporcionará el código que crea el Circuit cuántico correspondiente en Qiskit.

Si quieres aprender más sobre la descripción de estados cuánticos, operadores de Pauli y otras puertas de un solo qubit, consulta Información cuántica del Sistema Único del curso Conceptos Básicos de Información Cuántica de John Watrous.

Prácticas: Circuits cuánticos usando puertas de un solo qubit

Aquí hay cuatro pequeñas prácticas para obtener diferentes estados en el qsphere. Puedes resolverlas con el Circuit Composer y copiar y pegar el código que proporciona en las celdas respectivas para crear los Circuits cuánticos, o puedes insertar directamente una combinación de las siguientes líneas de código en el programa para aplicar los diferentes Gates:

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

El '(0)' indica que aplicamos esta puerta al qubit 'q0', que es el primero (y en este caso único) qubit.

Intenta alcanzar el estado dado en el qsphere en cada uno de los ejercicios siguientes.

i) Comencemos realizando una inversión de bit. El objetivo es alcanzar el estado $\vert1\rangle$ partiendo del estado $\vert0\rangle$ .

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) A continuación, creemos una superposición. El objetivo es alcanzar el estado $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$ .

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) Combinemos esas dos. El objetivo es alcanzar el estado $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$ .

¿Puedes combinar las dos tareas anteriores para encontrar la solución?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) Finalmente, pasamos a los números complejos. El objetivo es alcanzar el estado $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Cuestionario Cuántico con Compuertas Multi-Qubit

¡Excelente trabajo! Ahora que has comprendido las compuertas de un solo qubit, veamos las compuertas que operan sobre múltiples qubits. Aquí se te pedirá resolver 4 cuestionarios de estado cuántico combinando compuertas de un solo qubit y compuertas multi-qubit. Las compuertas básicas para dos qubits son las siguientes:

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

Si quieres saber más sobre las diferentes compuertas multi-qubit y sus relaciones, visita Quantum Information de sistemas múltiples, del curso Basics of Quantum Information de John.

Ten en cuenta que para dos qubits el estado general tiene la forma $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ , donde $a$ , $b$ , $c$ y $d$ son números complejos cuyos valores absolutos al cuadrado dan la probabilidad de medir el estado respectivo; por ej., $|a|^2$ sería la probabilidad de terminar en el estado '0' en ambos qubits. Esto significa que ahora podemos tener hasta cuatro puntos en la qsphere.

Comenzamos con la compuerta canónica de dos qubits, la NOT controlada (también CNOT o CX). Aquí, como con todas las compuertas controladas de dos qubits, un qubit se etiqueta como el "control" y el otro se llama el "objetivo" (target). Si el qubit de control está en el estado $|0\rangle$ , aplica la compuerta identidad $I$ al objetivo, es decir, no se realiza ninguna operación. En cambio, si el qubit de control está en el estado $|1\rangle$ , se aplica una compuerta X al qubit objetivo. Por lo tanto, con ambos qubits en uno de los dos estados clásicos, $|0\rangle$ o $|1\rangle$ , la compuerta CNOT se limita a operaciones clásicas.

Esta situación cambia drásticamente cuando primero aplicamos una compuerta Hadamard al qubit de control, llevándolo al estado de superposición $|+\rangle$ . La acción de una compuerta CNOT sobre esta entrada no clásica puede producir estados altamente entrelazados entre los qubits de control y objetivo. Si el qubit objetivo está inicialmente en el estado $|0\rangle$ , el estado resultante se denota por $|\Phi^+\rangle$ , y es uno de los llamados estados de Bell.

i) Construye el estado de Bell $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$ .

Para este estado tendríamos probabilidad $\frac{1}{2}$ de medir "00" y probabilidad $\frac{1}{2}$ de medir "11". Así, los resultados de ambos qubits están perfectamente correlacionados.

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

A continuación, intenta crear el estado de qubits perfectamente anti-correlacionados. Ten en cuenta el signo menos aquí, que indica la fase relativa entre los dos estados.

ii) Construye el estado de Bell $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$ .

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) Se te da el circuito cuántico descrito en la función a continuación. Intercambia los estados del primer y el segundo qubit para obtener esta QSphere.

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) Escribe un programa desde cero que cree el estado GHZ (en tres qubits), $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Ejecuta tu circuito y observa el resultado medido con una computadora cuántica real

Ahora que sabemos cómo construir un circuito cuántico para manipular un vector de estado de qubits, llega la parte más emocionante: ¡ejecutarlo y ver el resultado! Aquí aprenderemos la forma moderna y eficaz de ejecutar nuestros circuitos usando Qiskit.

Un patrón Qiskit es un marco general para descomponer problemas específicos de dominio y contextualizar las capacidades requeridas en etapas. Esto permite la composabilidad fluida de nuevas capacidades desarrolladas por los investigadores de IBM Quantum (y otros) y habilita un futuro en el que las tareas de computación cuántica son realizadas por una poderosa infraestructura de computación heterogénea (CPU/GPU/QPU).

Los cuatro pasos de un patrón Qiskit son los siguientes:

Mapear el problema a circuitos cuánticos y operadores
Optimizar para el hardware objetivo
Ejecutar en el hardware objetivo
Postprocesar los resultados

Acabamos de terminar el Paso 1: Mapeo, construyendo circuitos cuánticos para generar el estado cuántico deseado. Ahora, recorramos los pasos restantes para ver los resultados.

Optimizar

Aquí configuraremos el backend para ejecutar los circuitos; puedes seleccionar el least busy (menos ocupado) entre los grupos de QPU accesibles, o simplemente elegir un simulador si no tienes suficiente tiempo de QPU restante. Una vez seleccionado un backend, pass_manager transpilará tus circuitos a los conjuntos de compuertas nativas del backend elegido y los optimizará para obtener un mejor resultado. Puedes declarar fácilmente pass_manager usando generate_preset_pass_manager y configurando el optimization_level, donde un número más alto indica más pasos de optimización.

El siguiente paso es emocionante: ¡vamos a ejecutar el circuito cuántico usando Qiskit Runtime!

Lo haremos usando las dos primitivas de Qiskit:

Sampler muestrea el registro de salida de la ejecución de uno o más circuitos cuánticos. Su salida son conteos por medición individual (per-shot).
Estimator calcula el valor esperado de uno o más observables con respecto a los estados generados por el circuito cuántico. Su salida consiste en los valores esperados junto con sus errores estándar.

Aquí usaremos Sampler para ejecutar nuestros circuitos. La celda de código a continuación muestra cómo primero defines un backend y un pass manager para él. Luego, añadirá measurement a todos los circuitos y creará un arreglo de circuitos cuánticos (pub) para pasarlos al Sampler.

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Ejecutar

Ejecutemos nuestros circuitos. En caso de que haya muchos en la cola de espera en la nube, imprime y guarda el job_id para uso posterior y verifica el job_status. Después de ver que el estado del trabajo cambia a Done, recupera el resultado del trabajo.

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Postprocesar

El paso final es interpretar la visualización para comprender los estados cuánticos que hemos creado. Antes de graficar varios diagramas, traigamos todos los conteos de todos los circuitos. Luego haremos 4 gráficas categorizando los circuitos.

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

Los Estados de Un Solo Qubit

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

Los Estados de Un Qubit en Superposición

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

Estados de Dos Qubits

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

Estados de Tres Qubits

plot_distribution(counts_all[8], legend=['qc9'])

Desafío adicional

¿Encontraste algún ruido en los resultados experimentales del backend real? Eliminar el ruido de los qubits es una de las áreas de investigación activa. Prueba las diversas opciones de mitigación y supresión de errores de Qiskit Runtime para ver cómo cambia el ruido en los resultados de ejecución. (Nota) Estas opciones permiten mayor tiempo de QPU.

Información Adicional

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Creado por: Sophy Shin

Revisado por: Nate Earnest-Noble

Este contenido está bajo la Licencia Apache, Versión 2.0. Puedes obtener una copia de esta licencia en el archivo LICENSE en el directorio raíz de este árbol de fuentes o en http://www.apache.org/licenses/LICENSE-2.0.

Cualquier modificación o trabajo derivado de este documento debe conservar este aviso de copyright, y los archivos modificados deben incluir un aviso indicando que han sido alterados respecto a los originales.

1. Lo primero es lo primero: Qiskit​

¿Qué es Qiskit?​

Instalar Qiskit​

Solución de problemas​

2. Configura tu cuenta de IBM Cloud ​

3. Tu primer circuito cuántico​

Circuitos cuánticos​

Operaciones básicas sobre qubits y mediciones​

Descripción de estados de un solo qubit​

Visualización de estados cuánticos​

Manipulación de qubits​

Prácticas: Circuits cuánticos usando puertas de un solo qubit​

i) Comencemos realizando una inversión de bit. El objetivo es alcanzar el estado ∣1⟩\vert1\rangle∣1⟩ partiendo del estado ∣0⟩\vert0\rangle∣0⟩.​

ii) A continuación, creemos una superposición. El objetivo es alcanzar el estado ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩).​

iii) Combinemos esas dos. El objetivo es alcanzar el estado ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩).​

iv) Finalmente, pasamos a los números complejos. El objetivo es alcanzar el estado ∣↺⟩=12(∣0⟩−i∣1⟩)|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)∣↺⟩=2​1​(∣0⟩−i∣1⟩)​

4. Cuestionario Cuántico con Compuertas Multi-Qubit​

i) Construye el estado de Bell ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)∣Φ+⟩=2​1​(∣00⟩+∣11⟩).​

ii) Construye el estado de Bell ∣Ψ−⟩=12(∣01⟩−∣10⟩)\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)∣Ψ−⟩=2​1​(∣01⟩−∣10⟩).​

iii) Se te da el circuito cuántico descrito en la función a continuación. Intercambia los estados del primer y el segundo qubit para obtener esta QSphere.​

iv) Escribe un programa desde cero que cree el estado GHZ (en tres qubits), ∣GHZ⟩=12(∣000⟩+∣111⟩)\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)∣GHZ⟩=2​1​(∣000⟩+∣111⟩)​

5. Ejecuta tu circuito y observa el resultado medido con una computadora cuántica real​

Optimizar​

Ejecutar​

Postprocesar​

Desafío adicional​

Información Adicional​