Acasă/HLQuantum

✨ Abordare recomandată — scrie o dată, rulează oriunde

HLQuantum — abstractizare cuantică de nivel înalt

O bibliotecă Python care abstractizează complexitatea hardware-ului cuantic. Scrie-ți circuitul o singură dată cu HLQuantum și execută-l pe IBM Qiskit, Google Cirq, Amazon Braket, PennyLane, NVIDIA CUDA-Q sau IonQ — fără a schimba o singură linie de cod.

Open source6 backend-uriQPU realSuport GPU

Documentație oficială Ghid de pornire rapidă

De ce să folosești HLQuantum?

🔁

Scrie o dată, rulează oriunde

Același cod de circuit se execută pe oricare dintre cele 6 backend-uri acceptate — fără traducere, fără rescriere.

⚡

Accelerare GPU integrată

Direcționează transparent circuitele către simulatoarele GPU NVIDIA pentru accelerări masive pe circuite mari.

🛡️

Atenuarea erorilor

ZNE, atenuarea citirii și alte tehnici integrate — aplică-le cu un singur argument.

🧠

Algoritmi integrați

QFT, Grover, VQE, QAOA, Bernstein-Vazirani — gata de utilizare, independenți de backend.

🔀

Multi-backend asincron

Rulează experimente pe mai multe backend-uri simultan pentru benchmarking și verificare.

🤖

Integrare IA / MCP

Suportul Model Context Protocol permite agenților IA să orchestreze experimente cuantice.

Backend-uri acceptate

Backend	Framework	Instalare	QPU real
qiskit	IBM Qiskit	`pip install hlquantum[qiskit]`	Da
cirq	Google Cirq	`pip install hlquantum[cirq]`	Doar sim
pennylane	Xanadu PennyLane	`pip install hlquantum[pennylane]`	Doar sim
braket	Amazon Braket	`pip install hlquantum[braket]`	Da
cudaq	NVIDIA CUDA-Q	`pip install hlquantum[cudaq]`	Doar sim
ionq	IonQ (via Qiskit)	`pip install hlquantum[ionq]`	Da

Pornire rapidă

1. Instalează

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. Creează primul tău circuit

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. Schimbă backend-ul cu un singur parametru

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}")

Decoratorul @kernel

Decoratorul @hlq.kernel îți permite să scrii logica cuantică drept funcții Python standard. HLQuantum le compilează și le execută automat pe backend-ul selectat.

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
)

Algoritmi cuantici integrați

HLQuantum include implementări gata de utilizare ale algoritmilor cuantici comuni care funcționează pe orice backend.

Transformata Fourier cuantică (QFT)Estimarea fazeiAlgoritmul lui Shor

Analogul cuantic al transformatei Fourier discrete. Folosit ca subrutină în mulți algoritmi, inclusiv algoritmul de factorizare al lui 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)

Algoritmul de căutare al lui GroverCăutareAccelerare cvadratică

Oferă o accelerare cvadratică pentru căutarea nestructurată. Găsește un element marcat în √N pași în loc 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 — rezolvitor propriu cuantic variaționalChimieOptimizare

Găsește energia stării fundamentale a unui hamiltonian. Algoritm cheie pentru chimia cuantică pe dispozitivele 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 — optimizare cuantică aproximativăCombinatorieOptimizare

Algoritm aproximativ pentru probleme de optimizare combinatorie precum MaxCut, partiționarea grafurilor și planificarea.

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}")

Straturi și pipeline-uri de ML cuantic

HLQuantum include o compoziție inspirată din ML pentru circuitele cuantice — construiește ansätze variaționale ca modele stratificate, similare cu nn.Sequential de la 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
)

Execuție multi-backend asincronă

Rulează același circuit pe mai multe backend-uri simultan și compară rezultatele. Excelent pentru evaluarea nivelurilor de zgomot sau verificarea rezultatelor pe diferite platforme.

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())

Atenuarea erorilor

HLQuantum include tehnici integrate de atenuare a erorilor pentru execuția pe 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}")

Accelerare 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}")

🤖

Cuantic condus de IA (MCP)

HLQuantum include suport pentru Model Context Protocol (MCP), permițând agenților IA să construiască, să optimizeze și să execute circuite cuantice autonom. Acest lucru deschide o nouă paradigmă de descoperire a algoritmilor cuantici condusă de IA.

Află mai multe despre integrarea MCP a HLQuantum