westquant-bluequbit

WestQuant Execution Representation Scheduling on BlueQubit compute.

WestQuant learns to map (algorithm, circuit structure, accuracy target) to (representation, simulator, parameters) on BlueQubit's multi-backend compute platform.

WestQuant
    │
circuit / problem
    │
┌───▼───────────┐
│ Representation│
│    Search     │
└───┬───────────┘
    │
┌───┴───────────────┐
│ Circuit rep        │  Execution rep
│ gates/layout/basis  │  CPU / GPU / MPS / Pauli-path / QPU
│ transpilation       │  bond dimension / truncation threshold
└───┬───────────────┘
    ▼
BlueQubit
    │
    ▼
cost / runtime / accuracy
    │
    ▼
WQT training data

BlueQubit exposes multiple ways to solve the same quantum computation: CPU, GPU, MPS (CPU/GPU), Pauli-path, and QPU. Each has tunable parameters (MPS bond dimension, Pauli-path truncation threshold, shots, transpilation level).

This means WestQuant can search over:

a = (R_c, D, P, θ)

where R_c = circuit representation, D = device/simulator, P = preprocessing/transpilation, θ = simulator parameters.

The optimization target is:

min(T, C, E)  subject to  E < ε

where T = runtime, C = cost, E = approximation error.

pip install westquant-bluequbit[bluequbit,qiskit]

from westquant_bluequbit import BlueQubitSearch

search = BlueQubitSearch()

result = search.optimize(
    circuit,
    objectives=["runtime", "cost", "error"],
    devices=["cpu", "gpu", "mps.gpu", "pauli-path"],
    mps_bond_dimensions=[4, 8, 16, 32, 64],
    pauli_path_thresholds=[1e-1, 1e-3, 1e-5],
)

# Pareto-optimal execution configurations
for config in result["pareto_front"]:
    print(f"{config['device']}: {config['runtime_ms']:.0f}ms, ${config['cost']:.4f}")

# Search across devices
wq-bq search --circuit ghz --n-qubits 24 --devices cpu,gpu,mps.gpu

# MPS bond dimension sweep
wq-bq mps-sweep --circuit qaoa --n-qubits 28 --chi 4,8,16,32,64 --target-fidelity 0.999

# Pauli-path truncation sweep
wq-bq pps-sweep --circuit pauli --n-qubits 32 --thresholds 1e-1,1e-3,1e-5

# Full benchmark suite
wq-bq benchmark --families ghz,qft,qaoa,vqe,random,pauli --n-qubits 8,16,24 --devices cpu,gpu

# Cost estimate
wq-bq estimate --circuit ghz --n-qubits 32 --device mps.gpu

Default qubit counts: 8, 12, 16, 20, 24, 28, 32, 36, 40.

Each execution produces a policy record:

{
  "circuit_features": {"n_qubits": 24, "n_gates": 120, "n_2q_gates": 45, "depth": 30},
  "representation": "mps.gpu_chi64",
  "action": {"device": "mps.gpu", "options": {"mps_bond_dimension": 64}},
  "prediction": {"estimated_runtime_ms": 820, "estimated_cost": 0.04},
  "result": {"runtime_ms": 734, "cost": 0.037, "fidelity": 0.99991},
  "reward": {"accuracy": 0.99991, "runtime": 734, "cost": 0.037}
}

Learn f(circuit) → {CPU, GPU, MPS, PPS}. Which simulator representation is best for this circuit?

Search χ ∈ {2, 4, 8, 16, 32, 64, 128}. Measure (χ, fidelity, runtime, cost). Learn χ* = f(C, ε).

Search thresholds 10^{-1} to 10^{-5}. Get the accuracy-vs-compute curve.

Not just C → D, but (C, R) → (C', D). WestQuant changes gate decomposition, routing, basis — then selects the simulator. Same algorithm, different classical cost.

Compare BlueQubit's estimate() against actual runtime. Train T̂_WQ(C, R, D) — a representation-aware cost model.

Apache-2.0

• GitHub
• WestQuant Open
• BlueQubit