A Dynamic-Kernel/QPacket Executable for Quantum Repeater Chains in Q2NS/ns-3

AI summary

Overview

Research area: Quantum networking, specifically quantum-internet protocol architecture and ns-3-based simulation of entanglement distribution.

Technical level: Advanced.

Scope: This paper presents and evaluates a first executable specialization of the beyond-layering Dynamic Kernel/QPacket logic for end-to-end entanglement distribution over a linear quantum repeater chain in the Q2NS/ns-3 simulator.

What This Paper Is About

Quantum networks distribute entanglement, a non-local and non-copyable resource, so classical layering and classical store-and-forward forwarding do not directly apply. The beyond-layering protocol suite proposes carrying service intent and append-only action-commit stamps in a QPacket meta-header, with each node running a local Dynamic Kernel to plan and execute actions. This paper turns that design into a scoped, instrumented executable in Q2NS/ns-3 and checks its behavior against analytical link-resolvability models under heterogeneous node capabilities and pre-distributed entanglement.

Key Contributions

1. An executable Dynamic Kernel and QPacket specialization in Q2NS/ns-3 for end-to-end entanglement distribution over a linear repeater chain, instantiating QPacket meta-headers, append-only commit stamps, and a Planner–Executor–Engine pipeline.

2. A capability-aware link-preparation policy for heterogeneous micro-protocol libraries, supporting local entanglement generation, delegation via QPacket forwarding, pre-distributed entanglement, and explicit failure outcomes.

3. Verification of the implementation against analytical link-resolvability models for deterministic and random generator placement.

4. Instrumentation for committed actions, signaling load, QPacket forwarding behavior, runtime entanglement transmissions, and meta-header growth, plus a reproducibility artifact with execution scripts, raw CSV outputs, and plotting scripts.

Main Findings

• Analytical agreement: Simulated success probabilities match the analytical model for random generator placement with no pre-distributed entanglement, where success requires that no two adjacent nodes both lack the entanglement-generation micro-protocol. Markers in the figures use 95% binomial confidence intervals.

• Deterministic placement behavior: With no pre-distributed entanglement, the all and every2 placements always succeed, while the other placements always fail. The finalBottleneck placement, which leaves exactly one generator-unresolvable link, follows a success probability of p.

• Chain-length effect: For random generator placement, longer chains require higher generator probability g; results are shown for chains of 10, 100, and 1000 nodes.

• Sensitivity to generation versus pre-distribution: Under the implemented policy and linear-chain topology, success appears more sensitive to generator probability g than to pre-distributed entanglement probability p.

• Signaling load: Increasing pre-distributed entanglement probability reduces link-preparation signaling for successful placements, while initially failing placements may exchange more classical messages when additional resources allow the request to progress farther before termination. Results are reported for N = 100.

• Meta-header growth: Append-only QPacket stamps induce approximately linear terminal meta-header growth with chain length.

• Forwarding delay: Repeated forwarding of the growing meta-header produces a quadratic accumulated forwarding delay, which separates into a linear propagation term and a quadratic emission-delay term. Increasing pre-distributed entanglement probability reduces relative forwarding delay by reducing link-preparation stamps.

Methodology in Plain English

The authors build on the released Q2NS simulator without modifying its simulation core. Q2NS extends ns-3 with quantum nodes, quantum channels, quantum network devices, and a logically centralized NetController that tracks quantum states and networking objects. On top of this substrate, the authors implement the QPacket as a C++ structure holding the service intent and accumulated stamps, rather than as a concrete quantum-state encoding.

Each node runs a three-stage Dynamic Kernel. The Planner builds a directed acyclic graph of candidate actions from the QPacket, the node’s entanglement inventory, and classical reachability. The Executor binds feasible actions to micro-protocols and meta-protocols using the node’s local library. The Engine executes the schedule and appends stamps only when actions reach commit boundaries, then forwards, delivers, or drops the packet.

QPacket forwarding is modeled by assigning the packet a logical qubit-equivalent size equal to the number of classical bits needed to represent its current variables. Transmissions are serial, with an emission interval of 1 ns and a propagation delay of 0.5 ms, corresponding to 100 km of fiber at 5 µs/km. Classical messages are sent as UDP/IPv4 packets under 30 bytes over 1 Gbps point-to-point links with the same 0.5 ms propagation delay. Dynamic-Kernel processing and individual micro-protocol execution are instantaneous in simulation time, isolating forwarding and meta-header growth effects.

The experiments compare simulation outcomes with closed-form success probabilities across deterministic generator placements and random Bernoulli placement, with and without pre-distributed entanglement. Simulations were run on a MacBook with an Apple M5 chip and 16 GB of Unified Memory.

Why This Matters

This work shows that the Q2NS/ns-3 substrate can support reproducible, policy-specific evaluation of quantum-native protocol-suite concepts. It separates reusable beyond-layering structures from service-specific policy, and its agreement with analytical models indicates that control-plane hints are not required for correct execution, only for possible policy optimization.

Real-world applications include:

• Designing and validating quantum repeater chains for long-distance entanglement distribution.
• Planning entanglement resources for quantum key distribution infrastructure.
• Evaluating interconnects for distributed quantum computing.
• Studying resource allocation and signaling for quantum sensor networks.

Industry relevance: the implementation builds on a simulator available through the ns-3 App Store, making the approach accessible to network-simulation practitioners and useful for telecom and quantum-hardware teams that need policy-level evaluation before physical deployment.

Future Directions

• Incorporating realistic processing times, particularly in noisy scenarios where the quality of distributed entanglement decreases over time.
• Exploring control-plane hints, planned generator placement, waiting policies for temporarily unavailable generators, and alternative service policies that change the cost and timing model.
• Exposing a stable subset of the custom Dynamic-Kernel counters as ns-3 TraceSources and modularizing the specialization for broader reuse.
• Extending the logical QPacket model toward concrete physical encodings, including overheads from synchronization, hardware constraints, error correction, and general topologies requiring routing.

Target Audience

Quantum-networking researchers, protocol architects working on beyond-layering or quantum-native designs, ns-3 and Q2NS simulator developers, and graduate students studying entanglement distribution and quantum repeater chains. Readers should be comfortable with quantum networking concepts such as entanglement swapping, Bell-state measurements, and micro-protocol composition.

Authors’ abstract

The Quantum Internet operates on entanglement, a non-local, non-copyable, stateful network resource, which motivates protocol organization beyond classical layering. We present a first executable specialization of the Dynamic Kernel/QPacket logic from the beyond-layering protocol suite, targeting entanglement distribution over a linear quantum repeater chain. The implementation builds on Q2NS, an ns-3-based quantum-network simulation module available through the ns-3 App Store. It realizes QPacket meta-headers with service intent and append-only action-commit stamps processed by node-local Dynamic Kernels organized as a Planner--Executor--Engine pipeline, while being deliberately scoped to an analytically verifiable service and policy. Within this scoped setting, we study node heterogeneity through a link-preparation policy that accounts for pre-distributed entanglement and uneven entanglement-generation support across nodes, including delegation via QPacket forwarding. Simulations verify analytical link-resolvability models and expose signaling load, forwarding behavior, and QPacket meta-header growth. Results show that QPacket overhead is shaped by more than just encoding, including policy choices and available network resources. Overall, this study demonstrates how the Q2NS/ns-3 substrate can support reproducible, policy-specific evaluation of quantum-native protocol-suite concepts.