Inicio/HLQuantum

✨ Enfoque recomendado — Escribe una vez, ejecuta en cualquier parte

HLQuantum — Abstracción cuántica de alto nivel

Una biblioteca de Python que abstrae la complejidad del hardware cuántico. Escribe tu circuito una sola vez con HLQuantum y ejecútalo en IBM Qiskit, Google Cirq, Amazon Braket, PennyLane, NVIDIA CUDA-Q o IonQ — sin cambiar una sola línea de código.

Código abierto6 backendsQPU realCompatible con GPU

Documentación oficial Guía de inicio rápido

¿Por qué usar HLQuantum?

🔁

Escribe una vez, ejecuta en cualquier parte

El mismo código de circuito se ejecuta en cualquiera de los 6 backends compatibles — sin traducción ni reescritura.

⚡

Aceleración por GPU integrada

Redirige circuitos de forma transparente a simuladores de GPU NVIDIA para acelerar enormemente los circuitos grandes.

🛡️

Mitigación de errores

ZNE, mitigación de lectura y otras técnicas integradas — se aplican con un solo argumento.

🧠

Algoritmos integrados

QFT, Grover, VQE, QAOA, Bernstein-Vazirani — listos para usar e independientes del backend.

🔀

Multi-backend asíncrono

Ejecuta experimentos en varios backends simultáneamente para benchmarking y verificación.

🤖

Integración con IA / MCP

La compatibilidad con Model Context Protocol permite que los agentes de IA orquesten experimentos cuánticos.

Backends compatibles

Backend	Framework	Instalación	QPU real
qiskit	IBM Qiskit	`pip install hlquantum[qiskit]`	Sí
cirq	Google Cirq	`pip install hlquantum[cirq]`	Solo simulación
pennylane	Xanadu PennyLane	`pip install hlquantum[pennylane]`	Solo simulación
braket	Amazon Braket	`pip install hlquantum[braket]`	Sí
cudaq	NVIDIA CUDA-Q	`pip install hlquantum[cudaq]`	Solo simulación
ionq	IonQ (via Qiskit)	`pip install hlquantum[ionq]`	Sí

Inicio rápido

1. Instalación

terminal

# Install with your preferred backend
pip install hlquantum[qiskit]     # IBM Qiskit backend
pip install hlquantum[cirq]       # Google Cirq backend
pip install hlquantum[pennylane]  # PennyLane backend
pip install hlquantum[braket]     # Amazon Braket backend
pip install hlquantum[cudaq]      # NVIDIA CUDA-Q backend
pip install hlquantum[ionq]       # IonQ backend

# Or install multiple at once
pip install "hlquantum[qiskit,cirq,cudaq]"

2. Crea tu primer circuito

hello_quantum.py

import hlquantum as hlq

# Create a 2-qubit circuit
qc = hlq.Circuit(2)

# Apply gates using the fluent API
qc.h(0).cx(0, 1).measure_all()

# Run on the default backend (auto-detects installed SDK)
result = hlq.run(qc, shots=1000)
print(result)
# {'00': 507, '11': 493}

3. Cambia de backend con un solo indicador

switch_backends.py

import hlquantum as hlq

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

# The SAME circuit, on DIFFERENT backends — zero code changes
r1 = hlq.run(qc, shots=1000, backend="qiskit")   # Qiskit Aer
r2 = hlq.run(qc, shots=1000, backend="cirq")      # Google Cirq
r3 = hlq.run(qc, shots=1000, backend="pennylane") # PennyLane
r4 = hlq.run(qc, shots=1000, backend="cudaq")     # NVIDIA GPU
r5 = hlq.run(qc, shots=1000, backend="braket")    # Amazon Braket
r6 = hlq.run(qc, shots=1000, backend="ionq")      # IonQ

for name, result in zip(["Qiskit","Cirq","PennyLane","CUDA-Q","Braket","IonQ"],
                         [r1, r2, r3, r4, r5, r6]):
    print(f"{name}: {result}")

El decorador @kernel

El decorador @hlq.kernel te permite escribir lógica cuántica como funciones estándar de Python. HLQuantum las compila y ejecuta automáticamente en el backend seleccionado.

kernel_example.py

import hlquantum as hlq

@hlq.kernel
def ghz_state(n: int):
    """Create an n-qubit GHZ state."""
    qubits = hlq.qvector(n)
    hlq.h(qubits[0])
    for i in range(n - 1):
        hlq.cx(qubits[i], qubits[i + 1])
    hlq.measure_all(qubits)

# Run the kernel
result = hlq.run(ghz_state, args=(5,), shots=1000)
print(result)  # {'00000': ~500, '11111': ~500}

# Works on any backend
result_gpu = hlq.run(
    ghz_state,
    args=(20,),       # 20-qubit GHZ!
    shots=1000,
    backend="cudaq"   # GPU acceleration
)

Algoritmos cuánticos integrados

HLQuantum incluye implementaciones listas para usar de algoritmos cuánticos comunes que funcionan en cualquier backend.

Transformada cuántica de Fourier (QFT)Estimación de faseAlgoritmo de Shor

El análogo cuántico de la Transformada Discreta de Fourier. Se utiliza como subrutina en muchos algoritmos, incluido el algoritmo de factorización de Shor.

python

import hlquantum as hlq
from hlquantum.algorithms import QFT

# Create a QFT circuit for 4 qubits
qft_circuit = QFT(n_qubits=4)
result = hlq.run(qft_circuit, shots=1000)
print(result)

Algoritmo de búsqueda de GroverBúsquedaAceleración cuadrática

Proporciona una aceleración cuadrática para búsquedas no estructuradas. Encuentra un elemento marcado en √N pasos en lugar de N.

python

import hlquantum as hlq
from hlquantum.algorithms import Grover

# Search for item "101" in a 3-qubit space
grover = Grover(oracle_string="101")
result = hlq.run(grover.circuit, shots=2000)

# The marked state should have high probability
print(result)  # {'101': ~1800, others: ~200}

VQE — Solucionador cuántico variacional de valores propiosQuímicaOptimización

Encuentra la energía del estado fundamental de un hamiltoniano. Algoritmo clave para la química cuántica en dispositivos NISQ.

python

import hlquantum as hlq
from hlquantum.algorithms import VQE
from hlquantum.operators import PauliSum

# Define Hamiltonian
H = PauliSum.from_list([
    ("ZZ", -1.052), ("IZ", 0.398),
    ("ZI", -0.398), ("XX", 0.181),
])

vqe = VQE(hamiltonian=H, n_qubits=2, ansatz="TwoLocal", reps=2)
energy, params = vqe.run(backend="qiskit", max_iter=200)
print(f"Ground state energy: {energy:.6f}")

QAOA — Optimización aproximada cuánticaCombinatoriaOptimización

Algoritmo aproximado para problemas de optimización combinatoria como MaxCut, particionado de grafos y planificación.

python

import hlquantum as hlq
from hlquantum.algorithms import QAOA
import networkx as nx

# Define a MaxCut problem
graph = nx.Graph([(0,1),(1,2),(2,3),(3,0),(0,2)])

qaoa = QAOA(problem="maxcut", graph=graph, p=2)
result = qaoa.run(backend="pennylane", shots=2000)
print(f"Best cut: {result.best_solution}")
print(f"Cut value: {result.best_value}")

Capas y pipelines de ML cuántico

HLQuantum incluye composición inspirada en ML para circuitos cuánticos — construye ansätze variacionales como modelos por capas, de forma similar a nn.Sequential de PyTorch.

hl_pipeline.py

import hlquantum as hlq
from hlquantum.layers import RYLayer, EntanglingLayer, Sequential

# Build a variational quantum model
model = Sequential([
    RYLayer(n_qubits=4),         # Layer of RY rotations
    EntanglingLayer(n_qubits=4), # CNOT entangling layer
    RYLayer(n_qubits=4),         # Another RY layer
    EntanglingLayer(n_qubits=4),
])

# Run the model (initializes random params)
result = model.run(shots=1000, backend="pennylane")

# Train the model (gradient-based)
loss_history = model.fit(
    X_train, y_train,
    optimizer="adam",
    learning_rate=0.01,
    epochs=50
)

Ejecución multi-backend asíncrona

Ejecuta el mismo circuito en varios backends simultáneamente y compara los resultados. Ideal para hacer benchmarking de niveles de ruido o verificar resultados entre plataformas.

async_run.py

import hlquantum as hlq
import asyncio

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

async def benchmark_backends():
    tasks = {
        name: hlq.run_async(qc, shots=1000, backend=name)
        for name in ["qiskit", "cirq", "pennylane", "cudaq"]
    }
    results = {name: await task for name, task in tasks.items()}

    for name, result in results.items():
        print(f"{name}: {result}")

asyncio.run(benchmark_backends())

Mitigación de errores

HLQuantum incluye técnicas integradas de mitigación de errores para la ejecución en hardware real.

error_mitigation.py

import hlquantum as hlq
from hlquantum.mitigation import ZNE, ReadoutMitigation

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

# Zero-Noise Extrapolation (ZNE)
mitigated_result = hlq.run(
    qc,
    shots=2000,
    backend="qiskit",
    device="ibm_sherbrooke",  # Real hardware
    mitigation=ZNE(noise_factors=[1, 2, 3])
)

# Readout error mitigation
result_mit = hlq.run(
    qc,
    shots=2000,
    backend="qiskit",
    mitigation=ReadoutMitigation()
)

print(f"Raw result:      {hlq.run(qc, shots=2000)}")
print(f"Mitigated result: {mitigated_result}")

Aceleración por GPU

gpu_accel.py

import hlquantum as hlq

# Large circuit — 28 qubits
qc = hlq.Circuit(28)
for i in range(28):
    qc.h(i)
for i in range(27):
    qc.cx(i, i + 1)
qc.measure_all()

# CPU simulation (may be slow for 28 qubits)
result_cpu = hlq.run(qc, shots=100, backend="qiskit")

# GPU simulation — orders of magnitude faster!
result_gpu = hlq.run(qc, shots=100, backend="cudaq")  # NVIDIA
result_gpu2 = hlq.run(qc, shots=100, backend="pennylane",
                       device="lightning.gpu")           # lightning.gpu

print(f"CPU: {result_cpu}")
print(f"GPU (CUDA-Q): {result_gpu}")

🤖

Cuántica impulsada por IA (MCP)

HLQuantum incluye compatibilidad con Model Context Protocol (MCP), lo que permite a los agentes de IA construir, optimizar y ejecutar circuitos cuánticos de forma autónoma. Esto habilita un nuevo paradigma de descubrimiento de algoritmos cuánticos impulsado por IA.

Conoce más sobre la integración MCP de HLQuantum