⚛️ quantum physics

Quantum Simulation of Non-Hermitian Linear Response

This paper presents a systematic algorithmic mapping that transforms non-unitary multi-time correlation functions into a unitary form via Schrödingerization, enabling the efficient simulation of generalized non-Hermitian Green's functions on quantum hardware.

Original authors: Jeongbin Jo

Published 2026-03-19

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Jeongbin Jo

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

Imagine you are trying to predict how a crowded dance floor reacts when someone suddenly turns on a strobe light or plays a new song. In the world of physics, this is called Linear Response Theory. Scientists use it to understand how complex systems (like electrons in a metal or chemicals in a reaction) react to small nudges or disturbances.

For a long time, this theory worked perfectly for "closed" systems—like a dance floor in a sealed, soundproof room where no energy escapes. But in the real world, systems are "open." Energy leaks out (dissipation), people leave the room, or the music gets muffled. In physics terms, these are non-Hermitian systems.

The problem? Our current quantum computers are like strict rule-followers: they can only simulate "closed" rooms where energy is perfectly conserved. They struggle to simulate the messy, leaking, real-world scenarios because the math describing them involves "non-unitary" dynamics (math that doesn't conserve probability in the way quantum computers like).

Here is the simple breakdown of what this paper does to fix that problem:

1. The Problem: The "Leaky Bucket"

Imagine trying to simulate a bucket with a hole in the bottom (a system losing energy) using a quantum computer. The computer's native language is "perfect conservation." If you try to tell it to simulate a leak, it gets confused because the math gets messy and unstable. Traditional methods to fix this are like trying to patch the hole with a giant, heavy, expensive tarp (complex algorithms) that makes the simulation incredibly slow and requires too much computing power.

2. The Solution: The "Shadow Puppet" Trick

The authors, led by Jeongbin Jo, propose a clever trick called Schrödingerization.

Think of the leaking bucket (the real, messy system) as a shadow puppet on a wall. The shadow looks distorted and weird because of the light source.

The Old Way: Try to build a 3D model of the distorted shadow directly. It's hard and expensive.
The New Way (Schrödingerization): Instead of fighting the distortion, the authors say, "Let's add a new dimension." They imagine a second, invisible stage behind the wall. On this new stage, they create a perfect, non-leaking version of the puppet show.

By adding this extra "dimension" (a mathematical variable they call $\xi$ ), they transform the messy, leaking math into a clean, perfect, "unitary" math that quantum computers love. It's like taking a wobbly, shaky video and stabilizing it by adding a third dimension of data so the shake disappears.

3. How It Works: The "Fourier Translator"

Once they have this "perfect" version in the extra dimension, they use a mathematical tool called a Fourier Transform.

Imagine you have a song that is playing at a weird, distorted speed.
The Fourier Transform is like a super-powered equalizer that breaks that song down into its pure, individual notes.
In this paper, they break the "leaking" system down into a spectrum of perfect, stable waves. The quantum computer simulates these perfect waves easily.
Finally, they recombine the waves to get the answer for the original, leaking system.

4. Why This Matters

Before this paper, simulating these "leaky" systems on a quantum computer was like trying to drive a race car through a swamp; it was possible but incredibly inefficient and prone to breaking down.

This new method is like building a bridge over the swamp.

Efficiency: It doesn't require the massive "tarp" of old methods. It scales much better, meaning you can simulate bigger, more complex systems without the computer crashing.
Accuracy: They tested this on a simple model (a single atom losing energy) and showed that their "bridge" method produces results that match the perfect theoretical answer almost exactly.
Future Impact: This opens the door for quantum computers to simulate real-world chemistry, materials science, and biological processes where energy loss and dissipation are the norm, not the exception.

The Bottom Line

The authors found a way to translate the "messy, leaking" language of real-world physics into the "clean, perfect" language of quantum computers. They did this by adding a mathematical "extra dimension" that stabilizes the simulation, allowing us to finally use quantum computers to study how open, dissipative systems truly behave. It's a bridge from theory to practice, turning a formidable algorithmic challenge into a solvable puzzle.

1. Problem Statement

Linear response theory and Green's functions are fundamental tools for understanding how macroscopic and strongly correlated systems react to weak external perturbations. While the theoretical framework for non-Hermitian linear response (applicable to open quantum systems with dissipation) has been established (e.g., by Pan et al.), translating this theory into practical quantum algorithms remains a significant challenge.

The core bottleneck is the non-unitary nature of the time evolution operator ( $e^{Lt}$ ) in open systems, where $L$ is the Lindblad superoperator. Standard quantum computers operate via unitary gates. Traditional methods to simulate non-unitary dynamics, such as:

Dilation techniques: Embedding the system in a larger space.
Block-encoding (e.g., QSVT, GQSP): Requires complex state preparation and matrix inversion.
HHL algorithm: Often incurs exponential overhead in circuit depth and state preparation costs.

These approaches are often inefficient or lack scalability for high-dimensional open systems.

2. Methodology: Schrödingerization

The authors propose a novel quantum algorithmic protocol based on the Schrödingerization technique to map non-unitary dynamics into a unitary form suitable for quantum hardware.

A. Vectorization of the Lindblad Equation

The density matrix $\rho(t)$ of an open system is vectorized into a state $|\rho(t)\rangle$ in Liouville space. The Lindblad master equation is transformed into a linear ordinary differential equation (ODE):
$\frac{d}{dt} |\rho(t)\rangle = \mathcal{L} |\rho(t)\rangle$
where $\mathcal{L}$ is a non-Hermitian superoperator.

B. Decomposition and Warped Phase Transformation

To simulate the non-unitary propagator $e^{\mathcal{L}t}$ , the generator $\mathcal{L}$ is decomposed into Hermitian ( $H_1$ ) and anti-Hermitian ( $H_2$ ) components:
$\mathcal{L} = H_1 - iH_2$
The authors introduce a real continuous variable $\xi > 0$ and apply a warped phase transformation:
$w(t, \xi) = e^{-\xi} |\rho(t)\rangle$
This transformation couples the time evolution with an auxiliary dimension $\xi$ .

C. Fourier Mapping to Unitary Evolution

By taking the Fourier transform of $w(t, \xi)$ with respect to $\xi$ (yielding $\tilde{w}(t, \eta)$ where $\eta$ is the Fourier mode), the system is mapped to a set of uncoupled, unitary Schrödinger-like equations:
$i\partial_t \tilde{w} = (\eta H_1 + H_2) \tilde{w}$
The resulting effective Hamiltonian, $H_{\text{sch}}(\eta) = \eta H_1 + H_2$ , is strictly Hermitian for any real $\eta$ . This allows the dynamics to be simulated using standard unitary quantum gates.

D. Extracting Response Functions

The method extends the Kubo formula to non-Hermitian regimes. The linear response function $\chi(\tau)$ is calculated by:

Preparing an initial vectorized state corresponding to the perturbation (e.g., $V|\rho_{\text{eq}}\rangle$ ).
Evolving the system under $H_{\text{sch}}(\eta)$ for various Fourier modes $\eta$ .
Reconstructing the physical correlation function via an inverse Fourier transform (numerically approximated by summing over discrete $\eta$ modes).

3. Key Contributions

Systematic Algorithmic Mapping: The paper provides the first scalable pathway to extract generalized non-Hermitian Green's functions and two-time correlation functions directly on quantum hardware without exponential overhead.
Optimal State Preparation: Unlike block-encoding methods (QSVT/GQSP) that require expensive oracle constructions for non-unitary matrices, this approach only requires simulating the Hermitian parts $H_1$ and $H_2$ . This achieves optimal state preparation costs.
Theoretical Validation: The framework is analytically derived for the single-qubit amplitude damping channel, proving that non-unitary Lindblad dynamics can be structurally elevated to a unitary Schrödinger equation.
Complexity Analysis: The method scales as $O(\text{poly}(\log(1/\epsilon)))$ with respect to precision $\epsilon$ , offering an exponential improvement over traditional dilated solvers which scale as $O(\text{poly}(1/\epsilon))$ .

4. Results

The authors validated the framework through numerical simulations using Qiskit on a single-qubit amplitude damping model:

Convergence: Simulations using the Schrödingerization method successfully reproduced the exact analytic Lindblad dynamics.
Resolution Dependence:
- Low Resolution ( $N=20$ ): Captured qualitative trends but showed quantitative deviations due to truncation.
- High Resolution ( $N=200$ ): The simulated response converged perfectly to the exact solution.
Error Scaling:
- Fourier Grid ( $N$ ): The error decays exponentially as the number of Fourier modes $N$ increases. Since $N$ relates to auxiliary qubits as $M = \log_2(2N+1)$ , high precision is achievable with a small number of qubits.
- Truncation Limit ( $L$ ): The error associated with truncating the continuous variable $\xi$ scales as $e^{-L}$ , confirming the theoretical bound that $\ln(1/\epsilon) \sim L$ .

5. Significance

This work bridges a critical gap between the established physical theory of non-Hermitian linear response and quantum computational implementation.

Overcoming Non-Unitarity: It bypasses the fundamental barrier of simulating dissipative processes on quantum computers without relying on resource-heavy matrix inversion or complex block-encodings.
Applications: The algorithm enables the study of driven-dissipative strongly correlated electron systems and physical chemistry problems (e.g., open quantum systems in chemical reactions) that were previously inaccessible to quantum simulation.
Scalability: By achieving near-optimal state preparation costs and logarithmic scaling with precision, this approach positions Schrödingerization as a leading candidate for simulating high-dimensional open quantum systems on future fault-tolerant quantum computers.

Summary of Complexity Comparison (Table I)

Method	Precision Scaling	State Preparation	Oracle Requirement
Dilation	$O(\text{poly}(1/\epsilon))$	High	Block-encoding
QSVT / GQSP	$O(\log(1/\epsilon))$	High	Block-encoding
Schrödingerization	$O(\text{poly}(\log(1/\epsilon)))$	Optimal	Unitary Propagator

Note: The paper acknowledges that near-term implementation faces challenges regarding noise sensitivity in the inverse quantum Fourier transform (IQFT) due to circuit depth, but the theoretical framework is robust for fault-tolerant architectures.