⚛️ quantum physics

QBX: A Compiler for 2-local Qubit Hamiltonian Simulation on Quantum Chiplets

This paper introduces QBX, the first quantum compiler specifically designed for 2-local qubit Hamiltonian simulation on quantum chiplet architectures, which utilizes a scalable hierarchical approach and a highway mechanism to significantly reduce cross-chiplet communication costs and outperform existing general-purpose and domain-specific compilers in circuit depth and operation count.

Original authors: Zikun Li, Zhuoming Chen, Zhihao Jia

Published 2026-09-29

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Zikun Li, Zhuoming Chen, Zhihao Jia

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 computers promise to solve problems that would take classical machines thousands of years to crack, from designing new materials to simulating complex chemical reactions. To do this, they rely on tiny units of information called qubits, which can exist in multiple states at once. However, building a machine with enough qubits to be truly useful is incredibly difficult. Current devices are limited by noise and the fact that qubits lose their delicate quantum state very quickly. One of the most important tasks these machines are expected to perform is simulating how physical systems change over time, a process known as Hamiltonian simulation. This is essential for understanding everything from how magnets work to how superconductors conduct electricity without resistance. The specific type of simulation needed for these tasks often involves interactions between pairs of qubits, a structure scientists call a 2-local Hamiltonian.

The challenge is that as we try to build larger quantum computers to handle these simulations, the traditional approach of putting all the qubits on a single, giant chip hits a wall. The chips become too crowded, leading to interference and manufacturing failures. A promising solution is to build a computer out of many smaller, separate chips, called chiplets, that are linked together. While this modular approach solves the size problem, it introduces a new hurdle: communicating between these separate chips is much slower and noisier than communicating between qubits on the same chip. Existing software tools that translate scientific problems into instructions for quantum computers were not designed for this specific architecture. They either treat the machine as a single block, ignoring the difficulties of cross-chip communication, or they try to manage the connections without understanding the specific mathematical structure of the simulation, leading to inefficient and error-prone results.

Researchers at Carnegie Mellon University have developed a new software tool called QBX to bridge this gap. QBX is the first compiler specifically designed to translate 2-local Hamiltonian simulations for quantum computers built from chiplets. Instead of just shuffling instructions around, QBX looks at the mathematical structure of the problem to find shortcuts that other programs miss. The researchers realized that in these specific simulations, many operations share a common pattern. By grouping these similar operations together, the software can use a special mechanism called a "highway" to move information between distant qubits much more efficiently than standard methods allow. This highway acts like a dedicated express lane, allowing a single control signal to affect multiple target qubits simultaneously, rather than requiring a long, slow chain of individual connections.

The core innovation of QBX lies in how it organizes the work. The software first breaks the complex simulation down into smaller groups of interactions, ensuring that the most communication-heavy parts are kept on the same chip or on neighboring chips. It then maps these groups to the physical layout of the chiplets, minimizing the distance information has to travel. Once the map is set, QBX aggregates the instructions into blocks that can be executed in parallel. Crucially, it reuses the "highway" connections it builds. If a highway is constructed to move information for one part of the calculation, the software checks if that same highway can be used for the next part without rebuilding it from scratch. This reuse saves a tremendous amount of time and reduces the number of errors that occur during the process.

In their tests, the researchers found that QBX significantly outperformed both general-purpose quantum compilers and those designed for specific types of simulations. When compared to widely used tools like Qiskit and t|ket⟩, QBX reduced the depth of the resulting circuits by up to 8.9 times and 53.2 times, respectively. In the world of quantum computing, a shallower circuit means the calculation finishes faster, which is vital because qubits are fragile and can lose their state before a long calculation completes. The new tool also reduced the number of operations required, which directly lowers the chance of errors. While existing specialized compilers could handle small problems, they failed to scale up to the larger sizes that chiplet architectures are designed to support. QBX, however, successfully scaled to much larger simulations, handling problems with hundreds of qubits that caused other tools to time out or crash, though it is worth noting that even QBX encountered timeouts on the very largest benchmarks tested.

The performance gains were not just theoretical; they were measured across a wide variety of real-world physics models, including the Ising model used to study magnetism and the Heisenberg model used to explore magnetic properties. The researchers tested their system on simulated backends representing different sizes of chiplet arrays, from a few hundred qubits up to nearly a thousand. In every case, QBX produced circuits that were shallower and more efficient than those generated by its competitors. Even when compared to a previous chiplet-specific compiler that used highways, QBX showed improvements, reducing the circuit depth by nearly 1.7 times. This suggests that the key to unlocking the potential of modular quantum computers is not just better hardware, but software that understands the unique geometry and constraints of the machine it is driving.

The study confirms that a hierarchical approach, where the software first decides which qubits belong on which chip and then optimizes the local connections, is far superior to trying to manage everything at once. By treating the chiplet architecture as a structured system rather than a random collection of parts, QBX minimizes the costly and noisy interactions between chips. The researchers noted that while their tool is currently the best available for this specific task, the principles it uses—grouping similar operations and reusing communication pathways—could potentially be applied to other types of quantum simulations in the future. For now, QBX stands as a critical step forward, proving that with the right software, the modular path to large-scale quantum computing is not only feasible but highly efficient.

Technical Summary: QBX - A Compiler for 2-local Qubit Hamiltonian Simulation on Quantum Chiplets

Problem Statement

2-local qubit Hamiltonian simulation is a fundamental task in quantum computing, essential for applications ranging from material science (Ising, XY, and Heisenberg models) to optimization algorithms like QAOA. However, executing these simulations on current Noisy Intermediate-Scale Quantum (NISQ) devices is challenging due to limited qubit capacity, decoherence, and operation noise.

While monolithic quantum chips face scalability hurdles such as frequency collisions and reduced manufacturing yields, chiplet architectures (Multi-Chip Modules or MCMs) have emerged as a viable scaling solution. These architectures connect multiple smaller chiplets, but they introduce unique compilation challenges:

Communication Costs: Inter-chiplet couplings are significantly noisier and more expensive than intra-chiplet links.
Heterogeneity: Existing general-purpose compilers (e.g., Qiskit, t|ket⟩) treat all qubit connections uniformly, ignoring the noise disparity between on-chip and cross-chip links, leading to suboptimal fidelity.
Scalability of Domain-Specific Compilers: Existing domain-specific compilers for Hamiltonian simulation are designed for monolithic architectures. They fail to scale to the problem sizes suitable for chiplet systems and lack optimizations for cross-chiplet communication.
Underutilization of Hardware Features: Chiplet-specific mechanisms like highways (efficient long-range entanglement resources) are not fully leveraged by current compilers to reduce routing depth or aggregate operations.

Methodology

The authors propose QBX, the first domain-specific quantum compiler designed explicitly for 2-local qubit Hamiltonian simulation on chiplet architectures. QBX employs a scalable, hierarchical approach that integrates high-level semantic optimizations with hardware-aware mapping.

Core Concepts

Pauli Sets and Blocks:
- Pauli Sets: QBX aggregates multiple 2-local Pauli strings of the same type (e.g., $ZZ$ , $YY$ , $XX$ ) that share a common control (root) qubit. This aggregation transforms them into a single unit suitable for multi-target controlled gates.
- Pauli Blocks: A group of Pauli sets with the same control and target qubits but different Pauli types (e.g., $ZZ$ , $YY$ , $XX$ acting on the same pair). This structure allows for highway reuse.
Highway Mechanism:
- QBX utilizes "highways," which are entangled states (generalized GHZ or cat-like states) enabling constant-depth long-range communication.
- Control-Empty Reuse: If two highway gates share the same control and targets and are separated only by gates acting on the targets, the highway state can be reused without reconstruction.
- Cross-Y Reuse: In specific sequences (e.g., $ZZ$ followed by $YY$ ), the highway can be reused by applying a $Y$ gate to the control and $X$ gates to the highway qubits, avoiding the cost of rebuilding the entanglement.

Compilation Pipeline

QBX processes the Hamiltonian through five distinct stages:

Pauli Graph Partitioner: Constructs a graph where nodes are qubits and edges represent Pauli string interactions. It partitions this graph into subgraphs (sets) to minimize the number of Pauli strings spanning multiple sets. This is formulated as a constrained optimization problem solved via Integer Linear Programming (ILP) or the METIS heuristic for scalability.
Set Orchestrator: Maps the partitioned sets to physical chiplets. It solves a Quadratic Assignment Problem (QAP) via ILP to minimize the total communication cost (weighted by distance and intensity) between chiplets.
Pauli Block Scheduler: Aggregates Pauli strings within each set into Pauli blocks. It schedules these blocks into layers, determining whether to use highways (for cross-chiplet or large intra-chiplet blocks) or local routing. It maximizes concurrency by running disjoint blocks in parallel.
Intra-chiplet Mapper: Maps logical qubits to physical registers within each chiplet, optimizing for short-term locality (e.g., using the SABRE mapper).
Circuit Generator: Synthesizes the schedule layers into a final circuit. It dynamically reorders commuting layers to minimize routing distances and implements the highway construction, entanglement, and reuse logic (Control-empty and Cross-Y).

Key Contributions

First Domain-Specific Compiler for Chiplets: QBX is the first compiler to bridge the gap between high-level Hamiltonian semantics and the heterogeneous constraints of chiplet architectures.
Hierarchical Mapping Strategy: By decoupling qubit-to-chiplet assignment from intra-chiplet mapping, QBX effectively minimizes cross-chiplet communication distances and counts, a critical factor for chiplet fidelity.
Systematic Highway Reuse: The paper introduces and proves theorems for Control-empty and Cross-Y highway reuse, allowing the compiler to amortize the cost of highway construction across multiple Pauli operations.
Aggregation of Pauli Strings: The method of aggregating 2-local Pauli strings into Pauli sets and blocks enables the efficient execution of multi-target controlled gates, significantly reducing circuit depth compared to gate-level routing.

Results

The authors evaluated QBX against general-purpose compilers (Qiskit, t|ket⟩), a chiplet-specific compiler (MECH), and domain-specific Hamiltonian compilers (2QAN, Paulihedral) across 51 circuits involving QAOA and various physics models (Ising, XY, Heisenberg) on simulated backends with 324, 440, and 990 qubits.

Performance vs. General-Purpose Compilers:
- QBX-METIS reduced circuit depth by 2.57× compared to Qiskit and 10.35× compared to t|ket⟩.
- Effective CNOT counts (a metric for infidelity) were reduced by 1.30× (vs. Qiskit) and 2.62× (vs. t|ket⟩).
Performance vs. Domain-Specific Compilers:
- Compared to 2QAN, QBX achieved comparable depth (1.13× lower) but scaled to significantly larger problem sizes where 2QAN timed out. 2QAN's scheduling complexity ( $O(m^4)$ ) limited its scalability, whereas QBX's greedy scheduler runs in $O(N_c m n)$ .
- Paulihedral failed on all benchmarks due to recursion depth limits.
Performance vs. MECH:
- QBX outperformed MECH (a general chiplet compiler) by 1.69× in circuit depth and 1.08× in effective CNOT count, demonstrating the value of domain-specific semantic optimizations.
Scalability:
- QBX-METIS demonstrated superior scalability, handling problem sizes where ILP-based solvers (QBX-CPLEX) and other compilers failed or timed out.
- Sensitivity analysis showed that QBX's performance advantage over Qiskit widens as the number of chiplets increases.

Significance

The paper claims that QBX represents a significant step forward in making large-scale Hamiltonian simulation feasible on near-term quantum hardware. By recognizing that 2-local Hamiltonian simulation possesses specific structural properties (commutativity, homogeneity of Pauli types) that can be exploited on chiplet architectures, QBX avoids the suboptimal outputs of generic compilers.

The work highlights that domain-specific knowledge is crucial for chiplet architectures. Simply applying general routing optimizations is insufficient; compilers must leverage high-level semantics (like Pauli string aggregation) and hardware-specific features (like highway reuse) to overcome the noise and connectivity constraints of modular quantum systems. The authors position QBX as a necessary evolution in quantum compilation to support the scaling of quantum capacity via chiplet technologies.