Spectral functions on a quantum computer through system-environment interaction

This paper introduces an efficient quantum algorithm that models system-environment interactions to measure spectral functions with an $O(N)$ reduction in sampling overhead compared to standard techniques, demonstrating its effectiveness on a 27-site system using 54 qubits on a Quantinuum ion-trap quantum computer.

The Gist

Imagine you are trying to understand the "musical notes" (energy levels) that a complex material can play. In the real world, scientists use a high-tech camera called ARPES (Angle-Resolved Photoemission Spectroscopy) to take a picture of these notes. To do this, they shoot light at the material, knocking electrons out, and then measure how fast and in what direction those electrons fly.

The problem is that simulating this process on a computer is incredibly hard. It's like trying to predict the sound of a symphony by listening to every single instrument one by one, in total silence, and then trying to guess the whole song. On a quantum computer, the old way of doing this was like asking a musician to play one note, stop, reset, play the next note, stop, and reset again. If you have 1,000 instruments (or "sites" in the material), you have to repeat this process 1,000 times just to get one full picture. This takes forever and wastes a massive amount of time.

The New Idea: A "Fake" Environment

The authors of this paper came up with a clever shortcut. Instead of asking the computer to calculate the notes one by one, they decided to simulate the actual experiment directly on the quantum computer.

Think of it like this:

• The System: This is the material you want to study (the orchestra).
• The Environment: This is the "camera" or the "vacuum" that catches the electrons (the audience).

In their new method, they connect the "orchestra" to a "fake audience" (an environment) inside the computer. They let the orchestra interact with this audience for a short time. Then, instead of measuring the orchestra directly, they simply look at the audience to see who caught a note.

Because the audience is connected to the whole orchestra at once, one single measurement tells them the "notes" for the entire orchestra simultaneously.

The Big Win: Speed and Efficiency

The paper claims this is a game-changer for a specific type of quantum computer called an ion-trap computer (which uses trapped atoms as qubits).

• The Old Way: To get a clear picture, you might need to take 1,000 photos (measurements) because the camera is slow and blurry.
• The New Way: You only need one photo.

The authors say this saves a massive amount of time. If the old method took 100 hours, this new method might take just 1 hour. They call this an O(N) improvement, meaning if you double the size of the material you are studying, the old method gets twice as slow, but this new method stays just as fast.

The Catch: You Need More "Qubits"

There is a trade-off. To pull off this trick, you need to double the number of "qubits" (the basic units of the quantum computer) because you have to simulate both the material and the fake environment. It's like needing a bigger room to hold both the band and the audience. However, the authors argue that for these specific computers, saving time on measurements is much more important than having a few extra qubits.

The "Magic" Trick: The Fermionic Fourier Transform

To make the "fake audience" work, the computer has to perform a complex mathematical dance called a Fermionic Fourier Transform (FFT). Imagine shuffling a deck of cards so that all the hearts are together, all the spades are together, etc., but doing it in a way that respects the weird rules of quantum particles (fermions).

The authors didn't just use a standard shuffle; they invented a more efficient way to shuffle these specific quantum cards, especially for a setup where the number of cards isn't a power of 2 (like 27 cards). They tested this shuffle on a real machine (Quantinuum's H2) and proved it works.

The Real-World Test

The team didn't just write theory; they ran the experiment on a real quantum computer with 54 qubits (27 for the material, 27 for the environment). They successfully measured the "spectral function" (the musical notes) of a 27-site chain of particles.

Even though the real computer has some "noise" (like static on a radio), the results were clear enough to see the main features of the material. The "noise" made the signal a bit fainter, but it didn't distort the shape of the notes, meaning the physics they were looking for remained accurate.

Summary

In short, this paper introduces a new way to simulate how materials interact with light. By simulating the entire experiment (system + environment) at once, rather than calculating parts of it separately, they can get the answer N times faster (where N is the size of the system). This makes it much more practical to study large, complex materials on today's quantum computers, specifically the ion-trap kind.

Technical Summary

Problem Statement
Spectral functions, measured via angle-resolved photoemission spectroscopy (ARPES), are critical for elucidating the band structure of materials. Theoretically, these functions correspond to dynamical one-point functions in an equilibrium state. While classically challenging to compute, their measurement on quantum computers faces significant hurdles. Standard approaches, which involve computing dynamical correlations $\langle c^\dagger_j(t)c_0(0)\rangle$ and performing Fourier transforms, suffer from a large sampling overhead. Specifically, because the operators $c_j + c^\dagger_j$ for different sites $j$ do not commute, only one correlation can be measured per shot. To reconstruct the spectral function for all $N$ momenta, this necessitates a sampling overhead of $O(N)$. This is particularly problematic for ion-trap quantum computers, which possess high gate fidelity and connectivity but relatively slow shot times, making the $O(N)$ shot count a bottleneck for utility-scale applications.

Methodology
The authors propose a method to measure spectral functions $A(k, \omega)$ directly by modeling the physical interaction between the system and the environment as it occurs in ARPES experiments. The approach involves:

1. System-Environment Coupling: The system of interest (Hamiltonian $H_{sys}$) is coupled to an environment of $N$ sites (Hamiltonian $H_{env}$) via an interaction term $H_{int}$. The total Hamiltonian is $H = H_{sys} + \epsilon H_{int} + \omega H_{env}$.
2. State Preparation and Evolution: The system is initialized in an eigenstate $|E\rangle$ of $H_{sys}$, while the environment is initialized in a vacuum state $|0\rangle$ (for $A_+$) or a fully filled state $|all\rangle$ (for $A_-$). The total system evolves under $H$ for a fixed time $t$.
3. Measurement: Instead of measuring dynamical correlations, the protocol measures the momentum occupation number $n(k)$ on the environment. This requires performing a fermionic Fourier transform (FFT) on the environment qubits at the end of the evolution, followed by measuring local $Z$ Pauli matrices.
4. Theoretical Result: In the limit of weak coupling ($\epsilon \to 0$) and long time ($t \to \infty$), the expectation value $\langle n(k) \rangle$ is proportional to the spectral function $A(k, \omega)$ (convolved with a kernel that approaches a delta function as $t \to \infty$).
5. Fermionic FFT Implementation: To handle arbitrary system sizes (specifically $N=27$), the authors develop an efficient gate decomposition for a generic radix-$n$ fermionic FFT. They utilize a recursive structure involving "interleave" operations to make non-adjacent fermionic modes adjacent for the transform, optimized using graph decimation techniques for all-to-all coupled architectures.

Key Contributions

• Efficient Sampling: The primary contribution is a reduction in sampling overhead. By measuring the environment's momentum occupation, the method obtains spectral data for all $N$ momenta $k$ in a single shot, reducing the required number of shots by a factor of $O(N)$ compared to standard dynamical correlation approaches.
• Runtime Improvement: This shot reduction translates to an $O(N)$ improvement in overall runtime, which is crucial for platforms like ion-trap quantum computers where shot time is the limiting factor.
• Robustness to Trotter Error: The authors argue that their approach is more robust to time-evolution errors (Trotterization) than standard methods. While standard methods can yield unphysical negative values for spectral functions due to errors, the proposed method measures an occupation number, which remains a positive quantity even with imperfect evolution.
• Hardware Benchmarking: The authors implemented a radix-3 fermionic FFT on 27 qubits and benchmarked various compilation strategies (local CZs, CX ladders, graph decimation) on Quantinuum's H2-1 and H2-2 ion-trap systems. They identified the $\log_2(N)$ scaling compilation as providing the lowest energy and infidelity.
• Full Algorithm Demonstration: The complete algorithm was demonstrated on a 54-qubit system (27 system sites + 27 environment sites) on the Quantinuum H2-2 hardware, successfully computing the spectral function of a 1D free-fermion Hamiltonian.

Results

• Hardware Performance: On the H2-2 hardware, the method successfully reproduced the shape of the spectral band for a 27-site system. While hardware noise caused a general attenuation of the signal (a "noise floor" near 0.5), the physical features, such as band positions and widths, remained unbiased.
• Error Analysis: Comparisons with exact simulations showed that the proposed method achieves the same precision with significantly fewer Trotter steps than the standard dynamical correlation approach, particularly for small coupling $\epsilon$.
• Cost Analysis: For the specific 27-site experiment, the method incurred a two-qubit gate overhead (due to the environment and FFT) but saved a factor of $\sim 27$ in the number of shots. The authors estimate that without this method, the total runtime cost would have been approximately 11 times higher for the same precision.
• Finite Coupling Effects: Theoretical analysis and free-fermion simulations indicate that finite coupling $\epsilon$ introduces band broadening and "ghost bands." However, for $\epsilon t \lesssim \pi$, these effects are negligible, and the method faithfully approximates the spectral function.

Significance
The paper claims that this approach fundamentally improves the scalability of computing spectral functions on quantum computers. By trading a qubit and gate overhead for a massive reduction in sampling requirements, the method addresses a critical bottleneck for ion-trap quantum computers. The authors posit that as system sizes increase toward the utility scale (hundreds or thousands of sites), the $O(N)$ reduction in shots will become a decisive factor in the practical feasibility of simulating material properties on quantum hardware. The work also provides a concrete, efficient implementation of fermionic Fourier transforms for non-power-of-two system sizes, a necessary component for simulating realistic material models.