Programar un Ordenador Cuántico: Tutorial Qiskit

<\!-- wp:group {"className":"tldr-box","backgroundColor":"pale-cyan-blue"} -->

<\!-- /wp:group -->

📅 Última actualización: febrero de 2026 · IA Cuántica Avanzada

Por qué aprender a programar un ordenador cuántico en 2026 es una inversión de futuro

En febrero de 2026, la computación cuántica está exactamente donde estaba el deep learning en 2013: la tecnología funciona en laboratorios y en demostraciones limitadas, las herramientas son accesibles pero poco conocidas, y la inmensa mayoría de profesionales del sector tecnológico no ha escrito una sola línea de código cuántico. Los que lo hicieron con deep learning en 2013 se convirtieron en los profesionales más demandados de la siguiente década. La misma ventana de oportunidad existe ahora para la computación cuántica.

La demanda de talento cuántico supera ampliamente la oferta. Según un informe de McKinsey, el número de puestos de trabajo relacionados con computación cuántica crece a un ritmo del treinta y cinco por ciento anual, pero el número de profesionales cualificados apenas lo hace al diez por ciento. Esto crea una brecha de talento que se traduce en salarios significativamente superiores a la media del sector tecnológico, como detallamos en nuestro artículo sobre profesiones de futuro en computación cuántica.

La barrera de entrada para experimentar con computación cuántica nunca ha sido tan baja. IBM ofrece acceso gratuito a procesadores cuánticos reales. Los frameworks de programación son de código abierto y están documentados en detalle. No necesitas un doctorado en física cuántica para escribir tu primer circuito: con conocimientos de Python y una comprensión intuitiva de los conceptos básicos (que aprenderás en este tutorial) es suficiente para empezar.

Este tutorial está diseñado para programadores con experiencia en Python que quieran dar sus primeros pasos en la computación cuántica usando Qiskit, el framework más utilizado del mundo. Al final del artículo, habrás creado tu primer circuito cuántico, generado entrelazamiento cuántico y ejecutado un algoritmo de búsqueda cuántica. Si quieres entender primero los fundamentos teóricos de la IA cuántica, consulta nuestra guía introductoria antes de continuar.

Qué es Qiskit y cómo acceder gratis al ordenador cuántico de IBM

Qiskit (pronunciado «kiss-kit», del inglés Quantum Information Science Kit) es un framework de código abierto desarrollado por IBM para programar ordenadores cuánticos. Es el framework cuántico más utilizado del mundo, con más de un millón de descargas acumuladas y una comunidad de cientos de miles de desarrolladores. Está escrito en Python y se integra con el ecosistema científico de Python (NumPy, SciPy, Matplotlib) y con bibliotecas de machine learning (scikit-learn, PyTorch).

Qiskit se estructura en varios módulos. El módulo principal, Qiskit Terra, permite diseñar circuitos cuánticos, transformarlos (transpilación) para adaptarlos al hardware específico y ejecutarlos. Qiskit Aer proporciona simuladores cuánticos de alto rendimiento que se ejecutan en tu ordenador local. Qiskit Machine Learning ofrece implementaciones de algoritmos de quantum machine learning. Qiskit Nature se centra en simulación de moléculas y materiales. Y Qiskit Runtime es el servicio cloud que ejecuta circuitos en los procesadores cuánticos reales de IBM de forma optimizada.

Para acceder a los ordenadores cuánticos de IBM de forma gratuita, necesitas crear una cuenta en IBM Quantum (quantum.ibm.com). El plan gratuito incluye acceso a procesadores cuánticos reales con hasta ciento veintisiete qubits y diez minutos de tiempo de ejecución mensual, suficiente para cientos de experimentos básicos. El proceso de registro tarda menos de cinco minutos y te proporciona un token de API que necesitarás para conectar Qiskit con el hardware de IBM.

Una vez registrado, tienes dos formas de trabajar: directamente en el navegador usando los Jupyter notebooks integrados en la plataforma IBM Quantum (sin instalar nada), o en tu ordenador local instalando Qiskit como una biblioteca de Python. Para aprender, ambas opciones son válidas, pero para proyectos serios recomendamos la instalación local por su flexibilidad y velocidad.

Instalar Qiskit y configurar tu entorno de desarrollo paso a paso

La instalación de Qiskit es directa si ya tienes Python (versión tres punto ocho o superior) y pip. Estos son los pasos exactos para configurar tu entorno de desarrollo cuántico.

Paso uno: crear un entorno virtual. Es buena práctica aislar las dependencias de Qiskit en un entorno virtual de Python. Abre tu terminal y ejecuta: python -m venv qiskit_env seguido de source qiskit_env/bin/activate en Linux/Mac o qiskit_env\Scriptsctivate en Windows. Esto crea y activa un entorno limpio donde instalarás Qiskit sin interferir con otros proyectos.

# Paso 1: Crear entorno virtual
python -m venv qiskit_env

# Activar en Linux/Mac:
source qiskit_env/bin/activate

# Activar en Windows:
qiskit_env\Scripts\activate

Paso dos: instalar Qiskit. Con el entorno virtual activo, ejecuta: pip install qiskit. Esto instala el paquete principal de Qiskit incluyendo el diseñador de circuitos, el transpilador y las herramientas de visualización.

# Paso 2: Instalar Qiskit
pip install qiskit
pip install qiskit-aer
pip install qiskit-ibm-runtime

Para el simulador local de alto rendimiento, añade: pip install qiskit-aer. Para machine learning cuántico: pip install qiskit-machine-learning. La instalación completa tarda entre dos y cinco minutos dependiendo de tu conexión.

Paso tres: instalar Qiskit IBM Runtime. Para ejecutar circuitos en hardware real de IBM, necesitas el paquete de runtime: pip install qiskit-ibm-runtime. Este paquete gestiona la conexión con los servidores de IBM Quantum y la ejecución optimizada de circuitos.

Paso cuatro: configurar tu token de API. Entra en quantum.ibm.com, ve a tu perfil y copia tu token de API. En tu código Python, configúralo una vez con: from qiskit_ibm_runtime import QiskitRuntimeService seguido de QiskitRuntimeService.save_account(channel="ibm_quantum", token="TU_TOKEN_AQUÍ"). Esto guarda el token localmente para que no necesites introducirlo cada vez.

# Configurar token de IBM Quantum
from qiskit_ibm_runtime import QiskitRuntimeService

QiskitRuntimeService.save_account(
    channel="ibm_quantum",
    token="TU_TOKEN_AQUÍ"
)

Paso cinco: verificar la instalación. Abre un notebook de Jupyter o un script de Python y ejecuta: import qiskit seguido de print(qiskit.__version__). Si muestra la versión sin errores, estás listo para crear tu primer circuito cuántico. Opcionalmente, ejecuta from qiskit_ibm_runtime import QiskitRuntimeService seguido de service = QiskitRuntimeService() para verificar que la conexión con IBM Quantum funciona correctamente.

Tu primer circuito cuántico: puertas Hadamard, CNOT y medición

Un circuito cuántico es una secuencia de operaciones (puertas cuánticas) que manipulan el estado de los qubits. Es el equivalente cuántico de un programa: defines qué operaciones hacer sobre qué qubits y en qué orden, y luego ejecutas el circuito para obtener un resultado.

Vamos a crear un circuito sencillo que demuestra los dos conceptos más importantes de la computación cuántica: la superposición y la medición. El circuito usa un solo qubit, le aplica una puerta Hadamard (que crea superposición) y lo mide.

El código en Qiskit es: primero importamos con from qiskit import QuantumCircuit. Luego creamos el circuito con qc = QuantumCircuit(1, 1) (un qubit y un bit clásico para almacenar el resultado). Aplicamos la puerta Hadamard con qc.h(0) (al qubit cero). Y medimos con qc.measure(0, 0) (medimos el qubit cero y guardamos en el bit cero). Para visualizar el circuito usamos qc.draw('mpl') que genera un diagrama gráfico.

La puerta Hadamard (H) es la operación cuántica más fundamental. Toma un qubit en el estado cero (su estado inicial por defecto) y lo pone en superposición: una combinación al cincuenta por ciento de cero y uno. Cuando mides un qubit en superposición, obtienes cero o uno con igual probabilidad, de forma verdaderamente aleatoria (no pseudoaleatoria como los generadores de números aleatorios clásicos). Si ejecutas este circuito mil veces, obtendrás aproximadamente quinientos resultados «cero» y quinientos «uno».

Para ejecutar el circuito en el simulador local: from qiskit_aer import AerSimulator, luego simulator = AerSimulator(), después result = simulator.run(qc, shots=1000).result() y finalmente counts = result.get_counts(). La variable counts contendrá algo como {‘0’: 498, ‘1’: 502}, confirmando que el qubit estaba en superposición perfecta.

Este circuito tan simple ya demuestra algo imposible para un ordenador clásico: generar verdadera aleatoriedad cuántica. Cada vez que mides el qubit, el universo «decide» aleatoriamente si el resultado es cero o uno, sin que ningún algoritmo determinista pueda predecir o reproducir la secuencia exacta.

Entrelazamiento cuántico en la práctica: crear un par de Bell con código

El entrelazamiento cuántico es el fenómeno más contraintuitivo y más poderoso de la mecánica cuántica. Albert Einstein lo llamó «acción fantasmagórica a distancia» porque le parecía imposible. Y sin embargo, es real, medible y la base de toda la computación cuántica avanzada.

Un par de Bell es el estado entrelazado más simple posible: dos qubits correlacionados de tal forma que medir uno determina instantáneamente el resultado del otro. Si mides el primero y obtienes cero, el segundo será cero con certeza absoluta. Si obtienes uno, el segundo será uno. No hay comunicación entre ellos: es una correlación intrínseca del estado cuántico compartido.

Crear un par de Bell en Qiskit requiere solo dos operaciones. Primero creamos un circuito con dos qubits: bell = QuantumCircuit(2, 2). Aplicamos una puerta Hadamard al primer qubit: bell.h(0). Esto pone el qubit cero en superposición. Luego aplicamos una puerta CNOT (Controlled-NOT) con el qubit cero como control y el qubit uno como objetivo: bell.cx(0, 1). La puerta CNOT invierte el qubit objetivo si y solo si el qubit de control está en estado uno.

# Par de Bell (entrelazamiento)
from qiskit import QuantumCircuit

bell = QuantumCircuit(2, 2)
bell.h(0)           # Superposición en qubit 0
bell.cx(0, 1)       # CNOT → entrelazamiento
bell.measure([0,1], [0,1])

print(bell.draw())
# Siempre: 00 o 11, nunca 01 ni 10

Como el qubit de control está en superposición, el efecto es crear un entrelazamiento perfecto entre ambos qubits. Finalmente medimos: bell.measure([0, 1], [0, 1]).

Al ejecutar este circuito mil veces en el simulador, obtendrás resultados como {’00’: 506, ’11’: 494}. Observa que solo aparecen los resultados «00» y «11», nunca «01» ni «10». Esto confirma el entrelazamiento: ambos qubits siempre dan el mismo resultado, ya sea cero-cero u uno-uno. La correlación es perfecta y no existe en la física clásica ningún mecanismo que pueda producir este patrón exacto.

En un ordenador cuántico real, los resultados no serán perfectos. Verás pequeñas cantidades de «01» y «10» debido al ruido del hardware. La diferencia entre los resultados del simulador (perfectos) y los del hardware real (ruidosos) es una de las lecciones más valiosas de la computación cuántica práctica: el ruido es el enemigo principal, y aprender a mitigarlo es una habilidad esencial.

Ejecutar tu circuito en un ordenador cuántico real de IBM y leer los resultados

Ejecutar tu circuito en un ordenador cuántico real es sorprendentemente sencillo con Qiskit Runtime. El proceso tiene tres pasos: conectar con el servicio, seleccionar un backend (procesador) y enviar el circuito.

Primero conectamos: from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 seguido de service = QiskitRuntimeService(). Esto usa el token que configuraste anteriormente. Luego seleccionamos el procesador menos ocupado: backend = service.least_busy(operational=True, simulator=False). Esto elige automáticamente el procesador cuántico real con menor cola de espera.

Antes de ejecutar, necesitamos transpilar el circuito. La transpilación adapta tu circuito abstracto al hardware específico, traduciendo las puertas que usaste a las puertas nativas del procesador y asignando tus qubits lógicos a qubits físicos reales: from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager y luego pm = generate_preset_pass_manager(backend=backend, optimization_level=1) seguido de transpiled = pm.run(bell).

Finalmente ejecutamos: sampler = SamplerV2(backend) y job = sampler.run([transpiled], shots=1000). El método run envía el circuito al procesador cuántico y devuelve un objeto job. Puedes consultar el estado con job.status() y obtener los resultados con result = job.result() una vez completado. La espera puede ser de segundos a minutos dependiendo de la cola del procesador.

Los resultados de un procesador real mostrarán el ruido del hardware. Donde el simulador daba {’00’: 506, ’11’: 494} para nuestro par de Bell, el hardware real podría dar algo como {’00’: 468, ’11’: 472, ’01’: 33, ’10’: 27}. Esos resultados «01» y «10» son errores causados por el ruido del procesador. Calcular la fidelidad (qué porcentaje de resultados son correctos) es una de las métricas fundamentales para evaluar la calidad de un procesador cuántico. En este caso, la fidelidad sería (468+472)/1000 = 94%, lo que es un resultado típico para hardware actual.

Algoritmo de Grover simplificado: búsqueda cuántica con código completo

El algoritmo de Grover es uno de los algoritmos cuánticos más elegantes y con más aplicaciones prácticas. Resuelve el problema de búsqueda no estructurada: dado un conjunto de N elementos, encontrar el que cumple una condición específica. Mientras que un ordenador clásico necesita en promedio N/2 intentos, Grover lo consigue en aproximadamente la raíz cuadrada de N. Para una base de datos de un millón de elementos, esto significa mil intentos en lugar de quinientos mil.

Vamos a implementar una versión simplificada con dos qubits que busca el elemento «11» entre cuatro posibles (00, 01, 10, 11). El circuito tiene tres fases: preparación (superposición), oráculo (marca la solución) y amplificación (hace que la solución marcada sea más probable al medir).

# Algoritmo de Grover (2 qubits, busca |11⟩)
from qiskit import QuantumCircuit

grover = QuantumCircuit(2, 2)

# Superposición uniforme
grover.h([0, 1])

# Oráculo: marca |11⟩
grover.cz(0, 1)

# Difusor de Grover
grover.h([0, 1])
grover.z([0, 1])
grover.cz(0, 1)
grover.h([0, 1])

# Medir
grover.measure([0, 1], [0, 1])

print(grover.draw())
# Resultado: 11 con ~100% probabilidad

El código completo empieza creando el circuito: grover = QuantumCircuit(2, 2). La fase de preparación aplica Hadamard a ambos qubits para crear superposición uniforme: grover.h([0, 1]). Ahora cada uno de los cuatro estados (00, 01, 10, 11) tiene igual probabilidad del veinticinco por ciento.

El oráculo marca el estado objetivo «11» invirtiendo su fase: grover.cz(0, 1). La puerta CZ (Controlled-Z) aplica una fase negativa cuando ambos qubits están en estado uno, exactamente nuestro objetivo. El estado «11» ahora tiene una amplitud negativa mientras los demás son positivos.

La amplificación (operador de difusión de Grover) invierte las amplitudes alrededor de la media, amplificando la solución marcada: aplicamos grover.h([0, 1]), luego grover.z([0, 1]), después grover.cz(0, 1), y finalmente grover.h([0, 1]). Medimos: grover.measure([0, 1], [0, 1]).

Al ejecutar con mil shots, el resultado debería ser abrumadoramente «11» (cercano al cien por ciento en simulador, algo menos en hardware real). El algoritmo ha encontrado la solución en una sola consulta al oráculo, mientras que una búsqueda clásica necesitaría en promedio dos intentos. Con más qubits, la ventaja crece dramáticamente: para dieciséis elementos (cuatro qubits), Grover encuentra la solución en dos consultas en lugar de ocho. Esto conecta directamente con las aplicaciones prácticas que cubrimos en nuestro artículo sobre aplicaciones reales de la computación cuántica.

Tabla de puertas cuánticas: símbolo, función y equivalencia clásica

Puerta	Símbolo Qiskit	Qubits	Función	Equivalencia clásica	Código
Hadamard	H	1	Crea superposición: |0⟩ → (|0⟩+|1⟩)/√2	Ninguna directa (genera aleatoriedad cuántica)	qc.h(0)
Pauli-X	X	1	Invierte el estado: |0⟩ ↔ |1⟩	NOT	qc.x(0)
Pauli-Y	Y	1	Rotación de 180° alrededor del eje Y	Ninguna	qc.y(0)
Pauli-Z	Z	1	Invierte la fase: |1⟩ → -|1⟩	Ninguna	qc.z(0)
CNOT	CX	2	Invierte objetivo si control es |1⟩	XOR condicional	qc.cx(0,1)
CZ	CZ	2	Aplica fase Z si ambos son |1⟩	AND con fase	qc.cz(0,1)
Toffoli	CCX	3	NOT en objetivo si dos controles son |1⟩	AND	qc.ccx(0,1,2)
SWAP	SWAP	2	Intercambia estados de dos qubits	Intercambio de variables	qc.swap(0,1)
Rotación RY	RY(θ)	1	Rotación parametrizada eje Y	Ninguna (parametrizable)	qc.ry(θ,0)
Rotación RZ	RZ(θ)	1	Rotación parametrizada eje Z	Ninguna (parametrizable)	qc.rz(θ,0)
Medición	M	1	Colapsa superposición a 0 o 1	Lectura de bit	qc.measure(0,0)

Las puertas nativas de los procesadores IBM son {CX, ID, RZ, SX, X}. Qiskit transpila automáticamente las demás puertas a combinaciones de estas nativas.

De Qiskit a Cirq y PennyLane: comparativa de frameworks cuánticos

Qiskit es el framework más popular pero no el único. Cirq de Google y PennyLane de Xanadu son alternativas potentes con filosofías diferentes. Elegir el adecuado depende de tu objetivo.

Qiskit (IBM) es la opción más completa y con mayor comunidad. Sus fortalezas son el acceso gratuito a hardware real, la documentación más extensa (incluyendo el Qiskit Textbook interactivo), el mayor número de tutoriales y ejemplos, y una cobertura completa de aplicaciones (química, ML, optimización, finanzas). Su debilidad relativa es que la integración con frameworks de deep learning como PyTorch no es tan fluida como en PennyLane. Qiskit es la mejor opción para aprender computación cuántica general y para proyectos que necesiten acceso a hardware de IBM.

Cirq (Google) está diseñado para el control detallado de circuitos cuánticos y la investigación en hardware. Se integra con TensorFlow Quantum para machine learning cuántico. Sus fortalezas son el control granular sobre la compilación y ejecución de circuitos, la integración con el ecosistema de Google (TensorFlow, Colab, Cloud), y su enfoque en la eficiencia de ejecución. Su debilidad es que Google no ofrece acceso público gratuito a su hardware cuántico (a diferencia de IBM), por lo que Cirq se usa principalmente con simuladores o a través de Amazon Braket para acceder a hardware de terceros.

PennyLane (Xanadu) es el framework de referencia para quantum machine learning. Su filosofía es «diferenciación cuántica»: permite calcular gradientes a través de circuitos cuánticos de forma automática, exactamente como PyTorch y TensorFlow lo hacen para redes neuronales clásicas. Se integra nativamente con PyTorch, TensorFlow y JAX, y puede ejecutar circuitos en hardware de IBM, Amazon Braket, Google y Rigetti. PennyLane es la mejor opción para científicos de datos que quieran integrar componentes cuánticos en sus pipelines de ML existentes.

No es necesario elegir solo uno. Los conceptos son transferibles entre frameworks y muchos profesionales usan Qiskit para aprender, PennyLane para QML y Cirq para investigación. La clave es empezar con uno y experimentar.

Recursos para seguir aprendiendo: cursos gratuitos, libros y comunidades en español

Cursos gratuitos online: IBM Quantum Learning (learning.quantum.ibm.com) es el recurso más completo, con cursos desde nivel introductorio hasta avanzado, todos con notebooks interactivos de Qiskit. El Qiskit Textbook (qiskit.org/textbook) es un libro de texto interactivo que cubre desde álgebra lineal básica hasta algoritmos cuánticos avanzados. Coursera ofrece «Introduction to Quantum Computing» de la Universidad de Toronto y «Quantum Machine Learning» de la misma universidad. EdX tiene el certificado profesional del MIT en computación cuántica.

Libros recomendados: «Quantum Computing: An Applied Approach» de Jack Hidary es uno de los mejores libros prácticos con código Qiskit. «Programming Quantum Computers» de Eric Johnston es excelente para programadores. «Quantum Computation and Quantum Information» de Nielsen y Chuang es la biblia del campo para quienes quieran profundizar en la teoría. En español, «Computación cuántica» de varios autores de la editorial Ra-Ma ofrece una introducción accesible.

Comunidades y eventos: El Qiskit Community en Slack tiene miles de miembros activos que responden preguntas y comparten proyectos. Los Qiskit Global Summer Schools (anuales y gratuitos) ofrecen una semana de formación intensiva con ponentes de IBM y universidades. Los hackathons de IBM Quantum (varias veces al año) son oportunidades para trabajar en equipo en problemas reales. En España, el BSC-CNS organiza talleres y eventos de Quantum Spain, y las universidades mencionadas en nuestro artículo sobre el ecosistema cuántico español organizan seminarios regulares.

Práctica continua: La forma más efectiva de aprender computación cuántica es escribir código todos los días. Empieza reproduciendo los ejemplos de este tutorial, luego modifícalos (cambia las puertas, añade qubits, prueba diferentes algoritmos), y finalmente intenta resolver problemas por tu cuenta. El repositorio de IBM Quantum Challenges en GitHub contiene problemas de hackathons anteriores con soluciones, lo que es un excelente material de práctica.

Preguntas frecuentes sobre programación cuántica

¿Qué es Qiskit y para qué sirve?

Qiskit es un framework de código abierto desarrollado por IBM para programar ordenadores cuánticos usando Python. Permite diseñar circuitos cuánticos, simularlos localmente y ejecutarlos en procesadores cuánticos reales de IBM de forma gratuita a través de IBM Quantum.

¿Necesito saber física cuántica para usar Qiskit?

No necesitas un conocimiento profundo. Con Python básico y una comprensión intuitiva de la superposición y el entrelazamiento es suficiente para empezar. Qiskit abstrae la complejidad matemática y te permite experimentar de forma práctica desde el primer día.

¿Puedo ejecutar programas en un ordenador cuántico real gratis?

Sí. IBM Quantum ofrece un plan gratuito con acceso a procesadores cuánticos reales y diez minutos de tiempo de ejecución mensual. Solo necesitas crear una cuenta, obtener tu token de API y configurarlo en Qiskit.

¿Qué lenguaje de programación se usa para computación cuántica?

Python es el lenguaje dominante. Qiskit, Cirq y PennyLane son frameworks de Python. Microsoft usa Q#, un lenguaje propio. Para principiantes, Python con Qiskit es la mejor opción por la comunidad, documentación y acceso a hardware gratuito.

¿Cuál es la diferencia entre Qiskit, Cirq y PennyLane?

Qiskit (IBM) es el más completo y con mayor comunidad, ideal para aprender. Cirq (Google) se integra con TensorFlow Quantum. PennyLane (Xanadu) es el mejor para quantum machine learning con integración nativa en PyTorch. Los tres son gratuitos.

<\!-- wp:html -->

<\!-- /wp:html -->