QISKIT 

Qiskit es un conjunto de herramientas de código abierto desarrollado por IBM para trabajar con computadoras cuánticas. Proporciona un marco integral que permite a los desarrolladores y científicos de datos experimentar, desarrollar y ejecutar algoritmos cuánticos en dispositivos reales o simuladores cuánticos.

Las principales características y componentes de Qiskit incluyen:

  1. Terra: Ofrece las herramientas para construir y manipular circuitos cuánticos, así como para realizar simulaciones. Terra también facilita la transpilación de circuitos para ejecutar en hardware cuántico.

  2. Aer: Es un conjunto de simuladores cuánticos de alto rendimiento incluidos en Qiskit. Permite simular el comportamiento de los circuitos cuánticos en diferentes condiciones.

  3. Ignis: Se enfoca en la caracterización y mitigación de errores en computadoras cuánticas. Proporciona herramientas para evaluar y mejorar la calidad de las implementaciones cuánticas.

  4. Aqua: Es un conjunto de bibliotecas y algoritmos cuánticos de alto nivel, diseñados para diversas aplicaciones cuánticas, como optimización, aprendizaje automático, química cuántica y finanzas cuánticas.

  5. Algoritmos cuánticos: Qiskit incluye implementaciones de algoritmos cuánticos clave, como el algoritmo de factorización de Shor, el algoritmo de búsqueda cuántica de Grover, y otros.

Qiskit es un recurso valioso para la comunidad de computación cuántica, ya que permite a los usuarios tanto principiantes como experimentados explorar el mundo de la informática cuántica y contribuir al desarrollo de aplicaciones y algoritmos cuánticos.

 

De momento, tendremos que instalar un simulador en local, probablemente acompañado de Jupyter.

Aquí tenemos las indicaciones para realizarlo: https://docs.quantum.ibm.com/start/install

Ahí mismo tienes acceso a recursos y herramientas para experimentar con computación cuántica. Puedes entrar y comenzar por "Start", "Build"... hasta terminar ejecutando programas en hardware cuántico real de IBM. 

 

CONSTRUIR Y EJECUTAR CIRCUITOS CUÁNTICOS EN UN SIMULADOR

EJECUTAR EN ORDENADORES CUÁNTICOS REALES

Hay varias tareas a realizar a la hora de ejecutar un circuito en un ordenador cuántico real:

  1. Alta en Ibm Quantum Plataform

En primer lugar, deberás darte de alta, de forma gratuita, en Ibm Quantum Plataform.

En la plataforma Ibm Quantum verás tres pestañas:

    • Dashboard, que muestra información general así como los Jobs más recientes, acceso a las QPUs utilizadas, todas las QPUs, “Documentation”, “Learning”.
    • Compute resources, que muestra todas las QPU disponibles.
    • Jobs, que muestra todos nuestros Jobs.
  1. Tendrás que ir a “manage account” para obtener tu API token.

Enlace: https://quantum.ibm.com/

  1. Será necesario que tengas instalado Qiskit en tu entorno de trabajo

Aquí tenemos las indicaciones para realizarlo: https://docs.quantum.ibm.com/start/install

  1. Ejecutar los siguientes pasos:
    • Guardar las credenciales de Ibm Quantum (solamente la primera vez).
    • Recuperar las credenciales y comprobar que todo está bien.
    • Ver backends (ordenadores cuánticos) disponibles, seleccionar el menos ocupado y crear una sesión en dicho backend
    • Construir nuestro circuito.
    • “Transpilar” nuestro circuito.
    • Ejecutarlo
    • Analizar los resultados.

 

Nota sobre: TRANSPILER

“Transpilar” un circuito cuántico es el proceso de transformar un circuito cuántico de alto nivel en una versión equivalente que sea compatible con un ordenador cuántico específico. Este proceso es crucial debido a las limitaciones físicas y las especificaciones únicas de cada ordenador cuántico. Este proceso realiza varias tareas:

  • Asegurar la compatibilidad de puertas: si el computador cuántico no soporta algún tipo de puerta, hay que descomponerla en puertas que sí se soporten.
  • Existen restricciones a la hora de conectar ciertos tipos de puertas con ciertos tipos de qubits; el proceso de transpilación reordena el circuito y/o inserta operaciones de intercambio para solventar estas restricciones.
  • Optimización. Supone tratar de reducir el número de puertas mediante la fusión de puertas adyacentes y la eliminación de puertas innecesarias.
  • Calibraciones específicas del hardware concreto en el que se va a ejecutar el circuito.

En la segunda ejecución veremos un ejemplo de transpilar un circuito con dos niveles de profundidad para comparar los resultados. 

from qiskit_ibm_runtime import QiskitRuntimeService, Session, SamplerV2, EstimatorV2


# Save an IBM Quantum account.
QiskitRuntimeService.save_account(channel="ibm_quantum",
token="142aca5fb28d52d699c972fde878f1c3kjdue845lo3b7d2f99d52d01369195e4f5979af8dd832608ff633f475abf0eac9264d2ed3fc6e6492f7a497596e7eda3",

name="nombre_para_guardar",
set_as_default=True,
overwrite=True)
service = QiskitRuntimeService



# Cargar las credenciales guardadas
try:
service = QiskitRuntimeService(name="nombre_para_guardar")
print("Credenciales de la cuenta cargadas correctamente")
except Exception as e:
print(f"Error al cargar las credenciales: {e}")


# Optional: List all the instances you can access.
service = QiskitRuntimeService(channel='ibm_quantum')
print(f"Instancias accesibles: {service.instances()}")


# Verificar que la autenticación fue exitosa mostrando los backends disponibles
try:
backends = service.backends()
print("Backends disponibles:")
for backend in backends:
config = backend.configuration()
status = backend.status()
print(f"Backend: {backend.name}, Simulator: {config.simulator}, Operational: {status.operational}, Pending Jobs: {status.pending_jobs}")


# Filtrar los backends que no sean simuladores y que estén operativos
filtered_backends = [b for b in backends if b.status().operational]
# Verificar si hay backends disponibles después del filtrado
if not filtered_backends:
raise ValueError("No hay backends disponibles que no sean simuladores y que estén operativos.")

# Seleccionar el backend menos ocupado
backend = min(filtered_backends, key=lambda b: b.status().pending_jobs)
print(f"Seleccionado backend: {backend.name}")

# Crear una sesión
with Session(service=service, backend=backend) as session:
# Crear el Estimator y Sampler
estimator = EstimatorV2(session=session)
sampler = SamplerV2(backend=backend)
print("Sesión creada y Estimator y Sampler inicializados.")
except Exception as e:
print(f"Error durante la configuración de backends o creación de sesión: {e}")

 

 

# ESTA EJECUCIÓN NOS DA EL SIGUIENTE RESULTADO:

Credenciales de la cuenta cargadas correctamente
Instancias accesibles: ['ibm-q/open/main']
Backends disponibles:
Backend: ibm_brisbane, Simulator: False, Operational: True, Pending Jobs: 67
Backend: ibm_kyoto, Simulator: False, Operational: True, Pending Jobs: 7
Backend: ibm_osaka, Simulator: False, Operational: True, Pending Jobs: 53
Backend: ibm_sherbrooke, Simulator: False, Operational: True, Pending Jobs: 15
Seleccionado backend: ibm_kyoto
Sesión creada y Estimator y Sampler inicializados.


Nos ha indicado que hemos guardado y recuperado correctamente la información sobre nuestra
Ibm Quantum Plataform y que tenemos varias máquinas disponibles, las de Brisbane, Kyoto, Osaka y Sherbrooke
Selecciona la que está más libre, en este caso ibm_kyoto.
>>>>>>>>>>>>>>>>

# Preparamos un circuito con una puerta Hadamard y una Cnot (Bell, qubits entrelazados)

from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
# bell.measure_all()


bell.draw(output="mpl", style="iqp")

# EL RESULTTADO ES EL CIRCUITO DE LA DERECHA

:

# Obtenemos la distribución de resultados ideal
ideal_distribution = Statevector.from_instruction(bell).probabilities_dict()
plot_histogram(ideal_distribution)

 

# EL RESULTTADO ES EL DIAGRAMADE LA DERECHA

### Ejecutamos en el BAckend elegido: ibm_kyoto

bell.measure_all()

pm = generate_preset_pass_manager(backend=backend, optimization_level=1) #esto es para compilar para la máquina backend

isa_bell = pm.run(bell) # Compilamos
job = sampler.run([isa_bell]) # lanzamos el job

# Información sobre el job
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")

# Información sobre los resultaados
result = job.result()

# Mostrar los resultados
for idx, pub_result in enumerate(result):
print(f" > Counts for pub {idx}: {pub_result.data.meas.get_counts()}") # esto es en caso de measure_all
# print(f" > Counts for pub {idx}: {pub_result.data.c.get_counts()}") # esto es en caso de NO measure_all

# ESTA EJECUCIÓN NOS DA EL SIGUIENTE RESULTADO:

>>> Job ID: ct7zkx77rgf00085k3qg
>>> Job Status: QUEUED
 > Counts for pub 0: {'00': 2136, '01': 328, '11': 1369, '10': 263}



Nos indica que ha lanzado el Job con el ID indicado. A la finalización nos da los resultados:
El resultado ha sido '00' en 2136 ocasiones, '01' en 328, '11' en 1369 y '10'en 263

# Ahora mostraremos los resultados de forma gráfica

# Obtener las counts del resultado
# counts = pub_result.data.c.get_counts()
counts = pub_result.data.meas.get_counts() # esto es en caso de measure_all

# Convertir las claves numéricas a binario y almacenar en binary_prob
binary_prob = {k: v / sum(counts.values()) for k, v in counts.items()}

# Simular la distribución ideal
ideal_distribution = {'11': 0.5, '00': 0.5, '01': 0, '10': 0}

# Mostrar los resultados
plot_histogram([binary_prob, ideal_distribution], bar_labels=False, title="Resultados de Medida", legend=["Ejecución Real", "Ideal"])

 

# EL RESULTTADO ES EL DIAGRAMA DE ABAJO:

 

 

A continuación veremos tres imágenes del estado de la ejecución en Ibm Quantum Plataform: la primera con el Job en espera, la segunda tras su ejecución y la tercera muestra la información que nos ofrece.

# No necesitaremos conectarnos a nuestra cuenta de Ibm Quantum porque ya lo hemos hecho en el ejercicio anterior

# Create circuit to test transpiler on
from qiskit import QuantumCircuit, transpile
from qiskit.circuit.library import GroverOperator, Diagonal

# Use Statevector object to calculate the ideal output
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram

# Qiskit Runtime
from qiskit_ibm_runtime import QiskitRuntimeService, Batch

# Seleccionaremos la computadora con menos trabajos encolados y mostramos su nombre
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.least_busy(operational=True, simulator=False)
backend.name

# ESTA EJECUCIÓN NOS DA EL SIGUIENTE RESULTADO:

'ibm_kyoto'

# Construimos un circuito para ver como funciona el operador de GROVER que es
# un algoritmo cuántico para la búsqueda en una base de datos no estructurada
# La primera instrucción rea una matriz diagonal con 7 "1" y un "-1" en el elemento a buscar

oracle = Diagonal([1] * 7 + [-1])
qc = QuantumCircuit(3,3)
qc.h([0, 1, 2])
qc = qc.compose(GroverOperator(oracle))

 

qc.draw(output="mpl", style="iqp")

 

# EL RESULTTADO ES EL CIRCUITO DE LA DERECHA

# Obtenemos la distribución de resultados ideal
ideal_distribution = Statevector.from_instruction(qc).probabilities_dict()
plot_histogram(ideal_distribution)

 

# EL RESULTTADO ES EL DIAGRAMADE LA DERECHA:

# Vamos a profundizar un poco con la cuestión del "Transpiler".

# las explicaciones en amarillo

 

from qiskit import transpile
from qiskit.transpiler import PassManager
from qiskit_ibm_runtime.transpiler.passes.scheduling import (
ASAPScheduleAnalysis,
PadDynamicalDecoupling,)
from qiskit.circuit.library import XGate

# Mediremos los tres qubits quedando su reultado en los bits correspondientes
qc.measure([0, 1, 2], [0, 1, 2])

# Se inicializa una lista vacía para almacenar los circuitos transpileados.
circuits = []

# Se itera sobre dos niveles de optimización: 0 y 3. El nivel 0 es sin optimización y el nivel 3 es el máximo nivel de optimización
for optimization_level in [0, 3]:
t_qc = transpile(qc, backend, optimization_level=optimization_level, seed_transpiler=0) #se transpila qc para que sea compatible con el backend
count_ops = t_qc.count_ops() # Se cuentan las operaciones en el circuito transpileado.
print (t_qc.count_ops())
if "cx" in count_ops: # Se cuentan, por ejemplo, puertas "cx"
print(f"CNOTs (optimization_level={optimization_level}): ", count_ops["cx"])
else:
print(f"CNOTs (optimization_level={optimization_level}): 0")

circuits.append(t_qc) # Se agrega el circuito transpileado a la lista circuits.

 

# Get gate durations so the transpiler knows how long each operation takes
# Obtiene la duración de las puertas para que el transpiler sepa cuanto va a tardar la ejecución
durations = backend.target.durations()


# Define una secuencia de decoupling dinámico (dos puertas X) que se aplicará a los qubits en estado de espera.
# Esto se hace para contrarrestan los efectos de los ruidos y prolongan la coherencia de los qubits en espera.
dd_sequence = [XGate(), XGate()]


# Ejecuta el PassManager en el segundo circuito transpileado (con optimización nivel 3) para aplicar el decoupling dinámico.
pm = PassManager([ASAPScheduleAnalysis(durations), PadDynamicalDecoupling(durations, dd_sequence)])
circ_dd = pm.run(circuits[1])

# Add this new circuit to our list
# Agrega el nuevo circuito con decoupling dinámico a la lista circuits.
circuits.append(circ_dd)

""" NOTA IMPORTANTE: ¿Qué hemos hecho hasta ahora?

Hemos transpilado el cirduito originar con dos niveles de optimización:
Circuitos Transpilados con Diferentes Niveles de Optimización:

Nivel de Optimización 0: Transpilación sin optimización.
Nivel de Optimización 3: Transpilación con el nivel máximo de optimización.
Se hace esto para comparar el impacto de la optimización en el circuito, especialmente en términos de la cantidad de puertas CNOT (cx),
que son costosas en términos de tiempo de ejecución y propensas a errores.

Después de obtener el circuito optimizado, hemos aplicado una secuencia de desacoplamiento dinámico para mitigar los efectos del ruido
y prolongar la coherencia de los qubits.
EL objetivo sería evaluar cómo la transpilación con diferentes niveles de optimización afecta el circuito, específicamente cantidad de operaciones cx.

¿Cuántos Circuitos se Ejecutan?
En total, se añaden tres circuitos a la lista circuits:

Circuito transpilado con nivel de optimización 0.
Circuito transpilado con nivel de optimización 3.
Circuito transpilado con nivel de optimización 3 y con desacoplamiento dinámico aplicado.

Finalmente, podemos decidir cuál o cuáles de estos circuitos ejecutar en el backend cuántico.
En muchos casos, se ejecutan todos los circuitos para comparar los resultados y elegir el mejor
enfoque para futuras implementaciones.

Por ejemplo, podríamos ejecutar los circuitos así:
# from qiskit import execute
# results = []
# for circuit in circuits:
# job = execute(circuit, backend)
# result = job.result()
# results.append(result)
#
# Analizar los resultados
# for idx, result in enumerate(results):
# counts = result.get_counts() counts = result.get_counts()
# print(f"Resultados del circuito {idx}: {counts}")
"""


""" NOTA: El tercer ejemplo trata de explicar este tipo de circuitos generados """
# Dibuja el circuito final, especificando el formato de salida (en este caso, una imagen Matplotlib),
# el estilo (iqp), y sin mostrar los cables en espera.
circ_dd.draw(output="mpl", style="iqp", idle_wires=False)

# VEMOS A CONTINUACIÓN EL DIAGRAMA DEL CIRCUITO YA TRANSPILADO:

# Ejecutamos el circuito

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2

sampler=SamplerV2(backend)

job = sampler.run(circuits, shots=8000,)


# Información sobre el job
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")

# Información sobre los resultaados
result = job.result()

for idx, pub_result in enumerate(result):
print(f" > Counts for pub {idx}: {pub_result.data.c.get_counts()}")
# print(f" > Counts for pub {idx}: {pub_result.data.meas.get_counts()}") # esto es en caso de measure_all

# EL RESULTADO ABAJO:

>>> Job ID: ct6q5s7wmw20008w88h0
>>> Job Status: QUEUED
 > Counts for pub 0: {'010': 773, '000': 1302, '001': 652, '110': 700, '111': 1699, '011': 1179, '101': 699, '100': 996}
 > Counts for pub 1: {'000': 546, '111': 2354, '011': 2128, '101': 1090, '001': 938, '110': 286, '010': 412, '100': 246}
 > Counts for pub 2: {'001': 948, '100': 263, '011': 1432, '111': 3533, '101': 686, '010': 449, '000': 433, '110': 256}

# Veamos gráficamente los resultados

from qiskit.visualization import plot_histogram

# Obtener las counts del resultado
counts = pub_result.data.c.get_counts()
# counts = pub_result.data.meas.get_counts() # esto es en caso de measure_all

# Convertir las claves numéricas a binario y almacenar en binary_prob
binary_prob = {k: v / sum(counts.values()) for k, v in counts.items()}

# Simular la distribución ideal
ideal_distribution = {'111': 0.781, '000': 0.031, '001': 0.031, '010': 0.031, '011': 0.031, '100': 0.031, '101': 0.031, '110': 0.031}

# Mostrar los resultados
plot_histogram([binary_prob, ideal_distribution], bar_labels=False, title="Resultados de Medida", legend=["Ejecución Real", "Ideal"])

measure_all

# EL RESULTADO ABAJO:

Interpretación de las puertas tras aplicar transpiler

Ya hemos comentado que cuando transpilamos un circuito cuántico, adaptamos sus características a las de la máquina elegida para ejecutarlo, pudiendo resultar del proceso una descomposición de las puertas cuánticas, la inclusión de otras etc… E circuito más complejo que vemos en las ejecuciones anteriores tiene varias puertas que quizás desconozcamos; vamos a ver algunas:

  • Rz:
    • Descripción: Es una rotación alrededor del eje z del qubit en la esfera de Bloch.
    • Símbolo: Generalmente se representa como Rz(θ), donde θ es el ángulo de rotación.
    • Función: Modifica la fase del estado del qubit sin cambiar su probabilidad de medir 0 o 1.
  • √X (Raíz cuadrada de X o “SX”):
    • Descripción: Representa la raíz cuadrada de la puerta Pauli-X. También conocida como la puerta de Hadamard parcial.
    • Símbolo: A veces se muestra como √X ​.
    • Función: Es un operador unitario que, cuando se aplica dos veces seguidas, equivale a una puerta X. En la esfera de Bloch, puede ser vista como una rotación de 90 grados alrededor del eje x.
  • X:
    • Descripción: Es la puerta Pauli-X, también conocida como la puerta NOT cuántica.
    • Símbolo: Se muestra como X.
    • Función: Cambia el estado de un qubit de |0⟩ a |1⟩ y viceversa. Es una rotación de 180 grados alrededor del eje x en la esfera de Bloch.
  • Delay:
    • Descripción: Representa una pausa o espera en el circuito.
    • Símbolo: A veces se muestra simplemente como "delay" o con un símbolo de pausa.
    • Función: Se usa para sincronizar operaciones en diferentes qubits o para esperar un tiempo específico antes de realizar la siguiente operación.

 

Descomposición de la Puerta Hadamard

La puerta Hadamard H puede ser descompuesta en una combinación de puertas Rz y √X (SX):

H=Rz(π/2)⋅SX⋅Rz(π/2)

Esto es debido a que la puerta Hadamard puede ser vista como una rotación específica en la esfera de Bloch. El uso de Rz y SX en lugar de H puede ser beneficioso para ciertos backends que implementan estas puertas más eficientemente.

La transpilación puede resultar en diferentes configuraciones de puertas para distintos qubits debido a optimizaciones específicas del backend cuántico, interacciones entre puertas en el circuito, y características específicas de cada qubit. Esto puede resultar en que una puerta H se descomponga en Rz y SX  en un qubit, y de manera diferente en otro, todo con el objetivo de optimizar la ejecución en el hardware cuántico específico.

Vamos a comprobar a continuación, que aplicar una puerta de Hadamard equivale a aplicar Rz·SX·Rz:

 

# Preparamos un circuito con solamente una puerta Hadamard

from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_bloch_multivector, plot_state_city
import matplotlib.pyplot as plt
import numpy as np
# Qiskit Runtime
from qiskit_ibm_runtime import QiskitRuntimeService, Batch

# Crear el circuito cuántico
qc = QuantumCircuit(1)
qc.h(0)
# qc.measure_all()

qc.draw(output="mpl", style="iqp")

# Ejecutamos el circuito en un simulador para visualizar el estado del qubit
# en la esfera de Bloch.

# Simulador de estado cuántico
simulator = Aer.get_backend('statevector_simulator')

# Ejecutar la simulación
result = simulator.run(transpile(qc, simulator)).result()
statevector = result.get_statevector()


print(" ")
print("Statevector resultante:")
print(statevector_array)

# Imprimir los estados base y sus correspondientes amplitudes de probabilidad
n = qc.num_qubits
for i, amplitude in enumerate(statevector_array):
binary_state = format(i, f'0{n}b')
print(f"|{binary_state}⟩: {amplitude}")
# ____________________________________________________________

# Visualizar el estado final en la esfera de Bloch
from qiskit.visualization import plot_bloch_multivector, plot_state_city
import matplotlib.pyplot as plt

plot_bloch_multivector(statevector)

 

Ahora construiremos un circuito con puertas Rz y SX para comprobar que, efectivamente, ejecutar una puerta de Hadamard es equivalente a ejecutar una combinación de las puertas que acabamos de comentar; veremos qeu el resultado en la esfera de Bloch es exactamente igual.

 

# HACEMOS AHORA UN CIRCUITO CON PUERTAS Rz, SX y Rz
#====================================================#

from qiskit import QuantumCircuit
from qiskit_aer import Aer
from qiskit.visualization import plot_bloch_multivector, plot_state_city
import matplotlib.pyplot as plt
import numpy as np
from math import pi

# Crear un nuevo circuito cuántico
qc = QuantumCircuit(1)
qc.rz(pi/2, 0)
qc.sx(0)
qc.rz(pi/2, 0)

qc.draw(output="mpl", style="iqp")

# Ejecutamos el circuito en un simulador para visualizar el estado del qubit
# en la esfera de Bloch.

# Simulador de estado cuántico
simulator = Aer.get_backend('statevector_simulator')

# Ejecutar la simulación
result = simulator.run(transpile(qc, simulator)).result()
statevector = result.get_statevector()

print(" ")
print("Statevector resultante:")
print(statevector_array)

# Imprimir los estados base y sus correspondientes amplitudes de probabilidad
n = qc.num_qubits
for i, amplitude in enumerate(statevector_array):
binary_state = format(i, f'0{n}b')
print(f"|{binary_state}⟩: {amplitude}")
# ____________________________________________________________

# Visualizar el estado final en la esfera de Bloch
from qiskit.visualization import plot_bloch_multivector, plot_state_city
import matplotlib.pyplot as plt

plot_bloch_multivector(statevector)

 

Hemos visto que RZ·SX·Rz es lo mismo que aplicar una puerta H, pero vamos a verlo paso a paso para tratar de explicarlo:

 

 

Prepararemos un circuito que solamente tenga una puerta Rz.

Al ejecutarlo veremos que no ha tenido reflejo en la esfera de Bloch; esto es porque el vector estaba exactamente en el eje "z" y la puerta Rz lo que hace es, precisamente, aplicar una rotación alrededor del eje "z" del qubit en la esfera de Bloch.

 

# Circuito con una puerta Rz

qc = QuantumCircuit(1)

qc.rz(pi/2, 0)

 

qc.draw(output="mpl", style="iqp")

 

Prepararemos ahora un circuito que tenga una puerta Rz y una SX

Al ejecutarlo veremos que se ha aplicado una rotación alrededor del eje "x" .

 

# Circuito con una puerta Rz y una SX

qc = QuantumCircuit(1)

qc.rz(pi/2, 0)

qc.sx(0)

 

qc.draw(output="mpl", style="iqp")

 

Añadiremos otra puerta Rz al circuito anterior, y comprobaremos cómo, en esta ocasión, si que la puerta Rz tiene efecto en el vector representado en la esfera de Bloch, ya que le aplica una rotación de Pi/2 alrededor del eje "x".

 

 

# Circuito con una puerta Rz, una SX y una Rz

qc = QuantumCircuit(1)

qc.rz(pi/2, 0)

qc.sx(0)

qc.rz(pi/2, 0)

 

qc.draw(output="mpl", style="iqp")

linkedin facebook pinterest youtube rss twitter instagram facebook-blank rss-blank linkedin-blank pinterest youtube twitter instagram