Hello World: tu primer circuito cuántico

Construye un estado de Bell (dos qubits entrelazados) y ejecútalo de tres maneras:

1. Simulación ideal — resultados perfectos, sin necesidad de cuenta

2. Simulación con ruido — simula un dispositivo real, sin cuenta necesaria

3. Hardware cuántico real — requiere una cuenta de IBM Quantum gratuita (pasos de configuración a continuación)

Construir el circuito

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit import QuantumCircuit

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

qc.draw(output="mpl")

Opción 1: Simulación ideal (sin cuenta necesaria)

Usa StatevectorSampler — un simulador local con resultados perfectos, sin ruido.

from qiskit.primitives import StatevectorSampler

result = StatevectorSampler().run([qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

from qiskit.visualization import plot_histogram
plot_histogram(counts)

Opción 2: Simulación con ruido (sin cuenta necesaria)

Usa FakeManilaV2 — un simulador local que imita un dispositivo cuántico real de IBM, incluyendo sus características de ruido. El circuito debe transpilarse primero (adaptarse) al conjunto de puertas y la conectividad de qubits del dispositivo.

from qiskit.primitives import BackendSamplerV2
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

backend = FakeManilaV2()
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

result = BackendSamplerV2(backend=backend).run([isa_qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

plot_histogram(counts)

Opción 3: Hardware cuántico real

Requiere una cuenta de IBM Quantum gratuita. Para configurar una:

1. Regístrate en quantum.cloud.ibm.com/registration — no se requiere tarjeta de crédito durante los primeros 30 días

2. Inicia sesión en quantum.cloud.ibm.com y selecciona la región us-east (requerida para el Plan Abierto gratuito)

3. Crea una instancia (Plan Abierto gratuito) en Instances si aún no tienes una

4. Crea una clave de API en quantum.cloud.ibm.com (o en cloud.ibm.com/iam/apikeys)

5. Copia tu CRN (Cloud Resource Name) desde tu página de Instances

Luego, si aún no has guardado tus credenciales aquí, ejecuta la siguiente celda. Reemplaza <your-api-key> con la clave de API del paso 4, y <your-crn> con el CRN del paso 5. Hasta que lo hagas, la celda no guarda nada, así que ejecutar todas las celdas nunca puede sobrescribir una cuenta que hayas guardado antes.

from qiskit_ibm_runtime import QiskitRuntimeService

token = "<your-api-key>"
instance = "<your-crn>"

if token.startswith("<") or instance.startswith("<"):
    print("Paste your API key and CRN above first; nothing was saved.")
else:
    QiskitRuntimeService.save_account(
        channel="ibm_quantum_platform",
        token=token,
        instance=instance,
        set_as_default=True,
        overwrite=True,
    )
    print("Account saved.")

Nota: Los trabajos en hardware real pueden tardar algún tiempo dependiendo de los tiempos de cola. Si la celda aún se está ejecutando, puedes verificar el estado de tu trabajo y ver los resultados en quantum.cloud.ibm.com/workloads.

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

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
print(f"Running on {backend.name}")

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

result = SamplerV2(mode=backend).run([isa_qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

plot_histogram(counts)

¿Qué sigue?

• Tutorials — guías paso a paso sobre algoritmos, mitigación de errores, transpilación y más

• Guides — material de referencia sobre la ejecución de circuitos, las primitivas y Qiskit Runtime

• Courses — rutas de aprendizaje estructuradas desde fundamentos cuánticos hasta computación a escala de utilidad

• Modules — módulos conceptuales en profundidad sobre ciencias de la computación y mecánica cuántica