Revealing the quantum nature of memory in non-Markovian dynamics on IBM Quantum

This paper investigates non-Markovian memory effects on IBM Quantum processors using a collision-model approach, demonstrating the verification of quantum memory in single-qubit dynamics and proposing an alternative method to witness such memory in two-qubit systems despite current hardware limitations.

The Gist

The Big Idea: Does the Quantum Computer Have a "Memory"?

Imagine you are watching a movie.

• Markovian (No Memory): Every scene is completely independent. What happens in Scene 5 has absolutely nothing to do with Scene 4. If you pause the movie and come back later, the story doesn't care that you were gone. This is how most standard, "clean" quantum physics works.
• Non-Markovian (Has Memory): The story remembers the past. If a character trips in Scene 4, they might limp in Scene 5. The future depends on the history.

In the world of quantum physics, "memory" usually means the environment (the air, the heat, the vibrations) is talking to the system (the qubit). Sometimes, this environment acts like a classical notebook (it just records data like "I saw a spin up"). Other times, it acts like a quantum notebook (it holds onto delicate, spooky quantum entanglement).

The Question: Can today's noisy, imperfect quantum computers (like the ones from IBM) actually simulate a process where the environment holds a true quantum memory, or does the noise wash it out so it just looks like a classical notebook?

The Experiment: The "Bouncing Ball" Analogy

The researchers used a method called a Collision Model. Imagine a system qubit (let's call him Bob) and an environment qubit (let's call her Alice).

1. The Setup: Bob and Alice are strangers at first. They bump into each other (collide), swap some information, and then Bob moves on to the next collision.
2. The Twist: In a "memory" scenario, Alice doesn't forget Bob after they bump. She keeps a piece of him inside her. When Bob comes back for the next collision, Alice gives him back that piece of information.
3. The Test: To prove the memory is quantum and not just classical, the researchers used a special trick involving a third character, Charlie (the "ancilla").
   • Bob and Charlie start as twin telepaths (maximally entangled). They share a secret bond.
   • Bob goes off to play with Alice (the environment).
   • If Alice has a classical memory, she treats Bob like a normal object. The telepathic bond between Bob and Charlie gets weaker or stays the same.
   • If Alice has a quantum memory, she interacts with Bob in a way that actually strengthens or revives the bond between Bob and Charlie later on.

The Rule: If the bond (entanglement) between Bob and Charlie gets stronger after Bob interacts with Alice, then Alice must have a quantum memory. If it's just a classical notebook, the bond can never get stronger than it was before.

What They Did on IBM Quantum

The team used IBM's real quantum computers (specifically the ibm_sherbrooke processor) to run this experiment.

1. The Single-Qubit Test (The Easy Win)

They started with just one system qubit (Bob).

• Result: It worked! Even though the computer was noisy (like trying to hear a whisper in a hurricane), they could clearly see the "telepathic bond" between Bob and Charlie get stronger after the collision.
• Takeaway: Current quantum computers are good enough to prove that a system can have a genuine quantum memory. They successfully simulated a process where the environment "remembered" the quantum state in a way that a classical computer couldn't fake.

2. The Two-Qubit Test (The Hard Mode)

Next, they tried to do the same thing with two system qubits (Bob and Dave).

• The Problem: To make two qubits interact with the environment in the "real" theoretical way, the computer had to perform a massive number of complex operations (gates). It was like asking a tired runner to sprint a marathon while carrying a heavy piano.
• The Result: The noise was too strong. The computer got confused, the delicate quantum bonds broke, and the "memory" looked classical. The experiment failed to show quantum memory because the machine wasn't powerful enough to hold the complex circuit together long enough.

3. The "Toy Model" (The Clever Workaround)

Instead of giving up, they got creative. They designed a simpler, "toy" version of the two-qubit experiment.

• The Trick: Instead of a complex, heavy interaction, they used a simpler set of moves that still had the essential property of quantum memory but required far fewer steps.
• The Result: Success! With this simpler circuit, the IBM computer could again show that the memory was quantum. The "telepathic bond" revived.

Why Does This Matter?

Think of quantum computers as newly built cars.

• In the past, we thought these cars were too noisy and shaky to drive on a bumpy road (simulating complex quantum physics).
• This paper shows that, surprisingly, these cars can drive on the bumpy road.
• Specifically, they can simulate memory. This is crucial because the real world (chemistry, materials science, biology) is full of memory effects. If we want to use quantum computers to discover new drugs or materials, they must be able to simulate memory accurately.

The Bottom Line

The researchers proved that:

1. Yes, today's noisy quantum computers can simulate processes that rely on true quantum memory.
2. We can distinguish between a "classical notebook" memory and a "quantum notebook" memory, even with the noise.
3. While complex simulations are still too hard for current machines, clever, simpler designs can still reveal these deep quantum secrets.

It's a victory for the "NISQ" era (Noisy Intermediate-Scale Quantum), showing that even with imperfect hardware, we are starting to unlock the ability to simulate the most complex, memory-filled aspects of our universe.

Technical Summary

1. Problem Statement

The paper addresses a critical challenge in the era of Noisy Intermediate-Scale Quantum (NISQ) computing: determining whether current quantum hardware is capable of simulating non-Markovian quantum dynamics where the memory effects are genuinely quantum in nature, rather than classical.

• Context: While non-Markovian dynamics (where future states depend on history) can often be simulated using classical memory, certain physical processes require "quantum memory" (entanglement or quantum correlations with the environment) to be realized.
• The Challenge: Distinguishing between classical and quantum memory is experimentally difficult. Furthermore, NISQ devices suffer from noise and decoherence, which can degrade quantum features, potentially making a quantum-memorable process appear classical or Markovian.
• Goal: To verify if IBM Quantum processors can successfully implement and witness the "quantumness" of memory in both single-qubit and two-qubit systems despite hardware noise.

2. Methodology

The authors employ a collision model approach to discretize continuous-time non-Markovian dynamics, making them implementable on gate-based quantum circuits.

A. Theoretical Framework

• Memory Classification: The paper utilizes a map-based definition (from Ref. [51]) to distinguish memory types.
  • Classical Memory: The dynamics can be decomposed into a measurement on the system followed by a conditional operation based on the classical outcome.
  • Quantum Memory: The dynamics cannot be decomposed this way; it requires the system to retain quantum correlations with the environment.
• Witness Criterion: To detect quantum memory, the authors use the Concurrence of Formation ($C$) and Concurrence of Assistance ($C^\sharp$) on a system-ancilla state.
  • If $C^\sharp(t_1) < C(t_2)$ for two time steps $t_1 < t_2$, the memory is proven to be quantum.
  • This criterion avoids the need for full process tensor tomography, which is experimentally expensive.

B. Experimental Implementation

• Hardware: Experiments were conducted on the IBM Quantum ibm_sherbrooke (an Eagle processor with >100 qubits).
• Single-Qubit Dynamics:
  • Model: A non-Markovian amplitude damping process governed by a master equation with a time-dependent decay rate that changes sign.
  • Circuit: The system qubit interacts sequentially with an environment qubit via a unitary collision ($U_\delta$). An ancilla qubit is entangled with the system initially to monitor the Choi-Jamiołkowski state.
  • Verification: Quantum State Tomography (QST) is performed on the system-ancilla state at specific time steps ($t_1, t_2$) to calculate concurrences.
• Two-Qubit Dynamics:
  • Challenge: Directly extending the single-qubit model to two system qubits resulted in circuits requiring >500 gates per collision after transpilation, exceeding coherence times ($T_1, T_2$).
  • Solution (Toy Model): The authors designed a simplified circuit where two system qubits interact with two environment qubits via a product of two-qubit unitaries. This minimized gate depth and connectivity issues.
  • Error Mitigation: Readout error mitigation was applied to the two-qubit experiment to improve fidelity.

3. Key Results

A. Single-Qubit Dynamics

• Non-Markovianity: The experiment successfully demonstrated non-Markovian behavior. The trace distance and Bloch sphere volume increased between time steps, confirming memory effects.
• Quantum Memory Witness:
  • Theoretical prediction: $C^\sharp(t_1) = 0$ and $C(t_2) = 1$.
  • Experimental result (IBM Quantum): $C^\sharp(t_1) \approx 0.51$ and $C(t_2) \approx 0.62$.
  • Conclusion: Despite the fidelity dropping from theoretical ideals (Fidelity $\approx 0.57$ at $t_2$), the condition $C^\sharp(t_1) < C(t_2)$ held true. This proves that current noisy hardware can witness quantum memory in single-qubit dynamics.
• Comparison: Local simulations (using IBM's noise models) predicted better performance than the actual hardware, highlighting the impact of real-world noise.

B. Two-Qubit Dynamics

• Failure of Physical Model: The physically motivated extension of the single-qubit model failed on real hardware. The complex unitary required too many gates, causing the system to decohere into a random unitary process where no quantum memory could be detected ($C^\sharp \approx C$).
• Success of Toy Model: The simplified "toy" circuit, designed to minimize gate count and maximize qubit connectivity, succeeded.
  • Result: $C^\sharp(t_1) = 0.72 < 0.89 = C(t_2)$.
  • Conclusion: With careful circuit design (reducing gate depth and optimizing connectivity), current quantum computers can witness quantum memory in two-qubit dynamics.

4. Significance and Contributions

1. Experimental Verification of Quantum Memory: This is one of the first demonstrations that NISQ devices can not only simulate non-Markovian dynamics but also distinguish the quantum nature of the memory from classical memory effects.
2. Methodological Advancement: The paper validates a map-based criterion ($C^\sharp < C$) as a practical, experimentally feasible alternative to full process tensor tomography for characterizing memory in higher-dimensional systems.
3. Hardware Limitations and Mitigation: The study highlights that while hardware noise is significant, it does not necessarily preclude the observation of quantum features. However, it emphasizes that circuit optimization (minimizing gate count and utilizing high-connectivity qubit pairs) is critical for preserving quantum memory in multi-qubit systems.
4. Implications for Quantum Simulation: The results suggest that contemporary quantum computers are sufficiently advanced to simulate complex open quantum systems where quantum memory is a resource, paving the way for more accurate simulations in quantum chemistry, materials science, and thermodynamics.

5. Conclusion

The authors conclude that while noise on IBM Quantum processors degrades the fidelity of the simulation, it does not destroy the fundamental quantum nature of the memory effects in the tested models. By using collision models and appropriate witnesses, researchers can verify quantum memory in both single- and two-qubit systems, provided the circuit depth is managed to stay within the coherence limits of the hardware.