Build a portable quantum algorithm workflow in Python using the qBraid SDK and a framework it can transpile. Show that the algorithm remains performant after compilation to a constrained execution target.
This challenge is about more than simply transpiling a circuit. You should study how compilation choices affect both:
- algorithmic performance, and
- compiled resource cost
Your goal is to identify which compilation strategy best preserves useful algorithm behavior under realistic execution constraints.
Compiler-aware benchmarking
Submissions should answer a technical question:
How well does a quantum algorithm survive compilation across frameworks and execution targets?
All submissions must be implemented in:
- Python
Each team must build a workflow around a quantum algorithm, not just a circuit primitive.
A valid submission must:
- implement a nontrivial quantum algorithm in Python
- begin from at least one framework-level source representation such as cirq, braket, qiskit.
- use qBraid to compile or transpile the workload
- compare at least two qBraid compilation strategies
- run the compiled workload on at least two execution environments
- evaluate the tradeoff between:
- output quality
- compiled resource cost
The workload should be an algorithm, not just a simple state-preparation demo.
- QAOA for MaxCut on a small graph
- Quantum Fourier Transform-based routine
- Hamiltonian simulation of a small spin model
- Variational observable estimation
- Bernstein-Vazirani or Deutsch-Jozsa, if extended into a meaningful benchmark study
- Cutting edge quantum algorithms with few tutorials and your own personal twist / optimization
- Bell-state generation
- GHZ-only preparation
- “hello world” entanglement demos
- a single circuit with no algorithmic objective
- copying qbraid-algorithms and qbraid-lab-demo tutorials verbatim
Your submission is only eligible if qBraid is central to the workflow.
Examples of valid qBraid usage include:
qbraid.transpile(...)ConversionGraphConversionScheme- qBraid-based framework conversion
- qBraid-based target preparation or execution workflow
A submission that only uses native framework transpilation without meaningful qBraid usage is not eligible.
You must compare at least two qBraid compilation strategies.
Examples:
- default transpilation vs constrained path depth
- one target framework vs another
- one conversion scheme vs another
- one compilation path vs an alternative path
The point is not just to compile once, but to study how compilation choices affect the final result.
You must run the workload on at least two execution environments.
Examples:
- ideal simulator vs noisy simulator
- one simulator backend vs another
- unconstrained simulation vs constrained target simulation
Bonus: try running on real hardware.
Report at least one output-quality metric, such as:
- success probability
- approximation ratio
- expectation value error
- total variation distance
- Hellinger distance
- fidelity proxy
Report at least two compiled-resource metrics, such as:
- circuit depth
- 2-qubit gate count
- circuit width
- shot count
- measurement overhead
Each team must submit via PR:
A GitHub repository containing:
- Python source code
- runnable notebook or script
- dependency/setup instructions
Your repository README must include:
- the algorithm you chose
- the source framework representation
- the qBraid compilation strategies you compared
- the execution environments you used
- the metrics you collected
- a conclusion about the best tradeoff between quality and cost
A short presentation or demo recording explaining:
- what you built
- how qBraid was used
- what you learned from the benchmark
Your submission must clearly answer:
- What algorithm did you implement?
- What was your source representation?
- How did qBraid transform the workload?
- What two compilation strategies did you compare?
- What changed in the compiled programs?
- Which strategy best preserved algorithm performance?
- What was the cost of that strategy in compiled resources?
A submission is eligible only if it includes all of the following:
- a nontrivial algorithmic workload
- Python implementation
- at least one framework-level source representation such as Qiskit or Cirq
- explicit qBraid usage in code
- comparison of at least two qBraid compilation strategies
- execution on at least two environments
- quantitative analysis of both quality and compiled cost
- clear getting started procedures