← Back to Dashboard

07. Drug Discovery

Stage C - QPE (upgraded from VQE)

QPE for an illustrative two-qubit binding Hamiltonian (10 phase bits). 423k physical qubits, 35 logical. The Hamiltonian is not derived from a molecule.

Algorithm
QPE Molecular Binding Energy
Logical Qubits
5
Framework
Modern QDK (qsharp 1.31.0)

Resource Estimation (Azure Quantum RE)

Physical Qubits
423.1k
Logical Qubits
35
T-Gates
27
Rotations
32.8k
Runtime
5.1s

Resource Breakdown

Calibration Evidence (20-Run Ensemble)

Mean Value
-1.026
95% CI
± 0.002
Runs
20
Std Dev
0.004

Noise Resilience (Depolarizing Simulation)

Ideal outcome: [One, Zero] (96% probability)

p = 0.001
92.5%
p = 0.01
36.2%
p = 0.05
38.5%

Cross-Platform Emulator Results (100 shots)

These histograms predate the current kernel

This run was recorded in April 2026 against a VQE kernel that has since been replaced by phase estimation. The shot distribution below is a real measurement, but it is a measurement of a program that no longer exists in this repository, and it has not been re-run against the current kernel.

Quantinuum H2-1E
[1, 1]
62% of shots
Rigetti QVM
[1, 1]
64% of shots
✓ Cross-platform agreement: both simulators find the same dominant outcome
H2-1E Distribution
Rigetti QVM Distribution

Troyer Utility-Scale Classification

Quantum Simulation (Native Advantage Potential)
Quantum Speedup
Exponential over exact diagonalization if the initial state overlaps the ground state well; not established against the best classical methods
Classical Competitor
Molecular mechanics / DFT / docking algorithms
Honest Assessment (Troyer Framework)

Upgraded to QPE for molecular binding energy Hamiltonians. A quantum advantage in drug discovery would need strongly correlated electronic structure, such as some transition states and metal-containing active sites, that DFT and coupled cluster cannot treat reliably, and QPE is a candidate there only if a state with good ground-state overlap can be prepared. Our instance is a labelled toy model.

These two numbers describe different programs

The resource estimate below is for Main.BindingQPE(10, 1), the algorithm at utility scale. The Azure Quantum runs executed DrugBindingQPEKernel(), a small kernel sized to fit today's hardware. Qubit counts and runtimes from the estimate are not measurements of the run, and the run histogram is not a sample of the estimated circuit.

Pareto Frontier: Qubits vs Runtime

The estimator returns 6 viable configurations, not one answer. Every headline figure on this page comes from the leftmost point, which uses the fewest qubits and is therefore also the slowest. Buying 2.5x the qubits cuts runtime to 0.68x.

qubit_gate_ns_e3 with surface_code, error budget 1e-3. Points are Pareto-optimal: no other configuration is better on both axes.

Multi-Model Resource Comparison

Physical qubit requirements across 6 qubit technologies × 2 QEC schemes (inspired by Troyer Architecture Series, Part 3).

■ Gate-based + Surface code (blue)
Qubit ModelQECPhysical QubitsLogical Qubits
Superconducting (ns, 1e-4)surface_code43,99535
Trapped Ion (μs, 1e-4)surface_code43,99535
Superconducting (ns, 1e-3)surface_code423,05535
Trapped Ion (μs, 1e-3)surface_code423,05535

Problem Documentation

Problem 07 · Quantum-Assisted Drug Discovery

Overview

Drug discovery requires exploring vast chemical design spaces to identify ligands with strong binding affinity and favorable pharmacokinetics. Quantum computing promises more accurate electronic-structure evaluation and molecular similarity search. This problem pairs a classical baseline that scores ligand–protein interaction energy using coarse-grained Lennard-Jones plus Coulomb terms with a Q# project whose hardware kernel runs quantum phase estimation on small active-site models.

Directory Layout


07_drug_discovery/
├── estimates/                  # JSON artifacts from classical/quantum workflows
├── instances/                  # Molecule parameter sets (small/medium/large)
├── plots/                      # Generated figures from analyze.py
├── python/
│   ├── classical_baseline.py   # Deterministic scoring of ligand poses
│   └── analyze.py              # Visualization of energy histograms & rankings
└── qsharp/
    ├── qsharp.json            # Modern QDK project file
    └── Program.qs              # Placeholder quantum workflow

Quick Start


cd problems/07_drug_discovery

# Classical scoring (writes estimates/classical_baseline.json)
python python/classical_baseline.py

# Visualize score distributions and top candidates
python python/analyze.py

# Quantum placeholder
 python -c "import qsharp; qsharp.init(project_root='qsharp'); print('Build OK')"
 python tooling/run_all_qsharp.py  # runs via qsharp Python package

Next Quantum Milestones

1. Fragment Encoding – Map small active-site Hamiltonians (H₂, LiH, minimal basis) into qubit Hamiltonians.

2. Deeper QPE – Extend the phase register and Trotter depth toward chemically relevant precision.

3. Pose Re-ranking – Combine quantum energy estimates with classical docking scores.

4. Resource Estimation – Benchmark fault-tolerant requirements for chemically relevant precision.

This scaffold keeps the classical baseline reproducible while we iterate toward genuine quantum chemical modeling. 🧪⚛️

Objective Maturity Gate

  • **Current gate**: **Stage C complete** (hardware-aware validation evidence in place: QPE binding-energy kernel runnable, calibration ensemble across runs, backend assumptions documented, dual-model estimator profile, OpenQASM export for cross-platform validation, Azure smoke validation).
  • **Next gate target**: **Stage D** (advantage evidence package: fairness review against DFT/coupled-cluster baselines, residual risks for naturally-quantum molecular Hamiltonians, claim category locked).

Stage C evidence references for this problem:

  • Calibration ensemble: `estimates/quantum_calibration_ensemble.json` and `estimates/calibration_evidence.json`.
  • Backend assumptions: `estimates/backend_assumptions.md`.
  • Estimator profile (ns-e3 + surface-code-generic): `estimates/estimator_profile_summary.md`, `estimates/latest_qubit_gate_ns_e3.json`, `estimates/latest_surface_code_generic_v1.json`.
  • Cross-platform OpenQASM export: `estimates/vqe_binding.qasm`.
  • Azure smoke validation: `estimates/azure_smoke_report_small_d1.md`, `estimates/azure_job_manifest_small_d1.json`.

DiVincenzo Readiness (Stage C/D Overlay)

| Criterion | Status | Evidence / Notes |

|---|---|---|

| Scalable qubit system | partial | Problem-scoped instance baselines are in place; full hardware-scale projections are tracked as Stage C work. |

| Initialization | partial | Input/state initialization path is defined for current workflows, with backend-ready loading fidelity still to be hardened. |

| Coherence vs gate time | not-yet | Backend-calibrated coherence-vs-depth evidence is pending and required for Stage C/D promotion. |

| Universal gate set | partial | Q# scaffold/build path exists; gate-basis decomposition and transpilation evidence remain Stage C tasks. |

| Qubit-specific measurement | partial | Measurement outputs are defined for current validation flows; hardware readout characterization is pending. |

Advantage Claim Contract

  • **Claim category (current)**: `theoretical`.
  • **Problem class and regime**: Problem-specific challenge instances defined in this directory.
  • **Fair baseline**: Problem-local classical baseline in `python/` outputs.
  • **Quantum resource scaling claim**: Expected asymptotic advantage depends on algorithm family and implementation assumptions; no hardware-demonstrated speedup claim yet.
  • **Data-loading and I/O assumptions**: Must be documented alongside future advantage claims.
  • **Noise/error model assumptions**: Backend-specific model and calibration assumptions to be added at Stage C.
  • **Confidence/uncertainty method**: To be reported using shot-based confidence intervals or equivalent statistical bounds.
  • **Residual risks**: Oracle/state-preparation/transpilation overhead may dominate for near-term instance sizes.

Reproduce It

cd problems/07_drug_discovery make classical # Run classical baseline make analyze # Generate plots make build # Validate Q# compilation make run # Run Q# entry point

Key Files

  • qsharp/src/Main.qs Quantum algorithm implementation
  • qsharp/HardwareKernel.qs Azure-submittable QIR kernel
  • python/classical_baseline.py Classical reference implementation
  • estimates/classical_baseline.json Baseline metrics
View on GitHub →