⚛️ quantum physics

Pilot-Wave Simulator: Exact Classical Sampling from Ideal and Noisy Quantum Circuits up to Hundreds of Qubits

This paper introduces an exact classical sampling algorithm that combines tensor network contraction with a Markov process to simulate ideal and noisy quantum circuits, successfully demonstrating scalability up to 476 qubits for QAOA applications.

Original authors: Gleb Kalachev, Pavel Mosharev, Zuoheng Zou, Pavel Panteleev, Man-Hong Yung

Published 2026-07-22

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Gleb Kalachev, Pavel Mosharev, Zuoheng Zou, Pavel Panteleev, Man-Hong Yung

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

Imagine you are trying to predict the weather, but instead of clouds and wind, you are dealing with the tiniest building blocks of the universe: quantum particles. In the world of quantum physics, these particles don't just sit still; they exist in a superposition of many states at once, like a spinning coin that is both heads and tails until you catch it. To understand how these particles behave, scientists use "quantum circuits," which are like intricate mazes of logic gates that manipulate these spinning coins. The problem is that as you add more coins (or "qubits") to the maze, the number of possible outcomes explodes. It's like trying to track every single path a drop of water could take in a massive, branching waterfall. Traditional computers, which are great at following one path at a time, get overwhelmed and run out of memory long before they can solve the puzzle for even a medium-sized quantum machine. This is a huge hurdle because we need to test and design quantum algorithms before we can build the actual quantum computers, which are still rare and expensive.

Enter the "Pilot-Wave Simulator," a new tool developed by a team of researchers that acts like a clever guide through this chaotic waterfall. Instead of trying to map every single possible path at once (which is impossible for large systems), this simulator uses a trick inspired by an old idea in physics called the "pilot-wave" theory. Imagine a surfer riding a wave; the surfer (the classical state) moves along a specific path, but their movement is guided by the shape of the wave (the quantum state) ahead of them. The new algorithm lets a classical computer "surf" through the quantum circuit, updating its position step-by-step based on local clues, rather than calculating the entire ocean at once. This allows the team to generate exact, high-quality samples from quantum circuits with hundreds of qubits, including those that are noisy and imperfect, just like the real quantum devices we have today.

The Surfing Guide: How It Works

Think of a quantum circuit as a giant, multi-story game of "Chutes and Ladders" where the rules change at every turn. Usually, to know where a player will end up, you have to calculate the probability of every single possible route they could take. For a small game, a computer can do this easily. But for a game with 476 players (qubits), the number of routes is so huge that it would take more time than the age of the universe to calculate them all.

The Pilot-Wave Simulator changes the game. Instead of calculating the whole board, it focuses on one player at a time. It starts with the player at the beginning and asks, "If I move here, what are the odds I'll end up in this specific spot?" It uses a mathematical shortcut called a "tensor network" to peek at just the few necessary probabilities needed to make the next move. Then, it makes a random choice based on those odds, updates the player's position, and moves to the next step in the circuit. It's like navigating a maze by only looking at the next few turns rather than trying to see the whole maze from a helicopter.

The researchers call this a "Markov process," which is just a fancy way of saying the next step depends only on where you are right now and the local rules of the game. By combining this step-by-step surfing with the tensor network "peek," they can simulate circuits that were previously impossible to handle exactly.

The Big Test: QAOA and the "Pseudo-Boltzmann" Mystery

To prove their simulator works, the team put it to the test on a specific type of quantum algorithm called QAOA (Quantum Approximate Optimization Algorithm). You can think of QAOA as a quantum robot trying to find the lowest point in a bumpy landscape (the "ground state") to solve a difficult puzzle, like arranging magnets so they all point in the most efficient way.

The researchers simulated these circuits on grids of qubits, ranging from 24 up to a massive 476 qubits. They found something fascinating: the quantum robot didn't just pick random spots; it seemed to follow a "pseudo-Boltzmann" distribution. In plain English, this means the robot was more likely to land in low-energy (good) spots, and the deeper the circuit went (more layers of logic), the more it behaved like a system cooling down, favoring the best solutions even more. They confirmed that as the circuit got deeper, the "effective temperature" dropped, making the robot better at finding the bottom of the valley.

However, they also hit a wall. Even with their powerful new simulator, they found that for very large problems, the chance of the robot finding the absolute best solution dropped exponentially. It's like trying to find a specific grain of sand on a beach; as the beach gets bigger, your chances get tiny, even if you have a better shovel. This suggests that while shallow-depth QAOA circuits are interesting, they might not be the magic bullet for solving massive optimization problems on their own.

The Noise Factor: Realism vs. Perfection

Real quantum computers are messy. They suffer from "noise," which is like static on a radio or a gust of wind blowing the surfer off course. The researchers added realistic noise models (like depolarizing and amplitude damping) to their simulations to see how the Pilot-Wave simulator handled imperfections.

The results were clear: noise makes things worse. It raises the "effective temperature," meaning the quantum robot gets distracted and lands in higher-energy (worse) spots more often. In fact, when they simulated a noisy environment, the quantum algorithm performed worse than a simple, classical "local update" rule proposed by another scientist named Hastings. In these noisy simulations, the classical algorithm actually beat the quantum one at the same depth. This doesn't mean quantum computing is dead, but it does suggest that for now, simple classical tricks might be just as good as shallow quantum circuits when the hardware is imperfect.

The Scale: How Big Can We Go?

The most impressive part of this work is the sheer scale. The team managed to generate exact samples for circuits with up to 476 qubits at a depth of 1, and up to 49 qubits at a depth of 3. To put that in perspective, previous methods could only handle about 42 qubits with full simulation, or required massive supercomputers to estimate single numbers for slightly larger systems.

They ran these experiments on standard servers with hundreds of CPU cores, showing that this method is practical and doesn't require a supercomputer for every test. They also tested different shapes of qubit connections (topologies), like grids and hexagons, finding that the simulator works best on sparse, regular shapes, much like how a surfer prefers a clean, organized wave over a chaotic storm.

The Bottom Line

The Pilot-Wave Simulator is a powerful new tool that lets scientists "surf" through massive quantum circuits without drowning in calculations. It provides exact samples from circuits with hundreds of qubits, even when they are noisy. While it confirms that quantum circuits can produce interesting, low-energy distributions, it also suggests that for very large problems, the odds of finding the perfect solution drop quickly, and that in noisy environments, simple classical algorithms might still hold their own against shallow quantum ones. This tool gives researchers a way to benchmark and understand the behavior of future quantum devices before they are even built, helping to separate the hype from the reality of what these machines can actually do.

Technical Summary: Pilot-Wave Simulator for Exact Classical Sampling

Problem Statement
Classical simulation of quantum circuits is essential for designing and testing quantum algorithms, particularly in the NISQ era where access to real hardware is limited. However, standard simulation methods face severe scalability constraints. State-vector and density-matrix simulations suffer from exponential memory and computational overhead, restricting accurate simulation to a few dozen qubits. While Matrix-Product State (MPS) methods can handle hundreds of qubits, they are limited to low-entanglement regimes and often sacrifice precision. Other approaches, such as tensor network-based rejection sampling, are efficient for random circuits with uniform output distributions but fail for structured circuits (like QAOA) where output probabilities are highly non-uniform, requiring the evaluation of vast numbers of amplitudes to generate a single sample. Furthermore, existing exact sampling methods often struggle to incorporate realistic noise models without incurring prohibitive computational costs.

Methodology
The authors propose the Pilot-Wave (PW) simulator, an exact sampling algorithm that integrates sequential simulation frameworks with modern tensor network contraction techniques. The core methodology relies on the following principles:

Markovian Classical Evolution: The algorithm introduces a Markov chain on the classical state space $\{0, 1\}^n$ . A classical bitstring $s_t$ evolves stochastically at each time step $t$ according to transition probabilities derived from the quantum wavefunction $\psi_t$ . The probability of the classical state matches the quantum measurement distribution: $\text{Pr}(s_t = x) = |\langle x | \psi_t \rangle|^2$ .
Local Transition Rules: The evolution is driven by the local structure of the quantum circuit. For a gate $U_t$ $U_{t}$ acting on a subset of qubits, the transition probabilities depend only on a small number of amplitudes ( $L$ $L$ ) of the wavefunction.
- Monomial Gates: For gates that are products of permutations and diagonal matrices (e.g., CNOT, Pauli gates), the classical state updates deterministically.
- Non-Monomial Gates: For general gates, the gate matrix is decomposed into blocks. The algorithm identifies the connected component (block) containing the current classical state and samples the next state from this block based on the relative probabilities of the amplitudes within that block.
Tensor Network Amplitude Oracle: To compute the required amplitudes efficiently, the simulator uses a tensor network contraction engine. Crucially, it only evaluates the specific amplitudes needed for the current block decomposition, rather than the full state vector. This reduces the memory footprint significantly.
Noise Integration: The framework extends to noisy circuits by modeling noise channels (e.g., depolarizing, amplitude damping) as unitary operations on an ancillary qudit followed by immediate measurement. For noise models admitting a "local-submonomial" Kraus representation, the noise operators can be propagated through the circuit or fused with existing gates without increasing the tensor network complexity. This allows for exact sampling under noise with nearly the same time complexity as the noiseless case.

Key Contributions

Hybrid Algorithm: The paper presents a novel hybrid approach combining the sequential sampling paradigm of [13, 14] with tensor network contractions. Unlike rejection sampling, this method remains viable for highly non-uniform distributions typical of optimization circuits.
Scalability to Hundreds of Qubits: The authors demonstrate the ability to generate exact samples from structured QAOA circuits with up to 476 qubits (at depth $p=1$ ) and 49 qubits (at depth $p=3$ ).
Efficient Noisy Simulation: The method provides a low-overhead mechanism for simulating realistic noise models (Pauli, depolarizing, amplitude damping) without the exponential blowup typically associated with density matrix simulations.
Deterministic Handling of Sub-monomial Gates: The algorithm treats permutation-diagonal gates deterministically, avoiding unnecessary amplitude calls and further optimizing performance.

Experimental Results
The simulator was tested on QAOA circuits applied to Ising models on grid-like graphs:

Pseudo-Boltzmann Distributions: For ideal circuits, the sampling results confirmed that QAOA produces "pseudo-Boltzmann" energy profiles. The effective temperature decreases as circuit depth ( $p$ ) increases, enhancing the probability of sampling low-energy states.
Ground State Probability Scaling: The study quantified the exponential decrease in ground-state success probability as the number of qubits increases, even for fixed-depth circuits. For $N=49$ and $p=3$ , the simulator generated $\approx 10^9$ samples to estimate these probabilities.
Noise Impact: Under realistic noise models (simulating early-generation superconducting processors), the effective temperature increased, and the probability of finding low-energy states decreased predictably.
Comparison with Classical Heuristics: On 100 and 256-qubit grid Ising models, the performance of shallow-depth QAOA ( $p=1, 2$ ) was compared to Hastings' classical local-update algorithm. In ideal settings, the classical algorithm matched QAOA performance. In noisy settings, the classical algorithm outperformed the noisy QAOA.
Scaling: The time to generate a batch of samples scales polynomially with circuit size for depth $p=1$ , with performance varying based on graph topology (sparser and regular graphs are faster to simulate than random or dense graphs).

Significance and Claims
The authors position the Pilot-Wave simulator as a vital tool for the NISQ era, offering a practical alternative to full-state simulation for structured circuits.

Benchmarking Tool: The simulator provides a quantitative baseline for near-term hardware, allowing researchers to benchmark noisy devices against exact classical sampling.
Algorithmic Insight: The results challenge the utility of shallow-depth QAOA for large-scale optimization, suggesting that classical local-update rules may offer comparable or superior performance, especially in the presence of noise.
Methodological Scope: The authors emphasize that this is not a new tensor network contraction algorithm but an "exact sampling layer" on top of existing amplitude oracles. Its advantage is specific to shallow, sparse, structured circuits where the required prefix amplitudes remain tractable.
Future Applicability: The structural conditions of the algorithm suggest it could be applied to other locally interacting circuit families, such as hardware-efficient VQE ansätze and Trotterized simulations of local Hamiltonians.

The paper concludes that while the method does not reduce the cost of a single tensor network contraction, it enables exact sampling at qubit counts and noise regimes where previous methods were impractical, providing a rigorous framework for exploring the behavior of structured quantum circuits.