⚛️ quantum physics

Classical Pre-Training of Large Shallow Parametrized Quantum Circuits through Pauli Propagation and deployment on Quantum Hardware

This paper proposes a classical pre-training framework for large shallow parametrized quantum circuits using Pauli propagation to efficiently optimize loss functions via backward observable propagation, demonstrating successful deployment of the resulting parameters on 64-qubit IBM quantum hardware for tasks like variational eigensolving and generative modeling.

Original authors: Saverio Monaco, Jamal Slim, Ran Xue, Dirk Krücker, Kerstin Borras

Published 2026-10-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Saverio Monaco, Jamal Slim, Ran Xue, Dirk Krücker, Kerstin Borras

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

Quantum machine learning sits at the frontier where the strange rules of the subatomic world meet the practical need to solve complex problems. At its heart are circuits made of quantum bits, or qubits, which can exist in multiple states at once, allowing them to process information in ways that classical computers cannot. To make these circuits useful, scientists must "train" them, adjusting their internal settings to find the best solution for a specific task, much like tuning a radio to find a clear signal. However, as these circuits grow larger to tackle harder problems, the process of training them becomes a bottleneck. The standard method requires sending the circuit back and forth to a physical quantum machine thousands of times to measure how well it is performing. This is slow, expensive, and prone to errors because current quantum machines are fragile and noisy. The central challenge is finding a way to do the heavy lifting of training without constantly relying on the delicate hardware.

A team of researchers has developed a new approach that shifts the training burden entirely to classical computers, leaving the quantum machine only for the final test. Their method, called Pauli propagation, works by reversing the flow of information. Instead of sending a quantum state forward through the circuit to see what comes out, they start with the question they want to answer and work backward through the circuit's layers. By tracking how the question changes as it moves against the flow of the gates, they can write down a precise mathematical description of the circuit's behavior using only standard computer power. This description acts as a map, showing exactly how changing the circuit's settings will affect the final result. Because this map is built on a classical computer, the researchers can adjust the settings millions of times in seconds, a task that would take days or weeks if they had to run the circuit on a real quantum device for every single change.

The researchers tested this strategy on two very different problems using a circuit with 64 qubits, a size that is too large for even the most powerful classical supercomputers to simulate directly. In the first experiment, they tackled a problem from physics known as the Variational Quantum Eigensolver, which is used to find the lowest energy state of a system, similar to finding the most stable arrangement of magnets. They trained the circuit on a classical computer using their backward-propagation method and then deployed the resulting settings onto a real quantum processor named ibm berlin. While the classical training successfully optimized the parameters, the researchers observed a persistent gap between the results produced by the quantum hardware and the theoretical ground state. They attributed this gap to the hardware's precision in estimating the observable rather than a failure in the training procedure itself. In the second experiment, they trained the circuit to act as a generator for simple black-and-white images, essentially teaching it to create patterns that looked like handwritten digits. Again, they trained the model entirely on a classical computer and then ran the final version on the quantum processor. The machine produced recognizable, albeit noisy, images of digits, demonstrating that the method works for generative tasks as well.

A key finding of the study is that this approach allows for much more efficient use of the quantum hardware. The researchers found that the circuits they designed required far fewer complex gates than other common designs used for similar tasks. This reduction is crucial because every extra gate adds a layer of error and takes more time to run on a real machine. By using fewer gates, the circuits were shallow enough to be executed on current hardware without falling apart from noise. The study also highlighted that while the classical training was highly effective, the final results on the quantum machine still showed a gap compared to the perfect classical simulation. This gap was not due to a failure in the training method but rather the inherent limitations of the physical quantum processor, which struggles to measure outcomes with perfect precision. The researchers noted that the method is not a magic bullet that solves every problem instantly; it is a practical tool that makes training feasible at scales where it was previously impossible.

The work suggests a new path forward for the field, where the quantum computer is no longer the engine of the learning process but rather the final stage of execution. By moving the intensive work of optimization to classical machines, scientists can scale up to systems with hundreds of qubits without being held back by the speed and fragility of current hardware. The researchers acknowledge that there is still work to be done, particularly in refining the loss functions used for generative models and in accounting for the specific types of noise found in real devices. However, the demonstration on 64 qubits serves as a strong proof of concept. It shows that by thinking differently about how to train these circuits, we can bridge the gap between the theoretical potential of quantum machine learning and the practical reality of today's technology.

Technical Summary: Classical Pre-Training of Large Shallow Parametrized Quantum Circuits through Pauli Propagation

Problem Statement
Scaling Parametrized Quantum Circuits (PQCs) to a large number of qubits remains a central bottleneck in Quantum Machine Learning (QML). While quantum hardware is now available with over 100 qubits, extensive training on these devices is hindered by the cost of gradient estimation. The standard parameter-shift rule requires two circuit evaluations per parameter, becoming prohibitively expensive as the parameter count grows. Conversely, gradient-free optimizers (e.g., COBYLA, SPSA) reduce evaluation counts but offer weaker convergence guarantees and still necessitate repeated, costly access to quantum hardware. Existing solutions often restrict the ansatz architecture to reduce gradient costs or rely on classical simulation, which is limited to roughly 30 qubits.

Methodology: Pauli Propagation Framework
The authors propose a "train on classical, deploy on quantum" paradigm that extends classical training to a broader class of PQCs, specifically locally scrambling circuits, where the loss function is defined by the expectation values of observables. The core methodology relies on Pauli propagation, which operates in the Heisenberg picture. Instead of evolving the quantum state forward, the method evolves the observable $O$ backward through the circuit via the transformation $O'(\theta) = U^\dagger(\theta) O U(\theta)$ .

Key technical components include:

Observable Decomposition: The observable is decomposed into the $n$ -qubit Pauli basis. The propagation tracks how Pauli strings transform under conjugation by each gate.
Branching and Trigonometric Factors: Parametrized rotation gates cause Pauli strings to branch into two terms (cosine and sine branches) when they anticommute with the rotation axis. This results in an explicit parametric expression for the expectation value $\langle O \rangle(\theta)$ as a sum of products of trigonometric functions of the circuit parameters.
Exact Filtering: A natural filter discards any propagation path where the terminal Pauli string contains $X$ or $Y$ operators, as $\langle 0|X|0\rangle = \langle 0|Y|0\rangle = 0$ . Only paths ending in $I$ or $Z$ contribute to the expectation value.
Truncation Strategies: To make propagation tractable for large systems (e.g., 64 qubits), the authors implement two complementary approximation schemes:
- Weight Truncation: Discards paths where the Pauli weight (number of non-identity operators) exceeds a cutoff $w_{cut}$ . This is justified by the observation that for locally scrambling ansätze, the contribution of high-weight paths decays exponentially.
- Trigonometric-Degree Truncation: Discards paths where the number of branching gates (trigonometric degree) exceeds a cutoff $\delta_{cut}$ , based on the decay of high-degree terms under uniformly distributed parameters.
Pruning Heuristics: To further reduce computational cost without approximation error, the authors employ exact pruning strategies:
- Dead-qubit Pruner: Discards branches where a qubit carries $X$ or $Y$ and no remaining gates can change it back to $Z$ or $I$ .
- XY-weight Pruner: Discards branches where the number of qubits carrying $X$ or $Y$ exceeds the number of remaining gates capable of reducing this count.

Key Contributions and Applications
The paper demonstrates this approach on two 64-qubit benchmarks, a scale well beyond exact statevector simulation capabilities:

Variational Quantum Eigensolver (VQE):
- Task: Finding the ground state energy of a 2D transverse-field Ising model.
- Result: The method successfully optimized parameters for depth-1 (exact propagation) and depth-2 (truncated propagation) ansätze. The classically optimized parameters were deployed on the IBM quantum processor ibm_berlin. The results showed that the classical pre-training effectively reduced the quantum hardware usage to validation only, as the entire 1000-step optimization loop ran on classical hardware.
Quantum Generative Modeling:
- Task: Training a discrete-type generative model for binary images (downsampled MNIST) using a loss function based on the Maximum Mean Discrepancy (MMD) of Pauli-Z expectation values.
- Result: The authors trained a shallow ansatz (256 parameters) using Pauli propagation with weight truncation. The trained model was deployed on ibm_berlin to generate samples.
- Comparison: The proposed propagator significantly outperformed two IQP (Instantaneous Quantum Polynomial) baselines. It achieved a test MMD $^2$ roughly 12 times lower than an equal-parameter IQP circuit and outperformed an IQP circuit with 10 $\times$ more parameters (2560 gates), despite using only a tenth of the parameters. The authors attribute this to the causal structure introduced by non-commuting gates in their ansatz, which provides greater expressivity per parameter compared to the commuting gates of IQP circuits.

Significance and Claims
The paper positions this work as a proof of concept rather than a claim of optimality. Its primary significance lies in demonstrating the viability of the "train-on-classical, deploy-on-quantum" pipeline at the 64-qubit scale.

Scalability: The approach offers a scalable path forward for QML as qubit counts increase, bypassing the prohibitive cost of on-hardware gradient estimation.
Hardware Efficiency: By offloading training entirely to classical resources, the method minimizes quantum circuit executions to only what is necessary for final validation or sampling.
Parameter Efficiency: In the generative modeling task, the non-commuting ansatz required substantially fewer parametrized gates than IQP-style ansätze to achieve superior performance, reducing transpilation overhead and making deployment on current noisy intermediate-scale quantum (NISQ) hardware more feasible.
Future Directions: The authors note that while the method is promising, identifying loss functions that are both physically motivated and cheaper to propagate than the MMD estimator remains an open challenge. They also suggest that incorporating device noise models directly into the propagation could further improve the robustness of the trained parameters.

Technical Summary: Classical Pre-Training of Large Shallow Parametrized Quantum Circuits through Pauli Propagation

More like this