⚛️ quantum physics

Dynamical structure factor with a pumping approach on a trapped-ion quantum computer

This paper demonstrates the feasibility of computing dynamical structure factors on a Quantinuum Reimei trapped-ion quantum computer by introducing a novel pumping approach that uses a time-dependent Hamiltonian to target specific frequencies, thereby significantly reducing shot overhead compared to previous methods.

Original authors: Etienne Granet, Keisuke Murota, Henrik Dreyer, Kentaro Yamamoto, Juan Pedersen, Hidemaro Suwa

Published 2026-07-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Etienne Granet, Keisuke Murota, Henrik Dreyer, Kentaro Yamamoto, Juan Pedersen, Hidemaro Suwa

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: Listening to the "Music" of Atoms

Imagine you have a giant, complex musical instrument made of atoms. To understand how this instrument works, scientists usually shine a beam of tiny particles (neutrons) at it and listen to how the sound bounces back. This "sound" tells them about the material's structure. In physics, this sound is called the Dynamical Structure Factor (DSF).

For a long time, calculating this "sound" on a regular computer has been like trying to predict the exact path of every single drop of rain in a hurricane. It's too messy and complex.

This paper describes a new way to do this calculation using a quantum computer (a super-powerful machine that uses the laws of quantum physics). The researchers successfully used a specific type of quantum computer (trapped ions) to simulate the "music" of a material called copper sulfate, and their results matched real-world experiments almost perfectly.

The Old Way vs. The New "Pumping" Way

The Old Way (The Slow Walk):
Previously, to find the "sound" of the material, scientists had to simulate the system moving forward in time, stop, measure it, move it forward a tiny bit more, stop, measure it again, and repeat this thousands of times. It's like trying to figure out the melody of a song by listening to one second of it, pausing, listening to the next second, pausing, and so on. You have to do this for every moment to reconstruct the whole song. This takes a huge amount of time and computing power.

The New Way (The Pumping Approach):
The authors invented a method they call "pumping." Instead of walking through time step-by-step, imagine you are trying to find the pitch of a specific note in a song. Instead of listening to the whole song, you play a specific tone (a "pump") that matches the note you are looking for.

The Analogy: Think of a child on a swing. If you want to make the swing go high, you don't push it randomly. You push it at the exact rhythm of its natural swing.
The Method: The researchers "push" the quantum system with a force that oscillates at a specific frequency (the note they want to hear). If the system has energy at that frequency, it "resonates" (swings high). By measuring how much the system responds to this specific push, they can directly calculate the "sound" at that frequency without having to simulate every single moment in between.

Why is this better?
If you only care about a few specific notes (frequencies), this method is incredibly efficient. It skips the long, boring walk through time and goes straight to the answer.

How They Did It (The Experiment)

The Setup: They used a quantum computer called Quantinuum Reimei, which uses trapped ions (charged atoms held in place by magnetic fields) as its "bits."
The Model: They simulated a 1D Heisenberg model. Think of this as a row of 20 magnets lined up next to each other, interacting with their neighbors. This model is famous because it describes the physics of copper sulfate crystals very well.
The Process:
- Preparation: First, they cooled the quantum system down to its lowest energy state (the "ground state"), similar to getting the swing to sit perfectly still before starting.
- The Pump: They applied their "pumping" force (the oscillating push) at specific frequencies.
- The Measurement: They measured how the system reacted.
The Result: They compared their quantum computer's output to two things:
- A perfect, noise-free simulation (the theoretical ideal).
- Real-world data from actual neutron scattering experiments on copper sulfate crystals.

The Outcome: The quantum computer's results matched the real-world copper sulfate data almost perfectly. Even better, they achieved this without needing complex "noise correction" tricks, which are usually required to fix errors in quantum computers.

The "Secret Sauce" and Limitations

The Trade-off: The "pumping" force has to be just right. If it's too weak, the signal is too quiet to hear (drowned out by static). If it's too strong, it distorts the sound. The researchers found a "Goldilocks" zone where the signal was clear but didn't break the simulation.
The Preparation Bottleneck: While the "pumping" part is scalable (can be done for bigger systems), getting the system ready (the ground state) currently required a classical supercomputer to help design the setup. The authors admit that for now, they used a classical computer to help set the stage, so they haven't yet shown a "quantum advantage" for the preparation part, only for the measurement part. However, they suggest that future methods could combine their approach with other classical techniques to handle even larger systems.

Summary

This paper demonstrates a new, efficient way to use a quantum computer to listen to the "vibrations" of materials. By using a "pumping" technique that targets specific frequencies directly, they bypassed the need for slow, step-by-step time simulations. They proved this works on real hardware by successfully simulating a copper sulfate crystal, matching real-world experimental data with high accuracy.

Technical Summary: Dynamical Structure Factor with a Pumping Approach on a Trapped-Ion Quantum Computer

Problem Statement
The dynamical structure factor (DSF), denoted as $S(q, \omega)$ , is a critical quantity in condensed matter physics that describes the response of a material to neutron scattering. It is defined as the space-time Fourier transform of dynamical correlations $\langle O(x, t)O(0, 0) \rangle$ . Computing the DSF is challenging for classical computers because it requires both finding a representation of the ground or thermal state and simulating Hamiltonian dynamics over time, a task generally considered BQP-hard. While quantum computers offer a pathway to prepare finite-temperature states and perform efficient Hamiltonian dynamics, existing quantum algorithms for computing $S(q, \omega)$ typically rely on calculating dynamical correlations at many discrete time points and subsequently performing a Fourier transform. This approach incurs significant shot overhead, particularly when only a few specific frequency values are of interest.

Methodology: The Pumping Approach
The authors introduce a "pumping approach" that directly targets specific frequency values $\omega$ without the need to compute time-domain correlations and perform a Fourier transform. The core of the method involves driving the system out of equilibrium using a time-dependent Hamiltonian perturbed by a source term oscillating at the target frequency.

Hamiltonian Setup: Given a system Hamiltonian $H$ and an observable $O$ , the authors define a time-dependent Hamiltonian:
$H(t) = H - \epsilon O(0) \sin(\omega(T - t))$
where $\epsilon$ is a coupling constant and $T$ is the final evolution time.
Measurement Protocol: The system is evolved from an initial equilibrium state (e.g., ground state) using this time-dependent Hamiltonian. The expectation value of a momentum-space operator $\hat{O}_q$ is measured at time $T$ .
Extraction of DSF: By measuring the system with coupling $+\epsilon$ and $-\epsilon$ , the DSF is extracted via the relation:
$S(q, \omega) \approx \frac{\langle \hat{O}_q(T) \rangle_\epsilon - \langle \hat{O}_q(T) \rangle_{-\epsilon}}{\epsilon(1 - e^{-\beta\omega})}$
This formula is derived from a first-order expansion in $\epsilon$ , leveraging the detailed balance relation for thermal states.
Implementation Details:
- State Preparation: For the 1D Heisenberg model, the ground state is prepared using an adiabatic-inspired ansatz. The system is initialized in a Néel state and evolved via a linear interpolation between a staggered-field Hamiltonian and the Heisenberg Hamiltonian. The parameters are optimized classically using statevector simulations on a 20-site chain and then applied to the hardware.
- Time Evolution: The time evolution operator is approximated using a Trotter decomposition. The circuit consists of sequential single-qubit and two-qubit gates (specifically TK2 gates on the Quantinuum hardware).
- Regularization: Since $T \to \infty$ is not feasible, a finite $T$ is used, which effectively convolves the true DSF with a sinc function, smoothing the result but potentially introducing spurious features.

Key Contributions

Direct Frequency Targeting: The primary contribution is a method that allows quantum computers to target specific arbitrary frequencies $\omega$ directly, avoiding the computational cost of sampling the entire time domain.
Shot Efficiency: The authors demonstrate that for scenarios requiring only a few frequency values, this approach offers a significant reduction in shot overhead compared to methods requiring time-domain correlation measurements.
Hybrid Implementation: The work presents a full implementation on the Quantinuum Reimei trapped-ion quantum computer, integrated within a Fugaku–Reimei hybrid quantum–HPC environment. The classical optimization of state preparation parameters is performed on the Fugaku supercomputer, while the quantum circuits are executed on Reimei.

Results
The authors validated the method using two cases:

1D Heisenberg Model (20 sites): The DSF was computed for a 20-site chain and compared against noiseless simulations. The hardware results showed excellent agreement with the noiseless simulations, achieved without any noise mitigation techniques.
Copper Sulfate Crystal ( $CuSO_4$ ): The 1D Heisenberg model is known to describe the magnetic excitations of copper sulfate crystals. The computed DSF was compared against experimental neutron scattering data. The results from the quantum hardware agreed very well with the experimental data.

Specific parameters used included a system size $L=20$ , a Trotter step size $dt=0.24$, a total evolution time $T=2.4$ , and a coupling $\epsilon=2$ . The ground state preparation utilized a single round ( $R=1$ ) of the optimized ansatz. The study noted that using a single layer of the ansatz actually yielded a smaller deviation from the exact ground state results than using two layers, likely due to gate count reduction.

Significance and Claims
The paper claims that this pumping approach provides a practical and efficient pathway for computing dynamical structure factors on near-term quantum hardware. By simulating a "toy model version of a neutron scattering experiment" directly, the method bypasses the need for complex real-time correlation calculations.

The authors highlight the potential relevance of this protocol beyond neutron scattering, specifically for Nuclear Magnetic Resonance (NMR) simulations. In NMR, spectra are often sharply localized at specific frequencies, and this method could offer significant runtime savings by sampling fixed frequencies rather than long time-domain decays.

Regarding scalability, the authors are modest about the current state of quantum advantage. They acknowledge that the state preparation in this work relied on classically optimized ansatzes derived from exact statevector simulations, a regime where no quantum advantage exists. However, they propose that combining their DSF algorithm with scalable classical state preparation methods (such as Sparse Pauli Dynamics or Matrix Product States via DMRG) within a hybrid framework could eventually lead to a regime where the joint task of state preparation and structure factor computation becomes challenging for classical computers alone.