Nuclear Many-Body Systems as Benchmarks for Quantum Computing

Alessandro Baroni; Ermal Rrapaj; Sota Yoshida; Takayuki Miyagi

Nuclear physics gets a quantum benchmark suite with first cost estimates

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · glm-5.2

2026-07-10 01:00 UTC pith:IT5YRQXE

load-bearing objection Useful benchmarking framework for nuclear many-body quantum computing, but headline scaling exponents omit Trotter step growth, making large-system T-gate counts misleading. the 2 major comments →

arxiv 2607.08047 v2 pith:IT5YRQXE submitted 2026-07-09 quant-ph nucl-th

Nuclear Many-Body Systems as Benchmarks for Quantum Computing

Sota Yoshida , Alessandro Baroni , Takayuki Miyagi , Ermal Rrapaj This is my paper

classification quant-ph nucl-th PACS 21.60.Cs03.67.Lx03.67.Ac

keywords quantum computingnuclear structurechiral effective field theoryresource estimationT-gate countJordan-Wigner transformationQuantum Phase EstimationQuantum Krylov

verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper builds a software pipeline that takes realistic nuclear forces—derived from chiral effective field theory, including two-body and selected three-body interactions—and converts them into qubit Hamiltonians via the Jordan-Wigner transformation. It then feeds these encoded Hamiltonians into three quantum eigenvalue algorithms—Quantum Phase Estimation (QPE), Quantum Krylov subspace methods (QKrylov), and Observable Dynamic Mode Decomposition (ODMD)—and counts the T-gates each algorithm would need on a fault-tolerant quantum computer. The result is a set of scaling curves showing how quantum cost grows with the number of qubits (equivalently, the number of single-particle states) across valence-space shell model and no-core shell model problem classes. The central finding is a concrete hierarchy: ODMD is the cheapest in T-gate count, QKrylov is the most expensive due to measurement overhead, and Qubitization-based QPE outperforms Trotter-based QPE by roughly one order of magnitude. For valence-space systems at the scale of hundreds of qubits, QPE requires 10^10 to 10^14 T-gates—a range comparable to early estimates for the FeMoco molecule in quantum chemistry, suggesting nuclear physics problems sit at a similar level of quantum-computational difficulty.

Core claim

The paper's core contribution is a unified, reproducible workflow—implemented as an open-source software library—that bridges nuclear structure theory and quantum algorithm resource estimation, and the first systematic comparison of three eigenvalue algorithms under that shared cost model. The scaling laws it extracts (T-gate counts scaling as N_q^3.4 for valence NN, up to N_q^12.1 for no-core NN+3N in QKrylov) provide a quantitative baseline against which future algorithmic improvements for nuclear many-body problems can be measured. The comparison between Trotterization and Qubitization primitives, showing the latter is roughly 10x more efficient for QPE on nuclear Hamiltonians, is a key实用

What carries the argument

The central mechanism is the Jordan-Wigner encoding of second-quantized nuclear Hamiltonians (with up to three-body terms) into Pauli strings, combined with a T-gate cost model that counts: (1) the number of non-commuting Pauli-string pairs for Trotter error bounds, (2) a heuristic measurement-grouping reduction factor of ~3 for QKrylov, and (3) the LCU normalization λ_H for Qubitization-based estimates. The scaling of T-gate counts is driven by the combinatorial growth of Hamiltonian terms—roughly N_q^3.6 for NN and N_q^5.4 for 3N interactions in the M-scheme—which propagates through each algorithm's circuit structure (controlled time evolution for QPE, overlap and matrix-element circuits Q

Load-bearing premise

The cost model assumes that a single Trotter time step keeps the total Trotter error within target tolerance, and that a heuristic measurement-grouping reduction factor of 3 and a phenomenological saturation-based estimate of Hamiltonian coefficients hold across all system sizes. These assumptions are validated only for small systems (up to ~80 qubits), and the extrapolation to hundreds of qubits relies on scaling arguments that are not rigorously bounded.

What would settle it

If the Trotter error grows faster than the phenomenological N_q^4.6–N_q^8.1 scaling suggests (for instance, if non-commuting term pairs grow superlinearly with system size), the required number of Trotter steps—and hence the T-gate counts for Trotter-based QPE, QKrylov, and ODMD—would be substantially higher than projected, potentially erasing the apparent advantage of Qubitization or the cost hierarchy among algorithms.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

Algorithmic improvements in state preparation, measurement grouping, and Hamiltonian simulation could reduce the 10^10–10^14 T-gate estimates for nuclear QPE by orders of magnitude, as has happened for quantum chemistry benchmarks.
The scaling gap between NN-only and NN+3N interactions (e.g., N_q^3.7 vs N_q^6.1 for no-core QPE Trotter) quantifies the additional quantum cost of including three-body forces, which is essential for nuclear physics accuracy but absent from most quantum chemistry benchmarks.
The software pipeline can be extended to test emerging quantum-classical hybrid methods (e.g., quantum-selected configuration interaction) against established classical nuclear structure methods like the Monte Carlo Shell Model.
The Trotter error bounds, currently validated only for small systems, need rigorous extension to hundreds of qubits; if the phenomenological saturation-based estimates break down, the Trotter-step cost could be substantially higher than projected.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

If the scaling trends hold, the crossover point where quantum algorithms become competitive with classical nuclear structure methods (e.g., no-core shell model for A≳20) likely requires hundreds to thousands of logical qubits with T-gate counts in the 10^12–10^16 range—placing meaningful nuclear physics beyond early fault-tolerant hardware but within reach of mature fault-tolerant architectures.
The finding that Qubitization outperforms Trotterization by ~10x for nuclear Hamiltonians suggests that block-encoding-based methods may be even more advantageous for 3N interactions, where the commutator structure is more complex and the Trotter error grows faster (N_q^8.1 vs N_q^5.2 for NN-only in no-core).
The framework could be extended to scattering and reaction problems, where the relevant Hilbert spaces and spectral properties differ qualitatively from bound-state structure calculations, potentially requiring different algorithmic strategies than those benchmarked here.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Desk Editor's Note

Useful benchmarking framework for nuclear many-body quantum computing, but headline scaling exponents omit Trotter step growth, making large-system T-gate counts misleading.

read the letter

This paper introduces NuQuLib, a software framework that bridges realistic nuclear Hamiltonians (ChEFT, valence-space, NCSM, including 3N forces) to qubit encodings and quantum algorithms. The main value is infrastructure: a reproducible pipeline from nuclear structure inputs to Jordan-Wigner-encoded Hamiltonians, cost formulas for QPE/QKrylov/ODMD, and small-scale demonstrations that validate the workflow end-to-end. The code is public, which is a real plus. The cost formulas in Table II and Appendix A are clearly derived, and the comparison of Trotter vs. Qubitization for QPE is a useful first cut. The scaling exponents they report (N_q^3.4 for valence NN, N_q^6.1 for NCSM NN+3N) come from combinatorial term counting, not data fitting, so they are structurally sound as far as they go. The paper is also honest about its simplifications, which I appreciate. The soft spot is real but specific: the headline scaling exponents in Figure 6 assume a single Trotter step per unit time evolution, but their own Figure 7 shows the Trotter error bound B grows as N_q^4.6 to N_q^8.1. For first-order Trotterization, the number of steps r needed to hold error fixed scales as r ~ t*B/epsilon, which would multiply the T-gate count by an additional N_q^4.6 to N_q^8.1. This means the actual scaling for valence-space QPE would be closer to N_q^8 rather than N_q^3.4, and NCSM NN+3N would be N_q^12 or worse. The paper acknowledges this qualitatively but does not fold it into the headline numbers. Similarly, the '~10x advantage' of Qubitization over Trotterization (panels c,d) is not constant — Eq. C25 shows the ratio scales as B/lambda_H ~ N_q^2.6, so the crossover point is system-size-dependent. The measurement grouping factor of 3 (Eq. 12) and the saturation-based coefficient estimation (App. B) are empirical and validated only on small systems, but these are secondary issues. None of this invalidates the framework. The cost formulas, the code, and the workflow are the contribution. The specific T-gate counts for large systems should be read as lower bounds or order-of-magnitude estimates, not predictions. This is a solid infrastructure paper that deserves a serious referee who can push on whether the Trotter step issue should be addressed more prominently in the scaling claims.

Referee Report

2 major / 7 minor

Summary. This manuscript introduces NuQuLib, a software framework that bridges realistic nuclear Hamiltonians (from chiral EFT or phenomenological models) with quantum computing algorithms via Jordan-Wigner encoding. The paper defines benchmark problem classes spanning valence-space and no-core shell model formulations with NN and selected 3N interactions, and provides T-gate-count resource estimates for three eigenvalue algorithms: Quantum Phase Estimation (QPE), Quantum Krylov methods (QKrylov), and Observable Dynamic Mode Decomposition (ODMD). The cost model is based on first-order Trotterization for the time-evolution primitive, with a qubitization-based QPE comparison included. The main results (Fig. 6) show that ODMD is least resource-intensive, QKrylov most expensive, and qubitization-based QPE is roughly one order of magnitude more efficient than Trotter-based QPE. Small-scale demonstrations on classically simulable systems (Sec. VI) validate the workflow end-to-end, including QPE on 3n and 6He, QKrylov/ODMD on 20O, angular-momentum-projection state preparation on 18O, and a VQE example. The NuQuLib code is publicly available, which strengthens reproducibility.

Significance. The paper addresses a genuine gap: unlike quantum chemistry, nuclear physics lacks a standardized benchmarking infrastructure for quantum algorithms. The unified workflow from nuclear interactions to qubit-encoded Hamiltonians to quantum circuits is a useful contribution, and the public NuQuLib implementation is a concrete deliverable. The systematic comparison of three eigenvalue algorithms under a shared cost model, the inclusion of 3N interactions (which substantially increase Hamiltonian term counts), and the analysis of both valence-space and no-core formulations provide a meaningful baseline for future work. The cost formulas (Table II, App. A) are derived transparently from combinatorial term counting and standard algorithmic structure, without fitted parameters. The Trotter error analysis (App. B, Table III, Fig. 7), while heuristic for large systems, is validated against exact commutator bounds for small spaces. The paper also discusses block-encoding alternatives (App. C) including qubitization and QSVT, and provides an illustrative crossover analysis (Fig. 13).

major comments (2)

Section V.C and Figure 6: The headline scaling exponents (e.g., N_q^3.4 for valence QPE, N_q^6.1 for NCSM NN+3N) are derived purely from the scaling of the number of Hamiltonian terms N_H with N_q, since the algorithmic factors (2^{N_a}, N_iter, N_snap) are held fixed and the cost per Trotter step is T_U = N_H * T_epsilon. However, the Trotter error bound B shown in Fig. 7 scales as N_q^{4.6} to N_q^{8.1}. For first-order Trotterization over total time t, the number of steps r needed for error epsilon scales as r ~ t*B/(2*epsilon), adding a multiplicative factor of N_q^{4.6}--N_q^{8.1} to the T-gate count. This would change the valence-space QPE scaling from N_q^{3.4} to approximately N_q^{8} and the NCSM NN+3N scaling from N_q^{6.1} to N_q^{12} or worse. The paper acknowledges this issue qualitatively in Sec. V.A ('we assume the time duration delta_t to be small enough for the overall T
Section V.C, panels (c,d) of Figure 6, and Eq. (C25): The claim that qubitization-based QPE is '~10x more efficient' than Trotter-based QPE is presented as a roughly constant factor. However, Eq. (C25) shows the ratio T_Trotter/T_Qubitization is proportional to B/lambda_H, and Fig. 13 indicates B/lambda_H scales as N_q^{2.6}. This means the advantage of qubitization grows with system size rather than being a constant factor. The '~10x' statement in the text (Sec. V.C: 'we find the latter to be more efficient by about one order of magnitude') is thus system-size-dependent and could be significantly larger for hundreds of qubits. The authors should clarify that the 10x factor corresponds to specific small-to-moderate system sizes and that the crossover behavior is captured by the scaling of B/lambda_H shown in Fig. 13. The current phrasing risks being read as a size-independent claim.

minor comments (7)

Equation (12): The measurement grouping reduction factor of 3 is described as based on 'numerical experiments for smaller model spaces.' Since this factor enters the QKrylov cost linearly, it would help to state the range of model spaces tested and whether the factor shows any systematic drift with N_q, even if the authors believe it is stable.
Table III: The reduction factor N_red is stated to be 'fixed to 2 for all model spaces' in the Trotter error estimates, but the table itself shows N_red values ranging from 2.0 to 5.6 for different interactions. The relationship between the table values and the fixed value used in extrapolation should be clarified.
Figure 6 caption: The phrase 'The symbols without edge' is unclear; presumably this refers to open vs. filled symbols or similar. The caption should describe the visual encoding more precisely.
Section V.A: The assumption T_cU = 2*T_U for controlled time evolution is stated as a simplification. While reasonable for a scaling analysis, a brief justification or reference for this factor would strengthen the cost model, especially since controlled versions of Trotter steps can have different overhead depending on compilation.
Section VI: The Trotter order is set to 4 with 10 steps for the demonstrations, but the resource estimates in Sec. V use first-order Trotter. A brief note on why different orders are used for demonstration vs. estimation would help the reader reconcile the two.
Reference [22] (Gu et al.) and [23] (Gibbs et al.) are cited as recent cutting-edge works, but [22] is listed as Phys. Rev. C113, 034321 (2026) and [23] as arXiv:2603.11156. If these are genuinely 2026 works, the citation format is fine; if these are forward-dated, the references should be corrected.
The abstract states 'selected three-body (3N) interactions' but does not specify what 'selected' means. A brief parenthetical (e.g., 'at N3LO in chiral EFT' or 'with E3max truncation') would set expectations.

Circularity Check

0 steps flagged

No circularity found: resource estimates derive from combinatorial Hamiltonian structure and standard algorithmic cost formulas, with no self-referential reduction

full rationale

The paper's derivation chain is self-contained. The scaling exponents in Fig. 6 (e.g., N_q^3.4 for valence QPE, N_q^6.1 for NCSM NN+3N) follow directly from combinatorial term counting of nuclear Hamiltonians (NN bounded by N_q^4, 3N by N_q^6, with symmetry-reduced actual scaling ~3.6 and ~5.4 from Fig. 2) combined with standard quantum algorithm cost formulas (Table II: T_U = N_H × T_ε, with algorithmic factors held fixed). No parameter is fitted to data and then presented as a prediction. The Trotter error analysis (App. B) uses the phenomenological saturation property of nuclear binding energy (~8 MeV/nucleon) as an external physical input, not a circular one. The Qubitization vs. Trotter comparison (Eq. C25, ratio ∝ B/λ_H) is derived from independently computable quantities. Self-citations (Ref [97] for QPF, Ref [88] for hard-core boson mapping, Ref [26] for NuQuLib) appear in demonstration sections or as implementation tools, not as load-bearing theoretical premises. The skeptic's concern that Trotter step count is excluded from headline exponents is a valid completeness concern but is not circularity: the paper separately analyzes Trotter error growth (Fig. 7, Table III) and does not define any quantity in terms of itself. The scaling exponents are explicitly per-unit-time-evolution with fixed algorithmic parameters, not claimed as total end-to-end costs including Trotter repetition. No step reduces to its own inputs by construction.

Axiom & Free-Parameter Ledger

8 free parameters · 6 axioms · 1 invented entities

The free parameters are mostly heuristic choices for cost estimation rather than physically fitted constants. The key ad-hoc assumptions (Trotter step size, grouping factor, coefficient saturation) are clearly stated but validated only for small systems, creating uncertainty in large-system extrapolation.

free parameters (8)

T_epsilon (T-gate count per rotation) = 100
Assumed T-gate count for a single-qubit rotation gate with precision ~10^-10, based on Ref. [85]. Used as a fixed multiplier in all T-count estimates (Sec. V.A).
N_circ reduction factor = 3
Heuristic measurement grouping reduction factor from total Hamiltonian terms, based on numerical experiments for smaller model spaces (Eq. 12, Sec. V.A). Applied uniformly to all system sizes.
N_red (non-commuting pairs reduction factor) = 2
Fixed reduction factor for non-commuting pairs of Hamiltonian terms in Trotter error estimation, assumed constant across all model spaces (Sec. V.D.1, Table III).
delta_t (Trotter time step) = 0.01
Fixed time step for QPE resource estimates, chosen to cover ~628 MeV energy range (App. A.1). Not validated against actual Trotter error for large systems.
N_a (ancilla qubits for QPE) = 10 or 20
Number of ancilla qubits for inverse QFT in QPE, set to 10 (MeV precision) or 20 (keV precision) for illustration (Sec. V.C).
N_iter / N_snap = 50
Krylov subspace dimension (QKrylov) and number of snapshots (ODMD), set to 50 for illustration purposes (Sec. V.C).
h_tilde_Z (typical diagonal coefficient) = ~8*N_q/N_HZ MeV
Phenomenological estimate of typical diagonal Hamiltonian coefficient based on nuclear binding energy saturation (~8 MeV/nucleon). Used in SBE Trotter error bound (App. B).
h_tilde_ND (typical off-diagonal coefficient) = ~0.8*N_q/N_HZ MeV
Assumed one order of magnitude smaller than diagonal terms. Used in SBE Trotter error bound (App. B).

axioms (6)

standard math Jordan-Wigner encoding faithfully represents fermionic nuclear Hamiltonians on qubits
Standard fermion-to-qubit mapping used throughout (Sec. III.D). Well-established in quantum computing literature.
domain assumption Efficient initial state preparation is possible
Sec. V.A: 'we simply assume that it can be done efficiently unless explicitly stated otherwise.' This is a major assumption for QPE performance.
ad hoc to paper Single Trotter step achieves error within target tolerance at delta_t=0.01
Sec. V.A: 'we assume the time duration δt to be small enough for the overall Trotter error to be under control.' Validated only for small systems (Table III).
ad hoc to paper Measurement grouping reduction factor of 3 holds for all system sizes
Eq. 12 and Sec. V.A: reduction factor derived from 'numerical experiments for smaller model spaces' and applied uniformly.
domain assumption Nuclear interaction coefficients saturate (binding energy ~8 MeV/nucleon)
App. B: phenomenological assumption used to estimate typical Hamiltonian coefficients without explicit generation.
ad hoc to paper T_cU = 2*T_U (controlled time evolution costs twice uncontrolled)
Sec. V.A and Table II: simplifying assumption for controlled vs. uncontrolled gate cost.

invented entities (1)

NuQuLib software framework independent evidence
purpose: Bridge between nuclear structure codes and quantum computing backends; generates qubit-encoded Hamiltonians and quantum circuits
Publicly available on GitHub and Zenodo (Ref. [26]) with demonstration codes. Can be independently tested.

pith-pipeline@v1.1.0-glm · 41812 in / 3322 out tokens · 363914 ms · 2026-07-10T01:00:20.805122+00:00 · methodology

0 comments

read the original abstract

We present a framework for benchmarking quantum algorithms for nuclear many-body systems based on realistic nuclear Hamiltonians such as chiral effective field theory. To this end, we introduce a workflow that maps nuclear interactions in second quantization formalism to qubit Hamiltonians. This enables the systematic construction of benchmark instances spanning no-core and valence-space formulations with two-body (NN) and selected three-body (3N) interactions. Then, we proceed to provide resource estimates for three representative eigenvalue algorithms: Quantum Phase Estimation, Quantum Krylov methods, and Observable Dynamic Mode Decomposition. We compare their resource requirements in terms of T-gate counts and system size, and examine the impact of model-space choices and many-body interactions. The primitives included in our analysis are Trotterization, Qubitization, and Quantum Singular Value Transformation. Our results quantify scaling trends across algorithms and problem classes, and provide a basis for consistent comparisons of quantum approaches to nuclear many-body problems. The implementation is provided by the NuQuLib software stack.