# I Recreated IBM, ORNL, and Cleveland Clinic's Quantum Chemistry Paper on Fusion Fuel — Down to a Real IBM Hardware Job

On July 6, 2026, IBM, Oak Ridge National Laboratory, and Cleveland Clinic announced something that had never been done before: the first known quantum computer simulation of the chemistry inside a fusion reactor's fuel-breeding blanket. Not a full reactor. Not a full plasma. Nine molecular snapshots of a molten salt called FLiBe, run through a quantum-centric pipeline to figure out how tightly a rare hydrogen isotope — tritium — sticks to it.

I rebuilt the entire pipeline from scratch, on my own proxy clusters, ending on a real IBM quantum chip. Full interactive breakdown, every phase, every equation, every job ID, is here: [**FLiBe Fusion Blanket Chemistry — full interactive lab notebook**](https://artifacts.omlabs.co/s/flibe-fusion-blanket-chemistry-ornl-cleveland-clinic-ibm-quantum-recreation-1785410017498). This post is the narrative version of that notebook.

## Why fusion energy has a tritium problem

Fusion reactors that use the deuterium-tritium reaction need a steady supply of tritium to keep running. The problem is that tritium barely exists in nature — most of what's on Earth was made artificially, and a working fusion plant has to breed its own. The proposed solution is a "blanket" of molten salt, FLiBe (a mixture of lithium fluoride and beryllium fluoride), wrapped around the plasma. Neutrons thrown off by the fusion reaction hit lithium-6 atoms in the salt and split them into helium and tritium. That much is settled chemistry.

What's not settled is the second half: getting the tritium back out. Whether tritium stays chemically locked inside the salt or is recoverable depends on subtle electron-level binding chemistry — and that chemistry involves tightly correlated electrons in a hot, ionic, constantly shifting liquid, which is exactly the kind of system classical density functional theory struggles to get right. This is a real bottleneck standing between where fusion energy is today and a commercially viable reactor, and it's explicitly named as a target of the U.S. Department of Energy's Genesis Mission, which is trying to unify supercomputing, AI, and quantum computing across DOE's 17 national labs to speed up exactly this kind of materials discovery.

## What the original team actually computed

It's worth being precise here, because it's easy to over-read a headline like "quantum computer models fusion fuel." The ORNL/Cleveland Clinic/IBM team did not simulate a reactor. They took nine frozen molecular snapshots of small FLiBe clusters — a technique called quantum-centric supercomputing, the same general family of methods IBM and Cleveland Clinic have used to model 12,635-atom proteins — and computed the electronic energy of each cluster twice: once with a tritium atom attached, once without. The difference between those two numbers is the binding energy, and its sign and size tell you whether tritium wants to stay in the salt or leave it.

Cleveland Clinic's presence on a fusion-energy paper looks strange at first glance, until you know their quantum computing partnership with IBM already exists for large-scale biomedical simulation — the same wave function embedding and sample-based quantum diagonalization techniques transfer directly from protein chemistry to molten salt chemistry. It's a methods collaboration, not a fusion lab pivoting into medicine.

## Rebuilding it: nine salt clusters, twenty-seven structures

I couldn't use the original team's exact AIMD-generated geometries, so I built chemically faithful proxy clusters instead: nine FLiBe conformations, 21–23 atoms each, in three versions per conformation — the bare anion, the anion with tritium attached, and a check structure — giving 27 total structures. Everything downstream traces back to one equation:

```plaintext
E_bind = E(FLiBeT⁻) − E(FLiBeF⁻)
```

Tritium is defined as leaving the salt as a bare T⁺ ion with zero electronic energy, matching the paper's convention. A strongly negative `E_bind` means tritium is energetically comfortable staying put; understanding exactly how negative, and why, is the whole point of the calculation.

## The physics underneath: from Schrödinger's equation to qubits

Electrons aren't little balls sitting at fixed points — they're wave-like probability distributions, and the rulebook governing how they behave is the Schrödinger equation, `Hψ = Eψ`. Solving it exactly for anything bigger than a hydrogen atom is intractable, because electrons don't just respond to the nuclei around them, they also actively avoid each other — a subtle effect called electron correlation that mean-field methods systematically underestimate. FLiBe is an unpleasant test case for this: polarizable fluoride ions, strongly ionic Be–F bonds, and mixed ionic-covalent character all at once.

To make this computable at all, chemists use second quantization: instead of tracking exact electron positions, you track which orbital "seats" are occupied, using creation and annihilation operators. The Hamiltonian becomes a sum of one-electron terms (kinetic energy plus nuclear attraction) and two-electron terms (electron-electron repulsion), both computed directly from the molecule's geometry using a program called PySCF. Map each spatial orbital to two qubits — one for spin-up, one for spin-down — via the Jordan-Wigner transformation, and you've turned a chemistry problem into something a quantum computer can, in principle, represent. The paper's largest single fragment needed 33 orbitals, which is 66 qubits.

I ran RHF (restricted Hartree-Fock) mean-field calculations on all 27 clusters, in the same 6-31+G(d) basis set the original paper used — a dictionary of Gaussian orbital shapes, with extra "diffuse" functions (the `+`) that matter specifically because fluoride ions are soft and spread out, and polarization functions (the `d`) that let orbitals distort away from perfect spherical symmetry. All 27 converged cleanly.

## Cutting the molecule without losing the chemistry

Here's the part that makes this tractable at all: you never try to solve the whole 21-23 atom cluster as one giant quantum problem. You cut it into fragments, one per atom, using a technique called Embedded Wave Function theory (EWF). Each atom gets localized orbitals via intrinsic atomic orbitals (IAO), a "bath" of neighboring orbital character via a DMET Schmidt decomposition, and then an MP2-based bath expansion that pulls in just enough extra orbital space to keep the fragment chemically accurate. The output is a small, self-contained Hamiltonian per fragment, sized by its active space, M.

Not every fragment is the same size. Lithium and beryllium fragments stayed small, M≈8-15. Fluoride-centered fragments, because fluorine's lone pairs are so polarizable and mix heavily with beryllium's orbitals, ballooned to M≈27-33. This is where a simple rule decides the whole pipeline's shape: fragments with M < 13 get solved exactly, classically, with full configuration interaction (FCI) — the gold-standard, no-compromises answer. Fragments with M ≥ 13 are too large for classical exact diagonalization to handle cheaply, so they go to the quantum path instead.

## Where quantum actually enters: LUCJ and sample-based quantum diagonalization

The quantum method here is not VQE, and that distinction matters. Instead, each large fragment gets a Local Unitary Cluster Jastrow (LUCJ) circuit — a fixed-structure ansatz, seeded directly from a classical CCSD calculation's T1 and T2 amplitudes, run at circuit depth `n_reps=1`. That circuit is sampled thousands of times, either on a noiseless Aer simulator or on real IBM hardware, producing a long list of measured electron-configuration bitstrings.

From there, sample-based quantum diagonalization (SQD) takes over, entirely classically: it recovers the physically valid electron configurations from the noisy sample, builds a compact configuration-interaction Hamiltonian restricted to just those configurations, and diagonalizes it on a normal computer. The "ext" in ext-SQD means the subspace gets extended afterward with single excitations and rediagonalized, squeezing out a bit more accuracy. The quantum processor's only job is generating a good list of candidate configurations to search over — the actual energy comes from classical linear algebra. I solved 108 fragments this way across the full 27-structure set.

## The finding that actually matters

Here's the headline result, and it's a slightly uncomfortable one if you were hoping quantum hardware would be the star: comparing ext-SQD against exact classical FCI on the fragments small enough to check both ways, the two methods agreed to within roughly 0.7 kcal/mol, and to about 0.3 kcal/mol mean absolute deviation on conformational energy differences specifically. That's excellent agreement — the quantum-assisted solver is doing its job correctly.

But compare the embedded-fragment approach as a whole against uncut, full-molecule reference methods, and the gap jumps to around 110 kcal/mol on binding energy. The bottleneck isn't the quantum computer. It's how you slice the molecule into fragments in the first place. I found the same qualitative pattern in my own recreation, and it's worth sitting with: the most expensive, most hyped part of this pipeline — the quantum circuit — was never the weak link. The unglamorous classical embedding step was.

## My numbers against the published band

| Metric | My recreation | Paper's reported band |
| --- | --- | --- |
| Mean E\_bind (9 pairs) | −286 kcal/mol | ≈ −134 to −380 kcal/mol |
| Direction | Strongly bound tritium | Strongly bound tritium |
| ext-SQD vs FCI (solver error) | ≤ 0.7 kcal/mol | Comparable order |
| Embedding bias vs full-molecule | ~110 kcal/mol | Dominant error source |
| SQD fragments solved | 108 | All M ≥ 13 |

The mean landed inside the published range and the direction matched exactly, which is the qualitative result that actually matters. It is not a quantitative table match — my proxy geometries weren't the paper's exact AIMD-sampled structures, so the specific numbers were never going to line up atom-for-atom.

## Real IBM hardware, twice

Everything above can run on a simulator. I wanted the real thing too, and it took two attempts.

The first job went to `ibm_marrakesh` — job `d9kuplqbr2fc73e7u0g0` — and sat in queue for about 30 minutes before hitting my own 1,800-second queue ceiling and getting cancelled. Zero actual QPU time was burned; it never got past waiting in line. The lesson was blunt: the backend with the least-pending queue beats the backend with the biggest marketing qubit count, every time.

The second attempt went to `ibm_fez` instead. A 26-qubit LUCJ circuit (the M=13 fragment), transpiled to a depth of 752 with 1,170 two-qubit gates, 4,096 shots, submitted through Qiskit Runtime's SamplerV2. Total wall time 64.3 seconds, with 38.2 seconds actually in the RUNNING state — well inside my 120-second budget, kill switch never triggered. The fragment energy came back at −52.126 Hartree on hardware versus −52.117 Hartree in noiseless simulation, a difference of about 5.6 kcal/mol. That's real hardware noise, and it's a small, honest gap — nowhere near enough to change the qualitative conclusion, but a useful reminder that noiseless simulation and a real chip are not interchangeable numbers.

## The honest scoreboard

| Claim | Status |
| --- | --- |
| Same chemistry (FLiBe / tritium / anion stoichiometry) | ✅ Yes |
| Same method family (EWF + LUCJ + SQD) | ✅ Yes |
| Same basis set (6-31+G(d)) | ✅ Yes |
| Same fragment split rule (FCI < 13, SQD ≥ 13) | ✅ Yes |
| Qualitative "tritium strongly bound" direction | ✅ Yes |
| Real IBM Sampler hardware path | ✅ Yes |
| Exact paper AIMD cluster geometries | ❌ No — proxy structures |
| Full M≈33 / 66-qubit fragment coverage | ❌ No — largest fragments skipped |
| Paper's full shot campaign (10⁵–10⁶ shots) | ❌ No — 4,096 shots, one job |
| Complete EWF binding-energy reconstruction tables | ~ Partial — RHF-level binding only |

## What this actually teaches

I didn't discover new fusion chemistry, and I didn't run the paper's full computational campaign — nobody should read a solo recreation as replacing peer-reviewed national-lab work. What I did confirm, end to end, on my own infrastructure, is that this exact pipeline — Hartree-Fock, embedded wave function fragmentation, a classical FCI/CCSD ladder, LUCJ circuits, sample-based quantum diagonalization, and a real IBM chip at the end — runs correctly and reproduces the paper's central, slightly humbling lesson: in quantum-centric chemistry, right now, the embedding decision matters more than the qubit count. Getting the cut right is the hard part. The quantum computer is just very good at the part that's left over once you've cut correctly.

Every phase, every fragment Hamiltonian, every job ID, and the seven-episode "Salt Keepers" learning story I wrote alongside it are in the full notebook: [**FLiBe Fusion Blanket Chemistry — full interactive lab notebook**](https://artifacts.omlabs.co/s/flibe-fusion-blanket-chemistry-ornl-cleveland-clinic-ibm-quantum-recreation-1785410017498).