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:

# 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:

Paso 1: Construir el circuito GHZ

from qiskit import QuantumCircuit

def GHZ(num_qubits):

qc = QuantumCircuit(num_qubits)
qc.h(0)
for qubit in range(num_qubits-1):
    qc.cx(qubit, qubit + 1)
qc.measure_all()
return qc

num_qubits = 5

circuit = GHZ(num_qubits=num_qubits)
circuit.draw("mpl")

# ESTA EJECUCIÓN NOS DA EL SIGUIENTE RESULTADO:

Paso 2: Elegir un backend 

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

service = QiskitRuntimeService(channel="ibm_quantum")

### ELEGIR EL BACKEND MAS LIBRE DE TRABAJO
backend = service.least_busy(operational=True, simulator=False)

### ELEGIR UN BACKEND CONCRETO POR NOMBRE
# Seleccionar un backend específico por nombre
# backend_name = 'ibm_kyiv' # Cambia esto por el nombre del backend que deseas
# backend = service.get_backend(backend_name)

print(f"Backend seleccionado: {backend.name}")

print(backend)

# RESULTADO:

Paso 3: Transpilar el circuito para ejecución

pass_manager = generate_preset_pass_manager(optimization_level=3, backend=backend)
isa_circuit = pass_manager.run(circuit)
isa_circuit.draw("mpl", idle_wires=False, scale=0.7, fold=-1)

# CIRCUITO RESULTANTE ABAJO

Paso 4: Ejecultar el circuito en el SIMULADOR y en el BACKEND seleccionado

from qiskit_ibm_runtime import SamplerV2
from qiskit_aer import AerSimulator

# Ideal simulation
aer_sim = AerSimulator()
sampler_aer = SamplerV2(backend=aer_sim)
job_aer = sampler_aer.run([isa_circuit], shots=1000)

# Run on the real backend
sampler = SamplerV2(backend=backend)
job = sampler.run([isa_circuit], shots=1000)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job status: {job.status()}")

# RESULTADO:

Paso 5: Comparar ejecución en SIMULADOR y EN HARDWARE REAL

from qiskit.visualization import plot_distribution

result_aer = job_aer.result()
result = job.result()
samp_dist_aer = result_aer[0].data.meas.get_counts()
samp_dist = result[0].data.meas.get_counts()
plot_distribution([samp_dist_aer, samp_dist], legend=['Ideal', 'Real hardware'])

# VEMOS ABAJO EL RESULTADO

EXPLICACIÓN:

Podemos apreciar que la ejecución en el SIMULADOR nos ofrece el resultado esperado, cercano al 50% de posibilidades en cada resultado posible, concretamente 49% para '00000' y 51% para '11111'.

Sin embargo, la ejecución en real presenta unos resultados con errores provocados por la decoherencia de los sistemas cuánticos. Concretamente en esta ejecución los errores que deberían acercarse al 50% se quedan en 33,3% para el resultado '00000', y 39,8% para '11111', repartiéndose el resto de % hasta el 100% en algunos de los diferentes valores de entre los 32 posibles.

Se aprecia un salto significativo (15,7%) en el valor '00010', para el que no encontramos explicación; de hecho, en una nueva ejecución los resultados obtenidos han sido más normales.

INCLUIMOS A CONTINUACIÓN el gráfico de esta nueva ejecución, pero hemos decidido dejar también la anterior para mostrar que no siempre los resultados son los esperados.

Probemos con un circuito sencillo, concretamente un estado de Bell de dos qubits (máximo entrelazamiento).

Para ello arrastraremos sobre el primer qubit (q₀) una puerta de Hadamard:

En la zona de visualización tendremos lo siguiente:

Es el resultado lógico: el qubit 1 está siempre a 0 y el qubit 1 está a un 50% de probabilidades de estar en 0 o en 1. Más adelante se explican los otros modos de visualización.

A continuación, entrelazaremos los dos qubits a través de una CNOT entre q₀ y q₁

Nuestra visualización habrá cambiado porque ahora las únicas posibilidades es que los dos qubits estén a 0 y que los dos qubits estén a 1

Para acabar podemos incluir mediciones:

A la derecha podemos ver el código generado y podemos

exportarlo para utilizarlo en otras aplicaciones:

Inspeccionar paso a paso el circuito

• En el menú “Ver” seleccionamos los paneles para las visualizaciones que queramos utilizar.
• Hacemos clic en el interruptor Inspeccionarde la barra de herramientas. Hay que tener en cuenta que una vez que el Inspector de circuitos esté activado, no podremos agregar más operaciones hasta que lo desactivemos.
• Para movernos paso a paso a través de las visualizaciones de los componentes del circuito podemos utilizar los botones de avance y retroceso.
• Para inspeccionar solo alguna/s operación/es, podemos hacer clic en dichas operaciones y aparecerá una superposición que indica que se incluirán cuando ejecute el Inspector de circuitos. Para anular la selección de una operación, haga clic en ella nuevamente y la superposición desaparecerá.

Para cerrar el Inspector y volver a editar el circuito, hay que hacer de nuevo clic en el botón Inspeccionar en la barra de herramientas.

Representación del estado de los qubit

El disco que vemos al final de la línea que representa el qubit en IBM Quantum Composer proporciona el estado local de cada qubit al final del cálculo. Esta es la triple información que nos da:

1. Probabilidad de que el qubit esté en el estado∣1⟩ 

La probabilidad de que el qubit esté en el estado ∣1⟩ está representado por el relleno del disco azul:

2. Fase cuántica

La probabilidad de que el qubit esté en el estado ∣1⟩ está representado por el relleno del disco azul:

3. Pureza/entrelazamiento del Qubit

El radio del anillo negro representa la pureza reducida del estado del qubit. La pureza está en el rango [0, 5.1]; un valor de uno indica que el qubit no está entrelazado con ninguna otra parte. Por el contrario, una pureza reducida de 0,5 muestra que el qubit queda en un estado completamente mixto y tiene cierto nivel de entrelazamiento sobre el resto de N−1 qubits, y posiblemente incluso el entorno.

Estas son los tres tipos de visualizaciones que nos ofrece Composer:

1. Vista de Probabuilidades

(Máximo 8 qubits)

2. Vista de Q-Esfera

(Máximo 5 qubits)

Los nodos se disponen en la esfera q de modo que el estado base con todos los ceros ∣000⟩ está en su polo norte, y el estado base con todos unos ∣111⟩ está en su polo sur. Los estados base con el mismo número de ceros (o unos) se encuentran en una latitud compartida de la esfera q (por ejemplo, ∣001⟩, ∣010⟩, ∣100⟩, ∣001 ⟩, ∣010 ⟩, ∣100 ⟩). Comenzando en el polo norte de la esfera q y progresando hacia el sur, cada latitud sucesiva tiene estados base con un mayor número de unos; la latitud de un estado base está determinada por su Distancia de Hamming Desde el estado cero. La esfera q contiene información completa sobre el estado cuántico en una representación compacta.

Nota:

¿Cuál es la diferencia entre una esfera de Bloch y una Q-Esfera? Es importante destacar que la q-Esfera no es lo mismo que la esfera de Bloch, incluso para un solo qubit. La esfera de Bloch ofrece una visión local del estado cuántico, donde cada qubit se ve por sí solo. Cuando se intenta comprender cómo se comportan los registros de qubits (estados multiqubit) en la aplicación de circuitos cuánticos, resulta más esclarecedor adoptar una visión global y observar el estado cuántico en su totalidad. La Q-Esfera proporciona una representación visual del estado cuántico y, por lo tanto, este punto de vista global . Por lo tanto, al explorar aplicaciones y algoritmos cuánticos en pequeñas cantidades de qubits, la Q-Esfera debería ser el método de visualización principal.

3. Vista de Statevector

(Máximo 6 qubits)

Esta vista visualiza las amplitudes cuánticas como un gráfico de barras. El eje horizontal etiqueta los estados de base computacional. El eje vertical mide la magnitud de las amplitudes asociado con cada estado de base computacional. El color de cada barra representa la fase cuántica.

Si detenemos el cursor sobre alguna de las columnas, veremos la información correspondiente: