Quantum State Preparation via Schmidt Spectrum Optimisation

This paper introduces the Schmidt Spectrum Optimisation (SSO) algorithm, a scalable classical-quantum hybrid approach that efficiently prepares Matrix Product States by sequentially optimizing disentangling circuit layers and reversing them to generate the target state, outperforming existing variational and disentangling-based methods.

The Gist

Imagine you have a giant, incredibly tangled ball of yarn. This ball represents a complex quantum state—a specific arrangement of information that a quantum computer needs to solve a problem. Your goal is to take this tangled ball and turn it into a neat, straight line of yarn (a simple "product state") so you can easily handle it. Once it's straight, you can record the exact steps you took to untangle it, and then play those steps in reverse to perfectly recreate the original tangled ball whenever you need it.

The problem is that untangling this quantum yarn is incredibly hard. If you pull the wrong string, the whole thing gets knotted tighter, or you end up with a mess that's impossible to reverse.

This paper introduces a new, smarter way to untangle this yarn called Schmidt Spectrum Optimisation (SSO). Here is how it works, broken down into simple concepts:

The Old Way: Guessing and Checking

Previously, scientists tried to untangle quantum states using a method called the "Matrix Product Disentangler" (MPD). Think of MPD like trying to untangle a knot by blindly pulling on random strings.

• The Flaw: Sometimes, the "knot" you are looking at (the approximation) doesn't look like the real knot. So, the tool you use to untangle the fake knot fails to untangle the real one.
• The Result: The process often gets stuck, or the "string" (a technical measure called bond dimension) gets so thick and heavy that the computer can't handle it anymore. It's like trying to pull a rope that keeps doubling in thickness every time you tug it.

The New Way: The "SSO" Strategy

The authors propose a new strategy that acts more like a skilled tailor than a blind guesser.

1. The "Tail Loss" Objective
Instead of trying to untangle the whole knot at once, SSO looks at the "Schmidt spectrum." Imagine the yarn has a few thick, heavy threads and many thin, wispy ones. The "Schmidt spectrum" is just a list of how heavy those threads are.

• The Goal: SSO tries to make the two heaviest threads carry almost all the weight of the knot, while the rest become so thin they can be ignored.
• The Metaphor: It's like compressing a messy pile of clothes into a suitcase. SSO ensures that the two biggest, most important items take up 99% of the space, so the rest can be thrown away without losing the essence of the outfit.

2. The "Staircase" Approach
The algorithm builds a "staircase" of operations. It doesn't try to solve the whole problem in one giant leap. Instead, it takes one step at a time, optimizing a small layer of the circuit to make the knot slightly easier to untangle.

• Because it focuses on the "heaviest threads" (the Schmidt spectrum), it knows exactly which strings to pull to make the biggest difference.

3. Reversing the Process
Once the algorithm successfully untangles the knot into a simple, straight line (a state where only two "threads" matter), it records every single step it took.

• To prepare the quantum state later, the computer simply plays the recording in reverse. It starts with the simple line and applies the steps backward to recreate the complex, tangled knot perfectly.

Why is this better?

The paper tested this new method against the old "blind pulling" methods (MPD) and another recent method called CVD.

• Less Mess: The SSO method kept the "string" from getting too thick. While the old methods caused the string to grow exponentially (making the computer crash), SSO kept it manageable.
• Higher Accuracy: When the authors tried to recreate complex quantum states (like the ground states of magnetic materials or random patterns), SSO produced a much cleaner, more accurate result than the others.
• The "Safety Net": The authors proved mathematically that even if the process isn't perfect, the final result is guaranteed to be at least as good as the best possible "two-thread" version of the state. The other methods didn't have this safety guarantee.

The Bottom Line

The authors call their method SSO. It is a way to teach a classical computer how to design a quantum circuit that can create complex quantum states.

• It works by optimizing the "heaviest threads" of the entanglement.
• It untangles the state step-by-step.
• It reverses the steps to build the state.

The paper concludes that SSO is a "drop-in replacement" for older methods. It is faster, more reliable, and scales better, making it a promising tool for preparing the inputs needed for future quantum computers, especially those available in the near future.

Technical Summary

Technical Summary: Quantum State Preparation via Schmidt Spectrum Optimisation

Problem Statement
Quantum state preparation is a fundamental bottleneck for many quantum algorithms, requiring the transformation of an initial all-zero state into a specific, highly structured target state (e.g., approximations of many-body ground states). While Tensor Networks (TNs), particularly Matrix Product States (MPS), provide a compact classical representation of such states, translating them into efficient, shallow-depth quantum circuits remains challenging.

Existing approaches face significant limitations:

1. Exact Synthesis: While exact MPS synthesis is possible, decomposing multi-qubit gates into physical one- and two-qubit gates often results in circuits that are significantly deeper than necessary.
2. Matrix Product Disentangler (MPD): This approach attempts to approximate the target state by sequentially disentangling it toward a product state using local gates, then reversing the process. However, the MPD algorithm suffers from "pathologies": it often fails to effectively disentangle states where the $\chi=2$ approximation is poor, leading to ineffective layers. Furthermore, ineffective disentangling causes the bond dimension of intermediate states to grow exponentially with circuit depth, rendering the method unscalable.
3. Tensor Network Optimisation (TNO): Directly optimizing circuit parameters to maximize fidelity often suffers from barren plateaus and severe local minima, requiring careful initialization.

Methodology: Schmidt Spectrum Optimisation (SSO)
The authors introduce the Schmidt Spectrum Optimisation (SSO) algorithm, a "preparation-by-disentangling" framework that optimizes circuit layers classically to progressively remove entanglement from a target MPS.

• Core Strategy: Instead of optimizing for direct fidelity to the target, SSO optimizes a sequence of unitary layers $\{U_k\}$ to transform the target MPS $|\psi^{(1)}\rangle$ into a state $|\psi^{(L)}\rangle$ that is well-approximated by a low-rank ($\chi=2$) MPS.
• Ansatz: The algorithm employs a "staircase" ansatz, where each layer $U_k$ consists of a single layer of parameterized $SU(4)$ two-qubit gates acting on neighboring qubits.
• Objective Function (Tail Loss): The core innovation is the cost function. For each bipartition of the intermediate state, the algorithm minimizes the truncation error of the $\chi=2$ approximation. Specifically, it maximizes the sum of the squares of the two largest Schmidt coefficients ($\lambda_1^2 + \lambda_2^2$) across all bonds. This is equivalent to minimizing the "tail" of the Schmidt spectrum.
  • Theoretical Guarantee: The authors prove that minimizing this tail loss provides a tight upper bound on the infidelity of the final prepared state. Because any $\chi=2$ MPS can be analytically mapped to the all-zero state using a single layer of two-qubit gates, the final fidelity is guaranteed to be at least the fidelity of the $\chi=2$ approximation of the disentangled state.
• Optimization Process:
  1. Disentangling: Starting from the target MPS, the algorithm iteratively optimizes each layer $U_k$ to minimize the tail loss of the resulting state $|\psi^{(k+1)}\rangle$. This is done using gradient descent (L-BFGS-B) on a classical computer, utilizing automatic differentiation through tensor contractions.
  2. State Preparation: Once the target is disentangled to a $\chi=2$ state $|\tilde{\psi}^{(L)}\rangle$, a preparation circuit $U_{prep}$ is constructed analytically to generate this state from $|0\rangle^{\otimes n}$.
  3. Reversal: The final state preparation circuit is $U_S = U_1^\dagger U_2^\dagger \dots U_L^\dagger U_{prep}$.
• Post-Processing (SSO+All): To further improve results, the authors propose a joint optimization of all layers (initialized by the SSO output) to maximize the final fidelity directly, though this is noted to be computationally expensive for deep circuits.

Key Results
The authors benchmarked SSO against the MPD algorithm, the Classical Variational Disentanglement (CVD) algorithm, and optimized variants of MPD (MPD+LW, MPD+All) across several tasks:

• Random MPS: Tests on random MPS with $n=10$ and $n=16$ qubits.
• Ground States: Approximations of ground states for 1D and 2D local Hamiltonians, including the Transverse Field Ising model ($n=48$), Many-Body Localized (MBL) spin chains ($n=16$), Spinless Hubbard chains ($n=16$), and the 2D Heisenberg model ($4\times4$ grid).
• Performance:
  • Fidelity: SSO consistently achieved higher fidelity (lower infidelity) than MPD, CVD, and optimized MPD variants at fixed circuit depths. For example, in the 60-qubit Ising model benchmark, SSO achieved significantly higher fidelity than CVD.
  • Scalability (Bond Dimension): A critical finding is that SSO mitigates the exponential growth of the bond dimension ($\chi_{max}$) seen in MPD. While MPD often saw $\chi_{max}$ grow nearly exponentially with layer count, SSO maintained $\chi_{max} \approx O(\chi_{target})$ due to the effectiveness of its disentangling layers in reducing entanglement.
  • Comparison with CVD: SSO outperformed CVD even when CVD used the same "tail loss" objective. The authors attribute this to the SSO ansatz (staircase) which analytically maps the final $\chi=2$ state to a product state, providing a fidelity guarantee that CVD's variational approach lacks.
  • SSO+All: The joint optimization variant (SSO+All) yielded the best results across all benchmarks, further reducing error, though performance gains plateaued at deeper layers due to local minima issues common in deep tensor network optimization.

Significance and Claims
The paper claims that SSO represents a scalable and efficient framework for quantum state preparation, particularly for near-term quantum hardware where shallow-depth circuits are essential.

• Novelty: The primary contribution is the reformulation of the disentangling problem as an explicit optimization of the Schmidt spectrum (tail loss), coupled with a specific ansatz that guarantees the fidelity of the final state based on the quality of the $\chi=2$ approximation.
• Scalability: By effectively reducing entanglement at each step, SSO prevents the exponential blow-up of bond dimensions that plagues previous disentangling methods, allowing for deeper circuits without prohibitive classical computational costs.
• Practicality: The algorithm produces circuits composed entirely of local one- and two-qubit gates, optimized classically, making it a "drop-in replacement" for MPD-style disentangling in MPS state preparation.
• Limitations: The authors modestly note that while SSO+All improves results, global joint optimization of deep circuits still faces challenges with local minima and barren plateaus, suggesting that the greedy, layer-by-layer SSO approach is the most robust scalable component.

The work does not propose new experimental hardware or specific future applications beyond the general domain of preparing MPS-based states for quantum algorithms, but rather establishes a superior classical optimization method for generating the necessary quantum circuits.