Heterogeneous architectures enable a 138x reduction in physical qubit requirements for fault-tolerant quantum computing under detailed accounting

arXiv:2604.06319 · quant-ph · Submitted 2026-04-07 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: We're looking at the paper: "Heterogeneous architectures enable a 138x reduction in physical qubit requirements for fault-tolerant quantum computing under detailed accounting".

Paper summary: Mira: So looking at this paper "Heterogeneous architectures enable a one hundred thirty-eight times reduction in physical qubit requirements for fault-tolerant quantum computing under detailed accounting", what does this mean for the bigger picture <ref:2604.06319#pg1,Heterogeneous architectures enable a 138x reduction in physical qubit requirements for fault>?

Kai: It means we stop thinking about scaling by just making one big, fully fault-tolerant processor and start thinking about how to build these specialized, interconnected modules effectively.

Lev: The core finding is that system growth isn't tied to expanding a single processor; instead, it shifts to developing a quantum memory that is technologically simpler but has limited functionality.

Mira: This architecture provides a concrete way forward for developing specialized hardware components because it unifies the challenges from the bottom-up physical design with the top-down requirements of quantum error correction codes.

Kai: The implication is that we can get much closer to running real workloads on smaller physical qubit counts, like that one hundred ninety thousand qubits mentioned for factoring a two thousand forty-eight-bit number <ref:2604.06319#pg1>.

Lev: They also show how algorithm-specific accelerators, like the one they used for the Adder subroutine, can significantly speed up specific parts of a computation while still keeping the overall hardware footprint manageable.

Mira: The authors are providing a blueprint, Q-NEXUS, for developing these necessary components based on technologies that are already being tested in labs today.

Kai: The main hurdle they point out is getting that high performance quantum bus working reliably so all these modules can communicate efficiently.

Conclusion: Kai: So we're wrapping up on this paper about heterogeneous architectures and that big reduction in physical qubit counts for quantum computing.

Mira: It boils down to moving away from just building one giant, monolithic processor to building specialized parts that talk to each other.

Kai: Right, so the title is all about those heterogeneous architectures enabling a one thirty eight times reduction in physical qubits when you do the detailed accounting.

Lev: That number is huge, but Mira, we need to remember it's based on specific assumptions about how things are connected and how the error correction codes are applied.

Mira: Exactly. The paper shows that by letting each part of the system handle its own task—like computation versus memory—you get flexibility that a single machine just can't match.

Kai: I mean, they use this Q-CHESS compiler to handle all the timing mismatches between these different parts, which is actually a really clever way to manage it on real hardware.

Lev: From my side, it means the scaling challenge isn't about making one bigger processor; it’s about simplifying the memory part and making that quantum bus work really well for communication.

Mira: So the big implication is that we don't need one massive fault-tolerant machine anymore; we can build a system of specialized modules where most of the data lives in simpler storage.

Kai: That shifts how we think about building hardware, because now it’s about designing these distinct components instead of just scaling up a single block.

Lev: And the real win is seen when you look at factoring big numbers, like two thousand forty eight bit RSA integers, where they drop the physical qubit need from nine hundred thousand down to around one nine hundred thousand.

Mira: That kind of resource savings is exactly what we need to make factoring practical on near-term quantum hardware.

Kai: It’s a concrete framework for developing these specialized parts, which the authors call Q-NEXUS, grounding it in technologies that are actually being built now.

Lev: But they're still focused on that high performance quantum bus, the QB. That communication link between these modules is where the next big engineering challenge lies.

Pranav S. Mundada, Aleksei Khindanov, Yulun Wang, Claire L. Edmunds, Paul Coote, Michael J. Biercuk, Yuval Baum, Michael Hush

Q-CTRL

quant-ph

Submitted: 2026-04-07

Updated: 2026-04-13

Comments: 34 pages, 7 figures

DOI: 10.1088/1367-2630/aeb71b

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 90/100

The gist: Heterogeneous architectures enable a significant reduction in physical qubit requirements for fault-tolerant quantum computing…

Key concepts

Heterogeneous Architectures
This design uses different types of hardware for different jobs rather than one uniform processor. It separates quantum processing units (QPUs) from quantum memory and control systems. This allows the system to be flexible, using the best physical devices for specific tasks while managing complex error correction across all parts.
Q-CHESS Compiler
This is a software tool used to manage how different parts of the heterogeneous system work together. It models timing mismatches between subsystems that run at different speeds. The compiler orchestrates execution across modules with distinct roles like computation and storage, ensuring smooth operation despite these differences.
Separation of Processing and Memory
The architecture intentionally separates where calculations happen (QPUs) from where data is stored (quantum memory). This separation accommodates long idle times common in quantum algorithms. It enables specialized processing modules and dedicated interfaces for fault-tolerant connections between the QPU and memory.
Scaling Redefinition
The paper argues that scaling quantum computing is no longer about making one giant, perfect processor bigger. Instead, scaling shifts to using a fixed QPU size and focusing on simplifying the quantum memory with limited functionality. This allows for massive reductions in total physical qubit requirements.

Terminology

Summary

Heterogeneous architectures enable a significant reduction in physical qubit requirements for fault-tolerant quantum computing, achieving up to a 138 times reduction compared to monolithic baseline architectures under detailed accounting. p. 0

Where the paper says it

Heterogeneous architectures enable a 138x reduction in physical qubit requirements for fault-tolerant quantum computing under detailed accounting Pranav S. Mundada,∗ Aleksei Khindanov,† Yulun Wang,† Claire L.

This work presents a complete heterogeneous quantum computing architecture that unifies bottom-up physical-device-driven challenges with top-down Quantum Error Correction (QEC) code considerations. p. 0
Where the paper says it

Despite significant theoretical and experimental QEC progress, quantum computer architecture has suffered a significant gap, with bottom-up physical-device-driven challenges largely disconnected from top-down QEC-code-driven considerations. In this work, we unify these two views, presenting a complete heterogeneous quantum computing architecture incorporating task-specific hardware selection and QEC encoding, and agnostic to code selection or physical qubit parameters.

The core innovation lies in incorporating task-specific hardware selection and QEC encoding, making the overall architecture agnostic to the specific QEC code or physical qubit parameters used. p. 0
Where the paper says it

Despite significant theoretical and experimental QEC progress, quantum computer architecture has suffered a significant gap, with bottom-up physical-device-driven challenges largely disconnected from top-down QEC-code-driven considerations. In this work, we unify these two views, presenting a complete heterogeneous quantum computing architecture incorporating task-specific hardware selection and QEC encoding, and agnostic to code selection or physical qubit parameters.

A key architectural feature is the separation of quantum processing operations from quantum memory to accommodate lengthy idling periods inherent in common algorithms, thereby enabling greater flexibility between subsystems. p. 0

Where the paper says it

In this work, we unify these two views, presenting a complete heterogeneous quantum computing architecture incorporating task-specific hardware selection and QEC encoding, and agnostic to code selection or physical qubit parameters. The architecture is based on the observation that due to the lengthy idling periods encountered in common algorithms, it can be advantageous to separate quantum processing operations from quantum memory, enabling expanded flexibility in qubit modality and code choice between subsystems.

This design incorporates special-purpose processing modules and a microarchitecture dedicated to fault-tolerant interfaces connecting Quantum Processing Units (QPUs) and quantum memories. p. 0
Where the paper says it

The architecture is based on the observation that due to the lengthy idling periods encountered in common algorithms, it can be advantageous to separate quantum processing operations from quantum memory, enabling expanded flexibility in qubit modality and code choice between subsystems. Our approach further enables special-purpose processing modules, and includes a full microarchitecture for fault-tolerant implementation of interfaces between quantum processing units and quantum memories.

The system is structured around functional modules with distinct roles: Computation, Communication, Storage, Control, and Representation. p. 2
Where the paper says it

To address these competing constraints, we embrace modularity as a core design principle, adopting a fully heterogeneous architecture in which the system is decomposed into distinct modules with well-defined functional roles. Each module is specialized for computation, communication, or storage, rather than attempting to support all functionality within a single homogeneous lattice.

Execution across these modules is orchestrated by the Q-CHESS compiler, which models timing mismatches between subsystems operating at different clock rates. p. 1
Where the paper says it

Second, we describe and deliver a complete micro-architecture and compiler that explicitly models timing, connectivity, scheduling, buffering, and transfer latency across subsystems operating at different clock rates in order to allow effective resource estimation directly connected with physical-device parameters and constraints. Rather than treating execution as constituting uniform logical cycles parameterized by a single error rate and clock speed, we model the explicit sequence of machine instructions required for faulttolerant execution under realistic hardware constraints.

Detailed accounting reveals substantial benefits across various workloads. p. 0

Where the paper says it

Our approach further enables special-purpose processing modules, and includes a full microarchitecture for fault-tolerant implementation of interfaces between quantum processing units and quantum memories. Using this architecture and a new fully featured compiler functioning across subsystems at the scale of 1, 000 logical qubits, we schedule and orchestrate a variety of algorithms down to hardware-specific instructions; a detailed accounting of all operations reveals up to 551× reduction in algorithmic logical error and up to 138× reduction in physicalqubit overhead compared to a monolithic baseline architecture.

For a 1,000 logical qubit Quantum Fourier Transform (QFT), the heterogeneous architecture yields a 42--59 times reduction in logical error and a 60--138 times reduction in physical-qubit overhead relative to a homogeneous baseline using identical device parameters. p. 1
Where the paper says it

By co-designing the architecture at every level — logical compilation, physical micro-architecture, and hardware — we demonstrate substantial reductions in both error and physical-qubit overhead for algorithms at the scale of 1, 000 logical qubits, using physically realistic assumptions about available hardware devices and the quantum bus. For the Quantum Fourier Transform (QFT) — a subroutine critical to many implementations of Shor’s algorithm [36] — our heterogeneous framework achieves a 42 − 59× reduction in logical error and a 60 − 138× reduction in physical-qubit overhead relative to a homogeneous baseline using the same device parameters.

In the context of factoring 2048-bit RSA integers, utilizing an algorithm-specific accelerator for the Adder subroutine, coupled with an experimentally demonstrated grid-coupling topology, reduces factorization time by approximately 87% to 4. p. 0
Where the paper says it

Using this architecture and a new fully featured compiler functioning across subsystems at the scale of 1, 000 logical qubits, we schedule and orchestrate a variety of algorithms down to hardware-specific instructions; a detailed accounting of all operations reveals up to 551× reduction in algorithmic logical error and up to 138× reduction in physicalqubit overhead compared to a monolithic baseline architecture. We then consider the factorization of 2048-bit RSA-integers; using an experimentally demonstrated grid-coupling topology, factoring RSA-2048 requires 381k physical qubits and 9.

9 days at a modest 13% hardware penalty, requiring 439 k physical qubits. p. 2
Where the paper says it

Introducing a dedicated 37-logical-qubit algorithmspecific accelerator to overcome the runtime bottleneck in the Adder subroutine reduces factorization time by ∼ 87% to 4. 9 days, at a 13% hardware penalty, now requiring 439k physical qubits.

Assuming hypothetical long-range coupling and employing qLDPC codes for quantum memory, the resource requirements for factoring a 2048-bit number drop dramatically to just 190 k physical qubits and under 10 days. p. 2
Where the paper says it

These estimates use error rates and cycles times as in Table X, fully account for the physical qubits required for fault tolerant state-transfer and high quality T-cultivation, and only assume an experimentally demonstrated grid topology that does not incorporate long-range connectivity. If one then assumes that the nonlocal physical connectivity, required in [37] using qLDPC codes, is achievable in memory, the physical resource requirements for factoring a 2048-bit number in our heterogeneous architecture drop to 190k physical qubits and 9.

The central finding is that the scaling challenge in quantum computing is fundamentally redefined: system growth is no longer tied to expanding a single, fully fault-tolerant processor. p. 0

Where the paper says it

At the thousand-qubit scale, these constraints are no longer theoretical: IBM’s 1,121-qubit Condor processor [11] required approximately a mile of cryogenic flex I/O wiring within a single dilution refrigerator [12]. The industry’s subsequent shift toward multi-chip modular systems, including IBM’s Nighthawk series [13], and systems from Rigetti [14], Pasqal [15], IonQ [16], and Xanadu [17], 1 In well engineered classical ICs, empirical observations later formalized as Rent’s rule show that the number of external terminals scales sub-linearly with system size [6].

Instead, the QPU size is fixed, and scaling shifts to a technologically simplified quantum memory with limited functionality. p. 3
Where the paper says it

A Computation Requirement (Fixed-size processor, FXD): Computation of universal fault-tolerant quantum logic on quantum data shall be performed within fixed-size quantum processing unit(s) (QPU). Hardware designed to execute universal logic must remains limited in size, at scales where classical scaling limits and fault-tolerant protocol developments are well in hand [5, 45–48].

The total physical qubit requirement for factoring 2048-bit RSA integers drops from 0. p. 0
Where the paper says it

Using this architecture and a new fully featured compiler functioning across subsystems at the scale of 1, 000 logical qubits, we schedule and orchestrate a variety of algorithms down to hardware-specific instructions; a detailed accounting of all operations reveals up to 551× reduction in algorithmic logical error and up to 138× reduction in physicalqubit overhead compared to a monolithic baseline architecture. We then consider the factorization of 2048-bit RSA-integers; using an experimentally demonstrated grid-coupling topology, factoring RSA-2048 requires 381k physical qubits and 9.

9 M in a monolithic baseline to 0. p. 0
Where the paper says it

Our approach further enables special-purpose processing modules, and includes a full microarchitecture for fault-tolerant implementation of interfaces between quantum processing units and quantum memories. Using this architecture and a new fully featured compiler functioning across subsystems at the scale of 1, 000 logical qubits, we schedule and orchestrate a variety of algorithms down to hardware-specific instructions; a detailed accounting of all operations reveals up to 551× reduction in algorithmic logical error and up to 138× reduction in physicalqubit overhead compared to a monolithic baseline architecture.

19 M (B3) and 0.25 M (B6), while simultaneously reducing actively controlled qubits to 0. p. 8
Where the paper says it

Application-specific CCZ factories: In the RSA2048 analysis, we employ CCZ factories based on Tcultivation. For Shor’s algorithm, CCZ factories are more efficient and leverage recent advances in T-state cultivation, reducing Ndist to 12 (a 6× reduction in physical qubits) with minimal runtime impact [50].

14 M and local couplers from 1. p. 4
Where the paper says it

5 transfer of a qubit state across dense networks without creating an unrealistic load of local couplers, each requiring individually calibrated local operations [19, 20]. We define a QB as these interconnects combined with complete fault-tolerant transfer protocols across different modules.

8 M to 0.16 M, reflecting a qualitative shift where the majority of quantum data is stored in modules with reduced control and connectivity needs. p. 6
Where the paper says it

III Q-NEXUS ARCHITECTURE Reflecting the requirements above, we introduce QNEXUS (Quantum Networked EXecUtion and Storage), a heterogeneous architecture with explicitly defined functional modules, illustrated in Fig. Q-NEXUS separates the computation and storage of quantum data, facilitates communication between modules through a quantum bus, and leverages heterogeneous qubit representations to reduce overheads within a single architectural frame-

The architecture provides a concrete framework, Q-NEXUS, for developing specialized hardware components within fault-tolerant quantum systems, grounding the proposal in technologies already demonstrated or under current development. The primary implementation challenge remains the high-performance quantum bus (QB) facilitating communication between these specialized modules. p. 6
Where the paper says it

Communication: the architecture uses a quantum bus (QB) with a Micro-architecture (MCR) to communicate between modules using fault-tolerant transfer protocols; Long-range (LNG) routing of quantum data is handled by the QB when it minimizes logical SWAP gates. Storage: quantum data is stored in QM, which absorbs Idling (IDL) and serves as the primary Scaling (SCL) axis; supports Static (STC) short-term storage, Random-access (RND) long-term storage, and Hierarchical (HRC) organization.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Adaptive hardware selection based on task-specific needs can be integrated into AI systems by selecting qubit modalities and QEC codes for different processing modules to optimize performance for specific subroutines, such as using long-coherence systems for storage and fast qubits for universal logic.

  2. The introduction of a QCHESS compiler allows the system to schedule and orchestrate a variety of algorithms down to hardware-specific instructions, enabling resource estimation that accounts for timing mismatches between modules during processing of quantum data.

  3. AI systems can utilize explicit memory tiers like Static Transversal Quantum Memory (STQM) for low-latency temporary storage or Random Access Quantum Memory (RAQM) for long-duration storage, allowing the system to buffer quantum information required for near-term computation while accommodating large-scale and long-duration storage.

  4. Application specific accelerators can be implemented as dedicated Processing Units (ASQPU) optimized for frequently occurring subroutines, such as a 33 bit Adder accelerator, which can lead to significant runtime reductions by addressing recurring computational bottlenecks.

  5. The architecture supports code heterogeneity where different error-correcting codes are used for different modules, allowing the system to match the strengths and weaknesses of QEC codes to target functional specifications for heterogeneous modules.

Abstract

Quantum computer hardware is predicted to scale over hundreds of thousands of qubits coming online in the next decade. Despite significant theoretical and experimental QEC progress, quantum computer architecture has suffered a significant gap, with bottom-up physical-device-driven challenges largely disconnected from top-down QEC-code-driven considerations. In this work, we unify these two views, presenting a complete heterogeneous quantum computing architecture incorporating task-specific hardware selection and QEC encoding, and agnostic to code selection or physical qubit parameters. Our approach further enables special-purpose processing modules, and includes a full microarchitecture for fault-tolerant implementation of interfaces between quantum processing units and quantum memories. Using this architecture and a new fully featured compiler functioning across subsystems at the scale of 1,000 logical qubits, we schedule and orchestrate a variety of algorithms down to hardware-specific instructions; a detailed accounting of all operations reveals up to 551x reduction in algorithmic logical error and up to 138x reduction in physical-qubit overhead compared to a monolithic baseline architecture. We then consider the factorization of 2048-bit RSA-integers; using an experimentally demonstrated grid-coupling topology, factoring RSA-2048 requires 381k physical qubits and 9.2 days, which can be reduced to 4.9 days via addition of an algorithm-specific accelerator for the Adder subroutine (requiring 439k qubits). Finally, assuming hypothetical long-range coupling, implementing quantum memory using qLDPC codes reduces the resources required for factoring to just 190k qubits and under 10 days. These results and the tooling we have built indicate that heterogeneous quantum-computer architectures can deliver significant, verifiable benefits on realistic hardware.

Sources

Related papers