HLQuantum — उच्च-स्तरीय क्वांटम एब्स्ट्रैक्शन

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