Infinite DMRG for 1D Quantum Lattices

Hello! Welcome to the next step in your exploration of advanced computational methods.

In our previous lesson, we established the conceptual foundation of the Density Matrix Renormalization Group (DMRG). You learned that DMRG is a variational method that sidesteps the exponential complexity of many-body systems by working with Matrix Product States (MPS). We saw how the reduced density matrix provides the optimal criterion for truncating the Hilbert space of a block, keeping only the most probable states in the context of a larger system.

Today, we transition from the "why" to the "how." Your learning outcome is to implement the infinite-system DMRG algorithm to find the ground state of a one-dimensional quantum lattice model. We will deconstruct this algorithm into a concrete, step-by-step procedure and examine a Python implementation. This "infinite-system" or "warm-up" phase is the first stage of any DMRG calculation, designed to grow the system from a few sites to its target size while generating a good initial MPS.

1. From Concepts to Algorithm: The Infinite-System Loop

Recall from our last session that the core failure of early numerical renormalization methods was treating blocks in isolation. DMRG solves this by embedding the growing blocks within a superblock. For the infinite algorithm, this superblock typically has a four-part structure: Left Block - Site - Site - Right Block.

The algorithm iteratively grows the Left and Right blocks until the chain reaches the desired length. At each step, the chain grows by two sites. Let's outline the process for a single iteration.

The Infinite-DMRG Iteration:

1. Form the Superblock Hamiltonian: We construct the Hamiltonian for the entire Left Block - Site - Site - Right Block structure. For a nearest-neighbor model like the Heisenberg chain ($H=J{\sum }_i{\mathbf{S}}_i\cdot {\mathbf{S}}_{i+1}$), this Hamiltonian consists of:

   • The internal Hamiltonian of the Left Block ($H_L$).
   • The internal Hamiltonian of the Right Block ($H_R$).
   • The interaction between the Left Block and the first site.
   • The interaction between the two central sites.
   • The interaction between the second site and the Right Block.

   Symbolically, this looks like:

   $$H_{\text{super}}=H_L\otimes I_{s1}\otimes I_{s2}\otimes I_R+I_L\otimes H_{s1,s2}\otimes I_R+I_L\otimes I_{s1}\otimes H_R+H_{\text{interactions}}$$

   Where the interaction terms couple the boundaries of the blocks and sites.

2. Find the Ground State: We diagonalize $H_{\text{super}}$. Since this matrix can be large, but we only need the ground state (the lowest eigenstate), we use an iterative eigensolver like the Lanczos algorithm. This gives us the ground state vector $|{\Psi }_{\text{GS}}⟩$.

3. Calculate the Reduced Density Matrix: To update our Left Block, we need to know which of its states are most important for forming $|{\Psi }_{\text{GS}}⟩$. We form a new, larger block, Left-Block + Site, and find its reduced density matrix by tracing out the Site + Right-Block environment:

   $${\rho }_{L^{\prime }}={\text{Tr}}_{s2,R}(|{\Psi }_{\text{GS}}⟩⟨{\Psi }_{\text{GS}}|)$$

   Computationally, this is done by reshaping the vector $|{\Psi }_{\text{GS}}⟩$ into a matrix ${\Psi }_{L^{\prime },R^{\prime }}$ and computing ${\rho }_{L^{\prime }}={\Psi }_{L^{\prime },R^{\prime }}{\Psi }_{L^{\prime },R^{\prime }}^{†}$.

4. Truncate and Build the New Basis: We diagonalize ${\rho }_{L^{\prime }}$ to find its eigenvalues $w_{\alpha }$ and eigenvectors $|w_{\alpha }⟩$. The $m$ eigenvectors with the largest eigenvalues form the optimal, truncated basis for the new Left Block. We construct a transformation matrix $U$ whose columns are these $m$ eigenvectors.

5. Renormalize Operators: We transform all operators for the new Left Block into this new truncated basis. For example, the new block Hamiltonian becomes:

   $$H_{L,\text{new}}=U^{†}{H}_{L^{\prime }}U$$

   We must also transform the operators at the right edge of the block (e.g., $S^z$, $S^{+}$) as they will be needed to construct the superblock Hamiltonian in the next iteration.

6. Repeat: The new, renormalized Left Block becomes the Left Block for the next cycle. In the simplest infinite-DMRG scheme, we assume reflection symmetry and take the new Right Block to be a mirror image of the new Left Block. The process repeats, and the chain grows.

2. A Practical Implementation in Python

Theory is essential, but seeing the algorithm in code makes it concrete. We will now examine a Python implementation that performs infinite-system DMRG for the spin-1/2 Heisenberg model. Your strong background in Python and NumPy will make the code's structure easy to follow.

Let's dissect the main loop of the simple_dmrg.py script. The logic directly maps to the five steps we just discussed.

Code Walkthrough (simple_dmrg.py)

• Initialization: The script starts by defining the single-site operators (s_p, s_m, s_z, s_ident) and initializing the block operators (H_block, Sz_block, Sp_block) for a single-site block.

• The Main Loop: The for n_steps in range(...) loop executes the iterative growth.

  1. Form Superblock Hamiltonian (H_super):

     # Construct the superblock Hamiltonian
     H_super = (np.kron(H_block, s_ident2) + 
                np.kron(s_ident_block, H_site2) + 
                np.kron(s_ident_block, H_block).T + 
                J * (np.kron(Sz_block, s_z) + 
                     0.5 * (np.kron(Sp_block, s_m) + np.kron(Sp_block.T, s_p))) +
                J * (np.kron(s_z, Sz_block) + 
                     0.5 * (np.kron(s_p, Sp_block.T) + np.kron(s_m, Sp_block))))
     

     This code builds the superblock Hamiltonian for a block-site-site-block structure, assuming reflection symmetry (the right block is a transpose of the left block). You can see the terms for the block Hamiltonians and the interactions at the boundaries.

  2. Find Ground State:

     vals, vecs = eigsh(H_super, k=1, which='SA')
     psi = vecs[:, 0]
     

     scipy.sparse.linalg.eigsh is the iterative eigensolver. It efficiently finds the ground state vector psi (SA stands for 'Smallest Algebraic').

  3. Calculate Reduced Density Matrix (rho):

     psi = psi.reshape(m_block*2, -1)
     rho = np.dot(psi, psi.T)
     

     The ground state vector is reshaped into a matrix where rows correspond to the new enlarged left block (block-site) and columns to the environment (site-block). The density matrix rho is then calculated.

  4. Truncate (U):

     evals, evecs = np.linalg.eigh(rho)
     U = evecs[:, -m_new:]
     

     rho is diagonalized. The columns of U are populated with the eigenvectors corresponding to the m_new largest eigenvalues.

  5. Renormalize Operators:

     H_block_new = U.T.dot(np.kron(H_block, s_ident) + ... ).dot(U)
     Sz_block_new = U.T.dot(np.kron(s_ident_block, s_z)).dot(U)
     Sp_block_new = U.T.dot(np.kron(s_ident_block, s_p)).dot(U)
     

     The Hamiltonian for the enlarged block-site system is constructed and then transformed into the new truncated basis using U. The boundary operators are also transformed. These new operators (H_block_new, etc.) then replace the old ones for the next iteration.

This loop is the heart of the infinite-DMRG algorithm. It demonstrates how the abstract concepts are translated into concrete matrix operations.

3. Reinforcing the Algorithmic Structure

To solidify your understanding, it's helpful to see the same logic expressed in a different context. The following resource provides C++ code for DMRG, and its description of the algorithm is exceptionally clear.

The CalculateSuperblock function from the C++ resource shows the structure with striking clarity:
H_superblock = H_system + H_interaction + H_environment

This reinforces that regardless of the programming language, the underlying physics and algorithmic structure remain the same.

4. Your Turn: Implement and Experiment

Now it is time to put your knowledge into practice. Your task is to work with the SimpleDMRG code.

1. Download and Run: Get the simple_dmrg.py script from the Matrix Product Toolkit and ensure you can run it.
2. Analyze the Output: The script prints the ground state energy and truncation error at each step. The energy is for the entire superblock. Modify the code to calculate and print the ground state energy per site at each step (energy / (2 * m_block + 2)).
3. Visualize Convergence: Plot the ground state energy per site versus the number of DMRG steps. You should see it converge towards the known value for the infinite Heisenberg chain ($\approx -\mathrm{0.4431...}J$).
4. Experiment: Change the number of states kept, m_new. Try values like 10, 20, and 50. How does this parameter affect the final converged energy and the speed of convergence?

This hands-on exercise will move you from passively understanding the code to actively using and modifying it, which is the core of this lesson's objective.

Conclusion

In this lesson, we have bridged the gap between the concept and the implementation of the infinite-system DMRG algorithm. You have dissected the iterative loop that allows the system to grow while keeping the basis size manageable, and you have seen how this translates directly into Python code.

Key Takeaways:

• The infinite-DMRG algorithm iteratively grows a 1D system from a small core.
• Each step involves a sequence of operations: forming a superblock Hamiltonian, finding its ground state via an iterative eigensolver, calculating the reduced density matrix, using its eigenvectors to truncate the basis, and finally renormalizing all relevant block operators into this new basis.
• The entire process is a practical application of the concepts of entanglement and optimal basis selection that we discussed previously.
• The number of states kept, m (or m_new), is a crucial parameter that controls the trade-off between accuracy and computational cost.

Preview of the Next Lesson:
The infinite-system algorithm provides a good approximation of the ground state and, more importantly, a good set of MPS tensors. However, the basis states for blocks at the beginning of the growth process were optimized for a much smaller environment. To achieve high accuracy, we need to refine these tensors in the context of the full-size chain. In our next lesson, we will implement the finite-system DMRG algorithm, which uses the output of the infinite algorithm as a starting point and "sweeps" back and forth across the chain to variationally optimize the MPS and converge to a highly accurate ground state.