HLQuantum: High-Level Quantum Abstraction

# 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]"

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}

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

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 )

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 )

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

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

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