TEBD for 1D Spin Chain Dynamics

Hello! Welcome back to our series on advanced computational methods.

In our last lesson, you implemented the infinite-system DMRG algorithm to find the ground state of a 1D spin chain. This was a powerful application of the Matrix Product State (MPS) formalism to a static, time-independent problem. Today, we shift our focus from finding stationary states to simulating their evolution in time.

Your learning outcome for this lesson is to implement the Time-Evolving Block Decimation (TEBD) algorithm to simulate the real-time dynamics of a 1D spin chain. TEBD is a cornerstone algorithm for studying how quantum states evolve under a given Hamiltonian, making it indispensable for probing non-equilibrium physics in many-body systems. We will see that the time evolution operator can be broken down into a series of local "gates," much like in a quantum circuit, which we can then apply sequentially to an MPS.

1. From Schrödinger to Suzuki-Trotter

The time evolution of a quantum state $|\Psi ⟩$ is governed by the Schrödinger equation, whose formal solution is given by the time evolution operator:
$|\Psi (t)⟩=\hat{U}(t)|\Psi (0)⟩=e^{-i\hat{H}t}|\Psi (0)⟩$
(We'll set $\hslash =1$). For a many-body system, the Hamiltonian $\hat{H}$ is a sum of local terms, for instance, the nearest-neighbor Heisenberg model:
$\hat{H}={\sum }_j{\hat{h}}_{j,j+1}$
The challenge is that the local terms ${\hat{h}}_{j,j+1}$ generally do not commute with each other. This means we cannot simply write $e^{-i\hat{H}t}$ as a product of exponentials of the local terms. Applying the full operator $e^{-i\hat{H}t}$ to an MPS is computationally intractable because it would generate long-range entanglement and destroy the MPS structure.

The solution is to approximate the evolution over a small time step $\delta t$ using a Suzuki-Trotter decomposition. The core idea is to split the Hamiltonian into parts whose terms do commute among themselves. For a nearest-neighbor model, a natural split is between even- and odd-numbered bonds:
$\hat{H}={\hat{H}}_{\text{even}}+{\hat{H}}_{\text{odd}}=\left({\sum }_{j\text{ even}}{\hat{h}}_{j,j+1}\right)+\left({\sum }_{j\text{ odd}}{\hat{h}}_{j,j+1}\right)$
All terms within ${\hat{H}}_{\text{even}}$ commute with each other, as do all terms within ${\hat{H}}_{\text{odd}}$.

Using the Baker-Campbell-Hausdorff formula, we can approximate the time-evolution operator. The simplest (first-order) approximation is:
$e^{-i\hat{H}\delta t}=e^{-i({\hat{H}}_{\text{even}}+{\hat{H}}_{\text{odd}})\delta t}\approx e^{-i{\hat{H}}_{\text{even}}\delta t}{e}^{-i{\hat{H}}_{\text{odd}}\delta t}+\mathcal{O}(\delta t^2)$
A more accurate and commonly used (second-order) symmetric decomposition is:
$e^{-i\hat{H}\delta t}\approx e^{-i{\hat{H}}_{\text{even}}\frac{\delta t}{2}}{e}^{-i{\hat{H}}_{\text{odd}}\delta t}{e}^{-i{\hat{H}}_{\text{even}}\frac{\delta t}{2}}+\mathcal{O}(\delta t^3)$
This decomposition breaks the global evolution into a sequence of local two-site operations, or "gates," which we can apply efficiently to an MPS.

This decomposition is visually represented by applying layers of two-site gates to the MPS, as shown below.

2. Evolving the MPS: The Gate Application Algorithm

Now that we have a sequence of two-site gates, how do we apply them to our MPS? This process is the heart of TEBD and is beautifully explained through the lens of quantum circuits, which are themselves a form of tensor network.

Let's summarize the key steps for applying a two-site gate ${\hat{U}}_{j,j+1}=e^{-i{\hat{h}}_{j,j+1}\delta t}$ to an MPS, as shown in the video and the diagram above. Assume our MPS is in a canonical form where the tensors are denoted by $A$ and the diagonal matrices of singular values by $\lambda$.

1. Contract: Identify the two tensors at sites $j$ and $j+1$, $A_j$ and $A_{j+1}$, and the singular value matrix ${\lambda }_j$ between them. Contract these three tensors with the two-site gate ${\hat{U}}_{j,j+1}$. This forms a single, large tensor $\Theta$ that connects the bonds from sites $j-1$ and $j+2$.

   $$\text{Diagrammatically: }\Theta =({\lambda }_{j-1}\cdot A_j)\cdot ({\lambda }_j\cdot A_{j+1})\cdot {\hat{U}}_{j,j+1}$$

   (Note: There are different conventions for absorbing the $\lambda$ matrices; a common one is to absorb the $\lambda$ on the bond being updated, as well as the adjacent ones.)

2. Reshape and Decompose: Reshape the four-index tensor $\Theta$ into a matrix where the rows correspond to the incoming bond from site $j-1$ and the physical index of site $j$, and the columns correspond to the physical index of site $j+1$ and the outgoing bond to site $j+2$. Perform a Singular Value Decomposition (SVD) on this matrix:

   $$\Theta \to M\to U\Sigma V^{†}$$

3. Truncate and Update: The matrix $\Sigma$ contains the new singular values for the bond between sites $j$ and $j+1$. To prevent the bond dimension from growing indefinitely, we truncate it by keeping only the $\chi$ largest singular values. This is the "Block Decimation" step. The error introduced by this truncation is the sum of the squares of the discarded singular values.

4. Restore MPS Form: The matrices $U$ and $V^{†}$ (after reshaping) become the new MPS tensors $A_j^{\prime }$ and $A_{j+1}^{\prime }$, and the truncated $\Sigma$ becomes the new singular value matrix ${\lambda }_j^{\prime }$. The state is now an MPS again, ready for the next gate application.

Applying a single-site gate is much simpler: just contract the gate with the corresponding MPS tensor. This operation does not change the bond dimension at all.

3. Sources of Error

It is crucial to understand the two distinct, controllable sources of error in a TEBD simulation:

1. Trotter Error: This is an approximation error from the Suzuki-Trotter decomposition itself. It depends on the size of the time step $\delta t$. For a second-order decomposition, the error per step is $\mathcal{O}(\delta t^3)$, leading to a global error of $\mathcal{O}(T\cdot \delta t^2)$ for a total time $T$. This error can be reduced by using smaller time steps or higher-order decompositions.

2. Truncation Error: This error arises from discarding singular values during the SVD step to maintain a fixed bond dimension $\chi$. It depends on how much entanglement is generated by the evolution. If the state is highly entangled, many singular values will be significant, and truncating them will lead to a larger error. This can be reduced by increasing the bond dimension $\chi$.

4. Your Turn: Implementing the TEBD Algorithm

With the theory in place, it's time to implement it. Your task is to write a Python script that simulates the time evolution of a 1D spin chain using TEBD. The pseudocode provided in the TensorNetwork.org resource is an excellent blueprint.

Here is a step-by-step guide for your implementation:

1. Setup:

   • Define your model parameters: chain length N, total evolution time T, time step dt, and max bond dimension chi.
   • Define your local operators (Pauli matrices sx, sy, sz) and the identity id.
   • Construct the two-site Hamiltonian term h_j,j+1 for the Heisenberg model.

2. Initial State:

   • Create an initial MPS. A simple choice is a Néel state (|↑↓↑↓...⟩). This can be represented as an MPS with all bond dimensions equal to 1. An MPS is typically stored as a list of tensors.

3. Gate Preparation (PREPARE_U):

   • Calculate the gate matrices for the even and odd bonds using scipy.linalg.expm:
     • U_even = expm(-1j * h * dt / 2)
     • U_odd = expm(-1j * h * dt)
   • You will need to reshape these (d*d, d*d) matrices into 4-index tensors (d, d, d, d) for easy contraction, where d is the local dimension (2 for spin-1/2).

4. Core Gate Application Function:

   • Write a function apply_gate(tensor1, tensor2, singular_values, gate, chi) that performs the central TEBD step on two adjacent tensors.
   • Inside this function:
     a. Absorb the singular_values matrix into the tensors.
     b. Contract the two tensors and the gate to form the combined tensor $\Theta$. Use numpy.tensordot.
     c. Reshape $\Theta$ into a matrix.
     d. Perform the SVD using numpy.linalg.svd.
     e. Truncate the results to the maximum bond dimension chi. Keep track of the discarded weight (sum of squares of discarded singular values) to monitor the error.
     f. Reshape the resulting U and V_dagger back into MPS tensors.
     g. Return the new tensors and the new singular value matrix.

5. Main Evolution Loop:

   • Loop from t = 0 to T in steps of dt.
   • In each step, perform a full second-order Trotter update:
     a. Apply U_even to all even bonds (0,1), (2,3), ... using your apply_gate function.
     b. Apply U_odd to all odd bonds (1,2), (3,4), ...
     c. Apply U_even again to all even bonds.
   • After each full time step, calculate and store observables of interest, for example, the magnetization $⟨{\hat{S}}_i^z⟩$ at each site.
   • Plot the evolution of your observable over time. A classic experiment is to start with a single spin flipped in a ferromagnetic ground state and watch it propagate.

This is a substantial but highly rewarding coding project that will cement your understanding of tensor network dynamics. Your proficiency with Python and NumPy will be invaluable here.

Conclusion

In this lesson, you have learned the theory and algorithmic structure of the Time-Evolving Block Decimation (TEBD) method. We have seen how a seemingly intractable global time evolution can be systematically approximated as a sequence of local, two-site unitary gates via the Suzuki-Trotter decomposition.

Key Takeaways:

• TEBD simulates real-time dynamics of 1D quantum systems represented by MPS.
• The Suzuki-Trotter decomposition breaks the time-evolution operator into a product of local, two-site gates.
• Applying a two-site gate to an MPS involves a contract-SVD-truncate cycle that updates the local tensors while controlling the bond dimension.
• The accuracy of TEBD is governed by a trade-off between the Trotter error (controlled by the time step $\delta t$) and the truncation error (controlled by the bond dimension $\chi$).

Preview of the Next Lesson:
So far in this module, we have focused on deterministic methods based on the MPS ansatz (DMRG and TEBD), which are exceptionally powerful for 1D systems with low entanglement. In our next lesson, we will begin exploring a completely different paradigm for tackling many-body problems: Quantum Monte Carlo (QMC). We will start by outlining the principles of these stochastic, sampling-based methods, which excel in different regimes, particularly for higher-dimensional systems and for calculating properties of systems in thermal equilibrium.