⚛️ quantum physics

Tensor-network simulation of strongly coupled multi-fluxonium circuits

This paper introduces a tensor-network simulation method using matrix product states and operators to efficiently compute the low-lying spectrum of strongly coupled multi-fluxonium superconducting circuits, overcoming the exponential memory limitations of exact diagonalization by scaling with the number of modes and truncation parameters rather than the full Hilbert-space dimension.

Original author: Christian Hensel, Andrés N. Cáliz, Pau Torrente, María Hita-Pérez, Arnau Riera

Published 2026-11-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original author: Christian Hensel, Andrés N. Cáliz, Pau Torrente, María Hita-Pérez, Arnau Riera

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 author. For technical accuracy, refer to the original paper. Read full disclaimer

Designing a superconducting quantum processor is a bit like trying to predict the behavior of a complex machine before it is ever built. The machine is made of tiny electrical circuits that carry electricity without resistance, cooled to temperatures near absolute zero. These circuits are the heart of the processor, and their behavior is dictated by a mathematical description of their energy levels. To understand what the machine will do, scientists must calculate the lowest energy states of these circuits. However, as more components are added to the circuit, the complexity of the calculation explodes. The number of possible states grows so rapidly that even the most powerful computers cannot handle the full picture when the circuit becomes large enough to be useful. This creates a bottleneck: engineers cannot design better machines because they cannot accurately simulate the ones they are trying to build.

The challenge is particularly acute when the components of the circuit are strongly linked to one another. In many traditional approaches, scientists try to break a complex circuit into smaller, manageable pieces, solve each piece separately, and then stitch the answers together. This works well when the pieces are loosely connected, but it often fails when the parts are tightly intertwined, as they are in the advanced circuits being developed today. If the pieces are not separated correctly, the final answer can be wrong, and there is no easy way to tell if the mistake happened because the pieces were chosen poorly or because the calculation was not precise enough.

A team of researchers at Qilimanjaro Quantum Tech and several institutions in Barcelona has developed a new way to solve this problem. Instead of chopping the circuit into arbitrary subsystems, they treated the entire circuit as a single, unified system. They used a mathematical technique called a tensor network, which is designed to handle complex, interconnected data without needing to store every single possibility in memory. By focusing on the natural vibrations, or modes, of the entire circuit, they were able to represent the system in a way that is both compact and accurate. This approach allowed them to simulate a circuit with three quantum units, known as fluxonia, which was previously impossible to calculate with standard methods.

The researchers tested their method on two different circuits. The first was a pair of fluxonia connected by a tunable link. For this smaller system, they could compare their new method against a traditional, exact calculation to see if it was accurate. The results were striking: the new method matched the exact calculation to within one millionth of a gigahertz, a level of precision that is more than sufficient for designing quantum processors. This validation gave them confidence to move on to the larger, more difficult circuit.

The second circuit consisted of three fluxonia linked by two tunable couplers. This system has eleven distinct modes of vibration and a theoretical number of possible states that is so vast it exceeds the memory capacity of the world's most powerful supercomputers if one tries to store all the data at once. A standard computer would need to store a number of values equivalent to 17 billion gigabytes to hold the full picture, which is far beyond current capabilities. Even a smarter approach that only stores the non-zero values would still require more memory than a single computer node possesses.

Using their new tensor-network method, the researchers were able to solve for the lowest energy levels of this massive three-fluxonium circuit. They found that they could calculate the eight lowest energy states with high precision using a bond dimension of 32. In plain terms, this means the computer only needed to keep track of a relatively small number of connections between the parts of the system to get the right answer. The entire calculation took 81 minutes and used just 1.3 gigabytes of memory on a single central processing unit. This is a tiny fraction of the resources that would be required by older methods, which would have been completely unable to run the simulation at all.

The success of this simulation demonstrates that the researchers can now model circuits that were previously out of reach. The method does not rely on guessing how to split the circuit or making approximations about how the parts interact. Instead, it uses the natural structure of the circuit itself to find an efficient path to the answer. The researchers confirmed that their results were stable and reliable by running the calculation multiple times with different starting points and by checking how the answer changed as they adjusted the precision of the calculation. They found that the results converged quickly, meaning that the method is robust and does not get stuck in incorrect solutions.

This work provides a powerful new tool for the design of quantum processors. By allowing engineers to simulate complex, strongly coupled circuits with high accuracy and low computational cost, the method removes a major barrier to building better quantum machines. It shows that even when the components of a circuit are deeply entangled, it is possible to understand their collective behavior without needing to store an impossible amount of data. The researchers have demonstrated that the path forward for quantum circuit design does not require waiting for computers to become infinitely powerful, but rather requires smarter ways to use the computers we already have.

Technical Summary: Tensor-network simulation of strongly coupled multi-fluxonium circuits

Problem Statement
Designing superconducting quantum processors requires predicting the low-lying energy spectrum of coupled circuits. In lumped-element models, the Hilbert-space dimension grows exponentially with the number of circuit nodes. Standard approaches, such as Born-Oppenheimer separations or hierarchical diagonalization, rely on splitting the circuit into user-defined subsystems. However, for circuits where elements are "strongly coupled" in a structural sense—meaning normal modes hybridize multiple junctions such that no single junction belongs to a local subsystem—these partition-based methods face significant challenges. A poor partition choice can lead to slow convergence or undetected errors. Furthermore, exact diagonalization becomes computationally intractable for circuits with more than a few nodes due to memory constraints, particularly when the coupling prevents sparse matrix representations.

Methodology
The authors propose a tensor-network method that avoids explicit subsystem partitioning. The approach consists of the following steps:

Normal Mode Diagonalization: The linear part of the circuit (capacitance matrix $C$ , geometric inverse-inductance matrix $L^{-1}$ , and junction list) is diagonalized to find normal modes. This defines a global basis where the Hamiltonian is linear in the inductive and capacitive terms.
Matrix Product Operator (MPO) Construction: The full lumped-element Hamiltonian, including the non-linear Josephson junction cosines, is mapped to an MPO. Each normal mode serves as a "site" in the tensor network. The cosine term for each junction is expanded into a sum of products of single-mode operators, resulting in an MPO with a small bond dimension and one site per mode.
DMRG Solution: The Density Matrix Renormalization Group (DMRG) algorithm is used to find the low-lying eigenstates. The method relies on two tunable truncation parameters:
- Fock Cutoff: The number of Fock states retained per normal mode.
- Bond Dimension ( $\chi$ ): The maximum bond dimension allowed for the Matrix Product State (MPS).
Convergence Strategy: The authors perform convergence studies by sweeping both truncation parameters independently. A solution is considered converged if the deviation in transition frequencies between the current setting and a larger reference setting is below 1 MHz.

Key Contributions

Subsystem-Free Formulation: Unlike hierarchical methods, this approach does not require the user to decompose the circuit into subsystems. The normal modes act as the sites, and the non-local nature of the junctions is handled naturally by the MPO structure.
Scalability: The computational cost is determined by the number of modes, the bond dimension, and the per-site Fock dimension, rather than the total Hilbert-space dimension. This allows the simulation of circuits with Hilbert spaces ( $10^9$ states) that are inaccessible to exact diagonalization.
Validation: The method is validated against exact diagonalization for a two-fluxonium circuit, showing agreement within 1 MHz. It is then applied to a three-fluxonium circuit (11 normal modes, $10^9$ states) where exact diagonalization is impossible.

Results

Two-Fluxonium Circuit: For a circuit with two fluxonia and a tunable coupler (6 normal modes), the tensor-network method agrees with exact diagonalization of the same truncated space to within 1 MHz. The method achieves this with a bond dimension $\chi$ of 4–6. The computational cost is competitive with or lower than exact diagonalization for the required accuracy, particularly regarding memory usage.
Three-Fluxonium Circuit: For a circuit with three fluxonia and two couplers (11 normal modes), the method successfully computes the lowest eight energy levels.
- Convergence: At a bond dimension of $\chi=32$ and a specific Fock cutoff (12 levels on low modes, 4 on others), the lowest eight levels are converged to within 1 MHz.
- Efficiency: A single solve at this setting takes 81 minutes and 1.3 GB of memory on a single CPU node.
- Comparison to Exact Methods: Exact diagonalization of the same $10^9$ -state space would require approximately $1.7 \times 10^{10}$ GB for a dense matrix or exceed the 230 GB RAM of the CPU node even with sparse storage (due to the dense nature of junction operators in the normal-mode basis). A matrix-free exact solver was estimated to require ~2.2 TB of RAM, making it infeasible.
- Bond Dimension: The required bond dimension for the three-fluxonium circuit ( $\chi=32$ ) is significantly smaller than the theoretical maximum needed to represent any state in the space (which could be up to 20,736), indicating that the low-energy states have a specific structure amenable to tensor network compression.

Significance and Claims
The paper claims that the tensor-network approach makes the simulation of strongly coupled superconducting circuits "affordable" by decoupling the computational cost from the exponential Hilbert-space dimension. The method is "generic" because it relies on the normal modes of the linearized circuit rather than ad-hoc subsystem definitions.

The authors modestly state that while the method achieves 1 MHz accuracy for the spectrum, this tolerance does not necessarily resolve very small residual interactions (like static ZZ shifts) that might be smaller than the tolerance scale. They also note that reducing the computed spectrum to an effective qubit Hamiltonian without perturbative expansion is deferred to future work. The primary contribution is demonstrating that a specific, strongly coupled three-fluxonium circuit can be solved with high precision on a single CPU node using a method that avoids the memory bottlenecks of exact diagonalization and the partitioning ambiguities of hierarchical methods.

Technical Summary: Tensor-network simulation of strongly coupled multi-fluxonium circuits

More like this