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.


Gure Ibm Quantumi buruzko informazioa behar bezala gorde eta berreskuratu dugula adierazi digu, 
eta hainbat makina ditugula eskuragarri: Brisbane, Kyoto, Osaka eta Sherbrooke.
Aukeratzen du askeen dagoena, kasu honetan 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")

# EMAITZA ESKUMAKO ZIRKUITOA DA

:

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

# EMAITZA ESKUMAKO DIAGRAMA DA

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

# EXEKUZIO HONEK HURRENGO EMAITZA EMAN DIGU:

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



Esaten digu ID horrekin Bidali duela Job bat. Amaitu ondoren emaitza hauek eman digu:
Emaitza '00' izan da 2136 alditan, '01' 328 alditan, '11' 1369tan eta '10' 263tan

# 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"])

# EMAITZA HEMEN BEHEKO DIAGRAMA DA:

Jarraian, Ibm Quantum Plataformean exekuzioaren egoeraren hiru irudi ikusiko ditugu: lehena, Joba itxoiten; bigarrena, exekuzioaren ondoren; eta hirugarrena, eskaintzen digun informazioa.

# 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

# EMAITZA:

'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")

# EMAITZA ESKUMAKO ZIRKUITUA DA:

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

# EMAITZA ESKUMAKO DIAGRAMA DA:

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

# JARRAIAN IKUSI AHAL DUGU ZIRKUITUAREN DIAGRAMA, TRANSPILATU ONDOREN:

# 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

# EMAITZA BEHEAN:

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

# EMAITZA HEMEN BEHEAN:

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

Ateen interpretazioa transpiler egin ondoren

Esan bezala, zirkuitu kuantiko bat transpilatzen dugunean, zirkuituaren ezaugarriak egokitu egiten ditugu zirkuitua egiteko aukeratutako makinaren ezaugarrietara, eta prozesuaren ondorioz ate kuantikoak deskonposatu egin daitezke, beste batzuk sartu... Eta aurreko exekuzioetan ikusten dugun zirkuiturik konplexuenak baditu zenbait ate agian ezagutzen ez ditugunak; hona hemen batzuk:

• Rz:
  • Describapena: Blochen esferako qubitaren z ardatzaren inguruko errotazioa da.
  • Sinboloa: Oro har, Rz(θ) bezala irudikatzen da, eta, bertan, θ errotazio angelua da.
  • Funtzioa: Qubitaren egoeraren fasea aldatzen du, 0 edo 1 neurtzeko probabilitatea aldatu gabe.

• √X (X-ren erro karratua o “SX”):
  • Deskribapena: Pauli-X atearen erro karratua irudikatzen du. Hadamardeko ate partziala ere esaten zaio.
  • Sinboloa: Batzuetan horrela agertzen da: √X
  • Funtzioa: Operadore unitario bat da, bi aldiz jarraian aplikatzen denean, X ate baten baliokidea dena. Blochen esferan, x ardatzaren inguruko 90 graduko errotazio gisa ikus daiteke.

• X:
  • Deskribapena: Pauli-X atea da, NOT ate kuantikoa bezala ere ezagutzen dena.
  • Sinboloa: X gisa agertzen da.
  • Funtzioa: Aldatu qubit baten egoera |0⟩ tik  |1⟩era eta alderantziz. 180 graduko biraketa da, X ardatzaren inguruan, Blochen esferan.

• Delay:
  • Deskribapena: Zirkuituan etenaldi bat edo itxaronaldi bat irudikatzen du.
    Sinboloa: Batzuetan "delay" bezala edo etenaldi sinbolo batekin agertzen da.
    Funtzioa: Qubitetan eragiketak sinkronizatzeko edo hurrengo eragiketa egin aurretik denbora jakin bat itxaroteko erabiltzen da.

Hadamard ateko deskonposizioa

Hadamard H atea,  Rz eta √X (SX) ateen arteko konbinazio batean deskonposatu daiteke:

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

Hadamard atea Blochen esferan errotazio espezifiko gisa ikus daitekeelako. Rz eta SX erabiltzea H erabili beharrean onuragarria izan daiteke ate horiek eraginkortasun handiagoz inplementatzen dituzten zenbait backendentzat.

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.

Jarraian ikusiko dugu Hadamard ate bat aplikatzea, Rz·SX·Rz aplikatzearen baliokidea dela. 

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

Ikusi dugu RZ · SX · Rz H ate bat aplikatzea bezalakoa dela, baina pausoz pauso ikusiko dugu azaltzen saiatzeko:

1. urratsa: GHZ zirkuitoa eraiki:

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")

# EMAITZA:

2. urratsa: Backend aukeratu

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)

# EMAITZA:

3. urratsa: Zirkuitoa "transpilatu" exekutatu ahal izateko

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)

# SORTUTAKO ZIRKUITOA:

4. urratsa: SIMULAGAILUAN eta aukeratutako BAKCKENDEAN exekutatu

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()}")

# EMAITZA:

5. urratsa: konparatu exekuzioa SIMULAGAILUAN eta HARDWARE ERREALEAN

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'])

# EMAITZA HEMEN BEHEAN: