Network-Based Quantum Computation

• Network-Based Quantum Computation (NBQC) is a paradigm that interconnects spatially distributed, error-corrected quantum processors via high-fidelity entanglement links for scalable and fault-tolerant computing.
• It employs distributed gate protocols, measurement teleportation, and continuous qubit movement to optimize both local operations and nonlocal quantum communication.
• NBQC underpins applications such as distributed Shor factoring, quantum machine learning, and secure cryptographic primitives, driving innovation in modular quantum architectures.

Network-Based Quantum Computation (NBQC) is a paradigm wherein spatially distributed quantum processors (nodes) execute joint quantum algorithms by exchanging quantum and classical information over a network. This approach is motivated by the practical limitations on the physical size and interconnect density of monolithic quantum computers, and by the exponential scaling of the Hilbert space with the global qubit count. By networking together smaller modules—each running a local error-corrected quantum computer—and interconnecting them with quantum links capable of efficiently distributing entanglement and classical synchronization, NBQC aims to achieve scalable, fault-tolerant quantum computation with performance rivaling or exceeding large-scale monolithic architectures (Jacinto et al., 11 Apr 2025, Naito et al., 14 Jan 2026, Gyongyosi et al., 29 May 2025).

1. Fundamental Architecture and Models

NBQC systems comprise a graph $G=(V,E)$, with each vertex $v\in V$ representing a quantum processor (QPU or module) and each edge $e\in E$ corresponding to a physical or logical quantum link. The modules themselves are typically organized as $d\times d$ surface-code blocks for fault-tolerant operation, hosting logical qubits with code distance $d$ and supporting lattice surgery for operations within and across modules (Jacinto et al., 11 Apr 2025).

In the canonical NBQC model, each module maintains a finite set of logical qubits, local error-correction resources, and communication subblocks dedicated to generating high-fidelity Bell pairs with its neighbors (Jacinto et al., 11 Apr 2025, Naito et al., 14 Jan 2026). Module connectivity can be organized as a 1D chain, 2D grid, star, tree, or ring network, each with distinct trade-offs in parallelism, resource overhead, and routing complexity (Fang et al., 2022, Li et al., 24 Feb 2025, Naito et al., 14 Jan 2026).

Key execution primitives include:

• Distributed Gate Protocols: Remote CNOT and other two-qubit gates implemented via gate teleportation, consuming pre-shared Bell pairs and classical correction bits (Fang et al., 2022, Gyongyosi et al., 29 May 2025).
• Measurement Teleportation: Joint stabilizer measurements (lattice surgery) between modules realized by local CNOT gates, Bell-pair ancillas, and parity extraction across modules (Jacinto et al., 11 Apr 2025).
• Continuous Qubit Movement: Logical qubits circulate around purpose-built ring or network topologies via repeated teleportation, minimizing communication-induced idle time and hiding Bell-pair generation latency (Naito et al., 14 Jan 2026).

The NBQC execution model is parameterized by module size (number of logical qubits per node), link performance (Bell-pair generation rate $b$ and fidelity $F$), local operation time $T_{\mathrm{local}}$, and the overall network topology $G$.

2. Communication Protocols and Resource Requirements

At the core of NBQC is the ability to generate and consume high-rate, high-fidelity Bell pairs between modules. Quantum and classical communication are integrated into layered protocols:

• Physical Layer: Quantum hardware (atomic qubits, superconducting circuits, trapped ions, photonic interfaces), optical fibers or microwave links (Li et al., 24 Feb 2025, Fang et al., 2022).
• Link Layer: Entanglement generation, heralding (with midpoint protocols), error detection, and buffering (Dahlberg et al., 2019). Key formulas include pair generation rate $R_{\rm link} = \nu \eta p_{\rm det} p_{\rm mem}$ and fidelity degradation with distance and loss.
• Network Layer: Entanglement swapping, multi-hop routing (e.g., shortest path, Dijkstra-based), and resource scheduling—often modeled via pool or queue structures to manage EPR resource contention (Fang et al., 2022, Dahlberg et al., 2019).
• Application Layer: Distributed quantum algorithm execution, circuit partitioning, logical gate scheduling, and classical orchestration.

Fault-tolerant NBQC requires Bell-pair fidelities $F \geq 98.4\%$ and link rates $b \geq 2d$ Bell pairs per surface-code cycle to match monolithic performance (Jacinto et al., 11 Apr 2025). Failure to meet these thresholds yields sharply increased overhead: as $F$ degrades, code distance $d$ and thus physical resource requirements must be increased to maintain logical error suppression.

3. Computational Models and Algorithmic Strategies

NBQC supports multiple computational paradigms:

• Circuit-Based NBQC: Distributed circuits are mapped such that nonlocal two-qubit gates invoke gate teleportation across links, with local gates executed natively (Fang et al., 2022, Gyongyosi et al., 29 May 2025).
• Measurement-Based NBQC (MBQC): Distributed computation over cluster or graph states, with adaptive single-qubit measurements distributed across modules implementing the desired unitary up to Pauli corrections (Fang et al., 2022, Beaudrap et al., 2014).
• Network-Layer MBQC: Linear quantum network coding protocols realized as graph-state MBQC with structure mirroring the underlying communication network (Beaudrap et al., 2014).
• Continuous Circulation (many-small-node NBQC): Logical qubits “move” via teleportation among a ring or Clos-style switching fabric, ensuring no logical operation is ever stalled by Bell-pair latency provided the network is properly dimensioned (Naito et al., 14 Jan 2026).

Runtime is typically minimized when the network is engineered so that qubit movement, Bell-pair generation, and magic state factory operation are tightly parallelized: $T_{\rm NBQC} = T_{\rm Bell} + D T_{\rm local}$, where $D$ is logical circuit depth (Naito et al., 14 Jan 2026).

Table: Asymptotic resource scaling for different NBQC protocols (Naito et al., 14 Jan 2026)

Scheme	Time	Node Count
Circuit-based DFTQC	$D T_{\rm Bell}$	$O(n)$
MBQC (brickwork ring)	$T_{\rm Bell} + nDT_{\rm local}$	$O(n T_{\rm Bell}/T_{\rm local})$
MBQC (clique ring)	$T_{\rm Bell} + D T_{\rm local}$	$O(n^2 T_{\rm Bell}/T_{\rm local})$
Circuit-agnostic NBQC	$T_{\rm Bell} + D T_{\rm local}$	$O(n^2 T_{\rm Bell}/T_{\rm local})$
Circuit-specific NBQC	$T_{\rm Bell} + D T_{\rm local}$	$O(\sum_{i,j}\mathrm{Bias}_{i,j}^{\log_s t})$

4. Error Correction, Performance, and Scalability

Surface code error correction is nearly universally adopted at the node level, enabling logical qubit error rates $P_L \approx \alpha (p/p_{\rm th})^{(d+1)/2}$, with $p$ physical gate error and $p_{\rm th}$ the code threshold (Jacinto et al., 11 Apr 2025). In NBQC, both local operations and distributed gates (consuming Bell pairs) contribute to logical error. The system tolerates Bell-pair error rates $p_{\rm Bell} \lesssim 2\%$ ($F \gtrsim 98.4\%$) without additional code distance or performance penalty.

Increasing $p_{\rm Bell}$ beyond threshold induces a superlinear increase in both space and time overhead, necessitating code distance increases from $d\to 41$ to $d\to 49$ as $F$ drops from $98.4\%$ to $96\%$ (Jacinto et al., 11 Apr 2025).

Scalability is limited by

• Bell-pair generation rates and fidelities,
• Quantum memory coherence times,
• Overheads due to network topology (e.g., 1D chain vs. grid),
• Classical synchronization and routing,
• Magic state distribution for non-Clifford operations.

Resource-optimal NBQC is achieved by tailoring network topology and switching capacity to the actual traffic pattern (i.e., number of remote gates per $T_{\rm Bell}$ window) (Naito et al., 14 Jan 2026).

5. Platform Implementations and Demonstrations

NBQC has been realized or simulated on multiple hardware platforms:

• Neutral Atom Arrays: Parallelized atom–photon Bell-pair generation at telecom wavelengths demonstrated network node architectures suitable for high-fidelity modular NBQC with up to $N$-fold multiplexing (Li et al., 24 Feb 2025).
• Trapped Ions and NV Centers: Operating system (OS)-style QNodeOS platforms support portable, multitasked NBQC applications across NV- and ion-based hardware, using platform-agnostic APIs and high-level quantum programming languages (Donne et al., 2024).
• Superconducting Circuits: Quantum network processing units (QNPUs) decouple communication from computation, using EPR resource management and distributed QASM (DistQASM) programming for efficient remote-gate scheduling (Li et al., 2 Sep 2025).
• Satellite-enabled QIN: Free-space optical links using satellites distribute Bell pairs over hundreds of kilometers, demonstrating satellite-enabled NBQC with realistic rates and fidelities using trapped-ion local processors (Parny et al., 15 Sep 2025).
• Single-photon Schemes: Deterministic multi-qubit controlled-phase gates realize distributed algorithms with much lower gate depth relative to concatenated circuit approaches (Cohen et al., 2018).

Toolkit support (e.g., QNET) offers simulation of circuit-based, MBQC, and real-world protocols at scale (Fang et al., 2022).

6. Applications and Open Challenges

Applications of NBQC include distributed Shor factoring, modular phase estimation, delegated/blind quantum computing, quantum-enhanced sensing, distributed QML, and secure cryptographic primitives (Gyongyosi et al., 29 May 2025, Fang et al., 2022).

Major technical challenges persist:

• Achieving simultaneous high-fidelity ($F \gtrsim 99\%$) and high-rate ($b \gtrsim 10^3$/s) entanglement generation across heterogeneous hardware,
• Fault-tolerant magic-state distribution and consumption in distributed settings,
• Efficient resource management, measurement-based routing, and dynamic task partitioning,
• Cross-vendor software stack standardization (OpenQIR/UQIR), and
• Practical demonstration of fault-tolerant NBQC at network scales beyond laboratory testbeds (Naito et al., 14 Jan 2026, Donne et al., 2024, Fang et al., 2022).

Progress in hardware integration (telecom atom–photon interfaces, integrated photonics, quantum repeaters), software orchestration (OS-like multitasking, API gateways), and theoretical protocol optimization will be essential for scaling NBQC to global quantum internet dimensions.