Density Matrix Renormalization Group (DMRG)

At a Glance

• DMRG is a variational algorithm for finding ground states of 1D quantum systems.
• Optimizes a Matrix Product State (MPS) to minimize energy with respect to a Hamiltonian (MPO).
• Supports multiple optimization schedules (static, logarithmic, polynomial).
• Highly efficient for low-entanglement systems and a cornerstone of modern tensor network algorithms.

Overview

The Density Matrix Renormalization Group (DMRG) is a powerful algorithms for simulating 1D quantum many-body systems. It finds the ground state of a Hamiltonian by optimizing a Matrix Product State representation using the variational principle.

Unlike exact diagonalization (which scales exponentially), DMRG exploits the limited entanglement in low-energy states of local Hamiltonians. This allows it to efficiently represent ground states with a controlled bond dimension, making large systems tractable.

Key idea: Rather than storing the full quantum state (which is exponentially large), DMRG maintains an MPS with manageable bond dimension and iteratively improves it by sweeping through the chain, optimizing a number of sites at a time.

tip

For an introduction to Matrix Product States and tensor networks, see the Linear Tensor Networks concept page.

The Key Concept: Variational Optimization

DMRG is a variational method, meaning it finds the MPS that minimizes the energy expectation value:

$$E[\psi] = \frac{\bra{\psi}\hat{H}\ket{\psi}}{\bra{\psi}\ket{\psi}}$$

The algorithm works by:

1. Local optimization: At each step, focus on a local region and optimize its tensor using the effective ("renormalized") Hamiltonian. The current Aleph implementation uses two-site updates.
2. Sweeping: Repeat left-to-right and right-to-left sweeps through the chain until convergence
3. Bond dimension growth: Adaptively increase bond dimension to capture more entanglement where needed
4. Truncation: Remove small singular values to keep bond dimension manageable

This local optimization with sweeps is extremely efficient because the effective Hamiltonian for the local region can be computed in polynomial time rather than exponential.

Code example:

// Set up a simple quantum system
var L = 10
var H = Ising_1d(L, complex(0.5))  // Ising model with transverse field

// Create initial guess
var psi0 = make_random_mps(L, 2, 4, as_complex)

// Configure DMRG
var options = [
    "schedule": "logarithmic",
    "max_iterations": 100,
    "max_bond_dimension": 16,
    "energy_accuracy": 1e-8,
    "verbose": "sweep"
]

// Run DMRG
var result = dmrg(psi0, H, options)
var ground_energy = result[0]
var ground_state = result[1]

print("Ground state energy: " + string(ground_energy))

Algorithm Structure: The Optimization Loop

DMRG's core is the local optimization loop. The current Aleph implementation performs two-site updates:

1. Position orthogonality center at sites $i$ and $i+1$
2. Form effective Hamiltonian $H_\text{eff}$ acting on the two-site tensor
3. Minimize $\bra{\psi^{(2)}} H_\text{eff} \ket{\psi^{(2)}}$ to update the two-site tensor
4. Factorize the updated tensor using SVD, splitting back into two sites
5. Truncate small singular values according to truncation settings
6. Move orthogonality center to the next site and repeat

This process repeats in left-to-right and right-to-left sweeps until the energy converges.

Update Size

While the current implementation uses two-site updates, DMRG as an algorithm is more general. Single-site updates are faster, at the cost extra tuning parameters. In the presence of long-range couplings, it may be justified to use more sites in the update to increase convergence rate.

Control Knobs: Optimization Schedules

DMRG's behavior is controlled primarily through the optimization schedule, which determines how the bond dimension grows during sweeps. Because the bond dimensions given as input to the schedule is the actual maximum bond dimension of the MPS at the previous sweep, the truncation interacts with the schedule. As such, the dynamic schedules we provide only determine the maximum rate of growth of the bond dimensions.

In the absence of a schedule (i.e. the static schedule), DMRG tends to reach the maximum allowed bond dimension very quickly, before settling down to the required bond dimension required to efficiently represent the ground state at the target precision. The schedules serves to trottle that growth, which leads to faster sweeps, and faster convergence in absolute time.

Static Schedule

Bond dimension remains constant throughout the optimization.

Use case: Fast preliminary calculations; when correct bond dimension is already roughly known

var options = ["schedule": "static", "max_bond_dimension": 16]

Logarithmic Schedule

Bond dimension grows logarithmically faster than linear with sweep number. Provides slow, conservative growth. Ideal when the initial state provides a good estimate of the required bond dimension.

Use case: Default choice; balances efficiency and accuracy for most systems

At each sweep, the maximum bond dimension is adjusted by:

$\chi_\text{new} = \chi_\text{current} + \lfloor s \log_2(\chi_\text{current}+1)\rfloor$

where $s$ is the slope parameter. The value of $\chi_\text{new}$ is capped at the supplied maximum bond dimension.

var options = [
    "schedule": "logarithmic",
    "max_bond_dimension": 32,
    "slope": 2.0  // Controls growth rate
]

Polynomial Schedule

Bond dimension grows polynomially with sweep number. With degrees greater than one, it allows faster growth than logarithmic schedule when significantly larger bond dimensions are needed.

Use case: When rapid bond dimension growth is required for timely convergence and initial state significantly underestimates required bond dimension.

At each sweep, the maximum bond dimension is adjusted by:

$\chi_\text{new} = \chi_\text{current} + \lfloor s \cdot \chi_\text{current}^{(p-1)/p} \rfloor$

where $s$ is the slope and $p$ is the polynomial degree. The value of $\chi_\text{new}$ is capped at the supplied maximum bond dimension.

Special cases include:

• Degree 1: Linear growth $\chi_\text{new} = \chi_\text{current} + \lfloor s \cdot \chi_\text{current} \rfloor$
• Degree 2: $\chi_\text{new} = \chi_\text{current} + s \lfloor\sqrt{\chi_\text{current}}\rfloor$

var options = [
    "schedule": "polynomial",
    "max_bond_dimension": 64,
    "degree": 2,  // Polynomial degree
    "slope": 2.0  // slope of the dominant term (bond^degree)
]

Convergence Control

Several parameters control when DMRG considers the optimization converged:

• energy_accuracy: Stop when the energy difference between two subsequent sweeps is smaller than the tolerance (default: 1e-4)
• max_iterations: Maximum number of sweeps to perform (default: 100)
• truncation_accuracy: SVD truncation tolerance controlling bond dimension reduction (default: 1e-10)

The maximum possible accuracy of the energy is limited by the truncation accuracy. Indeed, with truncation induced error $\epsilon$, the final state is $\ket{\psi_\epsilon} = \ket{\psi} + \sqrt{\epsilon}\ket{\psi_\perp}$ where $\ket{\psi}$ is the exact ground state and $\ket{\psi_\perp}$ is an error contribution orthonormal to the ground state. This implies that the final energy is $E_\epsilon = E_\mathrm{exact} + \epsilon G$ where $G>E_\mathrm{exact}$ is the average energy of the error contribution. Typically, this error contribution is of the order of the truncation accuracy.

Example with tight tolerances:

var options = [
    "energy_accuracy": 1e-10,
    "truncation_accuracy": 1e-12,
    "max_iterations": 200,
    "max_bond_dimension": 128
]

Monitoring Progress: Logging

Use the verbose option to track convergence:

var options = [
    "verbose": "sweep"  // Options: "none", "sweep", "update", "all"
]

• "none": No output
• "sweep": Print energy after each full sweep
• "update": Print energy after each local optimization update
• "all": Maximum verbosity

Practical Considerations

Initial State Matters

A good initial guess can significantly accelerate convergence, use the known symmetries of the final state to improve your initial state.

Bond Dimension Selection

The key trade-off: larger bond dimension → better accuracy but slower computation.

Rule of thumb: Set max_bond_dimension to be significantly larger than what you estimate the MPS needs, but still small enough to avoid memory issues. Then:

• If DMRG converges before reaching max_iterations and the final bond dimension is smaller than max_bond_dimension, you can be confident the result is accurate.
• If DMRG hits the maximum iteration count or the final bond dimension equals max_bond_dimension, the result may not be converged and you should increase max_bond_dimension. Seed the next DMRG with the pa`tially converged mps.
• As of today, the only way to monitor the number of iterations is to set the verbose to "sweep" or "all".

Example:

// Start with generous upper bound on bond dimension
var options = [
    "max_bond_dimension": 128,
    "max_iterations": 100,
    "energy_accuracy": 1e-8,
    "verbose":"sweep"
]

var result = dmrg(psi0, H, options)
var ground_state = result[1]

// Check convergence quality
if (ground_state.max_bond() < 128) {
    print("Converged with bond dimension: " + string(ground_state.max_bond()))
    print("Result is reliable")
} else {
    print("Hit maximum bond dimension - may need to increase it")
}

System Size Limits

With the two-sites update, DMRG scales as $O(L \chi^3 d^2)$ per sweep where $L$ is system size, $\chi$ is bond dimension, $d$ is local dimension.

• Typical use: Systems with $L = 100$ to $1000$ sites
• Achievable: $L$ up to several thousand with reasonable bond dimension
• Impractical: 2D or long-range interactions

Return Value

DMRG returns a list with two elements:

var result = dmrg(psi0, H, options)
var ground_energy = result[0]    // Ground state energy (real number)
var ground_state = result[1]     // Ground state MPS

The ground state is normalized and in canonical form (orthogonality center at position 0).

Applications

Entanglement Analysis

The optimized bond dimension structure reveals entanglement:

var result = dmrg(psi0, H, options)
var psi_gs = result[1]

// Check where entanglement is concentrated
print(psi_gs.max_bond())

See Also

• Linear Tensor Networks: Introduction to MPS and MPO representations
• Factorization: SVD and bond dimension truncation techniques