⚛️ quantum physics

Tensor-Network-Based Unraveling of Non-Markovian Dynamics in Large Spin Chains via the Influence Martingale Approach

This paper presents an efficient tensor-network algorithm that extends the Tensor Jump Method with time-dependent decay rates and the Influence Martingale formalism to enable scalable, resource-efficient simulation of both Markovian and non-Markovian open quantum dynamics in large one-dimensional spin chains.

Original authors: Sujay Mondal, Siddhartha Dutta, Abhijit Bandyopadhyay

Published 2026-06-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Sujay Mondal, Siddhartha Dutta, Abhijit Bandyopadhyay

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: Simulating a Noisy Quantum World

Imagine you are trying to predict the weather. If the world were a simple, closed box with no wind or rain, it would be easy to model. But in reality, the atmosphere is an "open system"—it's constantly interacting with the sun, oceans, and other chaotic forces.

In the quantum world, things are even messier. A quantum computer or a collection of atoms (a "spin chain") is never perfectly isolated. It is constantly bumping into its environment, causing it to lose energy (dissipation) and lose its special quantum properties (decoherence).

The Problem:
Simulating these messy interactions on a normal computer is incredibly hard.

The Explosion: As you add more particles (like adding more people to a room), the amount of information needed to describe them grows exponentially. It's like trying to write down every possible conversation in a stadium; the paper size needed would exceed the size of the universe very quickly.
The Memory Effect: Usually, scientists assume the environment "forgets" the system instantly (Markovian). But sometimes, the environment has a "short-term memory." It remembers what the system did a moment ago and pushes back (Non-Markovian). This is like a bouncy ball that doesn't just stop when it hits the floor but bounces back up because the floor was soft and stored the energy. Simulating this "push back" is mathematically tricky because it sometimes requires calculating with "negative probabilities," which makes no sense in standard math.

The Solution: A New Algorithm

The authors (Sujay Mondal, Siddhartha Dutta, and Abhijit Bandyopadhyay) have built a new, efficient computer algorithm to handle these messy, memory-filled quantum systems. They call it the Tensor-Network-Based Unraveling via the Influence Martingale Approach.

That's a mouthful, so let's break it down with analogies:

1. The "Tensor Network" (The Compression Trick)

Instead of trying to write down every single detail of a 100-atom chain (which would require more memory than exists on Earth), they use a "Tensor Network."

Analogy: Imagine a long, tangled necklace. Instead of listing the position of every single bead, you describe the necklace as a series of linked loops. You only keep track of the connections that matter. This allows them to simulate systems with up to 100 qubits (quantum bits) without the computer crashing.

2. The "Tensor Jump Method" (The Stochastic Walk)

To simulate the noise, they don't calculate the average outcome directly. Instead, they run thousands of "what-if" scenarios, or trajectories.

Analogy: Imagine a drunk person walking home. You can't predict exactly where they will be in 10 minutes. But if you simulate 1,000 different drunk people walking randomly, you can figure out the average path they will take.
Their method, called the Tensor Jump Method, simulates these random walks (trajectories) for quantum particles. When a particle "jumps" (interacts with the environment), the simulation updates the path.

3. The "Influence Martingale" (The Magic Weight)

This is the paper's biggest innovation. When the environment has a "memory" (Non-Markovian), the math sometimes demands "negative probabilities." Since you can't have a negative chance of an event happening, standard simulation methods break.

Analogy: Imagine you are betting on a horse race, but the rules change mid-race. Sometimes the odds go negative because the track is slippery. To fix this, the authors use a "Magic Weight" (the Influence Martingale).
They run the simulation using "fake" positive odds (shifted rates) so the math works. Then, at the end, they apply the "Magic Weight" to every result to correct it back to reality. It's like running a race on a flat track but then mathematically adjusting the times to account for the wind and hills you would have faced. This allows them to simulate the "memory" effects without getting stuck on negative numbers.

4. The "Influence Radius" (The Local Neighborhood)

Simulating a 100-atom chain with memory effects is still heavy on the computer. The authors realized something clever: Distance matters.

Analogy: If you drop a stone in a pond, the ripples affect the water nearby immediately. But if you are standing on the other side of the lake, the ripples from that specific stone haven't reached you yet, or they are so tiny they don't matter.
They introduced the concept of an "Influence Radius." They found that to calculate what is happening at one specific atom, you only need to worry about the "memory" effects of its immediate neighbors. You don't need to calculate the memory effects of atoms on the other side of the 100-atom chain.
Result: This acts like a filter. It tells the computer, "Ignore the distant noise; it won't change the result enough to matter." This makes the simulation fast enough to run on large systems.

What Did They Actually Do?

Built the Engine: They combined existing tools (Tensor Networks and Stochastic Jumps) with a new mathematical trick (Influence Martingales) to handle time-dependent, memory-filled noise.
Tested it: They simulated a 100-spin chain (a line of 100 quantum magnets).
Verified it: They compared their results with a "perfect" but incredibly slow method (MPO-based exact simulation) on smaller systems. Their new method matched the perfect results almost exactly.
Proved the Radius: They showed that by only looking at a small "radius" of neighbors, they could get accurate results for the whole 100-spin chain without needing a supercomputer.

Summary

The paper presents a new way to simulate quantum systems that are noisy and have "memories." By using a "compression" technique (Tensor Networks), a "random walk" strategy (Jump Method), a "correction weight" (Influence Martingale), and a "local filter" (Influence Radius), they can simulate large quantum systems (up to 100 qubits) that were previously too difficult to model. This helps scientists understand how quantum devices behave in the real, noisy world.

Technical Summary: Tensor-Network-Based Unraveling of Non-Markovian Dynamics in Large Spin Chains via the Influence Martingale Approach

Problem Statement
The classical simulation of open quantum system dynamics faces significant hurdles due to the exponential growth of the Hilbert space with system size. While tensor-network methods like Matrix Product States (MPS) have successfully addressed the scaling issues for closed systems and Markovian open systems, simulating non-Markovian dynamics remains challenging. Non-Markovian regimes, characterized by memory effects and information backflow, often require tracking the system's full history or solving integro-differential equations with memory kernels, which incurs prohibitive computational costs. Furthermore, standard stochastic unraveling techniques, such as the Monte Carlo Wave-Function (MCWF) method, rely on positive decay rates to interpret quantum jumps probabilistically. In non-Markovian regimes described by time-convolutionless (TCL) master equations, decay rates can temporarily become negative, rendering standard unraveling invalid due to the "negative probability" problem. Existing trajectory-based approaches for non-Markovian systems have been limited to small systems (e.g., up to 13 qubits) and struggle to scale to the many-body regimes (50–100 qubits) necessary for studying collective phenomena like thermalization and entanglement spreading.

Methodology
The authors propose an efficient algorithm that extends the Tensor Jump Method (TJM) to handle both time-inhomogeneous Markovian and genuinely non-Markovian dynamics in large one-dimensional quantum systems. The core of the approach involves three integrated components:

Tensor Network Framework: The method utilizes MPS to represent pure-state trajectories, avoiding the exponential scaling of density matrices. Time evolution is governed by the Time-Dependent Variational Principle (TDVP), which dynamically adjusts the bond dimension to balance accuracy and computational cost. The algorithm employs a Suzuki–Trotter decomposition to separate unitary (coherent) and dissipative (non-unitary) evolution steps.
Influence Martingale Formalism: To address the issue of negative decay rates ( $\gamma_k(t) < 0$ ) in non-Markovian TCL master equations, the authors adopt the influence martingale approach. Instead of direct unraveling, they introduce a reference ensemble with strictly positive, shifted decay rates $r_k(t) = \gamma_k(t) + C_t$ , where $C_t$ is a time-dependent shift ensuring $r_k(t) > 0$ . The physical dynamics are recovered by reweighting the reference trajectories using an influence martingale $\mu_t$ . The martingale evolves stochastically, with continuous drift and discrete jump contributions, ensuring that the ensemble average $\mathbb{E}_{ref}[\mu_t |\psi(t)\rangle\langle\psi(t)|]$ reproduces the exact non-Markovian density matrix evolution.
Influence Radius: To enable scalability in large systems (up to 100 spins), the authors introduce the concept of an "influence radius." Numerical analysis reveals that the effect of non-Markovian noise on a local observable decays with distance from the source of the noise. Consequently, the martingale correction (the shift $C_t$ and the resulting weight $\mu_t$ ) need only be computed for decay rates within a finite spatial neighborhood of the observable, rather than over the entire system. This significantly reduces the computational overhead associated with the martingale weight fluctuations.

Key Contributions

Extension of TJM: The paper generalizes the Tensor Jump Method to accommodate time-dependent decay rates, including those that become temporarily negative, by integrating the influence martingale formalism.
Scalability to Large Systems: The algorithm is demonstrated on one-dimensional transverse-field Ising chains comprising up to 100 spin qubits, a scale previously inaccessible for non-Markovian trajectory simulations using standard methods.
Influence Radius Concept: The introduction of the "influence radius" provides a resource-efficient framework. It quantifies the local extent required for martingale corrections, allowing for scalable simulations where the computational cost does not necessarily grow with the total system size for local observables.
Unified Framework: The approach provides a single computational framework capable of simulating time-inhomogeneous Markovian processes (positive time-dependent rates) and non-Markovian dynamics (negative rates) without switching between fundamentally different algorithms.

Results

Benchmarking: The authors benchmarked their trajectory-based results against numerically exact Matrix Product Operator (MPO) simulations for a 30-site chain. The results showed systematic convergence with the number of trajectories ( $N_{traj}$ ) and weak dependence on the maximum bond dimension ( $\chi_{max}$ ) for the specific model parameters, indicating that the method captures the correct dynamical trends even with relatively small trajectory ensembles ( $N_{traj} = 100$ ).
Martingale Behavior: Simulations confirmed that the ensemble average of the influence martingale $\mathbb{E}[\mu_t]$ remains close to unity, validating the trace preservation of the method. The martingale exhibited temporal variations specifically during intervals where the physical decay rates $\gamma_k(t)$ were negative.
Scaling and Influence Radius: By varying the magnitude of the non-Markovian decay rates, the authors demonstrated that the error in local observables scales with the integrated shifted jump intensity over the system. Applying the "influence radius" concept to 100-site chains (with non-Markovian noise localized at boundaries or random sites) showed that high accuracy could be maintained with $N_{traj} = 100$ by restricting the martingale calculation to the relevant local neighborhood, effectively decoupling the computational cost from the total system size for local measurements.

Significance
The paper claims that this work provides a scalable and efficient route for simulating non-Markovian many-body open-system dynamics, overcoming the limitations of direct density matrix evolution and standard stochastic methods. By combining tensor networks with the influence martingale formalism and the "influence radius" heuristic, the authors enable the study of collective many-body phenomena (such as entanglement spreading and dissipative transitions) in regimes where memory effects are significant. The method is presented as a tool for exploratory research, allowing for the characterization of decoherence and dissipation in large-scale quantum systems under realistic noise conditions without consuming massive computational resources. The framework is positioned as a foundation for future investigations into diverse physical scenarios, microscopic bath models, and interacting many-body Hamiltonians.