Inspiration

Quantum optimization demos have a credibility problem. Many show a QAOA circuit solving a tiny problem with no classical baseline, so nobody can tell whether the quantum part adds anything. Finance teams face the same question in practice: when is quantum worth trying, and when is a laptop enough? We wanted a tool that answers that question with evidence instead of hype, using portfolio selection as a real, familiar problem.

What it does

QuantaBench takes a constrained optimization problem, converts it to a QUBO, solves it with QAOA, and benchmarks the result against classical solvers on the same data.

For the flagship demo, you choose the number of assets, a target number of holdings, and a risk-aversion level. QuantaBench then:

  • builds the mean-variance + cardinality QUBO and shows it as a readable equation,
  • synthesizes a QAOA circuit with Classiq (reporting qubits, depth and gate counts),
  • executes it through qBraid, with an automatic Qiskit Aer fallback,
  • compares the result with brute force (exact), simulated annealing and a greedy heuristic,
  • reports approximation ratio, probability of finding the optimum, feasibility rate, Sharpe ratio, runtime and the efficient frontier.

Every run reports whether a fallback backend was used, and classical results are shown even when they win. The pipeline is problem-agnostic: a new problem plugs in by implementing one interface.

How we built it

  • Quantum: QAOA (p = 1 to 3) modeled and synthesized in Classiq, executed through qBraid, with Qiskit Aer as a fallback behind a backend adapter.
  • Optimization: COBYLA with seeded restarts and warm starts from layer p-1 to p.
  • Classical baselines: NumPy/SciPy brute force, seeded simulated annealing and greedy selection.
  • Backend: Python and FastAPI with Pydantic models, a versioned REST API, live progress streaming and a disk cache of precomputed runs.
  • Frontend: React, TypeScript and Tailwind dashboard with interactive frontier, histogram and convergence charts.
  • Verification: unit tests that the QUBO and Ising energies match for every bitstring on a small instance, and that brute force returns the true optimum.

Challenges we ran into

  • Penalty tuning: the cardinality constraint needs a penalty weight large enough to dominate the objective, but too large a value flattens the energy landscape and hurts QAOA. Finding a balance took repeated testing on small instances.
  • Optimizer convergence: QAOA parameters get stuck in local minima, so we used multiple seeded restarts and warm starts between depths.
  • Reliability under time pressure: quantum cloud access can fail through quotas, queues or auth. We built an adapter with automatic fallback and cached results so the demo never depends on one service.
  • Honest comparison: making the quantum and classical runs use identical data, seeds and metrics took more care than the circuit itself.

Accomplishments that we're proud of

  • An end-to-end pipeline from CSV to benchmarked results that runs deterministically.
  • Real use of both Classiq (circuit synthesis with resource reporting) and qBraid (backend access).
  • A benchmark that reports where quantum does not help, which we think is the most useful result for anyone evaluating quantum readiness.
  • A plug-in problem interface, so the same workbench can handle other QUBO problems.
  • Automatic fallback and saved runs, so the demo works even when a cloud service does not.

What we learned

  • At today's problem sizes (roughly 8 to 12 qubits), classical solvers are hard to beat on solution quality and speed. The value now is in learning how these algorithms behave, not in claiming advantage.
  • Problem formulation, especially constraint penalties, affects results as much as the circuit design does.
  • Reproducibility (seeds, caching, shared metrics) is what makes a quantum result trustworthy.
  • Resource-aware synthesis in Classiq makes depth versus width tradeoffs visible in a way that hand-built circuits do not.

What's next for QuantaBench

  • Run larger instances on real hardware through qBraid and study the effect of noise.
  • Add more problem plug-ins (scheduling, routing, Max-Cut) and sponsor-specific datasets.
  • Try constraint-preserving mixers and other QAOA variants against the penalty-based approach.
  • Publish the benchmark methodology and results as an open-source reference for evaluating quantum optimization fairly.
  • Build a "quantum readiness report" feature that tells a finance team at what problem size and structure quantum becomes worth testing.

Built With

Share this project:

Updates

Submission history