Matrix Product States for 1D Quantum Systems

Recommended resources

The freely available resources this lesson will direct you to.

Garnet Chan "Matrix product states, DMRG, and tensor networks" (Part 1 of 2)www.youtube.com
Tutorial on Tensor Networks and Quantum Computing with Miles Stoudenmirewww.youtube.com
Introducing matrix product states for quantum practitionerspennylane.ai
A Practical Introduction to Quantum Many-Body Simulation ...a1akhtar.physics.ucsd.edu

Hello! Welcome to the first lesson in our new module, "Advanced Computational Many-Body Methods."

In the previous module, we developed powerful numerical tools for single-particle quantum mechanics, culminating in the simulation of quantum transport using the Landauer-Büttiker formalism. While incredibly useful, those methods generally apply to non-interacting systems. Your primary goal is to tackle the frontier of many-body quantum theory, and that requires a new set of tools.

The biggest challenge in many-body physics is the sheer size of the problem. As we add particles, the Hilbert space dimension grows exponentially, a problem famously known as the "curse of dimensionality." Storing the complete wavefunction for even a few dozen spins is impossible on any existing or conceivable computer.

Today, we will learn about the formalism that provides a way around this exponential wall for a large and physically important class of systems. Your learning outcome for this lesson is to represent one-dimensional quantum many-body states using the Matrix Product State (MPS) formalism. This is the foundational concept behind some of the most powerful numerical methods in condensed matter physics, such as the Density Matrix Renormalization Group (DMRG).

1. The Problem and the Physical Insight

Before diving into the mathematics of MPS, it's crucial to understand why such an efficient representation is possible. The naive assumption that we need to describe every possible state in the enormous Hilbert space is, fortunately, incorrect for many physical systems.

Garnet Chan "Matrix product states, DMRG, and tensor networks" (Part 1 of 2)

To begin, let's watch a segment from a lecture by Prof. Garnet Chan. He provides an excellent motivation for tensor networks by explaining the curse of dimensionality and introducing the key physical principle that saves us: the low-entanglement nature of physical ground states.

Watch from 02:05 to 07:31. Focus on the two main ideas: The exponential scaling of the Hilbert space and why this makes the many-body Schrödinger equation seem intractable. The concept that physical Hamiltonians at low energies do not explore the entire Hilbert space, but are restricted to a 'corner' characterized by low entanglement.

The crucial insight mentioned in the video is that ground states of local, gapped Hamiltonians obey an area law of entanglement, rather than a "volume law." This means the entanglement between a subregion and the rest of the system scales with the size of the boundary (the "area") between them, not the size of the subregion itself (the "volume").

For a 1D system, a subregion is a contiguous block of sites. Its boundary consists of just two points, regardless of how large the block is. This means the entanglement entropy is bounded by a constant, not growing with the subsystem size. MPS is a representation that is perfectly suited to capture this area-law scaling.

2. A New Language: Tensor Diagrams

Working with high-order tensors and their numerous indices quickly becomes notationally cumbersome. We will adopt the Penrose graphical notation, which is both intuitive and powerful.

Tutorial on Tensor Networks and Quantum Computing with Miles Stoudenmire

This tutorial by Miles Stoudenmire provides a very clear introduction to the graphical notation we'll be using.

Watch from 07:56 to 13:32. Pay close attention to the rules: A shape represents a tensor. A line (or leg) coming out of a shape represents an index. Joining two lines implies a sum over that shared index (tensor contraction).

In this notation:

A many-body wavefunction $Ψ_{σ_{1}, σ_{2}, ..., σ_{N}}$ is a single, large tensor with $N$ "physical" indices (the dangling legs).
A Matrix Product State is a decomposition of this large tensor into a chain of smaller, interconnected tensors. The connections represent "virtual" or "bond" indices being contracted.

Matrix Product State (MPS) and Matrix Product Operator (MPO) Diagrams — Graphical representation of (a) a Matrix Product State (MPS) and (b) a Matrix Product Operator (MPO). The vertical lines are physical indices ($n_i$) and the horizontal lines are virtual indices ($l_i$) that are contracted between adjacent sites.

Test your understanding!

Consider a diagram with two squares, each with two legs. Let the left square be matrix $A_{ij}$ and the right be $B_{k l}$ . If the right leg of $A$ (index $j$ ) is connected to the left leg of $B$ (index $k$ ), what mathematical operation does this diagram represent?

Show answer

It represents matrix multiplication: $\sum_{j} A_{ij} B_{j l}$ . The result is a new matrix $C_{i l}$ with two uncontracted legs.

3. Deconstructing the Wavefunction: MPS from SVD

How do we obtain this MPS representation? The most direct way to understand it is through a constructive algorithm that uses a sequence of Singular Value Decompositions (SVD). The SVD is the ideal mathematical tool for this because it optimally splits a matrix into its fundamental components and tells us how important each component is via the singular values.

The process involves repeatedly reshaping the state tensor into a matrix, performing an SVD to split off one site, and absorbing the remainder into the rest of the chain.

Tutorial on Tensor Networks and Quantum Computing with Miles Stoudenmire

The following segment from Miles Stoudenmire's tutorial provides a clear, animated, step-by-step walkthrough of how to convert a full tensor into an MPS using SVDs.

Watch the section from 17:52 to 26:24. Don't worry about catching every detail on the first pass. The goal is to understand the rhythm of the algorithm: reshape, SVD, save one tensor, and repeat with the remainder.

The key steps of this "tensor train" decomposition are:

Start with the full state tensor $Ψ_{σ_{1}, σ_{2}, \dots, σ_{N}}$ .
Reshape it into a matrix $M$ with dimensions $d \times d^{N - 1}$ , separating the first site's index $σ_{1}$ from all others.
Perform an SVD: $M = U Λ V^{†}$ . The matrix $U$ becomes the first MPS tensor, $A^{[σ_{1}]}$ .
The remainder, $Λ V^{†}$ , is a new tensor representing the rest of the chain. Reshape it to separate the second site's index $σ_{2}$ , perform another SVD, and so on.
Repeat this process down the chain.

The size of the virtual indices that connect the tensors is called the bond dimension, denoted by $χ$ . In the exact decomposition, $χ$ can grow exponentially towards the middle of the chain. The power of MPS comes from truncation: by keeping only the $χ$ largest singular values at each step, we create a compressed approximation of the state. For states satisfying the area law, this is an excellent approximation.

To see how this algorithm translates into code, let's examine a practical implementation.

Introducing matrix product states for quantum practitioners

This PennyLane tutorial provides a Python implementation that mirrors the SVD algorithm we just saw. Studying the code will solidify your understanding of the process.

Read the section 'Turn any state into an MPS'. Follow the 3-site example both analytically and in the provided code snippets. Then, examine the full dense_to_mps function. Notice how it iteratively reshapes the psi vector and applies an SVD (split function) to peel off one tensor at a time. The bond_dim argument is where the truncation happens.

4. What is an MPS? A Look at Concrete Examples

An MPS is more than just a compression scheme; it's a structure that can encode physical rules and correlations.

Example 1: The Parity State

A simple, non-trivial state is an equal superposition of all bitstrings with an even number of '1's. This state has global correlations—you can't determine if a bitstring is valid by looking at only part of it. Yet, it has a remarkably simple MPS representation.

Tutorial on Tensor Networks and Quantum Computing with Miles Stoudenmire

Let's return to Miles Stoudenmire's tutorial for a beautiful, constructive example of an MPS for the even parity state. This illustrates how the virtual indices can carry information (in this case, the parity) along the chain.

Watch from 39:43 to 46:56. The core idea is that the local MPS tensor is an identity matrix if the physical bit is 0, and a flipping matrix (Pauli-X) if the bit is 1. The bond dimension needed is only \chi=2 (to encode even/odd parity), regardless of the system size!

Example 2: The AKLT Ground State

A classic example from condensed matter is the ground state of the Affleck-Kennedy-Lieb-Tasaki (AKLT) model, a chain of spin-1 particles. This state is the prototype of a symmetry-protected topological (SPT) phase and can be represented exactly by an MPS with bond dimension $χ = 2$ .

A Practical Introduction to Quantum Many-Body Simulation ...

This paper gives the explicit matrices for the AKLT ground state. It's a good exercise to see a physically relevant state written in this form.

Read Section 4.2, 'AKLT Ground State' (pages 10-11). Look at the three matrices given for A[0], A[+1], and A[-1]. The text then shows how products of these matrices generate the coefficients of the N=2 ground state. This demonstrates the 'Matrix Product' nature of the state.

5. The Power of the MPS Formalism

The reason MPS is so widely used is that it doesn't just provide compact storage; it allows for efficient computations.

Efficient Storage: The memory required to store an MPS scales as $O (N d χ^{2})$ , which is polynomial in $N$ and $χ$ , compared to the exponential $O (d^{N})$ for the full state vector.
Efficient Computations: Many important operations can be performed directly on the compressed MPS form. For example, calculating the inner product $⟨ ψ^{'} ∣ ψ ⟩$ doesn't require reconstructing the full state vectors. Instead, it can be done with a sequence of local tensor contractions that "zips" across the chain, with a cost that scales polynomially, typically $O (N d χ^{3})$ .

Tutorial on Tensor Networks and Quantum Computing with Miles Stoudenmire

Let's watch a final segment that summarizes the benefits of the MPS form and illustrates the efficient inner product calculation.

Watch from 28:15 to 37:50. The speaker discusses the polynomial scaling of storage and then walks through the efficient 'zipper' algorithm for computing an inner product. The performance comparison at the end (trillion-element dot product in milliseconds) is a dramatic demonstration of the power of this method.

6. Canonical Forms and Operators

The MPS representation of a state is not unique. You can insert an invertible matrix $G$ and its inverse $G^{- 1}$ between any two tensors, $A^{[i]} A^{[i + 1]} = (A^{[i]} G) (G^{- 1} A^{[i + 1]})$ , and the overall state remains unchanged. This "gauge freedom" can be used to our advantage by fixing the tensors into a canonical form.

The most common are left- and right-canonical forms, where the tensors are chosen to be isometries. For a left-canonical MPS, contracting a tensor with its conjugate from the left gives the identity matrix. This is incredibly useful because it means that the environment to the left of any site is trivial.

Introducing matrix product states for quantum practitioners

The PennyLane tutorial has a concise section explaining these canonical forms and their utility.

Read the section 'Canonical forms'. Focus on the graphical identity that contracting a left-orthonormal tensor with its conjugate yields a simple line (the identity). This property is what makes local calculations, like expectation values, so efficient.

Finally, just as states can be represented as an MPS, operators can be represented as a Matrix Product Operator (MPO). This is essential for representing Hamiltonians and time-evolution operators, which we will need for finding ground states and simulating dynamics. The structure is analogous to an MPS, but each local tensor has two physical indices (an input and an output) instead of one.

Conclusion

In this lesson, we have taken our first major step into the world of computational many-body physics. We confronted the "curse of dimensionality" and saw how the physical principle of the area law allows us to find a path around it using the Matrix Product State formalism.

Key Takeaways:

The Hilbert space of a many-body system grows exponentially, making brute-force simulation impossible.
Physical ground states of local Hamiltonians typically exhibit low entanglement and obey an area law, making them representable on a small "corner" of the full Hilbert space.
Matrix Product States (MPS) are a tensor network representation that factorizes a many-body state into a one-dimensional chain of smaller tensors, perfectly suited for area-law states.
An MPS can be constructed from a dense state vector via a sequence of Singular Value Decompositions (SVDs). The number of singular values kept, the bond dimension $χ$ , controls the accuracy of the representation.
The MPS formalism allows for efficient storage and computation. Operations like calculating inner products and expectation values scale polynomially with system size, not exponentially.
Canonical forms simplify calculations, and Matrix Product Operators (MPOs) provide an analogous representation for operators like the Hamiltonian.

Preview of the Next Lesson:
We have now learned how to represent a one-dimensional quantum state efficiently as an MPS. The natural next question is: how do we find the MPS representation of the ground state of a given Hamiltonian without ever constructing the full state vector? In the next lesson, we will answer this by exploring the conceptual basis of the Density Matrix Renormalization Group (DMRG), an algorithm that variationally optimizes an MPS to find the ground state.