⚛️ quantum physics

Efficient classical simulation of large-scale unitary cluster Jastrow circuits

This paper introduces a polynomial-time classical algorithm capable of efficiently simulating large-scale single-layer unitary cluster Jastrow circuits, enabling a laptop to reproduce and outperform a recent 77-qubit quantum experiment in less than a minute.

Original authors: Hrishikesh Belagali, Thomas Van Camp, R. Pradeep, Sourin Das, Namit Anand, Ryan LaRose

Published 2026-07-24

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Hrishikesh Belagali, Thomas Van Camp, R. Pradeep, Sourin Das, Namit Anand, Ryan LaRose

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 solve a massive, tangled knot of string that represents a molecule. In the world of chemistry, figuring out how these knots settle into their most stable shape (their "ground state") is like trying to predict the weather in a hurricane: it's incredibly hard because every piece of string pulls on every other piece. For decades, scientists have hoped that quantum computers—machines that use the weird rules of tiny particles to do math—could untie these knots faster than any normal computer. The idea is that while a regular computer has to check every possible twist one by one, a quantum computer can check many twists at once. Recently, researchers have been building these quantum machines to simulate complex molecules, like iron-sulfur clusters found in nature, hoping to find new medicines or materials. The big question has been: Are these quantum machines actually doing something a regular computer can't, or are we just using a sledgehammer to crack a nut that a regular computer could have handled with a little more cleverness?

This paper is about a team of researchers who decided to test that sledgehammer. They looked at a specific type of quantum experiment called the "Unitary Cluster Jastrow" (UCJ) circuit, which has been used in some of the biggest and most impressive quantum chemistry experiments to date. These experiments involved quantum computers with up to 77 qubits (the quantum version of bits) and thousands of gates, running on supercomputers with thousands of nodes just to process the results. The researchers asked: "Can we do this same calculation on a regular laptop?" The answer, surprisingly, is yes. They developed a new, super-fast mathematical trick that allows a standard computer to calculate the energy of these specific quantum circuits in polynomial time—meaning the time it takes grows reasonably with the size of the problem, rather than exploding into infinity.

The team found that they could reproduce the results of the largest experiment ever done on an iron-sulfur cluster (which used 77 qubits and 10,570 gates) in less than a minute on a laptop. In fact, because their method was so fast, they were able to tweak the circuit parameters to find an even lower energy state than the one the quantum experiment achieved, which had taken 6,400 supercomputer nodes and hours of processing time to get. However, there is a catch. The paper explicitly states that this "win" only works for single-layer circuits. If you add more layers to the circuit (making it deeper and more complex), the math breaks down, and the problem likely becomes too hard for regular computers again. The authors conclude that while single-layer UCJ circuits are not enough to prove quantum advantage (the point where quantum computers beat classical ones), we will need to build much deeper, multi-layered circuits to truly see what quantum computers can do that classical ones cannot.

To understand how they did this, think of the quantum circuit as a complex machine that transforms a starting state (like a flat sheet of paper) into a final, crumpled shape. Usually, to see what the final shape looks like, you have to run the machine and then try to reverse-engineer the crumpling, which is a nightmare for regular computers because the number of possibilities is astronomical. The authors' trick was to work backward. Instead of trying to predict the final crumpled shape, they took the "rules" of the molecule (the Hamiltonian) and ran them backward through the machine.

Imagine you have a recipe for a cake, but instead of baking it and then tasting it, you start with the finished cake and work backward through the recipe to see exactly what ingredients were used. The authors showed that for these specific single-layer circuits, you can run the recipe backward without the number of ingredients exploding into infinity. They used a mathematical tool called Löwdin's formula, which is like a special calculator that can quickly figure out the value of a complex shape without having to measure every single point on it. By combining this backward-running method with a clever way of handling the "phases" (the timing and angles of the quantum moves), they kept the calculation efficient.

The results were striking. When they applied their method to the iron-sulfur cluster experiment, they got an energy value of -326.796 Hartrees, which is lower (better) than the -326.645 Hartrees achieved by the quantum experiment using the Sample-based Quantum Diagonalization (SQD) method. The quantum experiment had to use a massive supercomputer (Fugaku) with 6,400 nodes to get its result, while the authors got a better result on a laptop in under a minute. They also tested this on hydrogen chains with up to 160 qubits, showing that their method scales well, though the time it takes does grow as the system gets bigger (roughly following a power of 4.448, which is much better than the exponential explosion that would happen with older methods).

However, the paper is very clear about what this does not mean. It does not mean quantum computers are useless. The authors point out that their method only works for "weak simulation," which means calculating the energy, but it cannot "strong simulate" the process of sampling random bitstrings (the raw data output) that the quantum computer produces. The original experiment used those random bitstrings to clean up errors and improve the result. Because the authors' method doesn't generate those random strings, it can't do that specific type of error correction. But, by being so fast, they could simply optimize the circuit settings better than the experimenters did, beating the final result anyway.

The most important takeaway is a boundary line. The authors argue that single-layer circuits are not the "holy grail" of quantum advantage. If a regular computer can simulate them in a minute, they aren't doing anything special. To truly beat classical computers, we need to build circuits with two or more layers (L ≥ 2). The math gets too messy for their trick to work once you add those extra layers, and that is likely where the real quantum power lies. So, while this paper shows that we can simulate the current "state-of-the-art" quantum chemistry experiments on a laptop, it also tells us that the real race is just beginning: we need to build deeper, more complex circuits to find the problems that classical computers truly cannot solve.

Technical Summary: Efficient Classical Simulation of Large-Scale Unitary Cluster Jastrow Circuits

Problem Statement
Recent experiments in quantum chemistry have utilized the Unitary Cluster Jastrow (UCJ) ansatz, particularly its local variant (LUCJ), to simulate ground states of strongly correlated molecules on quantum hardware. Notable experiments, such as those reported in Sci. Adv. 11, 25 (2025), have executed circuits with up to 77 qubits and over 10,000 gates, requiring massive classical supercomputing resources (e.g., 6400 nodes on Fugaku) for post-processing via Sample-based Quantum Diagonalization (SQD). While the classical hardness of sampling from UCJ circuits has been established (linked to IQP computations), the specific task of computing the energy expectation value for single-layer UCJ circuits has not been fully characterized. Existing classical simulation strategies for these circuits face exponential scaling or rely on truncations that compromise chemical accuracy. The central problem addressed is whether the energy of single-layer UCJ circuits can be computed exactly and efficiently on classical hardware, independent of the locality constraints imposed on the quantum hardware.

Methodology
The authors present a polynomial-time classical algorithm for the exact computation of the energy of any single-layer ( $L=1$ ) UCJ circuit. The algorithm operates in the second-quantized formalism and avoids the exponential growth of terms typically associated with backpropagation in other simulation methods. The approach proceeds in three distinct steps:

Backpropagation through Orbital Rotations: The algorithm first propagates the fermionic Hamiltonian backward through the final orbital rotation operators ( $e^{K_\mu}$ ). Using Lemma 1, the one-electron ( $h$ ) and two-electron ( $g$ ) integrals are updated via unitary transformations. This step is performed exactly in $O(N^3)$ and $O(N^5)$ time respectively, where $N$ is the number of orbitals, without increasing the number of terms in the Hamiltonian.
Propagation through Jastrow Operators: The Hamiltonian is then propagated through the Jastrow operators ( $e^{iJ_\mu}$ ). Lemma 2 demonstrates that this operation can also be performed exactly in $O(N^5)$ time. Crucially, this step does not increase the term count; instead, each term in the Hamiltonian accumulates a scalar phase and a vector phase dependent on the number operators. This holds true for both general UCJ and sparse LUCJ circuits.
Energy Evaluation via Löwdin's Formula: The final energy is computed as the expectation value of the modified Hamiltonian against the reference Slater determinant. Because the Jastrow propagation introduces non-orthogonal phases, the matrix elements are evaluated between non-orthogonal Slater determinants. The authors utilize Löwdin's formula (Lemma 3) to compute these matrix elements efficiently. The computational bottleneck involves forming and factorizing a matrix $S$ (related to the overlap of determinants), leading to an overall algorithmic complexity of $O(N^7)$ . The authors note that in practice, memoization of matrix elements reduces the observed scaling to approximately $O(N^{4.45})$ .

Key Contributions

Polynomial-Time Algorithm: The paper establishes that computing the energy of a single-layer UCJ circuit is classically tractable in $O(N^7)$ time, independent of the connectivity constraints of the quantum hardware.
Exact Simulation: Unlike previous methods that rely on truncation or heuristic approximations, this algorithm provides an exact calculation of the energy expectation value.
Distinction from Strong Simulation: The authors clarify that their method constitutes "weak simulation" (computing observables) rather than "strong simulation" (sampling bitstrings). Consequently, the algorithm cannot perform bitstring-based post-processing like SQD, which is used in experiments to mitigate hardware noise.

Results
The authors validate their algorithm through two primary case studies:

Iron-Sulfur Cluster (72 Qubits): The algorithm was applied to the 77-qubit (72 active qubits) iron-sulfur cluster experiment from Sci. Adv. 11, 25 (2025). While the original experiment required 6400 nodes on Fugaku for 1.44 hours to achieve an energy of $-326.645$ Ha via SQD, the authors' classical algorithm simulated the same circuit on a laptop in less than one minute. Furthermore, by optimizing the single-layer UCJ parameters using the fast classical energy evaluator (L-BFGS-B), they achieved a ground state energy of $-326.796$ Ha, surpassing the experimental result obtained via SQD.
Hydrogen Chains (Up to 160 Qubits): The algorithm was scaled to simulate Hydrogen chains with up to 160 qubits, representing the current limits of state-of-the-art superconducting quantum computers. The results showed that the single-layer UCJ ansatz, initialized with Coupled Cluster Singles and Doubles (CCSD) parameters, closely tracks Hartree-Fock energies (average difference of ~11 mHa). Optimization of parameters for systems up to 40 qubits yielded energies comparable to CCSD.

Significance and Claims
The paper concludes that single-layer UCJ circuits are insufficient for demonstrating quantum advantage in chemistry. The ability to simulate these circuits exactly and efficiently on classical hardware implies that the "quantum advantage" claimed in recent large-scale experiments relies on the specific post-processing (SQD) or the potential need for deeper circuits.

The authors explicitly state that achieving beyond-classical computation likely requires $L \ge 2$ layers of the (L)UCJ ansatz. They argue that their algorithm fails for $L \ge 2$ because the orbital rotations between Jastrow layers disrupt the diagonal structure required for Löwdin's formula. Given that alternating layers of Givens rotations and CZ gates are known to be universal for quantum chemistry, the authors suggest that while $L \ge 2$ is necessary for quantum advantage, it may not be sufficient without addressing the significant gate overhead on current hardware. The work serves as a benchmark, demonstrating that current single-layer experiments do not yet exceed the capabilities of optimized classical algorithms.

Technical Summary: Efficient Classical Simulation of Large-Scale Unitary Cluster Jastrow Circuits

More like this