⚛️ quantum physics

Preparation Circuits for Matrix Product States by Classical Variational Disentanglement

This paper introduces a classically efficient, parallelizable algorithm that prepares Matrix Product States by iteratively optimizing parameterized disentangling gates to minimize bipartite entanglement, offering a near-term alternative to sequential approaches for generating low-entanglement quantum states.

Original authors: Refik Mansuroglu, Norbert Schuch

Published 2026-04-15

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Refik Mansuroglu, Norbert Schuch

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: Untangling a Knotted Rope

Imagine you have a massive, incredibly complex knot of rope. This knot represents a quantum state (a specific arrangement of particles in a quantum computer). To do useful work with a quantum computer, you often need to start with a specific, complex knot.

However, quantum computers today are like fragile, new tools. They can't handle very long or complicated instructions (circuits) without making mistakes. If you try to build the knot from scratch using a long, step-by-step recipe, the instructions become too long, and the computer gets confused or breaks.

The authors of this paper propose a clever new way to solve this. Instead of trying to build the knot from scratch, they start with the finished knot and work backwards to untangle it until it becomes a simple, straight piece of rope. Once they figure out how to untangle it, they simply reverse that process to know exactly how to tie the knot on the quantum computer.

They call this method Classical Variational Disentanglement (CVD).

The Problem: The "Barren Plateau" and the "Gate Budget"

To understand why this is special, we need to know two problems quantum scientists face:

The Gate Budget: Current quantum computers are like a car with a very small gas tank. You can only drive a short distance (run a short circuit) before you run out of fuel (make too many errors).
The Barren Plateau: Imagine trying to find the bottom of a valley in a thick fog. If the valley is too wide and flat (a "barren plateau"), you can't tell which way is down. In quantum computing, this means the computer can't figure out how to improve its settings to create the right state. It gets stuck.

Previous methods tried to build the knot layer by layer. This often required too many steps (too much gas) or got stuck in the fog (barren plateaus).

The Solution: The "Untangler"

The authors' method flips the script. Instead of building the knot, they use a classical computer (a regular laptop) to act as a professional untangler.

Here is how the process works, step-by-step:

1. The Starting Point (The MPS)

They start with a mathematical description of the knot called a Matrix Product State (MPS). Think of this as a blueprint of the knot that is easy for a regular computer to read. It breaks the big knot down into small, manageable links.

2. The Untangling Game

The computer tries to find a series of simple moves (gates) that can "untangle" the knot.

The Goal: Turn the complex knot into a straight, simple rope (a "product state" where every piece is independent).
The Scorecard: How do they know if they are doing a good job? They measure the entanglement (how knotted the pieces are). If the pieces are less knotted, the score goes down. The computer's goal is to get the score as close to zero as possible.

3. The "Brick Wall" Strategy

The computer tries to untangle the knot using a "brick wall" pattern. Imagine a wall of bricks where you can only pull out two bricks at a time (two neighboring qubits).

The computer adjusts the angle of these two bricks to see if it loosens the knot.
It does this layer by layer, moving from one end of the rope to the other.
Crucial Trick: Because the computer is smart, it knows that if it successfully untangles a section, the "complexity" of the remaining knot shrinks. This keeps the math simple enough for the regular computer to handle, even for very long ropes.

4. The Reversal (The Magic Trick)

Once the computer finds the perfect sequence of moves to turn the complex knot into a straight rope, it simply hits the "Rewind" button.

The sequence of moves to untangle becomes the sequence of moves to tie the knot.
This reversed sequence is the Quantum Circuit that you send to the quantum computer.

Why This is a Game-Changer

The paper highlights three major superpowers of this method:

1. It Stays Simple (Classical Efficiency)
Usually, trying to untangle a complex knot makes the math explode in complexity. But because this method focuses on reducing the entanglement at every step, the math stays manageable. It's like peeling an onion; as you remove layers, the onion gets smaller, not bigger. This ensures the classical computer never gets overwhelmed, no matter how long the rope is.

2. No More Getting Lost (No Barren Plateaus)
Because the computer only looks at two bricks (two qubits) at a time to decide if the knot is getting looser, it always has a clear direction. It's like navigating a maze where you can always see the next turn. This avoids the "barren plateau" problem where the computer gets lost in a flat fog.

3. It Works for "Messy" Knots
The authors tested this on two types of knots:

Natural Knots: The ground states of physical materials (like magnets). These are naturally somewhat simple.
Artificial Knots: They created a knot where the "entanglement" was spread out over many qubits using error-correcting codes (like hiding a secret message inside a complex code). Even though the knot looked impossible to untangle locally, their method successfully found a way to concentrate the messiness and untangle it.

The Bottom Line

This paper introduces a new tool for the "near-term" era of quantum computing. It allows scientists to use their powerful classical computers to design the perfect, short, and efficient instructions for today's imperfect quantum computers.

Instead of guessing how to build a complex quantum state, we can now reverse-engineer the solution by mathematically "untying" the knot first. This makes preparing quantum states faster, more reliable, and less likely to fail due to the limitations of current hardware.

1. Problem Statement

The preparation of quantum states, particularly Matrix Product States (MPS), is a critical subroutine for quantum simulation, variational algorithms (like VQE), and quantum machine learning. While MPS are efficient classical representations of low-entanglement states, converting them into quantum circuits for execution on hardware presents significant challenges:

Hardware Constraints: Near-term quantum devices have limited gate budgets and connectivity. Existing sequential preparation methods often require deep circuits or exact gate counts that are infeasible for current hardware.
Barren Plateaus: Variational Quantum Algorithms (VQAs) often suffer from "barren plateaus," where gradients vanish exponentially with system size, making optimization impossible.
Bond Dimension Control: Standard fidelity-based optimization does not constrain the bond dimension of the resulting MPS. This can lead to an exponential growth in circuit complexity, rendering the preparation classically inefficient to verify or simulate.
Approximation vs. Exactness: There is a need for strategies that allow for controlled approximation errors (matching gate error rates) rather than demanding exact zero-error preparation, which is often unnecessary for practical applications.

2. Methodology: Classical Variational Disentanglement (CVD)

The authors propose Classical Variational Disentanglement (CVD), a classical algorithm that compiles a quantum circuit to prepare a target MPS by working in reverse. Instead of building the state from $|0\rangle^{\otimes n}$ , CVD attempts to disentangle the target MPS $|\psi\rangle$ back into a product state $|0\rangle^{\otimes n}$ using a parameterized unitary circuit $U$ . The preparation circuit is then simply the inverse, $U^\dagger$ .

Key Components:

Ansatz: The disentangler $U$ is constructed as a "brick-wall" circuit of parameterized local gates $G_{i,i+1}$ acting on neighboring qubits. Each gate is a general $SU(4)$ operator (or adapted for higher dimensions) with 9 parameters.
Cost Function: The optimization minimizes the entanglement entropy (specifically Rényi or von Neumann entropy) across all bonds of the MPS.
- The MPS is maintained in the canonical $\Gamma$ - $\Lambda$ form, where $\Lambda$ matrices contain the Schmidt values.
- The cost function is the sum of entropies $S_{A,\alpha}$ calculated directly from the Schmidt values $\lambda_j$ in the $\Lambda$ matrices, avoiding the need to compute full reduced density matrices.
Layer-by-Layer Optimization: To ensure classical efficiency, the algorithm optimizes the circuit layer by layer. When a gate is applied, the MPS tensors are contracted, and a Singular Value Decomposition (SVD) is performed.
Truncation: To prevent the bond dimension from growing exponentially during the contraction of non-optimized gates, the algorithm applies a truncation map $T_D$ that keeps only the largest $D$ Schmidt coefficients. This allows the algorithm to remain classically efficient even for deep circuits.

3. Key Contributions and Theoretical Guarantees

The paper provides rigorous theoretical proofs that distinguish CVD from previous approaches:

Bond Dimension Bounding (Lemma 1): The authors prove that minimizing the Rényi entropy with a small index $\alpha$ provides a strict upper bound on the bond dimension $D$ . This ensures that the classical simulation of the optimization process remains efficient regardless of circuit depth, provided the entropy is minimized.
Error Bounds (Lemma 2): An explicit error bound is derived for the final state preparation. The total error is shown to be bounded by the truncation error $\epsilon$ , the circuit depth $L$ , and the system size $n$ . Specifically, the error scales as $\epsilon + L\sqrt{2(n-1)p}$ , where $p$ is the truncation error.
Absence of Barren Plateaus (Lemma 3): The authors prove that the cost landscape does not suffer from barren plateaus.
- The cost function is ultra-local (defined on only two sites), allowing gradients to be computed efficiently.
- They calculate the variance of the gradient for random MPS and show it scales polynomially with the bond dimension $D$ (specifically $\propto 1/(2D+1)^2$ ), rather than exponentially. This guarantees that the optimizer can find the direction of descent.
Flexibility: Unlike sequential preparation, CVD is not tied to a specific circuit layout (though brick-wall is used for demonstration) and can adapt to fixed gate budgets by stopping optimization once the error threshold is met.

4. Numerical Results

The authors tested CVD on several benchmarks using the Julia library "ITensor":

1D Spin Models (Ising, XY, Heisenberg):
- CVD successfully prepared ground states with high fidelity (per-site overlap error $\approx 10^{-4}$ ).
- The bond dimension was effectively suppressed, and the algorithm converged rapidly.
- The method demonstrated scalability, with per-site errors saturating rather than growing exponentially with system size.
Fermi-Hubbard Model:
- CVD was used to prepare a low-rank approximation of the ground state for a 25-site (50 qubit) Fermi-Hubbard model.
- Even with a restricted bond dimension ( $D=5$ ), the resulting state had an energy close to the target, demonstrating its utility as a "pre-processing" step for quantum algorithms that require a good initial guess.
Entangled Logical Qubits (Error Correction Codes):
- The algorithm was tested on logical Bell pairs encoded in $[5,1,3]$ and $[11,1,5]$ stabilizer codes.
- Separated vs. Interlaced: CVD successfully disentangled "separated" logical qubits. However, for "interlaced" qubits (where entanglement is distributed non-locally), the algorithm struggled to find the correct swap sequence, getting stuck in local minima. This highlights a limitation: CVD is strictly local and may require blocking strategies for highly non-local correlations.
Special States (GHZ, Cluster, AKLT):
- GHZ: Required depth $n/2$ , consistent with theoretical lower bounds for local circuits.
- Cluster State: Prepared exactly with depth 2.
- AKLT: Achieved an approximate preparation with low error ( $1.8 \times 10^{-3}$ ) in 13 layers, outperforming trivial sequential approaches in terms of circuit depth.

5. Significance and Conclusion

Classical Variational Disentanglement represents a significant advancement in the interface between classical tensor network methods and quantum circuit compilation.

Near-Term Relevance: It offers a practical pathway to generate initial states for quantum computers that respect hardware constraints (gate depth and connectivity) while maintaining classical simulability for verification.
Trainability: By proving the absence of barren plateaus and providing error bounds, CVD addresses two of the most critical bottlenecks in variational quantum algorithms.
Versatility: The method is applicable to ground state preparation, quench dynamics, and potentially quantum machine learning (compiling Matrix Product Functions).
Future Outlook: While currently limited by its local nature (struggling with long-range entanglement without swapping), the authors suggest that blocking sites or combining with other strategies could extend its applicability to more complex, strongly correlated systems.

In summary, CVD transforms the problem of state preparation into a classical optimization task that is provably efficient, trainable, and capable of generating hardware-friendly quantum circuits with controlled approximation errors.