Truncating loopy tensor networks by zero-mode gauge fixing: the $Z_2$ lattice gauge theory at finite temperature

This paper introduces a gauge-fixing-free truncation method for loopy tensor networks that identifies and removes redundant bond dimensions by analyzing zero modes of the metric tensor, demonstrating its effectiveness in optimizing the purification of the two-dimensional finite-temperature $Z_2$ lattice gauge theory using iPEPS.

The Gist

The Big Picture: Untangling a Messy Knot

Imagine you are trying to describe a very complex, giant 3D knot made of string. In the world of quantum physics, this "knot" represents a system of many particles interacting with each other. To simulate this on a computer, scientists use a tool called a Tensor Network. Think of a tensor network as a digital map of that knot, made up of many small blocks (tensors) connected by strings (bonds).

The problem is that in two-dimensional systems (like a flat sheet of particles), these networks often get "bloated." They contain hidden loops of information that don't actually add any new details to the picture, but they make the computer work much harder than it needs to. It's like trying to carry a backpack full of empty water bottles just because they are attached to the straps.

This paper introduces a new method to shrink the backpack without losing any of the important water (information).

The Problem: Invisible Loops

The author, Jacek Dziarmaga, points out that standard computer methods often miss these "invisible loops."

• The Analogy: Imagine a group of people holding hands in a circle. If you ask, "Who is holding hands with whom?" the computer might think everyone is unique. But in reality, they are all just part of the same circle. The computer wastes space treating them as separate, distinct entities when they are actually redundant.
• In the paper, these are called "virtual entanglement loops." They inflate the size of the data (the "bond dimension") making calculations slow and inefficient.

The Solution: The "Zero-Mode" Trick

The paper proposes a clever way to cut out the empty space. Here is how it works, step-by-step:

1. The "Cut and Check" Method
Instead of trying to fix the whole knot at once, the method picks one specific string (bond) in the network and temporarily cuts it.

• The Analogy: Imagine you have a long chain of paperclips. You cut one link and pull the two ends apart. You then look at the two ends to see if they are actually saying the same thing.

2. Finding the "Ghost" (The Zero Mode)
When the author looks at the two ends of the cut string, they calculate a "metric" (a measure of how much the ends overlap).

• The Analogy: Sometimes, you'll find that one end of the chain is just a "ghost" of the other. They are mathematically identical. In physics terms, this is a Zero Mode. It means there is a piece of information that is 100% redundant. It's like having two copies of the same file on your computer; you only need one.
• The method identifies this "ghost" and removes it, shrinking the size of the string (reducing the bond dimension).

3. What if there isn't a perfect ghost?
Sometimes, the two ends aren't exactly identical, but they are almost identical (like a slightly blurry copy).

• The Analogy: Imagine you have a photo that is 99% the same as another. The paper's method doesn't just look for a perfect match; it finds the "best possible approximation" of a ghost. It mixes a few of the "fuzziest" copies together to create a single, clean version that represents them all.
• This allows the computer to throw away the extra data even when the redundancy isn't perfect, significantly reducing the error.

Why This is Better Than Old Methods

Usually, when scientists want to shrink these networks, they use a standard tool called SVD (Singular Value Decomposition).

• The Analogy: Standard SVD is like using a generic pair of scissors to cut a knot. It works, but it might leave behind a lot of loose string or cut the wrong part, leaving the knot messy.
• The New Method (ZMT): The new method is like using a laser cutter that first scans the knot to find exactly where the string is loose and redundant. It cuts only the useless parts.

The Result:
When the author tested this on a specific physics model (the Z2 Lattice Gauge Theory at finite temperature), the new method produced errors that were 10 times smaller than the old method.

• The Analogy: If the old method was like taking a blurry photo of a landscape, the new method takes a crystal-clear photo of the same landscape, but uses the same amount of memory storage.

The "No-Prep" Advantage

One of the coolest features of this method is that it doesn't require "gauge fixing."

• The Analogy: Imagine you are trying to measure a room, but the walls are painted with confusing patterns that make it hard to tell which way is up. Usually, you have to repaint the walls (gauge fixing) before you can measure. This new method is like a ruler that works perfectly regardless of the paint pattern. It works "out of the box," making the process faster and less prone to human error.

Summary

This paper presents a smarter way to compress complex quantum data. By finding and removing "ghost" information (redundant loops) that standard methods miss, the author can simulate complex physical systems with much higher accuracy and less computer power. It's a more efficient way to untangle the knots of the quantum world.

Technical Summary

Technical Summary: Truncating Loopy Tensor Networks by Zero-Mode Gauge Fixing

Problem Statement
Tensor network (TN) methods, such as Projected Entangled Pair States (PEPS), are powerful tools for simulating strongly correlated quantum many-body systems in two dimensions. However, the presence of closed loops in PEPS renders local tensor optimization less effective. These loops introduce internal correlations that are not fully captured by standard local procedures, often leading to inefficient compression where the bond dimension is artificially inflated by virtual entanglement loops that are decoupled from physical indices. While previous work (Ref. 31) introduced an approach to address this, the existing formulation required precise definitions of these loops and lacked effective gauge invariance under local transformations of gauge indices.

Methodology: Zero-Mode Truncation (ZMT)
The paper proposes a refined algorithm, Zero-Mode Truncation (ZMT), to identify and eliminate linear dependencies among states constituting a tensor network bond, thereby reducing the bond dimension without prior gauge fixing.

1. Identification of Linear Dependence: The method begins by "cutting" a specific bond in the network to define a set of states $|\psi_{ij}\rangle$. The overlaps of these states define a metric tensor $g_{ij,i'j'} = \langle \psi_{ij} | \psi_{i'j'} \rangle$.
2. Zero-Mode Exploitation: If the metric tensor possesses an exact zero mode $Z$ (satisfying $\sum g Z = 0$), it implies a linear dependence $\sum Z_{ij} |\psi_{ij}\rangle = 0$. This dependence introduces a gauge freedom allowing the state to be rewritten with a singular matrix, which can be truncated via Singular Value Decomposition (SVD) to reduce the bond dimension by one.
3. Generalization to Near-Zero Modes: In practical scenarios where an exact zero mode does not exist (i.e., the smallest eigenvalue is non-zero but small), the method constructs an ansatz $Z_{ij}$ as a linear combination of the $\kappa$ lowest-lying eigenmodes of the metric tensor.
4. Variational Optimization: The coefficients of this linear combination are optimized using a conjugate gradient method to minimize a cost function representing the truncation error. This error is defined as the squared norm of the difference between the state before and after truncation.
5. Gauge Invariance: The algorithm is shown to be effectively gauge invariant. The optimal truncation subspace and the resulting eigenvalues are invariant under standard tensor-network gauge transformations, meaning no explicit gauge fixing is required before applying the truncation.

Application and Results
The method is applied to the thermal states of the two-dimensional $Z_2$ lattice gauge theory on a square lattice. The thermal state is represented as an infinite Projected Entangled Pair State (iPEPS) obtained via imaginary-time evolution (purification).

• Benchmarking: The performance of ZMT is compared against standard SVD-based truncation.
• Truncation Error: The results demonstrate that ZMT yields significantly lower truncation errors. Specifically, the final truncation error after ZMT optimization is approximately one order of magnitude smaller than that obtained using standard SVD initialization followed by optimization.
• Initial vs. Final Error: Notably, even the initial truncation error (immediately after the zero-mode identification but before variational optimization) in the ZMT scheme is lower than the final error of the SVD scheme at later stages of the evolution.

Key Contributions and Significance
The paper claims to present a more efficient and effectively gauge-invariant version of the method introduced in Ref. 31. The primary contributions are:

• Algorithmic Simplification: The new formulation significantly simplifies the algorithm compared to its predecessor.
• Gauge Invariance: The method operates effectively without requiring prior gauge fixing, as the optimal truncation is naturally gauge invariant.
• Pragmatic Approach: Rather than attempting a precise definition of elusive virtual loops, the method adopts a pragmatic approach of selecting a bond, inspecting the local state dependencies via the metric tensor, and truncating based on identified (near-)zero modes.
• Performance: The application to the $Z_2$ lattice gauge theory validates the method, showing a substantial reduction in truncation error compared to standard techniques, thereby improving the expressiveness and efficiency of PEPS representations in the presence of loop correlations.

The work concludes that by exploiting locally available information about loop correlations through zero-mode gauge fixing, local bond optimization can be significantly improved, offering a robust tool for simulating thermal states in lattice gauge theories.