Scattering phase shift in quantum mechanics on quantum computers: non-Hermitian systems and imaginary-time simulations

This paper proposes and validates two quantum algorithms—imaginary-time simulation of Hermitian systems and real-time simulation of non-Hermitian systems—that overcome fast oscillatory behavior in scattering phase shift extraction by utilizing block encoding and Hadamard tests to handle non-unitary evolution without mid-circuit measurements.

The Gist

The Big Problem: The "Too Fast to See" Dance

Imagine you are trying to watch a dancer (a subatomic particle) perform a complex routine (scattering off another particle). In the real world, this happens incredibly fast. If you try to film it with a standard camera (a standard quantum computer simulation), the dancer moves so quickly that the video looks like a blur of static. You can't see the steps, you can't count the spins, and you definitely can't figure out the choreography.

In physics terms, this is the problem of real-time simulation. The math involves waves that oscillate (wiggle back and forth) so violently that the signal gets lost in the noise almost immediately. It's like trying to hear a whisper in the middle of a rock concert.

The Solution: Two New Ways to Watch the Movie

The authors of this paper propose two clever "workarounds" to slow down the dancer so we can actually see what's happening. They suggest changing the rules of the game slightly to make the math easier to handle on a quantum computer.

Method 1: The "Time Travel" Camera (Imaginary Time)

Instead of watching the dancer move forward in normal time, imagine you hit the "rewind" button and watch the movie in Imaginary Time.

• The Analogy: Think of a hot cup of coffee cooling down. In real time, the steam rises and swirls chaotically. But if you look at the cooling process (imaginary time), the steam just slowly disappears, and the coffee settles down smoothly. The chaotic "wiggles" turn into a smooth, steady slope.
• The Catch: To do this on a quantum computer, you have to deal with "non-unitary" operations. In quantum mechanics, things usually have to be reversible (like a perfect video that can be played backward). This method creates a process that isn't perfectly reversible (like the coffee cooling down; you can't un-cool it easily).
• The Fix: The authors use a special trick called Block Encoding. Imagine you are trying to put a square peg (the non-reversible math) into a round hole (the quantum computer). Block encoding builds a special adapter that lets you fit that square peg into the machine without breaking it.

Method 2: The "Ghost World" Camera (Non-Hermitian Systems)

The second method is even stranger. Instead of changing the time, they change the space. They imagine the particles are moving in a "Ghost World" where the distance between points is imaginary.

• The Analogy: Imagine you are walking through a hallway. In the real world, the walls are solid. In this "Ghost World," the walls are made of fog. You can walk through them, but they exert a weird, invisible force that changes how you move.
• The Catch: This creates a Non-Hermitian system. In physics, "Hermitian" means the system is balanced and fair (energy is conserved). "Non-Hermitian" means the system is unbalanced—energy might seem to appear or disappear.
• The Fix: Just like in Method 1, they use the Block Encoding adapter to handle this unbalanced math. They also use a Hadamard Test, which is like a special referee that checks the "score" of the game by comparing two different versions of the same event to see the difference.

How They Put It All Together: The "Magic Adapter"

The core innovation of this paper is combining two existing tools into a new, powerful machine:

1. Block Encoding: The adapter that lets the quantum computer handle "impossible" math (non-unitary operations).
2. Hadamard Test: The referee that measures the result.

They built a quantum circuit (a recipe for the computer) that uses these tools. The best part? The recipe is simple. It doesn't require the computer to stop halfway through, check the answer, and adjust (which is very hard to do). You just feed the recipe in, and it runs.

The Results: Does It Work?

The authors tested their ideas on a "simulator" (a supercomputer pretending to be a quantum computer) using simple models:

• One particle (1-qubit): The method worked perfectly. The "blur" disappeared, and they could see the smooth curve of the data.
• Two particles (2-qubit): It still worked, but the "noise" (statistical errors) started to creep in after about 10 to 15 steps.

The Verdict:

• Imaginary Time is like a slow, steady walk. It works well, but it requires a lot of extra "helper" bits (ancillary qubits) to manage the math. It's like needing three assistants to carry one heavy box.
• Non-Hermitian (Real Time) is like a sprint. It's faster and actually requires fewer helpers. In their tests, it was three times more efficient than the imaginary time method for the same job.

Why Should You Care?

Right now, we can only simulate very small quantum systems. But nature is full of complex interactions (like how atoms stick together to form molecules, or how particles collide in the Large Hadron Collider).

This paper provides a new "lens" for quantum computers. By using these two methods, scientists might be able to simulate complex chemical reactions or nuclear physics problems that are currently impossible to solve. It's like taking a blurry, shaky video of a storm and turning it into a crystal-clear, slow-motion documentary where you can count every raindrop.

In short: They found two ways to slow down the chaotic dance of quantum particles so our computers can finally learn the steps.

Technical Summary

1. Problem Statement

The extraction of scattering phase shifts in quantum mechanics using quantum computers typically relies on real-time evolution of correlation functions. However, this approach faces a significant challenge:

• Fast Oscillatory Behavior: In real-time simulations, the integrated correlation functions (ICF) oscillate rapidly. This makes it difficult to extract meaningful phase shift data before the signal is lost in statistical noise.
• Post-Processing Limitations: Previous attempts to mitigate this involved post-data analysis techniques (e.g., $E \to E + i\epsilon$ or $L \to iL$ rotations). While effective mathematically, the $L \to iL$ rotation results in a non-Hermitian Hamiltonian.
• Hardware Constraint: Standard gate-based quantum computers perform unitary evolution. Simulating non-Hermitian systems (which involve non-unitary operators) or imaginary-time evolution (which also involves non-unitary operators like $e^{-H\tau}$) requires specialized algorithms that were not fully explored in the context of scattering phase shifts.

2. Methodology

The authors propose and test two alternative simulation strategies to circumvent the oscillatory problem, both of which result in non-unitary evolution:

A. Two Proposed Approaches

1. Imaginary-Time Simulation (Hermitian System):
   • Rotate time $t \to -i\tau$.
   • The evolution operator becomes $e^{-H\tau}$.
   • The Hamiltonian remains Hermitian, but the evolution is non-unitary (exponential decay/growth).
2. Real-Time Simulation (Non-Hermitian System):
   • Rotate space $L \to iL$.
   • The Hamiltonian becomes non-Hermitian ($H(iL) = H_1 + iH_2$).
   • The evolution operator becomes $e^{-iH_1 t} e^{H_2 t}$. The term $e^{H_2 t}$ is non-unitary.

B. Quantum Algorithm: Block Encoding + Hadamard Test

To handle the non-unitary operators ($A$) in both scenarios, the authors combine two established quantum algorithms:

1. Block Encoding: The non-unitary operator $A$ is embedded into a larger unitary matrix $U_A$ using $n$ ancillary qubits.
   $$U_A (|\alpha\rangle \otimes |0\rangle^{\otimes n}) = A|\alpha\rangle \otimes |0\rangle^{\otimes n} + \dots$$
2. Hadamard Test: Used to extract the trace of the operator, $\text{Tr}[A]$.
   • By measuring the probability difference of the ancillary qubit states (0 vs. 1) after a Hadamard gate, the real and imaginary parts of $\langle \alpha | A | \alpha \rangle$ are obtained.
   • Summing over all basis states $|\alpha\rangle$ yields $\text{Re}(\text{Tr}[A])$ and $\text{Im}(\text{Tr}[A])$.

Key Algorithmic Features:

• No Mid-Circuit Measurements: The algorithm does not require intermediate measurements or adaptive feedback, making it suitable for current quantum hardware constraints.
• Linear Scaling: The size (number of qubits) and depth (circuit length) of the quantum circuit grow linearly with the evolution time (number of time steps $N$).
• Pauli Decomposition: The Hamiltonian is decomposed into Pauli strings to facilitate block encoding.

3. Key Contributions

• Unified Framework: Demonstrated that both imaginary-time evolution of Hermitian systems and real-time evolution of non-Hermitian systems can be solved using the same combined algorithm (Block Encoding + Hadamard Test).
• Non-Hermitian Simulation on Unitary Hardware: Provided a concrete circuit implementation for simulating non-Hermitian Hamiltonians (arising from $L \to iL$ rotation) on standard unitary quantum computers.
• Efficiency Comparison: Analyzed the resource costs of both methods, showing that the non-Hermitian real-time approach is computationally more efficient for the specific scattering model tested.

4. Numerical Results

The authors tested both approaches on a 1D quantum mechanical scattering model with contact interactions using a quantum simulator (assuming error-free hardware, accounting only for statistical noise).

• Single-Qubit System:
  • Imaginary Time: The simulation matched the exact analytic solution for over 10 time steps before statistical fluctuations overwhelmed the signal. No oscillations were observed.
• Two-Qubit System:
  • Imaginary Time: Agreement with the exact solution lasted for ~5 time steps. The signal degraded faster than the 1-qubit case because the circuit required $3N + 1$ ancillary qubits (due to 3 non-unitary terms in the Hamiltonian).
  • Real-Time (Non-Hermitian): Agreement lasted for ~15 time steps (real part) and ~10 steps (imaginary part).
  • Efficiency Gain: The non-Hermitian circuit required only $N + 1$ ancillary qubits (only 1 non-unitary term to block encode). Consequently, the non-Hermitian approach was 3 times more efficient in terms of ancillary qubit resources compared to the imaginary-time approach for the 2-qubit system.

5. Significance and Outlook

• Circumventing Oscillations: The study successfully demonstrates that transforming the problem into imaginary time or non-Hermitian real time effectively eliminates the fast oscillatory behavior that plagues standard real-time scattering simulations.
• Scalability: While current tests are limited to small systems (1-2 qubits) due to the linear growth of ancillary qubits, the method is scalable. The authors note that running these circuits on actual fault-tolerant quantum hardware would likely yield a quantum advantage over classical simulators.
• Broader Application: The proposed algorithm is general and can be applied to other quantum systems beyond simple scattering, including lattice QCD and nuclear physics, where extracting scattering observables is critical.

In conclusion, the paper provides a robust, implementable quantum algorithm for calculating scattering phase shifts by leveraging non-unitary evolution techniques, offering a viable path forward for quantum simulations of scattering phenomena.