HLQuantum vs Qiskit puro: cuándo usar una capa de abstracción

Hay una pregunta real al comenzar un proyecto de computación cuántica: ¿deberías escribir los circuitos directamente en Qiskit o usar la capa de abstracción de HLQuantum por encima? Ambas son opciones válidas, y la respuesta correcta depende de lo que estés construyendo.

Esta publicación te ofrece una comparación concreta y basada en código para ayudarte a decidir.

La diferencia fundamental

Qiskit es el SDK cuántico de IBM. Te da control directo y preciso sobre cada puerta, qubit, medición y paso de compilación. Está orientado nativamente al hardware de IBM y tiene el ecosistema más profundo para flujos de trabajo específicos de IBM.

HLQuantum es una API unificada que se sitúa por encima de Qiskit, Cirq, PennyLane, Braket, CUDA-Q e IonQ. Escribes un solo circuito; este lo traduce y lo despacha a cualquiera que sea el backend al que lo apuntes. Sacrifica algo de control de bajo nivel a cambio de portabilidad y simplicidad.

Lado a lado: estado de Bell

Qiskit puro:

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

sim = AerSimulator()
result = sim.run(qc, shots=1000).result()
print(result.get_counts())  # {'00': 501, '11': 499}

HLQuantum:

import hlquantum as hlq

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

result = hlq.run(qc, backend='qiskit', shots=1000)
print(result.counts)  # {'00': 501, '11': 499}

Aproximadamente la misma verbosidad para un único backend. La diferencia aparece cuando añades más backends.

Lado a lado: ejecución en múltiples backends

Qiskit puro (para añadir un segundo backend, tienes que reescribir):

# Qiskit Aer
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
qc_qiskit = QuantumCircuit(2, 2)
qc_qiskit.h(0); qc_qiskit.cx(0, 1); qc_qiskit.measure_all()
result_qiskit = AerSimulator().run(qc_qiskit, shots=1000).result()

# PennyLane — API completamente diferente, reescribir el circuito
import pennylane as qml
dev = qml.device('default.qubit', wires=2)
@qml.qnode(dev)
def bell():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    return qml.probs(wires=[0, 1])
result_pennylane = bell()

# CUDA-Q — otra API más, reescribir de nuevo
import cudaq
@cudaq.kernel
def bell():
    qvec = cudaq.qvector(2)
    h(qvec[0]); cx(qvec[0], qvec[1]); mz(qvec)
result_cudaq = cudaq.sample(bell, shots_count=1000)

HLQuantum (un circuito, cualquier backend):

import hlquantum as hlq

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

# Cambia de backend con una sola palabra
result_qiskit    = hlq.run(qc, backend='qiskit')
result_pennylane = hlq.run(qc, backend='pennylane')
result_cudaq     = hlq.run(qc, backend='cudaq')    # GPU
result_cirq      = hlq.run(qc, backend='cirq')
result_ionq      = hlq.run(qc, backend='ionq', device='aria-1')
result_ibm       = hlq.run(qc, backend='qiskit', device='ibm_sherbrooke')

Aquí es donde HLQuantum rinde sus frutos — prototipar en un simulador local y desplegar en una QPU sin reescribir el circuito.

Lado a lado: VQE

VQE con Qiskit puro:

from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.mappers import JordanWignerMapper
from qiskit_nature.second_q.circuit.library import UCCSD
from qiskit_algorithms import VQE
from qiskit_algorithms.optimizers import COBYLA
from qiskit.primitives import Estimator

driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735')
problem = driver.run()
mapper = JordanWignerMapper()
hamiltonian = mapper.map(problem.second_q_ops()[0])

ansatz = UCCSD(
    problem.num_spatial_orbitals,
    problem.num_particles,
    mapper,
    initial_state=problem.reference_state,
)

vqe = VQE(Estimator(), ansatz, COBYLA())
result = vqe.compute_minimum_eigenvalue(hamiltonian)
print(f"H2 ground state: {result.eigenvalue.real:.4f} Ha")

VQE con HLQuantum:

import hlquantum as hlq

result = hlq.algorithms.vqe(
    molecule='H2',
    basis='sto-3g',
    backend='qiskit',
    optimizer='COBYLA',
)
print(f"H2 ground state: {result.energy:.4f} Ha")

# Cambia a GPU:
result_gpu = hlq.algorithms.vqe(molecule='H2', backend='cudaq')

Qiskit puro te da control total sobre el ansatz, el mapper y el driver. La línea única de HLQuantum es ideal para comparar backends u obtener resultados rápidamente; Qiskit puro es mejor cuando necesitas ansatze personalizados o ajuste fino del algoritmo.

Cuándo usar Qiskit puro

Usa Qiskit directamente cuando:

Te diriges exclusivamente al hardware de IBM — el transpilador de Qiskit y las primitivas de IBM Runtime te dan el mejor rendimiento en las QPU de IBM. La abstracción de HLQuantum añade sobrecarga.
Necesitas control detallado del circuito — descomposiciones de puertas personalizadas, pasos específicos del transpilador, control a nivel de pulso, circuitos dinámicos con mediciones a mitad del circuito.
Estás haciendo investigación en el ecosistema de IBM — usando qiskit-nature, qiskit-finance, qiskit-optimization o qiskit-machine-learning — estos se integran más profundamente con Qiskit puro.
El rendimiento es crítico — el código directo de Qiskit tiene menos sobrecarga que la capa de traducción de HLQuantum.
Estás contribuyendo al ecosistema de Qiskit — escribiendo plugins de Qiskit, tutoriales o artículos de investigación donde Qiskit es la implementación de referencia.

Cuándo usar HLQuantum

Usa HLQuantum cuando:

Necesitas flexibilidad de backend — comparar el rendimiento de simuladores, hacer benchmarking de circuitos en distintas arquitecturas o acceder a múltiples QPU en la nube.
Estás prototipando algoritmos — escribe una vez, prueba en todas partes. No tienes que recablear circuitos al pasar de la simulación local a la GPU y al hardware real.
Estás enseñando o aprendiendo — una API consistente en todos los backends facilita el aprendizaje. No hay necesidad de aprender 6 APIs diferentes.
Quieres algoritmos integrados — hlq.algorithms.vqe(), hlq.algorithms.qaoa(), hlq.algorithms.grover() se encargan del código repetitivo.
Estás construyendo aplicaciones multi-backend — si tu aplicación necesita ejecutarse en la QPU que tenga la cola más corta o el menor costo, el despachador de HLQuantum se encarga de ello.

Migración: Qiskit → HLQuantum

Si tienes código de Qiskit existente, HLQuantum puede consumir circuitos de Qiskit directamente:

import hlquantum as hlq
from qiskit import QuantumCircuit

# Circuito de Qiskit existente
qc = QuantumCircuit(3)
qc.h(0); qc.cx(0, 1); qc.cx(1, 2)

# Envuélvelo y ejecútalo en cualquier backend
result = hlq.run(hlq.from_qiskit(qc), backend='pennylane')
result_gpu = hlq.run(hlq.from_qiskit(qc), backend='cudaq')

No se requiere reescritura — puedes añadir las capacidades multi-backend de HLQuantum al código de Qiskit existente de forma incremental.

Lista de verificación para decidir

Starting a new project?
├── Need IBM-specific features (Qiskit Runtime, pulse control)?  → Raw Qiskit
├── Need to run on multiple backends or compare performance?     → HLQuantum
├── Learning quantum computing for the first time?               → HLQuantum
└── Building a research paper targeting IBM hardware?            → Raw Qiskit

Migrating existing Qiskit code?
├── Want to add GPU acceleration?     → HLQuantum (from_qiskit + cudaq)
├── Want to try IonQ hardware?        → HLQuantum (from_qiskit + ionq)
└── Want to stay IBM-only?            → Stay with Qiskit

Ambos no son mutuamente excluyentes. Muchos flujos de trabajo comienzan con Qiskit puro para el diseño del circuito y luego lo envuelven con HLQuantum para el despliegue multi-backend.

Empieza aquí: Guía de HLQuantum · Guía del SDK de Qiskit · Compara todos los SDKs