El Transpiler de Qiskit y las restricciones de los procesadores cuánticos

El transpiler de Qiskit es el motor de compilación que transforma un circuito cuántico abstracto en uno que pueda ejecutarse físicamente en un procesador cuántico real.

Un circuito abstracto puede usar cualquier puerta lógica: Hadamard, Toffoli, SWAP, rotaciones arbitrarias… pero los procesadores reales solo entienden un pequeño conjunto de puertas nativas. El transpiler se encarga de tres tareas principales:

1. Descomposición de puertas. Traduce cada puerta no nativa en combinaciones de puertas que el hardware sí implementa.

2. Ruteo de qubits (SWAP insertion). Los qubits no están todos conectados entre sí. Si tu circuito pide una operación entre dos qubits que no son vecinos en el procesador, el transpiler inserta puertas SWAP para mover el estado cuántico a través del grafo de conectividad del dispositivo.

3. Optimización. Cancela puertas redundantes, fusiona rotaciones consecutivas y minimiza la profundidad del circuito para reducir el error acumulado.

Todo esto se controla a través de PassManager, una cadena de passes (transformaciones) que el transpiler aplica en orden. La función transpile() ejecuta un PassManager preconfigurado según el nivel de optimización elegido (0 al 3).

Restricciones en los procesadores IBM actuales

Las distintas familias de procesadores cuánticos de IBM, Eagle (127 qubtis), Heron (133-156 qubits) y Nighthawk (120 qubits) tienen diferentes puertas nativas y conectividad. Por ejemplo, Eagle dispone de 127 qubits programables con tecnologías de empaquetado innovadoras para el control y la escalabilidad de los qubits. Sus puertas nativas (basis gates) son: ECR, ID, RZ, SX, X. El gate de dos qubits nativo es ECR (Echo Cross-Resonance), diferente al CX que se usaba en generaciones anteriores.

A continuación, vamos a ver un ejemplo en el que definimos un circuito con puertas arbitrarias y lo transpilamos usando un backend ficticio que imita exactamente las características físicas de un procesador cuántico Eagle de IBM.

Primero, importamos las librerías necesarias, entre ellas el fake_provider, que sirve para realizar pruebas locales, y definimos el backend como FakeSherbrooke, que imita la arquitectura del procesador IBM Eagle.

from qiskit import QuantumCircuit, transpile
from qiskit_ibm_runtime.fake_provider import FakeSherbrooke
 
# ── 1. Backend: Eagle 127q (local, sin cuenta IBM) ────────────────────────────
# Basis gates reales: ['ecr', 'id', 'rz', 'sx', 'x']
# Topología: heavy-hex lattice
backend = FakeSherbrooke()

Definimos un circuito general con las puertas que deseamos.

# ── 2. Circuito original (puertas abstractas) ─────────────────────────────────
qc = QuantumCircuit(3, 3)
qc.h(0)        # Hadamard   → no nativa en Eagle
qc.cx(0, 1)    # CNOT       → no nativa en Eagle
qc.cx(1, 2)    # CNOT
qc.t(0)        # T gate     → no nativa en Eagle
qc.s(1)        # S gate     → no nativa en Eagle
qc.measure([0, 1, 2], [0, 1, 2])
 
print("CIRCUITO ORIGINAL")
print("=================")
print(qc.draw(output="text"))
print(f"Puertas: {dict(qc.count_ops())}")
print(f"Profundidad: {qc.depth()}")

Ahora pasamos el transpiler que descompone las puertas originales en las puertas básicas del procesador, aplicando un nivel de optimización ligero.

# ── 3. Transpilación ──────────────────────────────────────────────────────────
# El transpiler:
#   • Descompone H, CX, T, S → ECR + RZ + SX + X (basis gates de Eagle)
#   • Asigna qubits lógicos a qubits físicos del chip (layout)
#   • Inserta SWAPs si el circuito pide CNOTs entre qubits no conectados
t_qc = transpile(
    qc,
    backend=backend,
    optimization_level=1,   # 0=sin opt · 1=ligera · 2=pesada · 3=máxima
    seed_transpiler=42,     # resultado reproducible
)

Ahora, vemos el circuito final, que solo contiene puertas ECR, ID, RZ, SX, X, tiene una profundidad mayor y se han sustituido las CNOTs entre dos qubits por ECRs, que es un operador de entrelazamiento nativo fundamental en muchos ordenadores cuánticos de circuito superconductor.

print("\nCIRCUITO TRANSPILADO (solo puertas nativas IBM Eagle)")
print("======================================================")
print(t_qc.draw(output="text"))
print(f"Puertas: {dict(t_qc.count_ops())}")
print(f"Profundidad: {t_qc.depth()}")