Quantum Sampling Reaches a Nucleus Beyond a 768-GB Node's Memory
Quentir Defense Monitor
Evidence-based insights for quantum defense and security. Published by Quentir Systems LLC · August 18, 2026.
Magnesium-32 is a modest nucleus, twelve protons and twenty neutrons, and it has a habit of humbling the people who try to compute it. It sits in a region of the nuclear chart called the island of inversion, where the tidy ordering of nucleon orbits breaks down and the ground state defies textbook rules. To describe it honestly, a calculation has to let protons and neutrons roam across a large set of orbitals at once, and the number of configurations that bookkeeping produces grows exponentially. On August 17, three physicists at the Indian Institute of Technology Roorkee reported something worth a defense reader's attention: they computed this nucleus by pulling candidate configurations out of an IBM quantum processor, after their 768-gigabyte PARAM Ganga node ran out of memory trying to do the job the classical way.
The paper by Durgesh Pandey, Ankit Kumar Das, and P. Arumugam applies a technique called sample-based quantum diagonalization to the nuclear shell model, by their account for the first time. The result is early and small, and it carries error bars a nuclear data evaluator would wince at. It is also a clean demonstration of a specific capability class: using a noisy quantum processor as a configuration sampler to push a nuclear structure calculation past the memory ceiling of a classical machine. That capability class has an obvious customer in every nuclear weapons enterprise, which is why the paper deserves a closer reading than its quiet posting suggests.
A memory wall, not a speed wall
The nuclear shell model is the workhorse theory of nuclear structure. It treats a nucleus the way quantum chemistry treats a molecule: valence protons and neutrons occupy single-particle orbitals, they interact through an effective force, and the physical states emerge from diagonalizing a matrix whose basis is every allowed arrangement of those particles. The trouble is the size of that basis. For magnesium-32 in the model space the Roorkee team used, 48 single-particle states are in play, so the unrestricted space holds 2^48 arrangements, and even after enforcing the right particle numbers the working space still holds on the order of 2^35 configurations.
What kills the classical calculation is memory rather than time. The team ran on a high-memory node of PARAM Ganga, the supercomputer at IIT Roorkee, with 768 gigabytes of RAM. Exact diagonalization agreed with the smaller-space results through 36 spin-orbitals, became memory-limited in accuracy at 40, and died with an out-of-memory error at 44 and 48. The community has spent decades building truncation schemes and clever approximations to live inside that wall, and every truncation is a place where the answer can quietly go wrong. A method that changes how the memory demand scales matters more to this field than a method that merely runs faster.
What the quantum computer actually did
Sample-based quantum diagonalization, described plainly in IBM's technical explainer, splits the work in two. The quantum processor prepares a rough trial state that overlaps with the true ground state and is then measured many times, with each measurement returning a bitstring that names one configuration of particles in orbitals. The classical computer collects those sampled configurations, discards the corrupted ones through a recovery step that exploits particle-number conservation, projects the Hamiltonian into the subspace the good samples span, and diagonalizes that much smaller matrix. The quantum machine never has to hold or optimize the full solution. It only has to be a good guesser of which configurations matter, and the noise that wrecks deep variational circuits mostly produces bad samples that the recovery step filters out.
The honest numbers are the point of the paper. On argon-38, a benchmark nucleus small enough to solve exactly, the classical answer for the ground state is a binding energy of 152.677 MeV, and the SQD run on noisy hardware landed at 152.144 MeV with an uncertainty of about 0.4 MeV, placing the SQD ground-state energy 0.533 MeV above the exact model-space result. The same job that took a variational quantum eigensolver hundreds of seconds of iterative back-and-forth had a reported SQD time-to-solution estimate of 3.16 seconds. On the frontier calculation, magnesium-32 across all 48 spin-orbitals, the method produced an unconverged approximate ground-state energy of -102.445(7432) MeV, versus the cited experimental -122.012 MeV, in a space exact diagonalization on that node could not reach. The team ran on IBM's cloud hardware and compared generations directly, finding the newer Heron-class processor close to 3.5 times faster than the older Eagle class for this workload. A memory bottleneck was sidestepped by renting a sampler, and that is achievement enough.
Quantum pillar: simulation (nuclear and radiation effects). Use posture: dual-use. Technology readiness: TRL 3 of 9. The scheme ran end to end on real IBM Heron and Eagle processors against a benchmark nucleus and one frontier case, an experimental proof of concept whose result remains unconverged and roughly 20 MeV from the cited experimental value.
Why nuclear structure is a defense workload
Since the United States stopped explosive nuclear testing in 1992, its confidence in the stockpile has rested on simulation. The Department of Energy says so directly: supercomputers under the Advanced Simulation and Computing program let scientists examine weapon design, safety and performance in nanosecond slices, standing in for the observations that live testing once provided. Those weapons codes do not conjure their physics from nothing. They draw on libraries of evaluated nuclear data, cross sections, level schemes and transition strengths, curated in files like the ENDF library maintained at Brookhaven. Where experiments are impossible or nuclei are too short-lived to measure, those evaluations lean on structure theory, and the shell model carries much of that load.
Read as capability, the chain is short. Better shell-model reach means better nuclear data for the nuclei that cannot be measured. Better nuclear data feeds radiation transport, and radiation transport is how a force predicts weapon outputs, hardens its electronics and warheads against an adversary's radiation environments, models detector response for treaty monitoring and interdiction, and attributes seized material in nuclear forensics. A method that extends the trustworthy core of shell-model calculations serves the offensive side of that ledger, the effects modeling, and the defensive side, the hardening and the forensics, with the same arithmetic. That is the textbook shape of a dual-use capability, and it diffuses by default: the method is published, the classical half runs on a single fat node, and the quantum half is rentable by the hour on commercial cloud hardware, subject to account access, geography and export controls. Nothing about this capability waits for a national quantum program.
The caveat that keeps the reading honest runs the other way. The Roorkee team hit their wall at 768 gigabytes. The weapons laboratories run machines like El Capitan with memory measured in petabytes, so the wall arrives much later for them. What the paper demonstrates is where the wall stands for a university group with cloud access, and how far a sampler moves it. The interesting question for a program office is what the same trick does at the top end of classical computing, and that question is open.
What stands between a sampler and a weapons code
The distance is simple to state in numbers. A half-MeV miss on a benchmark nucleus, and error bars of several MeV on the frontier one, sit well outside the accuracy requirements evaluators may set for particular nuclides, observables, applications and available evidence before a number enters a library that weapons codes consume. Production weapons codes carry pedigreed provenance for every input, and a subspace sampled from a noisy processor on someone else's cloud has none yet. There is no uncertainty quantification framework for SQD outputs of the kind evaluators require, no independent replication of the magnesium-32 result, and no demonstration yet on the odd, deformed, high-mass nuclei where the memory wall actually constrains the laboratories. Access is a dependency too: the sampler in this experiment belongs to IBM, and a defense program that cares about assured access would need either domestic hardware or a demonstration that the method transfers across processor families as easily as the paper's Heron-to-Eagle comparison hints.
None of those gaps is a reason to look away. They are a reason to date the capability correctly. Quantum processors already carry hundreds of qubits while this workload used a few dozen, the sampling step is exactly the kind of shallow-circuit job that near-term hardware does tolerably well, and the classical side of the pipeline is ordinary HPC that every nuclear enterprise already owns. The Roorkee result is what the bottom rung of a capability ladder looks like: a published recipe, commodity access, and a real calculation that classical exact methods on the same machine could not finish. Buyers who track quantum simulation for defense should log this one as the paper's claimed first application of SQD to the nuclear shell model, and should expect the next data point to come from a laboratory with a much bigger classical machine and a much quieter publication policy.
Sources
Primary source: Durgesh Pandey, Ankit Kumar Das, and P. Arumugam of the Department of Physics, Indian Institute of Technology Roorkee, "Scalable nuclear shell model calculations on noisy quantum computers," arXiv preprint, August 17, 2026. Supporting material from IBM Research's sample-based quantum diagonalization explainer, the U.S. Department of Energy on stockpile simulation, and the ENDF evaluated nuclear data library at Brookhaven National Laboratory.