⚛️ quantum physics

A Recursive Module-Coupling Algorithm for Computing Low-Energy Eigenstates

This paper proposes a recursive module-coupling algorithm that constructs a physics-informed variational basis from locally-coupled modules to efficiently compute multiple low-energy eigenstates simultaneously, offering both a classical speedup and a systematic framework for hierarchical quantum circuit construction demonstrated effective on NISQ devices.

Original authors: Dihang Sun, Nannan Ma, Ching Hua Lee, Tianqi Chen, Jiangbin Gong

Published 2026-09-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Dihang Sun, Nannan Ma, Ching Hua Lee, Tianqi Chen, Jiangbin Gong

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

In the vast landscape of modern physics, understanding how collections of particles behave together is a central quest. When scientists study materials, magnets, or even the fundamental forces of nature, they often need to solve a specific mathematical puzzle: finding the lowest energy states of a system. These states are like the resting positions of a complex machine; knowing where the machine settles tells us how it will react to the world around it. However, as the number of particles in a system grows, the number of possible configurations explodes so rapidly that even the most powerful supercomputers struggle to keep track. It is a problem of sheer scale, where the memory required to describe the system grows faster than the universe itself can hold. To make progress, researchers have long relied on clever shortcuts that focus only on the most important parts of the puzzle, ignoring the rest to find a solution that is good enough to be useful.

A team of researchers from Singapore has now proposed a new way to tackle this problem, one that works like a recursive assembly line. Instead of trying to solve the entire system at once, their method builds the solution from the bottom up, piece by piece. They start by solving the energy puzzle for very small groups of particles, called modules. Once they know the lowest energy states of these small pieces, they combine two modules together to form a larger block. Crucially, they do not carry every single possibility from the smaller pieces into the larger one. Instead, they keep only the most relevant low-energy states, discarding the rest to keep the calculation manageable. They then treat this new, larger block as a single unit and repeat the process, coupling it with another block to make an even bigger one. By repeating this cycle, they can construct a description of a massive system without ever having to store the impossible amount of data that a full calculation would require.

The researchers tested this approach on a classic model of magnetic materials, known as the transverse-field Ising chain, which is a standard benchmark for such problems. Using classical computers to simulate the process, they found that their method could accurately reproduce the lowest energy levels of systems containing up to eighty particles. They discovered that by keeping a surprisingly small number of states from each step—sometimes as few as four or eight out of thousands of possibilities—they could achieve results that were nearly indistinguishable from the exact, perfect solution. The accuracy remained high even as the system grew larger, and the method proved robust enough to handle different ways the particles could be connected to one another. This suggests that the low-energy behavior of a large system is indeed built from the low-energy behaviors of its smaller parts, and that this structure can be captured efficiently without brute force.

Beyond just calculating numbers on a classical computer, the team showed that this modular strategy translates naturally into a format that can run on actual quantum computers. Current quantum machines are still in their early stages, often noisy and limited in size, making them difficult to program for complex tasks. The researchers demonstrated that their step-by-step assembly process could be converted into a series of quantum circuits that are small enough to run on today's hardware. They trained these circuits to act as "encoders," which map simple logical inputs onto the complex physical states of the system. By testing these circuits on real quantum processors provided by IBM, they showed that the method could successfully prepare low-energy states with a reasonable degree of accuracy, even in the presence of the noise that plagues current devices. This is a significant step forward because it moves the problem from a purely theoretical exercise to a practical protocol that can be executed on existing technology.

The work offers a distinct alternative to other popular methods used in the field, such as the density matrix renormalization group, which is currently the gold standard for one-dimensional systems. While those methods often require sweeping back and forth across the entire system many times to refine the answer, this new approach builds the solution hierarchically, allowing multiple energy states to be found simultaneously rather than one by one. The researchers found that for tasks requiring moderate accuracy, their method could be significantly faster than existing techniques. This speed is particularly valuable when scientists need to estimate the energy gap between the ground state and the first excited state, a measurement that is critical for understanding how a system might behave in quantum annealing or other advanced applications.

The implications of this work extend to the future of quantum computing itself. By providing a systematic way to construct quantum circuits that prepare specific states, the method offers a reliable starting point for more complex simulations. In many quantum algorithms, the quality of the final result depends heavily on the quality of the initial state. If a researcher can quickly generate a good approximation of a low-energy state using this modular method, they can then feed that state into other, more demanding algorithms to refine the answer further. The researchers demonstrated that their approach works not just in simulation but on real hardware, bridging the gap between theoretical efficiency and practical implementation.

Ultimately, this research provides a new toolkit for exploring the quantum world. It shows that by breaking a massive, intractable problem into smaller, manageable chunks and reassembling them with care, we can bypass the limitations of both classical and quantum hardware. The method does not claim to solve every problem perfectly, but it offers a highly efficient path to the answers that matter most: the low-energy states that govern the physical world. As quantum computers continue to evolve, techniques like this recursive module-coupling algorithm will likely become essential for turning these powerful machines into practical tools for discovery, allowing scientists to probe the behavior of matter in ways that were previously out of reach.

Technical Summary: A Recursive Module-Coupling Algorithm for Computing Low-Energy Eigenstates

Problem Statement
Finding the eigenstates of many-body Hamiltonians is a fundamental challenge in physics and computational science due to the exponential growth of the search space with system size. While classical methods like the Density Matrix Renormalization Group (DMRG) and quantum algorithms like the Variational Quantum Eigensolver (VQE) have been developed, they face limitations. DMRG optimizes a global matrix product state through repeated sweeps, which can be computationally expensive and sequential for excited states. VQE, while popular in the Noisy Intermediate-Scale Quantum (NISQ) era, often suffers from barren plateaus and requires complex ansatz designs. Furthermore, many applications require not just the ground state but several low-energy excited states simultaneously, and obtaining high-fidelity state preparation for subsequent refinement (e.g., imaginary-time evolution) remains difficult.

Methodology
The authors propose a Recursive Module-Coupling Algorithm that constructs a physics-informed, low-dimensional variational subspace iteratively. The core methodology operates on two levels: a classical numerical solver and a quantum circuit implementation.

Classical Recursive Projection:
- Module Decomposition: The system is partitioned into smaller, locally interacting modules (e.g., $n$ -site blocks).
- Local Diagonalization: The low-energy eigenstates of each isolated module are computed and truncated to retain the lowest $k$ states.
- Recursive Merging: Two adjacent modules are coupled via their inter-module interaction. The variational subspace for the merged system is constructed as the tensor product of the retained low-energy subspaces of the constituent modules ( $V_k = \text{span}\{|\alpha\rangle_A \otimes |\beta\rangle_B\}$ ).
- Effective Hamiltonian: An effective Hamiltonian of dimension $k^2$ is assembled within this product subspace and diagonalized to obtain the new set of low-energy eigenstates for the larger block.
- Iteration: This process is repeated hierarchically (e.g., $n \to 2n \to 4n$ ) until the target system size is reached. Unlike DMRG, which sweeps a global state, this method builds the basis from local eigenstates, allowing multiple low-energy states to be obtained simultaneously at each step without enforcing orthogonality to previously found states.
Quantum Circuit Implementation:
- Block Encoders: To avoid storing explicit amplitude vectors (which scales exponentially), the algorithm employs parameterized quantum circuits ("block encoders") trained to map logical basis states to the physical low-energy subspace of a module.
- Hierarchical Construction: Trained encoders for smaller blocks are reused as fixed components to construct encoders for larger blocks. A logical variational circuit couples these encoded subspaces to search for the low-energy states of the merged system.
- Training: The block encoders are trained using a Ky Fan subspace objective to minimize the energy of the first $k$ states. The logical circuit is then optimized to find the ground and excited states within the encoded tensor-product space.

Key Contributions

Physics-Informed Subspace Construction: The method constructs the variational basis directly from the tensor products of local module eigenstates, rather than optimizing a generic global ansatz. This leverages the locality of interactions to create a compact, physically tailored subspace.
Simultaneous Multistate Eigensolving: The algorithm naturally yields several low-energy states (ground and excited) on an equal footing at each merge step, avoiding the sequential convergence issues often found in excited-state DMRG.
Modular Quantum Realization: The recursive structure is translated into a standardized quantum circuit framework. This allows for the hierarchical assembly of large circuits from previously optimized, reusable encoder modules, compatible with current gate-based quantum hardware.
Error Analysis: The authors provide theoretical bounds showing that the truncation error per site remains bounded and scales systematically with the retained dimension $k$ , while the total error grows at most extensively with system size.

Results

Classical Simulations: Numerical tests on transverse-field Ising chains (up to $L=80$ ) demonstrate that the method achieves high fidelity (e.g., $>0.99$ for $L=10$ with $k=7$ ) and accurately reproduces the low-energy spectrum and gap structure across phase transitions.
Efficiency: For moderate accuracy targets (relative errors $\sim 4-5\%$ ), the modular method is shown to be tens of times faster than DMRG, particularly when calculating multiple low-energy states simultaneously. The computational cost scales as $O(k^6 \log_2(L/L_0))$ .
Quantum Hardware Experiments: Proof-of-principle experiments were conducted on IBM quantum processors (specifically ibm_pittsburgh). Despite hardware noise, the trained circuits successfully prepared low-energy states of the Ising model with reasonable computational-basis distribution fidelities (up to $\sim 0.83$ for the ground state with $k=4$ ). The results confirm that the encoded-subspace approach is feasible on NISQ devices, though performance is limited by gate errors and decoherence as circuit depth increases.

Significance and Claims
The paper claims that this recursive module-coupling framework offers a distinct alternative to existing eigensolvers by combining the physical intuition of renormalization group ideas with a modular, recursive structure. Its primary significance lies in:

Computational Advantage: Providing a fast, high-quality approximation for low-energy states, particularly useful as a starting point for more refined algorithms like imaginary-time evolution or as a guide for quantum annealing.
Scalability and Reusability: The ability to recursively reuse trained quantum encoders allows for the systematic construction of state-preparation circuits for larger systems without redesigning the entire ansatz.
NISQ Compatibility: Demonstrating that meaningful low-energy eigenstates can be prepared directly on current noisy quantum hardware, bridging the gap between classical subspace construction and quantum state preparation.

The authors position this work as a complement to existing algorithms, offering a systematic prescription for hierarchically constructing quantum circuits and providing fast estimates of energy gaps, rather than claiming to supersede high-precision methods like DMRG for all one-dimensional ground-state calculations.

Technical Summary: A Recursive Module-Coupling Algorithm for Computing Low-Energy Eigenstates

More like this