TensorMixedStates: a Julia library for simulating pure and mixed quantum states using matrix product states

The paper introduces TensorMixedStates, a user-friendly Julia library built on ITensor that enables efficient simulation of both pure and mixed quantum states, including dissipative dynamics via Lindblad equations and non-unitary gates, using matrix product state representations.

The Gist

The Big Picture: Simulating a Leaky Quantum World

Imagine you are trying to predict how a complex machine works. In the world of quantum physics, this machine is made of tiny particles (like atoms or electrons). Usually, scientists try to simulate these particles as if they are in a perfect, sealed box where nothing ever gets in or out. This is called a "pure" state.

However, in the real world, nothing is perfectly sealed. These quantum machines are constantly bumping into their environment, leaking energy, or getting "noisy." This is called a "mixed" state. Simulating a leaky, noisy system is incredibly hard for computers because the math gets messy and explodes in complexity very quickly.

TensorMixedStates is a new computer program (a library) written in the Julia language that helps scientists simulate these "leaky" quantum systems. It acts like a specialized toolkit that allows researchers to track how quantum states change when they are disturbed by noise, heat, or dissipation.

The Core Tool: The "MPS" Backpack

To understand how this library works, you need to understand the concept of a Matrix Product State (MPS).

Imagine you have a very long chain of people holding hands. If you want to describe the whole chain, you could try to write down the exact position of every single person at once. For a long chain, this list would be impossibly huge.

Instead, the MPS method says: "Let's just describe how each person is holding hands with their immediate neighbor." By breaking the big problem down into small, local connections, we can compress the information. It's like describing a long story by summarizing the relationship between each pair of characters rather than rewriting the whole book every time.

The TensorMixedStates library takes this "backpack" method and upgrades it.

• Old versions of these tools could only carry "pure" states (perfect, sealed boxes).
• TensorMixedStates can carry "mixed" states (leaky, noisy boxes). It treats the messy, leaking information as a special kind of vector that can still be compressed and managed efficiently.

How It Works: The "Lego" Approach

The paper explains that this library is built on top of another famous tool called ITensor. Think of ITensor as a high-quality set of Lego bricks that are very good at snapping together.

• The Problem: The original Lego set (ITensor) was designed to build perfect, rigid structures (pure states). It didn't have the right connectors for wobbly, melting structures (mixed states).
• The Solution: The authors built a new "adapter kit" (TensorMixedStates) that sits on top of the Lego set. This kit allows you to build those wobbly, melting structures using the same strong Lego bricks underneath.

The library offers three main superpowers:

1. Handling the Mess: It can represent density matrices (the math for mixed states) using the same efficient "backpack" (MPS) method used for pure states.
2. Time Travel: It can simulate how these systems change over time. This includes:
   • Schrödinger evolution: How a system changes when it's perfectly isolated.
   • Lindblad evolution: How a system changes when it's leaking energy or interacting with a noisy environment.
   • Quantum Channels: How a system changes when you apply specific "gates" or operations that might introduce errors (like a noisy quantum computer).
3. User-Friendly Interface: The authors built a "high-level" interface. This means a scientist can write a complex simulation in just a few lines of code, almost like writing a recipe, rather than having to write thousands of lines of raw math code.

Real-World Examples in the Paper

The paper doesn't just talk about theory; it shows the library working on six different physical scenarios. Here is a simple breakdown of what they tested:

• The Noisy Fermion Chain: Imagine a line of electrons hopping along a wire. The researchers added "dephasing noise" (like static on a radio) to see how the electrons spread out. The library's results matched the exact mathematical answers perfectly.
• The Leaky Spin Chain: Imagine a row of tiny magnets (spins). The ends of the row are connected to a "reservoir" (a heat bath) that tries to flip the magnets. The library successfully simulated how the magnetism flows through the chain.
• The Boson Source: Imagine a pipe injecting particles into a line of empty spots. The library tracked how the particles filled up the line over time, even when the local space for particles was limited.
• The Graph State Decoherence: Imagine a complex web of entangled qubits (quantum bits). The researchers watched how this web unraveled (decohered) when exposed to noise. The library was able to simulate this for a massive system of 512 qubits, which is a huge number for this type of calculation.
• The Noisy Circuit: Imagine a quantum computer circuit where the gates (the switches) sometimes make mistakes. The library simulated a "brick wall" pattern of gates and errors, showing how the "entanglement" (the quantum connection between parts) grows and then gets destroyed by the noise.

Why This Matters (According to the Paper)

The paper claims that this library fills a gap. While there are great tools for simulating perfect quantum systems, tools for simulating realistic, noisy systems were scarce or difficult to use.

• Efficiency: It uses the best algorithms available (like TDVP and DMRG) to keep the calculations fast and accurate.
• Precision: It includes built-in checks to tell the user if the simulation is getting "sloppy" (e.g., if the math starts to drift away from physical reality).
• Accessibility: It allows researchers to set up sophisticated simulations in a few lines of code, making it easier to study how quantum systems behave in the real, noisy world.

In short, TensorMixedStates is a new, user-friendly engine that lets scientists drive their quantum simulations through the rough, noisy terrain of the real world, rather than just on the smooth, perfect roads of theory.

Technical Summary

Technical Summary of "TensorMixedStates: a Julia library for simulating pure and mixed quantum states using matrix product states"

Problem Statement
The simulation of open quantum many-body systems is a critical challenge in modern physics, driven by experimental progress in cold atoms, trapped ions, and superconducting circuits. Unlike closed systems, open systems interact with their environment, leading to noise, dissipation, and decoherence, which are often described by the Lindblad master equation. While tensor network methods, specifically Matrix Product States (MPS), have become the standard for simulating pure states (using libraries like ITensor or TenPy), software for simulating mixed states (density matrices) within the MPS framework is significantly more limited. Existing solutions often lack flexibility, are restricted to specific local Hilbert spaces (e.g., qubits only), or do not integrate seamlessly with state-of-the-art algorithms. Furthermore, representing mixed states requires handling density matrices as vectors in a doubled Hilbert space, introducing complexities in operator actions (e.g., $O\rho$, $O\rho O^\dagger$, commutators) that standard pure-state frameworks do not natively support.

Methodology
The authors introduce TensorMixedStates (TMS), a Julia library built on top of the ITensor library. TMS is designed to simulate both pure and mixed quantum states using MPS representations.

• Core Architecture: TMS leverages the robust low-level tensor manipulation and high-performance algorithms (DMRG, TDVP) of ITensor. However, recognizing that ITensor's native framework is optimized for pure states, TMS implements a new state and operator framework from scratch to accommodate mixed states.
• Mixed State Representation: The library represents the density matrix $\rho$ as a vectorized state $|\rho\rangle\rangle$ in a larger space of dimension $d^2$. This allows the use of MPS techniques where the density matrix is decomposed into a product of 4-index tensors (or 3-index tensors in the vectorized basis).
• Operator Framework: A key design choice is the development of a flexible operator framework capable of handling the four distinct ways an operator can act on a density matrix: $O\rho$, $O\rho O^\dagger$, $[O, \rho]$, and $\{O^\dagger O, \rho\}$. This includes support for Lindblad dissipators and general quantum channels (Kraus operators).
• Algorithms:
  • Time Evolution: TMS supports continuous time evolution via the Lindblad equation using two primary algorithms: TDVP (Time-Dependent Variational Principle) and WI/WII approximations (MPO approximations of the exponential map). The WI/WII methods are noted as complementary to TDVP, particularly for non-Hermitian evolutions.
  • Steady States: The library computes steady states by finding the ground state of the Hermitian operator $L^\dagger L$ using DMRG, avoiding the need for long-time integration.
  • Discrete Evolution: It supports the application of non-unitary gates and quantum channels.
• Interface: TMS offers a dual interface: a low-level API for fine-grained control and a high-level interface (runTMS) that allows users to define complex simulation workflows (state creation, evolution, measurement) in a few lines of code.

Key Contributions

1. Generalized Mixed State Simulation: TMS extends MPS capabilities beyond qubits to general local Hilbert spaces, including bosons, fermions, spins, and $t-J$ models, addressing a gap in the software ecosystem for open quantum systems.
2. Flexible Operator Framework: It provides a comprehensive set of tools to construct Hamiltonians, Lindblad dissipators, and general quantum channels, handling the algebraic complexity of mixed-state operations.
3. Algorithmic Suite: The library integrates TDVP and WI/WII approximations for time evolution and DMRG for steady-state calculations specifically adapted for the Lindbladian formalism.
4. User-Friendly Design: The high-level interface simplifies the setup of sophisticated simulations, while the underlying Julia/ITensor architecture ensures multithreading and efficient tensor contractions.
5. Validation: The library is validated against exact analytical solutions for several quasi-free models (fermionic and bosonic chains with dephasing or injection, XX spin chains with boundary dissipation) and known results for graph state decoherence and noisy quantum circuits.

Results
The paper demonstrates the library's capabilities through six examples:

• Fermionic Chain with Dephasing: Simulations of fermion density and Operator Space Entanglement Entropy (OSEE) show excellent agreement with exact asymptotic results for various dissipation strengths.
• XX Spin Chain with Boundary Dissipation: Time evolution of magnetization and spin current matches results from previous literature.
• Free Bosons with Localized Source: The library successfully models the dynamics of a bosonic chain with particle injection, capturing density profiles and total particle number growth, though computational cost increases with local Hilbert space dimension.
• Free Fermions with Localized Source: Comparisons between TDVP and WI/WII algorithms show that both offer similar precision for this model, though TDVP requires significantly more CPU time.
• Decoherence of a Complete-Graph State: The library handles large system sizes (up to $N=512$) efficiently, as the low entanglement of the state allows for small bond dimensions.
• Noisy Quantum Circuit: The library simulates a brick-wall quantum circuit with unitary gates and depolarizing noise, tracking the growth and subsequent decay of OSEE due to noise.

Significance and Claims
The authors position TMS as a necessary tool to fill the gap in software for simulating open quantum systems with MPS. They claim that the library offers a "user-friendly interface" allowing sophisticated simulations in "a few lines of code" while maintaining access to "state-of-the-art algorithms" via ITensor. The paper emphasizes that the library does not implement trajectory unraveling but focuses on direct density matrix evolution. The significance lies in its ability to handle general local Hilbert spaces (unlike its predecessor, Lindbladmpo) and its integration with the modern Julia ecosystem. The authors modestly note that while the library is powerful, the computational cost for systems with large local dimensions (like bosons) remains high, and future work will focus on incorporating conserved quantum numbers (QNS) and automated MPO compression to further improve efficiency.