Report on 2104.08283v1

Kevin SlagleOpenalex Unknown 2021 · DOI · arXiv · OpenAlex

Abstract

Many recent tensor network algorithms apply unitary operators to parts of a tensor network in order to reduce entanglement. However, many of the previously used iterative algorithms to minimize entanglement can be slow. We introduce an approximate, fast, and simple algorithm to optimize disentangling unitary tensors. Our algorithm is asymptotically faster than previous iterative algorithms and often results in a residual entanglement entropy that is within 10 to 40% of the minimum. For certain input tensors, our algorithm returns an optimal solution. When disentangling order-4 tensors with equal bond dimensions, our algorithm achieves an entanglement spectrum where nearly half of the singular values are zero. We further validate our algorithm by showing that it can efficiently disentangle random 1D states of qubits.

Introduction: The Challenge of Disentangling

In the world of quantum physics and many-body systems, Tensor Networks (like MERA or PEPS) are essential for simulating complex states. A crucial component is the "disentangler"—a unitary operator applied to parts of the network to strip away short-range correlations. By reducing entanglement, these operators make the overall system much easier and cheaper to compute.

Figure 1: A unitary operator $U$ applied to a tensor $A$ to reduce entanglement between subsystems.

Finding the perfect disentangler is computationally demanding. Traditionally, iterative optimization methods like gradient descent or alternating least squares (ALS) are used. These are notoriously slow and often get stuck in local minima. High-precision second-order methods (like Newton’s method) scale poorly; for a bond dimension ($\chi$) of 16, a single iteration can take 40 CPU hours and 34 GB of RAM as complexity grows as $O(\chi^{12})$.

Methods: A Fast Constructive Approach

Researcher Kevin Slagle proposes a shift from iterative optimization to a direct, constructive approach. The Fast Tensor Disentangling Algorithm uses a sequence of linear algebra operations to jump straight to a "good" solution. The core idea involves approximating the product of the unitary $U$ and the tensor $A$ as a simplified network of smaller tensors, as shown in Figure 3.

Figure 3: Diagrammatic representation of the algorithm's core approximation, $(U \cdot A) \sim M^{(1)}M^{(2)}M^{(3)}$.

Instead of hundreds of iterative steps, the algorithm performs a fixed sequence of operations:

  1. Random Projection: Breaking degeneracies with a random vector.
  2. Truncated Singular Value Decomposition (SVD): Isolating the most significant components of the input tensor.
  3. Gram-Schmidt Orthonormalization: Ensuring the final result is a valid unitary tensor.

This approach scales as $O(\chi^6)$, making it significantly more efficient than $O(\chi^{12})$ iterative solvers.

Key Results and Insights

  • Massive Speedups: For a bond dimension of $\chi=16$, the algorithm provided a 20,000x speedup over gradient descent, taking only 10 milliseconds on a standard CPU.
  • Performance: Residual entanglement entropy was typically within 10% to 40% of the global minimum. The algorithm actually performs better on tensors with more internal structure.
  • The "Half-Zero" Spectrum: When disentangling certain order-4 tensors, the algorithm produces an entanglement spectrum where nearly half of the singular values are zero, indicating perfect entanglement removal from those channels.
  • Wavefunction Disentangling: In a 10-qubit test, the algorithm successfully removed almost all entanglement after 500 layers of gates, outperforming standard gradient descent which often stalled.

Conclusion

The primary advantage of this algorithm is its speed and simplicity. While approximate and not guaranteed to find the absolute global minimum, it is "good enough" for many applications. It is particularly valuable as a high-quality "seed" for more precise optimization, providing a starting point that allows subsequent gradient descent to converge much faster.

Summary updated

Abstract

Many recent tensor network algorithms apply unitary operators to parts of a tensor network in order to reduce entanglement.However, many of the previously used iterative algorithms to minimize entanglement can be slow.We introduce an approximate, fast, and simple algorithm to optimize disentangling unitary tensors.Our algorithm is asymptotically faster than previous iterative algorithms and often results in a residual entanglement entropy that is within 10 to 40% of the minimum.For certain input tensors, our algorithm returns an optimal solution.When disentangling order-4 tensors with equal bond dimensions, our algorithm achieves an entanglement spectrum where nearly half of the singular values are zero.We further validate our algorithm by showing that it can efficiently disentangle random 1D states of qubits.Many recent tensor network algorithms [1-7] rely on the application of unitary (or isometry) tensors in order too reduce the short-ranged entanglement and correlations within the tensor network.Examples of such algorithms include: MERA [8-10], Tensor Network Renormalization [11-13], Isometric Tensor Networks [14] and 2D DMRG-like canonical PEPS algorithms [15, 16], purified mixed-state MPS [17], and unitary tensor networks [18-20].Optimizing these unitary tensors is a difficult task, and many of the algorithms applied in the previously cited literature are CPU intensive, although there has been recent progress [20-22].One popular approach is the alternating least squares method [23] (variants of which were used in Refs.[10, 11, 15, 16, 20]).However, convergence can be slow, especially when a good initial guess for U is not used.Another approach (used in Refs.[14, 17]) is to iteratively minimize the entanglement entropy [defined later in Eqs. ( 10)] across part of the tensor network, as depicted in Fig. 1.However, these iterative methods are also very CPU intensive.An iterative first-order gradient descent algorithm can converge very slowly, especially when narrow valleys are present in the entanglement entropy cost function [24].Convergence is even more challenging for Renyi entropies S α with α ≤ 1/2 due to |λ| 2α singularities for small singular values λ, which can even prevent convergence to a local minima in the limit of infinitesimal step size for many algorithms.Applying a second-order Newton method can require less iterations.However, for large bond dimensions χ the CPU time and memory requirements grow rapidly as O(χ 12 ) and O(χ 8 ), respectively, with e.g.χ = 16 requiring roughly 40 CPU core hours and 34 GB of RAM just to diagonalize and store the Hessian for a single iteration.In this work, we introduce a simple and asymptotically faster algorithm to calculate a reasonably good disentangling unitary tensor.That is, given a (χ 1 χ 2 ) × χ 3 × χ 4 tensor (blue
BibTeX
@inproceedings{slagle2021report,
  author = {Kevin Slagle},
  title = {{Report on 2104.08283v1}},
  booktitle = {Openalex Unknown},
  year = {2021},
  doi = {10.21468/scipost.report.3062},
}
Figure