⚛️ quantum physics

Low-depth simulation of non-Markovianity under quantum hardware noise

This paper proposes a low-depth simulation method for non-Markovian dynamics and memory channels using trajectory mixing, which replaces entangling gates with statistical mixtures of pure-state trajectories to significantly improve state fidelity and preserve quantum correlations on noisy near-term quantum hardware.

Original authors: Diana A. Chisholm

Published 2026-07-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Diana A. Chisholm

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 simulate how a delicate glass vase (a quantum system) behaves when it's sitting in a windy, noisy room (its environment). In the world of quantum computing, we want to predict exactly how that vase will shake, wobble, or eventually break, but we have a problem: our quantum computers are also very noisy and fragile.

This paper proposes a clever new way to run these simulations that avoids the usual heavy machinery, making it much more likely to succeed on today's imperfect quantum computers.

The Old Way: The "Heavy Backpack" Approach

Traditionally, to simulate a system interacting with its environment, scientists use a method called Stinespring dilation. Think of this as trying to simulate the wind by hiring a giant, clumsy robot (an "auxiliary qubit") to stand next to the vase and physically push it around.

To make the robot push correctly, you have to tie the vase and the robot together with very strong, complex ropes (entangling gates).

The Problem: These ropes are hard to tie without breaking. In quantum terms, the "two-qubit gates" needed to connect the system and the robot are very noisy. Every time you tie a rope, you introduce a high chance of error. If you need to simulate a long time period, you need a lot of ropes, and the errors pile up until the simulation is useless.

The New Way: The "Rolling Dice" Approach

The author, Diana Chisholm, suggests a different strategy called trajectory mixing. Instead of hiring a giant robot to push the vase, imagine you are running a simulation where you simply roll a die to decide what happens next.

The Metaphor: Imagine you have a thousand identical vases. Instead of one robot pushing them all, you send each vase down a slightly different path.
- Path A: A gentle breeze hits it.
- Path B: A strong gust hits it.
- Path C: No wind at all.
You run all these paths separately on your computer. Because you aren't tying the vases to a robot, you don't need those noisy, complex ropes. You only use simple, single-qubit operations (like flipping a coin or turning a dial).
The Result: At the end, you look at all the vases, count how many ended up in which state, and take an average. This statistical average gives you the same answer as the complex robot method, but with far fewer errors because you avoided the "noisy ropes."

What Did They Test?

The paper tests this "Rolling Dice" method on three specific scenarios to see if it works better than the "Heavy Backpack" method:

Pure Dephasing (The "Fuzzy" Vase):
- They simulated a qubit losing its "sharpness" (dephasing).
- Result: The "Rolling Dice" method kept the simulation very close to the perfect, theoretical answer. The "Heavy Backpack" method drifted off course quickly, like a boat losing its anchor in a storm.
Non-Markovian Dynamics (The "Memory" Vase):
- This is a tricky scenario where the environment "remembers" what it did to the system and pushes back later (like a boomerang effect).
- To simulate this, they had to use a "memory" qubit.
- Result: The "Rolling Dice" method still performed better, especially when looking at the relationship between the vase and its memory. However, because the vase and memory were constantly interacting (requiring some complex connections), the advantage wasn't as huge as in the first test, but it was still positive.
Memory Channels (The "Correlated" Wind):
- They simulated a scenario where two vases are sent through a channel that applies the same random wind to both at the same time. This tests if the method can preserve the "entanglement" (a special quantum bond) between them.
- Result: This was the biggest win. The "Rolling Dice" method kept the bond between the two vases almost perfectly intact. The "Heavy Backpack" method broke the bond almost immediately because the complex ropes needed to coordinate the two vases were too noisy.

The Catch: The "Too Many Paths" Problem

There is one downside. If you want to simulate a very long time, the number of possible paths (trajectories) grows exponentially. It's like trying to roll a die for every second of a year; the number of combinations becomes impossible to track.

The Solution: The paper shows you don't need to track every path. You can just randomly sample a few thousand paths (like taking a poll of 1,000 people instead of asking everyone in the country). Even with this limited sampling, the "Rolling Dice" method stayed accurate for much longer than the "Heavy Backpack" method.

The Bottom Line

The paper claims that by swapping complex, noisy connections (entangling gates) for a statistical mix of simple, independent runs (trajectory mixing), we can simulate open quantum systems much more effectively on current hardware.

It's like choosing to take a thousand small, simple steps to get to a destination, rather than trying to carry a heavy, broken-down truck. While the truck might seem like the "official" way to do it, the small steps get you there with much less damage. This makes it possible to simulate long, complex quantum interactions that were previously too noisy to run on real quantum computers.

Technical Summary: Low-depth simulation of non-Markovianity under quantum hardware noise

Problem Statement
Simulating open quantum systems on digital quantum computers is inherently challenging because quantum circuits natively support only unitary evolutions, whereas open systems undergo non-unitary dynamics due to environmental interactions. The standard approach, Stinespring dilation, simulates these dynamics by coupling the system to auxiliary qubits and tracing them out. However, this method requires dense interaction topologies and a high number of two-qubit gates (e.g., CNOTs), which are significantly noisier than single-qubit gates. On near-term hardware, the accumulation of errors from these auxiliary gates severely limits the fidelity and execution time of simulations, particularly for long-time evolutions or complex non-Markovian dynamics.

Methodology
The paper proposes leveraging the method of trajectory mixing (statistical mixing of pure state trajectories) to simulate open system dynamics without auxiliary qubits. This approach is specifically applied to mixed unitary channels, where a quantum channel $\Phi(\rho)$ can be expressed as a statistical mixture of unitary evolutions: $\Phi(\rho) = \sum_i p_i U_i \rho U_i^\dagger$ .

Key methodological features include:

State-Independent Probabilities: For mixed unitary channels, the probability of a specific unitary jump ( $p_i$ ) is independent of the system's state. This allows the simulation to proceed by running multiple independent circuits (trajectories) and statistically mixing the results, avoiding the need for costly state tomography to determine jump probabilities dynamically.
Trajectory Sampling: While the total number of possible trajectories scales exponentially ( $m^N$ , where $m$ is the number of Kraus operators and $N$ is the number of time steps), the authors employ stochastic sampling (Monte Carlo approach) to simulate long-time evolutions with a statistically sufficient subset of trajectories.
Noise Modeling: The simulations utilize a realistic noise model calibrated to modern quantum processors, including $T_1$ and $T_2$ relaxation/dephasing after single-qubit gates and a depolarizing channel after CNOT gates.
Comparison Baseline: The trajectory mixing method is benchmarked against the traditional auxiliary qubit approach (Stinespring dilation) across various scenarios.

Key Contributions and Simulations
The paper demonstrates the viability of this approach through four specific simulation scenarios:

Pure Dephasing: A single qubit undergoing free evolution and pure dephasing. The trajectory mixing method (using only single-qubit gates) maintains high state fidelity and closely tracks noiseless dynamics. In contrast, the auxiliary qubit method (requiring CNOTs) shows significant drift toward the center of the Bloch sphere due to gate noise.
Non-Markovian Dynamics (Amplitude Damping and Dephasing): The authors simulate non-Markovian evolutions via Markovian embeddings, where a system interacts with a memory qubit.
- Result: The trajectory mixing method consistently yields higher fidelity than the auxiliary qubit method, particularly when considering the joint system-memory state. However, the paper notes that for the system alone, the fidelity advantage is sometimes marginal. The authors suggest that because the system and memory constantly interact, the noise from two-qubit gates in the embedding model limits the advantage of the trajectory method in complex many-body scenarios.
Memory Channels: The simulation of a dephasing memory channel acting on two qubits sent in rapid succession. This channel preserves entanglement in Bell states.
- Result: The trajectory mixing method preserves concurrence (entanglement) almost perfectly, whereas the auxiliary qubit method causes significant decay. This highlights a major advantage: the trajectory method avoids the two CNOT gates required to correlate the auxiliary qubit with both system qubits.
Stochastically Driven Hamiltonians: The authors simulate non-Markovian dynamics driven by a Hamiltonian with Random Telegraph Noise (RTN). By breaking the evolution into intervals of constant noise and mixing trajectories, they achieve extremely high fidelities without auxiliary qubits or memory qubits.

Results
Using a noise model calibrated to current processors ( $T_1=232\,\mu s$ , $T_2=127\,\mu s$ , CNOT error $\approx 2.4\%$ ), the study finds:

Fidelity: The mixed trajectory method consistently retains higher state fidelity compared to the auxiliary qubit method across pure dephasing and memory channel scenarios.
Entanglement Preservation: In memory channel simulations, the trajectory method successfully preserves entanglement, while the auxiliary method fails to do so due to the accumulation of two-qubit gate errors.
Scalability: Even with limited sampling (1024 trajectories for 25 time steps), the trajectory method outperforms the auxiliary method, which suffers from constant fidelity decay as the number of time steps increases.

Significance and Claims
The paper claims that the trajectory mixing method offers a deployable blueprint for simulating non-local environmental effects on near-term quantum hardware. Its primary significance lies in:

Noise Reduction: By trading entangling gates for a statistical mixture of independent, pure-state circuits, the method drastically reduces the noise overhead associated with auxiliary qubits.
Resource Efficiency: It enables the simulation of long-time non-Markovian evolutions with limited resources, avoiding the "devastating noise overhead" of auxiliary gates.
Practicality: While the method requires running multiple circuits, the authors argue this is a favorable trade-off given the current error rates of two-qubit gates on quantum processors.

The authors remain modest regarding the method's universality, noting that for complex many-body dynamics where system-memory interactions are constant, the advantage may be less pronounced due to the inherent noise of the required two-qubit interactions in the embedding models. However, for specific channels and memory scenarios, the approach provides a clear path to higher fidelity simulations on existing hardware.