Hamiltonian dynamics from pure dissipation

arXiv:2604.18533 · quant-ph · Submitted 2026-04-20 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: Today's paper: "Hamiltonian dynamics from pure dissipation".

Mira: The fundamental difference between closed and open quantum dynamics lies in their environmental interaction, and this work demonstrates that internal Hamiltonian dynamics can be "faked" via external pure dissipation,

Kai: First, who's behind it and why it matters.

Title and authors: Kai: So, let's talk about "Hamiltonian dynamics from pure dissipation," looking at the title and who put this work together. It's a pretty descriptive title, but it immediately signals that the paper is focusing on how we can get Hamiltonian physics out of a dissipative framework.

Mira: I agree with Kai; the title sets expectations for us to be thinking about how environmental coupling can substitute for explicit coherent driving in quantum dynamics <ref:2604.18533#pg0>. The authors are Zhong-Xia Shang and Daniel Stilck Fran¸ca, and seeing their affiliations, we get a sense of the mathematical rigor behind this approach from Copenhagen <ref:2604.18533#pg0>.

Lev: From my side, I'm curious about what kind of mathematical representation they chose to start with; does their choice of GKSL representation immediately constrain the possibilities for simulating unitary evolution?

Kai: They start by focusing on a GKSL representation, which is important because it sets the stage for how the jump operators behave in relation to the Hamiltonian, even when there's no explicit Hamiltonian term in the Lindbladian <ref:2604.18533#pg0>.

Mira: That's where my concern lies; if they are using a representation without an explicit Hamiltonian, how do they ensure that the resulting dissipative generator can still capture the full dynamics of a standard closed quantum system?

Lev: I think that the key is in the nontraceless nature of those jump operators, which allows them to embed the necessary information about the coherent evolution within those dissipation terms <ref:2604.18533#pg0>.

Kai: So, essentially, they're arguing that even if you strip away a clear Hamiltonian term from your Lindbladian definition, you can still achieve Hamiltonian dynamics by carefully crafting those jump operators <ref:2604.18533#pg0>.

Mira: It shifts the focus from what the system *is* (a closed unitary evolution) to how it *appears* when coupled to an environment, which is a very different way of looking at quantum mechanics <ref:2604.18533#pg0>.

Lev: For real-world simulation, this suggests that if we can't perfectly isolate the system from the bath, modeling it purely dissipatively might be the only practical path forward <ref:2604.18533#pg1>.

Kai: Right, and when we look at the structure of their construction in equation (three), d rho/dt = Lrho = F rho F - one/2F F, rho, it looks like a standard Lindbladian form but with the added constraint that F is related to our Hamiltonian <ref:2604.18533#pg1>.

Mira: Exactly, and that constraint on F is what ties the dissipation directly to the structure of the evolution we are trying to mimic, which is a very strong requirement <ref:2604.18533#pg1>.

Lev: If this construction works, it means that for any target Hamiltonian we choose, there's a corresponding set of jump operators that can achieve the approximation within the stated error bounds <ref:2604.18533#pg2>.

Kai: And when you consider multi-jump systems, they show how to assign these jump operators F'i based on a decomposition of H into local terms H i, which makes the construction more systematic for complex problems <ref:2604.18533#pg1>.

Mira: That systematic approach is crucial because it shows that the approximation method isn't just a lucky guess but has a structural underpinning based on how the Hamiltonian itself is decomposed <ref:2604.18533#pg1>.

Lev: So, for someone trying to build an error correction scheme, this implies we might be able to use this structural knowledge of H to design more efficient codes that are tailored specifically to mimic desired unitary dynamics <ref:2604.18533#pg2>.

The paper's summary: Kai: Now that we know the setup, let's talk about what the paper is actually summarizing—the main argument it builds up through these pages. It boils down to this: internal Hamiltonian dynamics can be successfully mimicked by external pure dissipation within a specific time scaling <ref:2604.18533#pg0>.

Mira: That’s the high-level summary, but it’s important to remember that the paper doesn't just claim this works; it provides a concrete construction, showing that bounded-norm dissipative generators can approximate Hamiltonian dynamics within epsilon error in diamond norm using an evolution time of O(t two/epsilon) <ref:2604.18533#pg0>.

Lev: The key part for me is the error bound itself; if the construction holds, we need to know exactly what that epsilon means in terms of fidelity for a quantum process we care about <ref:2604.18533#pg1>.

Kai: Precisely, and they establish that this O(t two/epsilon) scaling is not just an arbitrary guess; it's the necessary worst-case cost because it captures the fundamental decoherence expense required to keep up with Hamiltonian speed <ref:2604.18533#pg0>.

Mira: The paper shows that this scaling is necessary and optimal geometrically, which means you can't do better than O(t two/epsilon) for time-independent dynamics <ref:2604.18533#pg2>.

Lev: I see the necessity of the lower bound proof; if Theorem two proves that any simulation *must* take at least that long, then we have a solid theoretical foundation for assessing the feasibility of this approach <ref:2604.18533#pg2>.

Kai: And they give us a direct example using F = I - i delta H to show how the dynamics naturally contain both the desired delta-strength Hamiltonian term and a delta squared-strength dissipation when you look at it carefully <ref:2604.18533#pg1>.

Mira: That specific example is very illustrative because it shows exactly how the Hamiltonian term gets "faked" by introducing a small perturbation scaled by delta in the jump operator <ref:2604.18533#pg1>.

Lev: So, for running this on hardware, this means we are not just simulating the Hamiltonian; we are essentially engineering an environment that acts like a specific type of noise to produce that desired Hamiltonian trajectory <ref:2604.18533#pg2>.

Kai: Exactly, and they show how to handle multi-jump systems by decomposing H into local terms H i and assigning corresponding jump operators F'i, leading to the final time approximation involving H i squared t two/epsilon <ref:2604.18533#pg1>.

Mira: That decomposition is very clean, and it confirms that this approximation technique has a systematic way to handle complexity beyond single-term systems <ref:2604.18533#pg1>.

Lev: If we take the scaling O(H i squared t two/epsilon), we can start thinking about how the complexity of our quantum simulation maps directly onto the required environmental interaction strength <ref:2604.18533#pg2>.

The paper's improvements: Kai: Moving on to what they suggest as improvements or new avenues, the paper really points toward using gauge changing to reduce the actual simulation cost significantly Gauge Changing. They show that by finding a better gauge, you can minimize the norms of operators like H and F, making the algorithmic cost much smaller Gauge Changing.

Mira: That reduction is significant because it means we move from a cost proportional to the absolute size of the Hamiltonian to one proportional to how small its components are in that specific mathematical representation Gauge Changing.

Lev: If we can achieve a better gauge where those norms are bounded by delta, as they suggest, then the computational cost scales directly with delta, which is related to the target error epsilon and time t <ref:2604.18533#pg2>.

Kai: That links back to the necessity of the O(t two/epsilon) scaling because it shows how much work we need to do, but gauge changing is our tool to make that required work as cheap as possible Gauge Changing <ref:2604.18533#pg0>.

Mira: The uniqueness argument also serves as an improvement in a sense; Proposition two proves that any smooth family of dissipative Lindbladians approximating Hamiltonian dynamics must follow a specific second-order structure, which fixes the first-order terms based on H <ref:2604.18533#pg0>.

Lev: That uniqueness is helpful for error correction research because it means that if we want to learn an unknown Lindbladian, we know the form it must take up to a certain order, which limits the search space Learning Arbitrary Lindbladians with Quantum Error Correction.

Kai: It’s not just about learning; they show that this framework can actively generate evolution for state freezing by using F = delta-one/two(I + i delta H), which is a novel Zeno-adjacent mechanism that works even outside the traditional Zeno subspace <ref:2604.18533#pg2>.

Mira: That active cancellation mechanism is intriguing because it offers a way to stabilize states against Hamiltonian driving without relying on specific subspace definitions, which could be useful for robust quantum state storage <ref:2604.18533#pg2>.

Lev: From an experimentalist's view, the ability to actively generate evolution through dissipation instead of just absorbing noise is a major concept for controlling dynamics in real-time experiments <ref:2604.18533#pg1>.

Conclusion: Kai: So, to wrap up this discussion on "Hamiltonian dynamics from pure dissipation," the main points are that we can approximate Hamiltonian evolution using external noise with an O(t two/epsilon) time scaling <ref:2604.18533#pg0>.

Mira: This capability is supported by a concrete construction, and they’ve shown that this cost is necessary and optimal from a geometric viewpoint because it reflects the fundamental decoherence cost of catching up to Hamiltonian dynamics <ref:2604.18533#pg2>.

Lev: For practical implementation, the key takeaway for those of us working on quantum error correction is that this framework provides a solid theoretical foundation by establishing the necessary lower bound on simulation time <ref:2604.18533#pg2>.

Kai: And they've given us tools like gauge changing to actively reduce the cost, suggesting that efficient simulation isn't just about finding a way around the complexity but about finding a more efficient representation Gauge Changing.

Mira: Overall, the implication for quantum dynamics is that this paper provides a powerful mathematical bridge between closed and open system descriptions using pure dissipation <ref:2604.18533#pg0>.

Lev: I just want to say that this work solidifies the idea that the scaling we observe in simulations isn't arbitrary; it has a definite geometric constraint tied to the underlying dynamics <ref:2604.18533#pg2>.

Kai: It really does, and I think seeing how they construct these dissipative generators gives us a clearer picture of what kind of noise structure we need to engineer for specific simulation tasks <ref:2604.18533#pg1>.

Zhong-Xia Shang, *, Daniel Stilck França †

Department of Mathematical Sciences, University of Copenhagen

quant-ph

Submitted: 2026-04-20

Updated: 2026-10-04

Comments: 6+7 pages, 2 figures

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 89/100

The gist: The fundamental difference between closed and open quantum dynamics lies in their environmental interaction, and this work demonstrates that internal Hamiltonian dynamics can be "faked" via external

Key concepts

Purely Dissipative Lindbladian
This is a quantum master equation describing dynamics driven solely by jump operators (dissipation) and no explicit Hamiltonian term. It models how an open system interacts with its environment, focusing only on the loss of coherence rather than coherent evolution.
Hamiltonian Approximation Scaling
The paper proves that to achieve an error $\epsilon$ in simulating a Hamiltonian evolution over time $t$, the required simulation time scales quadratically with $t$ and inversely with $\epsilon$. This establishes a necessary cost of $O(t^2/\epsilon)$ for purely dissipative models.
Gauge Changing
Gauge changing refers to transforming the parameters within the Lindbladian, such as the Hamiltonian or jump operators, to find a representation where their norms are smaller. This technique is used to reduce the computational cost of simulating these dynamics.
BQP-Completeness
The authors show that simulating Hamiltonian dynamics using purely dissipative models is BQP-complete beyond a fixed point. This indicates that these dissipative systems are computationally hard for tasks related to quantum computation.

Terminology

Summary

The fundamental difference between closed and open quantum dynamics lies in their environmental interaction, and this work demonstrates that internal Hamiltonian dynamics can be faked via external pure dissipation, showing that purely dissipative Lindbladians can approximate Hamiltonian evolution within a specific time scaling.

Core Finding on Approximation

The paper proves that purely dissipative Lindbladians (those with only jump operators and no explicit Hamiltonian term) can achieve approximate ideal t-time Hamiltonian evolution within an error ϵ in diamond norm using an evolution time of O(t 2/ϵ). This construction shows that internal, coherent Hamiltonian interactions can be well mimicked by strictly external, dissipative ones.

Construction of the Dissipative Generator

The authors demonstrate this approximation through specific constructions.

  1. They consider a purely dissipative, single-jump Lindbladian defined by Equation (3): dρ/dt = L[ρ] = F ρF† − 1/2 F†F, ρ.

  2. A direct example is setting the jump operator to be F = I - iδH, which leads to a form where the dynamics contain a δ-strength Hamiltonian term and a δ 2-strength dissipation when H is viewed as a jump operator (Equation 4).

  3. For multi-jump systems, they show that if H has a decomposition H = Σ P i Hi with local operators Hi, one can assign jump operators Fi = I - iδHi for each term, resulting in an approximation time of T = O(Σ Hi squared t 2/ϵ).

Necessity and Optimality

The scaling O(t 2/ϵ) is shown to be necessary and optimal from a geometric perspective, capturing the fundamental decoherence cost for catching up with the speed of Hamiltonian dynamics.

  1. Theorem 1 establishes that by setting δ = ϵ/t, the purely dissipative, single-jump Lindbladian can approximate Hamiltonian dynamics within error ϵ in diamond distance by an evolution time T = O(H squared t 2/ϵ).

  2. Theorem 2 provides a geometric lower bound, proving that for families of Hamiltonians H where a purely dissipative Lindbladian can simulate the target dynamics, the total Lindbladian evolution time T must satisfy T ≥ Ω(H squared / (mC 2 t 2/ϵ)). This confirms that O(t 2/ϵ) is the worst-case cost.

  3. This lower bound proof relies on analyzing an affine Bloch equation derived from the dissipative generator, showing a relationship between the effective rotational speed ω and the radial decoherence term-Tr(S), leading to T ≥ Θ squared / 384 mC 2 ϵ, which matches the required scaling.

Implications for Quantum Computation and Dynamics

The results have several profound implications across quantum information theory:

  1. Purely dissipative dynamics is BQP-complete beyond the fixed point, indicating that purely dissipative Lindbladians are BQP-hard when simulating Hamiltonian dynamics.

  2. A novel Zeno-adjacent freezing mechanism is introduced: by setting a jump operator F = δ(-1/2)(I + iδH), the system evolution can be actively generated via dissipation to cancel out the system evolution, allowing for state freezing regardless of whether the state is in the traditional Zeno subspace.

  3. The work establishes a no super-quadratic fast-forwarding theorem for this class of Lindbladians, showing that they cannot be simulated faster than quadratic time in t for certain sparse Hamiltonians.

  4. Gauge changing offers a way to reduce simulation cost: by finding a better gauge where the norms of the Hamiltonian and jump operators are smaller (e.g., H'∞ + Σ Fi'2/∞ = O(δ)), the algorithmic cost can be drastically reduced, as it is proportional to these norms.

Uniqueness of Construction

The paper proves that any smooth family of purely dissipative Lindbladians that can approximate Hamiltonian dynamics to arbitrary precision must have a form similar to the second-order construction presented. Proposition 2 establishes that if a smooth family satisfies the approximation condition (C2), then LD,δ = δLH + O(δ 2) in diamond norm, meaning the first-order term is uniquely fixed by H. Furthermore, it shows that nontrivial first-order jumps must take the form F j,δ = √γ j (I - δA j) + O(δ 2), confirming the uniqueness of the construction up to second order.

Simulation Cost Reduction via Gauge Changing

The gauge freedom in Lindbladians is used to show cost reduction. The algorithmic cost is proportional to H∞ + Σ Fi 2/∞.

Improvements for AI systems

As a fastidious and diligent researcher, I have analyzed this paper, Hamiltonian dynamics from pure dissipation. The core contribution is demonstrating that complex, coherent Hamiltonian dynamics (unitary evolution) can be approximated by purely dissipative Lindbladians (open-system dynamics) with a specific time complexity of order 1/epsilon.

Here are the specific improvements for AI systems based on this scientific finding:

The fundamental improvement lies in developing new simulation paradigms for quantum processes, particularly those involving complex Hamiltonians or high-dimensional state spaces, by leveraging the structure of open-system dynamics.

Here are the specific applications and capabilities of these improved AI systems:

  1. Enhanced Simulation of Complex Quantum Algorithms (BQP-Complete Tasks):

  2. Efficient Simulation of Quantum Phase Estimation (QPE) and Related Problems:

  3. Novel Quantum Zeno Effect Control Mechanisms:

  4. Reduced Computational Cost for Lindbladian Simulations via Gauge Optimization:

  5. Quadratic Fast-Forwarding Bounds for Dissipative Dynamics Analysis:

The improved AI systems derived from this research can perform the following specific tasks:

  1. The system can simulate the time evolution of a target Hamiltonian, even if it is complex or non-trivial, by employing a purely dissipative model. This allows for the simulation of algorithms that are known to be BQP-complete (like those related to finding ground states or solving certain optimization problems) without needing an explicit coherent Hamiltonian term in the simulation dynamics itself.

  2. The AI can perform quantum phase estimation (QPE) by constructing a single-jump Lindbladian where the jump operator is specifically designed based on the target Hamiltonian structure, offering a direct path to approximating QPE results with controlled error bounds derived from the dissipation cost scaling.

  3. The system can actively freeze or stabilize quantum states in response to specific environmental interactions (the Zeno-adjacent freezing mechanism). Unlike traditional Zeno effects that only freeze states within a predefined subspace, this improved AI can be engineered to suppress evolution across the entire Hilbert space, allowing for the stabilization of arbitrary target states against Hamiltonian driving.

  4. The system can optimize its own simulation efficiency. By utilizing the gauge freedom inherent in Lindbladian theory, the AI can dynamically transform its internal representation (the gauge) to one where the computational cost—measured by norms of operators like jump operators and Hamiltonians—is minimized, leading to faster simulations for specific target dynamics.

  5. The system can analyze whether a target Lindbladian is subject to quadratic fast-forwarding limits. By checking if the required simulation time scales as sub-quadratic (e.g., linear in the number of queries), the AI can determine if it belongs to a class of dissipative dynamics that is fundamentally limited or, conversely, identify classes where quadratic speed-ups are possible, guiding researchers on which quantum processes are efficiently simulatable via dissipation.

Abstract

The fundamental difference between closed and open quantum dynamics lies in their environmental interaction: closed systems are perfectly isolated and evolve reversibly under unitary Hamiltonian dynamics, whereas open systems continuously couple to an external bath, resulting in irreversible dissipation and information loss. In this work, we show internal Hamiltonian dynamics can be "faked`` via external pure dissipation, i.e., Lindbladians without a coherent Hamiltonian part. More concretely, we show that, in a GKSL representation with zero explicit Hamiltonian term but nontraceless jump operators, bounded-norm dissipative generators can approximate Hamiltonian dynamics within ε error in diamond norm using O(t 2/ε) evolution time. We further prove that for time-independent dynamics this O(t 2/ε) scaling is in the worst case, necessary and optimal from a geometric perspective, which captures the fundamental decoherence cost for catching up with the speed of Hamiltonian dynamics. Our construction leads to various implications, including the BQP-completeness of purely dissipative dynamics even before reaching approximate equilibrium, a Zeno-adjacent state-independent freezing effect, the no super-quadratic fast-forwarding theorem of a class of purely dissipative dynamics, and reducing Lindbladian simulation cost via gauge changing.

Sources

Related papers