← Back to Dashboard

02. Catalysis Simulation

Stage C - QPE (upgraded from VQE)

QPE for H₂ (STO-3G, 10 phase bits). 423k physical qubits, 35 logical. Reproduces the full-CI energy in simulation, for a molecule classical methods solve instantly.

Algorithm
QPE for H₂ ground state (STO-3G)
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
65.6k
Runtime
10.6s

Resource Breakdown

Calibration Evidence (20-Run Ensemble)

Mean Value
-1.135
95% CI
undefined
Runs
20
Std Dev
0.000

Every run returned the same value. The interval is a normal approximation, which has zero width when the runs do not vary, so it does not bound the mean; it is left undefined rather than shown as ± 0.

Noise Resilience (Depolarizing Simulation)

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

p = 0.001
99.7%
p = 0.01
72.5%
p = 0.05
60.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, 0]
69% of shots
Rigetti QVM
[1, 0]
70% 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 full configuration interaction if the initial state overlaps the ground state well; not established against the best classical methods
Classical Competitor
Full configuration interaction (FCI) / coupled cluster
Honest Assessment (Troyer Framework)

Upgraded to QPE for molecular Hamiltonians. Hoefler, Häner and Troyer see 'a huge potential in material science and chemistry'. QPE is exponentially cheaper than FCI once a state with good ground-state overlap is prepared, but coupled cluster, DMRG and selected CI already treat many large molecules accurately, and no generic exponential advantage over them has been established (Lee et al., Nat. Commun. 14, 1952, 2023). The case rests on strongly correlated systems such as FeMoco. The current H₂ instance is pedagogical.

These two numbers describe different programs

The resource estimate below is for Main.MolecularQPE(10, 1), the algorithm at utility scale. The Azure Quantum runs executed CatalysisQPEKernel(), 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 5 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.0x the qubits cuts runtime to 0.72x.

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

02. Quantum Catalysis Challenge

This problem explores quantum simulation of catalytic reaction mechanisms, comparing classical and quantum approaches for estimating reaction rates and energy barriers. The goal is to establish analytical baselines and prepare for quantum algorithm implementation.

Roadmap

  • [x] Scaffold directory structure
  • [x] Implement classical analytical baseline (Arrhenius model)
  • [x] Implement Q# analytical baseline (matching classical results)
  • [x] Generate parameter instances (small/medium/large)
  • [x] Validate outputs and plots
  • [ ] Update documentation and website status

Quickstart


cd problems/02_catalysis
make classical      # Run classical baseline analysis
make analyze        # Generate plots
make build          # Build Q# project (uses modern QDK  qsharp Python package)
make run            # Run quantum simulation

Outputs

  • `estimates/classical_baseline.json`: Structured Arrhenius rates for each instance
  • `plots/rate_vs_temperature.png`: Visualization of reaction rates vs. temperature
  • `qsharp/src/Main.qs`: Q# baseline source, compiled on-the-fly by the modern QDK (no DLL artifact)

Current Results

Running python python/classical_baseline.py produces the following reaction rates:

| Instance | Catalyst | Temperature (K) | Rate (s^-1) |

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

| small | Pt | 300 | 0.8727 |

| medium | Fe | 500 | 5.94×10^2 |

| large | Cu | 700 | 2.92×10^5 |

The Q# entry point RunAnalyticalCatalysisBaseline reports the same values, confirming parity between classical and quantum-friendly baselines.

References

  • Quantum simulation of chemical catalysis
  • Analytical models for reaction rates
  • Q# quantum chemistry libraries

Objective Maturity Gate

  • **Current gate**: **Stage C complete** (hardware-aware validation evidence in place: QPE chemistry kernel runnable, calibration ensemble across runs, backend assumptions documented, estimator profile produced for both ns-e3 superconducting and surface-code-generic models).
  • **Next gate target**: **Stage D** (advantage evidence package hardening: fairness review against best-known classical baseline, residual risks quantified, 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`.
  • Azure smoke validation: `estimates/azure_smoke_report_small_d1.md`, `estimates/azure_job_manifest_small_d1.json`.
  • Reproducible quantum kernel: `qsharp/src/Main.qs` runnable via `qsharp.run('Main.RunCatalysisAnalysis()', 1)`.

DiVincenzo Readiness (Stage C/D Overlay)

| Criterion | Status | Evidence / Notes |

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

| Scalable qubit system | partial | Current results validate analytical parity; scalable chemistry-kernel resource projections are pending Stage C implementation. |

| Initialization | partial | Reaction-parameter initialization is defined for analytical baselines; quantum state-loading fidelity work remains open. |

| Coherence vs gate time | not-yet | Backend-specific coherence and depth/runtime evidence has not yet been produced. |

| Universal gate set | partial | Q# baseline build path is validated, but gate-basis decomposition for a chemistry kernel is not finalized yet. |

| Qubit-specific measurement | partial | Output observables are defined for baseline workflows; hardware readout assumptions and uncertainty bands are 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/02_catalysis 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 →