Comparación de simuladores cuánticos gratuitos: Qiskit Aer vs Cirq vs PennyLane vs CUDA-Q

Los simuladores cuánticos te permiten probar circuitos sin esperar en las colas del hardware ni pagar por cada disparo. Pero con seis grandes simuladores disponibles de forma gratuita, ¿cuál deberías usar? Aquí tienes un análisis práctico.

La respuesta rápida

Qiskit Aer: el caballo de batalla

Qiskit Aer es el simulador gratuito más completo en funcionalidades. Admite múltiples métodos de simulación:

• statevector_simulator: Simulación exacta de hasta ~30 cúbits. La memoria escala como 2ⁿ números complejos (se necesitan 16 GB de RAM para 30 cúbits).
• qasm_simulator: Muestreo basado en disparos con soporte de modelos de ruido
• density_matrix: Simula estados mixtos y sistemas cuánticos abiertos
• mps: Matrix Product State — simula circuitos con entrelazamiento limitado de hasta cientos de cúbits
• stabilizer: Solo circuitos de Clifford, pero escala a miles de cúbits en tiempo polinómico

from qiskit_aer import AerSimulator

# Default: automatic method selection
sim = AerSimulator()

# Force a specific method
sim_sv = AerSimulator(method='statevector')
sim_dm = AerSimulator(method='density_matrix')
sim_mps = AerSimulator(method='matrix_product_state')

Cuándo usar Aer: Para cualquier flujo de trabajo de Qiskit, modelado de ruido, o cuando quieras reproducir de cerca el comportamiento del hardware de IBM.

PennyLane: lo mejor para el aprendizaje automático cuántico

PennyLane brilla cuando necesitas circuitos diferenciables. Su simulador default.qubit calcula gradientes exactos mediante la regla de desplazamiento de parámetros, lo que permite la optimización basada en gradientes de circuitos cuánticos:

import pennylane as qml
import numpy as np

dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev)
def circuit(theta):
    qml.RX(theta[0], wires=0)
    qml.RY(theta[1], wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

# Automatic gradient computation
grad_fn = qml.grad(circuit)
theta = np.array([0.5, 1.2])
print(grad_fn(theta))  # exact gradient

Para una simulación más rápida sin gradientes, usa lightning.qubit (backend en C++, ~10× más rápido que default.qubit):

pip install pennylane-lightning

dev = qml.device("lightning.qubit", wires=20)

Cuándo usar PennyLane: Algoritmos variacionales (VQE, QAOA), aprendizaje automático cuántico, cualquier flujo de trabajo que requiera gradientes de circuitos.

NVIDIA CUDA-Q: cuando la velocidad importa

CUDA-Q ofrece simulación acelerada por GPU que puede ser entre 100 y 10.000× más rápida que los simuladores de CPU para circuitos grandes. Si tienes cualquier GPU de NVIDIA, esta es la opción adecuada para circuitos de más de 25 cúbits:

import cudaq

@cudaq.kernel
def large_circuit(n: int):
    qvec = cudaq.qvector(n)
    h(qvec[0])
    for i in range(n - 1):
        cx(qvec[i], qvec[i + 1])
    mz(qvec)

# Run on GPU (specify 'nvidia' target)
cudaq.set_target('nvidia')
counts = cudaq.sample(large_circuit, 30, shots_count=10000)
print(counts)

Prueba de rendimiento (circuito GHZ, 28 cúbits, 1000 disparos):

• Qiskit Aer CPU: ~45 segundos
• PennyLane lightning.qubit: ~30 segundos
• CUDA-Q (GPU A100): ~0,8 segundos

Cuándo usar CUDA-Q: Cualquier circuito con más de 25 cúbits, simulaciones críticas en rendimiento, cargas de trabajo con múltiples GPU.

Cirq: modelado de ruido e investigación NISQ

Google Cirq incluye tres simuladores:

import cirq

# Exact statevector simulation
sim = cirq.Simulator()

# Density matrix with noise
noise_model = cirq.ConstantQubitNoiseModel(
    cirq.depolarize(p=0.01)
)
noisy_sim = cirq.DensityMatrixSimulator(noise=noise_model)

# Clifford circuits only (but exponentially faster for stabilizer states)
clifford_sim = cirq.CliffordSimulator()

Cuándo usar Cirq: Modelado de ruido NISQ, investigación de circuitos estabilizadores, flujos de trabajo de Google AI Quantum.

Amazon Braket LocalSimulator: aislamiento y portabilidad

El Braket SDK incluye un simulador local gratuito que reproduce exactamente la API de la nube:

from braket.devices import LocalSimulator
from braket.circuits import Circuit

device = LocalSimulator()

circuit = Circuit()
circuit.h(0)
circuit.cnot(0, 1)
circuit.probability()

task = device.run(circuit, shots=1000)
result = task.result()
print(result.measurement_counts)

Cuándo usar Braket local: Estás desarrollando para un despliegue en AWS y quieres un entorno local de desarrollo/pruebas que coincida con la API de la nube.

El atajo de HLQuantum

Si necesitas ejecutar el mismo circuito en varios simuladores para hacer pruebas comparativas o comparaciones, HLQuantum lo hace trivial:

import hlquantum as hlq
import time

qc = hlq.Circuit(28)
qc.h(0)
for i in range(27):
    qc.cx(i, i + 1)
qc.measure_all()

for backend in ["qiskit", "pennylane", "cudaq"]:
    t0 = time.time()
    result = hlq.run(qc, shots=1000, backend=backend)
    print(f"{backend}: {time.time() - t0:.2f}s")

Un circuito, tres backends, resultados directamente comparables.