Escaping barren plateaus in approximate quantum compiling

Niall F. Robertson, Albert Akhriev, Jiří Vála, Sergiy ZhukarXiv 2022 · DOI · arXiv

TL;DR

This paper introduces a new classical algorithm to overcome "barren plateaus"—regions where optimization gradients vanish—in the process of approximate quantum compiling. By utilizing a "local" cost function that incorporates "bit-flip" terms and a dynamic weighting scheme, the researchers demonstrate significantly faster and more reliable convergence for state and circuit preparation on up to 24 qubits.

What Problem Does This Paper Address?

Quantum compiling is the essential "translation" step that turns abstract quantum algorithms into specific gate sequences compatible with real hardware constraints (like limited qubit connectivity). One popular method is variational compiling, where a parameterized circuit is optimized to match a target unitary or state.

The "boss fight" of variational optimization is the barren plateau. As the number of qubits ($n$) increases, the gradient of the cost function (the "slope" the optimizer follows) often vanishes exponentially. This makes the optimization landscape look like a flat, featureless plain, leaving the optimizer with no direction to move. While recent work has addressed this for quantum-assisted compiling (running on actual quantum hardware), this paper tackles the problem for classically assisted compiling, where classical computers simulate sub-circuits to avoid the noise of current quantum devices.

Methods

The authors propose a shift from global to local cost functions.

  • Global Cost Functions: These measure the distance between the entire $n$-qubit state and the target. These are notorious for barren plateaus.
  • Local Cost Functions: These measure distances on smaller subsets of qubits. The authors prove that for local functions, gradients vanish only polynomially (much slower) rather than exponentially.

Key Innovations: 1. Truncated Local Cost Function: They derive an explicit expression for the cost function that includes "bit-flip" terms (using Pauli-X operators). This effectively "localizes" the objective, providing a gradient even when the global state is far from the target. 2. Dynamic Weighting Scheme ($\alpha$): They introduce a coefficient, $\alpha$, that balances the local and global terms. As the optimization progresses and the circuit gets "closer" to the target, $\alpha$ is gradually decreased to "tighten the grip" and ensure high-fidelity convergence. 3. Surrogate Model & Hysteresis: To handle the computational overhead of calculating many local terms for large systems (up to 24 qubits), they implement a surrogate model that focuses on the "maximal projection" (the most relevant bit-flip) and uses hysteresis to prevent the optimizer from jumping erratically between different local terms.

Datasets

As a theoretical and algorithmic paper, the "datasets" consist of simulated target states and circuits:

  • State Preparation: A target 24-qubit state generated by a random circuit.
  • Circuit Preparation: The time-evolution operator of a XXX Hamiltonian (a standard model for quantum magnetism) on 8 qubits. This serves as a benchmark to compare the algorithm's accuracy against standard techniques like Trotter decomposition.

Key Insights and Ideas

  • The "Bit-Flip" Guide: By including terms that represent single or double bit-flips from the target state, the cost function creates "basins of attraction" in the parameter landscape. This prevents the optimizer from getting lost in the flat regions of the global Hilbert space.
  • Polynomial vs. Exponential: The core "aha" moment is the analytical proof (Equation 29) showing that each additional local term reduces the power of the variance decay. This mathematically confirms why their approach can "escape" the plateau where global methods fail.
  • Classical Utility: While quantum-assisted compiling is scalable in theory, it is currently crippled by hardware noise. This paper argues that improving classical optimization for sub-circuits is a vital "middle ground" for near-term quantum advantage.

Key Results

  • State Preparation (24 Qubits): The proposed local cost function ($C_L^{(1)}$) converged to the target state in fewer than 30 iterations, while the standard global cost function ($C_G$) remained completely flat, failing to learn anything (see Figure 6).
  • Circuit Compilation (8 Qubits): The algorithm successfully compiled a time-evolution operator with higher fidelity than a standard first-order Trotter decomposition. Crucially, it escaped the barren plateau that trapped the global optimizer at a fidelity of only ~0.5, eventually reaching near-perfect fidelity (see Figure 8).
  • Optimizer Synergy: The authors found that a two-stage approach—starting with the Adam optimizer for the initial "rough" descent and switching to L-BFGS for fine-tuning—was most effective.

Limitations and Future Work

  • Classical Scaling: Despite the improvements, the approach is still limited by the exponential memory requirements of classical simulation. The authors suggest that integrating Tensor Networks (which can represent weakly entangled states efficiently) is the next logical step to scale beyond 24 qubits.
  • Ansatz Dependence: The success of the method depends on the choice of the "Ansatz" (the structure of the parameterized circuit). While they used a standard CNOT-block structure, more complex targets might require specialized architectures.
  • Higher-Order Terms: The paper primarily explores $k=1$ and $k=2$ local terms. For very deep or highly entangled circuits, even higher-order local terms might be necessary to maintain a healthy gradient.

Summary updated

Abstract

Quantum compilation provides a method to translate quantum algorithms at a high level of abstraction into their implementations as quantum circuits on real hardware. One approach to quantum compiling is to design a parameterised circuit and to use techniques from optimisation to find the parameters that minimise the distance between the parameterised circuit and the target circuit of interest. While promising, such an approach typically runs into the obstacle of barren plateaus - i.e. large regions of parameter space in which the gradient vanishes. A number of recent works focusing on so-called quantum assisted quantum compiling have developed new techniques to induce gradients in some particular cases. Here we develop and implement a set of related techniques such that they can be applied to classically assisted quantum compiling. We consider both approximate state preparation and approximate circuit preparation and show that, in both cases, we can significantly improve convergence with the approach developed in this work.
BibTeX
@misc{robertson2022escaping,
  author = {Niall F. Robertson and Albert Akhriev and Jiří Vála and Sergiy Zhuk},
  title = {{Escaping barren plateaus in approximate quantum compiling}},
  year = {2022},
  eprint = {2210.09191},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2210.09191},
}
Figure