With the emergence of the Quantum Internet, the need for advanced quantum networking techniques has significantly risen. Various models of quantum repeaters have been presented, each delineating a unique strategy to ensure quantum communication over long distances. We focus on repeaters that employ entanglement generation and swapping. This revolves around establishing remote endtoend entanglement through repeaters, a concept we denote as the “quantumnative” repeaters (also called “firstgeneration” repeaters in some literature). The challenges in routing with quantumnative repeaters arise from probabilistic entanglement generation and restricted coherence time. Current approaches use synchronized time slots to search for entanglementswapping paths, resulting in inefficiencies. Here, we propose a new set of asynchronous routing protocols for quantum networks by incorporating the idea of maintaining a dynamic topology in a distributed manner, which has been extensively studied in classical routing for lossy networks, such as using a destinationoriented directed acyclic graph or a spanning tree. The protocols update the entanglementlink topology asynchronously, identify optimal entanglementswapping paths, and preserve unused directlink entanglements. Our results indicate that asynchronous protocols achieve a larger upper bound with an appropriate setting and significantly higher entanglement rate than existing synchronous approaches, and the rate increases with coherence time, suggesting that it will have a much more profound impact on quantum networks as technology advances.
I. INTRODUCTION
Quantum networks^{1–3} offer many possibilities for applications that go beyond what classical networks can accomplish. Among these are quantum key distribution (QKD),^{4,5} sensing,^{6} secure communication,^{7} clock synchronization,^{8} and distributed quantum computing.^{9,10} Quantum repeaters have been developed using various techniques to facilitate longdistance communication for these applications. These methods can be broadly categorized into two groups: the first involves transmitting encoded quantum information^{11,12} and applying quantum error correction,^{13} similar to classical repeaters. The second, hereafter referred to as the quantumnative repeaters (or in some literature, firstgeneration repeaters^{14}) distributes longdistance entanglement^{14,15} through entanglement swapping^{16} (Fig. 1), allowing end users to carry out desired operations such as key distributions or secure communications. While a direct application of classical networking technologies to quantum networks by transmitting encoded quantum states may seem intuitive, the quantumnative repeater provides a more immediate solution to creating a network that utilizes endtoend entanglement, as the former approaches necessitate a considerably impractical quantity of qubits for error correction purpose.^{17,18}
The development of directlink entanglement generation has brought quantum networks closer to realization, with recent experiments demonstrating deterministic entanglement delivery between solidstate memories located in different physical locations,^{19} facilitated by the use of telecommunication wavelengths to extend the distance between the locations.^{20,21} However, the rate of directlink entanglement generation still decreases significantly over long distances due to photon loss and quantum state and operation instability resulting from unavoidable interactions with the environment. Quantum repeaters based on entanglement swapping are thus necessary to extend the entanglement generation (distribution) distance. However, they may not always be capable of achieving the desired fidelity levels required for certain applications.^{22,23} Entanglement purification (see Subsection II B) can improve fidelity, but it has a tradeoff. It reduces the number of entangled pairs shared between neighboring nodes on the network and requires a substantial amount of classical communication overhead.^{24} Entanglement swapping and purification form a quantumnative repeater scheme analogous to the link layer of classical networks (see Appendix A).
On top of the quantumnative repeater scheme, a network layer can be established to ensure an effective architecture^{25,26} for quantum networks, thereby enabling the full network capabilities. The quantum network layer plays a crucial role in determining the routing principles, i.e., quantumnative routing, that facilitate requests for generating endtoend entanglements between remote stations.^{27–29} Various metrics have been suggested to direct the routing process,^{30,31} and the entanglement rate—the number of entanglements generated per unit time—is a prevalent metric akin to throughput in classical networks, with entanglements (as the communication resources) replacing bits. In essence, designing a quantumnative routing protocol aims to determine the optimal path while maximizing the entanglement rate between any two nodes under specific constraints, such as operation probability, coherence time, and link capacity. It should be noted that a classical network is assumed to be present in the quantum network, responsible for performing routing computations and broadcasting routing information. In other words, each node in the quantum network must be able to communicate with one another via a classical network, cf., local operations and classical communications (LOCC). This assumption can be safely made given the expectation of a hybrid quantumclassical network and is a common practice in quantum routing techniques.^{27–32} After the paths have been established with the aid of LOCC, the intermediate nodes (repeaters) carry out entanglement swapping and purification. The resulting endtoend entanglements connecting the endpoints (end users) are then used as the communication resources for any desired operations. The nature of endtoend entanglement resembles connectionoriented circuitswitching, in contrast to the connectionless packet switching commonly used in classical networks, which was also proposed for quantum networks.^{33} To avoid confusion, the term quantumnative is explicitly used to denote that the technique applies only to quantum networks (to distinguish from the repeater approaches that relay qubits) and is not independent of classical networks.
The routing process in existing approaches^{27–30} is divided into two phases, namely external and internal, each assigned a specific time slot. During the external phase, pairs of network nodes with a direct connection try to establish entanglement using a physical link, resulting in an “instant topology” [Figs. 2(a) and 2(b)] consisting of directlink entanglements. In the internal phase, assuming that nodes are only aware of the directlink entanglement generation results of their neighbors (see Subsection II C), each repeater node swaps entanglement blindly to reach an endtoend entanglement between the two endpoints that request to communicate [Figs. 2(c) and 2(d)]. If the endtoend entanglement is not achieved, the two phases are repeated. It is essential to synchronize both phases to ensure that entanglement “links” remain available for the internal phase. However, this synchronization and blind attempts consume all entanglements in each time slot, leading to a low entanglement rate. Furthermore, there are no obvious solutions for connecting networks of networks in these existing approaches.
In this paper, we propose a set of asynchronous routing protocols that can find the path between any two endpoints in a network with a much higher entanglement rate than existing approaches. Also, the entanglement rate increases with coherence time, and there are gateways in the network to connect networks of networks. It removes the need for synchronized executions by iterating an instant topology consisting of entanglement links. The instant topology can be in the form of a graph that can be maintained in a distributed manner, such as a destinationoriented directed acyclic graph (DODAG)^{12} or a spanning tree. Such techniques have been wellstudied for classical lossy networks, which share the similarity of losing a connection (in a quantum context, an entanglement in the instant topology) with a probability depending on the quality of the physical link. Our theoretical analyses and simulations demonstrate that our asynchronous protocols achieve a larger upper bound and significantly higher entanglement rate compared to existing synchronous approaches. The entanglement rate increases as coherence time increases. Additionally, a treelike instant topology such as DODAG allows for the connection of networks of networks through the root nodes. These findings suggest that our proposed protocols will have a significant impact on the development of a Quantum Internet as technology advances (as coherence time increases and networks expand in scale).
The rest of the paper is organized as follows. First, we define the problem statement of this research by introducing the routing metric and the settings of the existing routing scheme we aim to optimize. Then, we propose the framework and two example algorithms for the asynchronous routing protocols that maintain an instant topology in a distributed fashion. Next, we evaluate the routing performance from various perspectives and provide a detailed explanation of a sample routing result with DODAG. Subsequently, we analyze the simulation results to examine the effectiveness of our scheme under different conditions and establish its superiority. Finally, we conclude the paper by discussing the limitations, the extent of usability, and potential areas for future research and expansion.
II. PRELIMINARIES
This section provides an overview of key concepts and methodologies relevant to our research. It offers essential background to ensure readers grasp the subsequent discussions and the context of our research question.
A. Entanglement swapping
Entanglement swapping, in essence, is to perform a Bell state measurement on two pairs of entangled qubits. In the circuit depicted in Fig. 3, three parties are involved: Alice, Bob, and a repeater. Alice possesses a qubit q_{0}, the repeater has qubits q_{1} and q_{2}, and Bob has a qubit q_{3}. Before t_{1}, operations (i.e., Hardamard and controllednot gates) are carried out to produce two pairs of entangled qubits: one between Alice and the repeater, $  q 0 q 1 \u27e9$, and another between the repeater and Bob, $  q 2 q 3 \u27e9$. Following this, the repeater executes a Bell state measurement, which is used initially to identify the specific Bell state that an entangled pair is in. After that, at t_{2}, the two entangled pairs $  q 0 q 1 \u27e9$ and $  q 2 q 3 \u27e9$ are swapped to form a new, single pair of entangled qubits, $  q 0 q 3 \u27e9$, which connects Alice and Bob with an entangled pair (i.e., an entanglement link).
B. Entanglement purification
As demonstrated in Fig. 4 at time t_{1}, Alice and Bob possess two entangled pairs, namely, $  q 1 q 2 \u27e9$ and $  q 0 q 3 \u27e9$, indicating a link capacity of two between them. This implies that two raw entanglements with moderate fidelity will be utilized to produce a single entanglement with higher fidelity. Alice owns q_{0} and q_{1}, while Bob owns q_{2} and q_{3}. Both $  q 1 q 2 \u27e9$ and $  q 0 q 3 \u27e9$ are considered lowquality (raw entanglements). Successful purification is determined by coincidence measurements in the Z basis. After the purification process, one of the entangled pairs is consumed, while the other becomes a higherquality entanglement. In this example, $  q 0 q 3 \u27e9$ is consumed, and $  q 1 q 2 \u27e9$ is preserved.
C. Global and local knowledge of direct links
For a quantum routing protocol to be effective, it must be capable of identifying the optimal path as and when required. If a previously selected path becomes unavailable, the proposal must be able to identify an alternative path from the current location to the destination. Since the global knowledge of the entire network's entanglement links is often not uptodate, the protocol must identify the best adjacent node based on its local knowledge of the entanglement links connected to it. Although the shortest path in an instant topology can be easily identified if a global view is available, it is unrealistic to assume every node has the latest version of it (e.g., to assume every node instantly knows the instant topology created by nodes $ A , D , E , H , I , F , C$ in Fig. 2). The status of all directlink entanglements can only be propagated through classical networks, which is relatively slow. In large networks, the instant topology may have already been altered by the time the global view has been broadcast to every network node. As a result, routing should be constrained to ensure that each node is only aware of the entanglement link states of its neighbors (e.g., node D only knows the directlink entanglement generation results of links D–A, D–B, D–G, and D–E. Specifically, D–A and D–E have been successful, while the other two have failed).
D. Finding disjoint paths
In a network, disjoint paths refer to two or more paths between a pair of nodes (i.e., source and destination) that do not share any common node or link/edge except for the source and destination. Here, we consider linkdisjoint paths where two paths do not have any link or edge in common. Finding disjoint paths is necessary in reality due to the current low link capacity in quantum networks. Assuming global knowledge of the instant topology, finding even two disjoint shortest paths in many scenarios remains an NPcomplete problem, such as the minmin (i.e., to minimize the length of the shorter path of the two disjoint paths), minmax (i.e., to minimize the length of the longer path of the two disjoint paths), and minsum (i.e., to minimize the sum of the length of the two disjoint paths) problems. In addition to singlecost minsum, others are NPcomplete. In addition, it is NPhard to obtain a ρapproximation to the optimal solution for any $ \rho > 1$. More details can be found in Ref. 34. This increases the time needed for classical operations (CO) to find the shortest paths. Calculating paths and propagating the global view of the instant topology within the entanglement coherence time is unrealistic. However, this problem will be eased in the future if there is a high link capacity.
E. Link capacity and desired fidelity
The maximum number of entanglements that can be generated between two parties is referred to as link capacity. As illustrated in Fig. 5, Alice and Bob each have two qubits, which means they can generate two entangled pairs, leading to resource/qubit allocation and scheduling issues. For more information, refer to Ref. 28. However, if there is redundant link capacity, a link in the instant topology can last longer since the other pairs of qubits (besides the one being used) will continually attempt entanglement generation, providing backup directlink entanglements. Redundant entanglements in one edge can also be utilized to generate multiple paths and support simultaneous connection requests. However, having four qubits does not necessarily mean we can achieve the maximum of two entanglements since various entanglementbased applications, such as QKD, require a minimum fidelity level. Some entanglements must be used up to attain the desired fidelity, as explained in Subsection II B. Consequently, the actual link capacity should be $ C / E ( f )$. Assuming homogeneous link and node quality, this is a constant factor applied to the entanglement rate. In the main text, without loss of generality, we set the link capacity C = 1 and the number of entanglements for purification E(f) = 1 since they are constant as average numbers. This simplifies the routing problem and allows us to focus on the entanglement rate change by maintaining a distributed graph.
III. THE ENTANGLEMENT ROUTING PROBLEM
Quantum networks have several constraints that do not apply to classical networks. One such constraint is the probabilistic nature of entanglement generation and swapping performed by repeaters. Without loss of generality, we consider the generation of the maximally entangled states (Bell states) between adjacent nodes and the operation of Bell state measurement at repeater nodes to swap entanglement. Each instance of generation or swapping has a chance of succeeding or failing, leading to probabilistic and unpredictable routing paths. As pathfinding takes place and directlink entanglements are generated, the instant topology changes constantly, emphasizing the need for an adaptive routing approach to creating an endtoend entanglement. Finally, once an endtoend entanglement is consumed, the network must establish a new one for a new connection request. In short, endtoend entanglements allow the creation of dedicated unicast channels between node pairs, regardless of their position in the network. As mentioned, this characteristic of entanglement resembles connectionoriented circuitswitching rather than the connectionless packet switching used in classical networking. Here, we present a definition of the quantumnative routing problem.
Let us consider a graph G(V, E) that represents the physical topology of the quantum network [Fig. 2(a)]. In this graph, each node $ v \u2208 V$ represents a quantumnative repeater, while each edge $ e \u2208 E$ denotes an optical link that connects two repeater nodes. The instant topology [Fig. 2(b)] is denoted as $ G \u2032 ( V \u2032 , E \u2032 )$, which is a subgraph of G. $ E \u2032$ is the set of directlink entanglements, and $ V \u2032$ are the nodes that are connected by the entanglements in $ E \u2032$. Additionally, each edge (link) e can support multiple entanglement generations with multiple qubit pairs between adjacent nodes, where the link capacity C(e) of link e is defined as the maximum number of entangled pairs generated between adjacent nodes connected by e. Each node contains a finite number of qubits (depicted as orange dots in Fig. 2), denoted as node capacity $ C ( v ) \u2265 \u2211 e \u2208 N ( v ) C ( e )$ where N(v) refers to the set of links connecting node v. To achieve a desired fidelity f, we need E(f) entanglements for purification, and each entanglement has an average coherence time, T_{co}. For simplicity, we assume that the link capacity C and purification number E(f) are both equal to 1. This implies that, as depicted in Fig. 2, only one qubit is present on one side of the physical link. Nonetheless, varying link capacities and purification numbers will not impact the evaluation of the routing scheme as they simply introduce a constant multiplier to the entanglement rate. The entanglement rate will increase linearly relative to the actual link capacity, as detailed in Subsection II E. Given our assumption that $ C / E ( f ) = 1$, we can omit the $ C / E ( f )$ multiplier from each entanglement rate equation.
In addition, for each entanglement generation between a direct link e, there is a probability p(e) that the generation will succeed, while each entanglement swapping at a repeater v has a probability q(v) of success. For convenience, we assume homogeneous entanglement generation probability, denoted by p, and entanglement swapping probability, denoted by q, on all network links and nodes. Finally, the entanglement rate, denoted by ξ, is the performance metric indicating the number of endtoend entanglements (Bell states) that can be generated in a unit time T. T must satisfy $ T \u2264 T c o$. Existing approaches usually consider the time required for both internal and external phases (as discussed in Sec. I) to be one unit time and assume it to be longer than the coherence time. To facilitate comparison, we set the unit time as $ T = ( T c o / n )$, where $ n \u2208 \mathbb{Z}$ and $ n \u2265 1$.
With these preliminaries, the problem of quantumnative routing is to design an effective algorithm that maximizes the entanglement rate under the constraint that nodes only possess local knowledge of adjacent links in the instant topology [for example, node E in Fig. 2(b) only knows the directlink generation results of E_{ED}, E_{EH}, E_{EF}, and E_{EC}]. Note that it is unrealistic to assume that a global view of the instant topology is known, which may allow an algorithm to determine the shortest paths in the instant topology. In existing protocols, such as in Refs. 27 and 28, that depend on global knowledge of the instant topology, entanglements need to possess longer coherence times as the network size (i.e., the number of network nodes) expands. This is because directlink entanglement information takes a relatively long time to traverse the entire network. Consequently, in a largescale quantum network, directlink entanglements may decay by the time all directlink generation results are collected. Thus, a distributed approach is necessary to find optimal paths with local knowledge of the instant topology.
Nonetheless, even if we assume to have a global view of the instant topology, it is still NPcomplete to find multiple disjoint shortest paths (for robustness) in many scenarios (see Subsection II D), given the restricted resources available at each link.^{35} However, many existing approaches assume that the global view of the instant topology is known, such as in Refs. 28–30 and 32. A recent work by Pant et al.^{27} proposes a blind search routing strategy with local knowledge of the instant topology, which, however, requires synchronized phases and consumes all directlink entanglements in each attempt, as shown in Figs. 2(c) and 2(d), resulting in a low entanglement rate. To ensure efficiency, entanglement swapping within a repeater should only occur when a path that includes that node is selected. Our approach, therefore, involves maintaining a distributed graph and reserving entanglements not used in the current paths for future use.
IV. ASYNCHRONOUS ROUTING SCHEME
In essence, our method of asynchronous routing functions on an eventdriven basis. It establishes and maintains the instant topology as a distributed graph (such as DODAG or spanning tree) and reacts to connection requests (events) by following the path determined in the graph, such as tracing the path through the most current DODAG's root. The crux of the matter is the former service, which outlines how to preserve the instant topology as a distributed graph that determines a route for any given pair of nodes. In particular, we illustrate the protocol using two sample graphs: DODAG and spanning tree. Protocol 1 presents the algorithmic steps of the routing processes, including quantum operations (QO), such as entanglement generation and swapping, and classical operations (CO), such as event listening and request handling. Moreover, the maintenance of the two example graphs (DODAG and spanning tree) is illustrated later in Protocol 1.1 and Protocol 1.2, which are replaceable by any distributed routing algorithms.
(N_{prev}, N_{next}: the previous and next node in the path.) 
(N_{dest}: destination.) 
⊳ Resource: System Interface and Variable 
1: $ C O \u2190 A \u2009 set \u2009 of \u2009 classical \u2009 operations$ 
2: $ Q O \u2190 A \u2009 set \u2009 of \u2009 quantum \u2009 operations$ 
3: $ N c \u2190 The \u2009 current \u2009 node \u2009 that \u2009 is \u2009 running \u2009 a \u2009 protocol \u2009 instance$ 
⊳ Ondemand Service: Topology Maintenance and Listener 
4: GraphUpdate(QO, CO, N_{c}) ⊳ Refer to Protocol 1.1 or 1.2 
5: CO.Listen(‘connection_request’, N_{prev}, N_{dest}) 
⊳ Request Handler: Path Navigation and Swapping 
6: function Navigate(N_{prev}, N_{dest}) 
7: $ N next \u2190$ NextHopDetermination( $ N c , N dest$) 
8: if N_{next} is not null then 
9: bool $ i \u2190 \u2009 Q O .$ EntanglementsSwapping $ ( N prev , N next )$ 
10: if i is true then 
11: CO.EmitConnRequestTo(N_{next}, (N_{c}, N_{dest})) 
12: else ⊳ When the quantum operation fails 
13: GraphUpdate(QO, CO, N_{c}) 
14: Navigate(N_{prev}, N_{dest}) 
15: end if 
16: else ⊳ When the current node is not in the graph 
17: GraphUpdate(QO, CO, N_{c}) 
18: Navigate(N_{prev}, N_{dest}) 
19: end if 
20: end function 
21: $ C O .$ ConnectionHandler $\u2190$ Navigate $ ( N prev , N dest )$ 
(N_{prev}, N_{next}: the previous and next node in the path.) 
(N_{dest}: destination.) 
⊳ Resource: System Interface and Variable 
1: $ C O \u2190 A \u2009 set \u2009 of \u2009 classical \u2009 operations$ 
2: $ Q O \u2190 A \u2009 set \u2009 of \u2009 quantum \u2009 operations$ 
3: $ N c \u2190 The \u2009 current \u2009 node \u2009 that \u2009 is \u2009 running \u2009 a \u2009 protocol \u2009 instance$ 
⊳ Ondemand Service: Topology Maintenance and Listener 
4: GraphUpdate(QO, CO, N_{c}) ⊳ Refer to Protocol 1.1 or 1.2 
5: CO.Listen(‘connection_request’, N_{prev}, N_{dest}) 
⊳ Request Handler: Path Navigation and Swapping 
6: function Navigate(N_{prev}, N_{dest}) 
7: $ N next \u2190$ NextHopDetermination( $ N c , N dest$) 
8: if N_{next} is not null then 
9: bool $ i \u2190 \u2009 Q O .$ EntanglementsSwapping $ ( N prev , N next )$ 
10: if i is true then 
11: CO.EmitConnRequestTo(N_{next}, (N_{c}, N_{dest})) 
12: else ⊳ When the quantum operation fails 
13: GraphUpdate(QO, CO, N_{c}) 
14: Navigate(N_{prev}, N_{dest}) 
15: end if 
16: else ⊳ When the current node is not in the graph 
17: GraphUpdate(QO, CO, N_{c}) 
18: Navigate(N_{prev}, N_{dest}) 
19: end if 
20: end function 
21: $ C O .$ ConnectionHandler $\u2190$ Navigate $ ( N prev , N dest )$ 
Protocol 1 is executed on each network node. To join the network, any node has to only abide by the protocol without requiring synchronization of operations and communications across all nodes. Lines 1 and 2 of Protocol 1 define the interfaces for executing classical operations (i.e., CO) and conducting quantum operations (i.e., QO). Line 3 assigns the identifier of the current node running the protocol instance to N_{c}. Starting from line 4, an ondemand service is initiated to update the instant topology continuously, based on the rules specified in the distributed graph, such as Protocol 1.1 or 1.2 in Secs. IV A and IV B. Line 5 is responsible for listening to incoming connection requests. It is worth noting that this is a selfpropagating entanglement swapping process, whereby each node that receives the connection request only has to focus on connecting itself with the destination node. Once a connection request arrives, line 21 processes it by redirecting the request to the Navigate function, which begins at line 6. The Navigate function verifies if both the current and destination nodes are present in the distributed graph. If it finds that both nodes are present in the graph, it proceeds to conduct entanglement swapping between the qubit connecting to the previous node N_{prev} and the qubit connecting to the next node N_{next}. Assuming a successful entanglement swapping, the Navigate function will send a connection request to the next node, requesting the establishment of a connection between the current and destination nodes. If the entanglement swapping is unsuccessful, or either the source or the destination node is absent from the distributed graph, the node will wait for an update to the graph before attempting to navigate again.
In short, to initiate the creation of endtoend entanglement between a source and a destination node, the source node issues a connection request, similar to line 11, to begin the navigation process. Each intermediate node requests the next node along the path toward the destination to perform entanglement swapping until the destination is reached. In Secs. IV A and IV B, we present two illustrations of the distributed graph: DODAG and spanning tree.
A. DODAG protocol
A DODAG^{36} is a graph with a treelike structure formed by selecting a root node and then growing by the exchange of control messages, as illustrated in Fig. 6. The routing protocol revolves around the utilization of one or more DODAGs, employing designated routing metrics and an objective function to assist in selecting the optimal path to the root node. Subsequently, communication between the two endpoints is established via the root node. The specific graph of a DODAG at any given time is referred to as a DODAG version. If needed, a network can support multiple DODAGs with different roots.
The routing metrics are the set of factors used to evaluate a candidate hop that determines a preferred path. These factors can vary, and here we include elements such as link quality, which is determined by link capacity (C) and the probability of directlink entanglement generation (p), as well as node quality, which is influenced by distance to the root node, number of qubits, probability of entanglement swapping (q), and coherence time (T_{co})—these metrics aid in creating a routing strategy that maximizes the entanglement rate. To focus on the primary concern of pathfinding, we assume that node and link qualities are homogeneous. However, in actual control messages, such as DIS (DODAG Information Solicitation), DIO (DODAG Information Object), and DAO (Destination Advertisement Object) in Fig. 6, distinct node and link qualities may be included to assist in selecting or eliminating parents and children. For example, if a link or node falls short of the minimum requirement (e.g., fidelity f < 0.5), it will be removed from the DODAG, along with its branches, and newer nodes will select stronger parents in their selection process. It is important to note that if a directlink entanglement is lost (either due to decoherence or removal), the branch that was disconnected from the DODAG tree will remain a floating DODAG branch. During this time, the disconnected node will act as the temporary root node for the branch until it can successfully rejoin the main DODAG. Once it has rejoined, the floating branch will become a part of the main DODAG once again.
The objective function for a DODAG establishes how nodes select and optimize the structure of the graph. It translates routing metrics into ranks that determine rules such as parent selection and loop avoidance (see Appendix B). In other words, the node's rank in a DODAG indicates its connectivity with the root and is determined as a scalar measure based on the routing metrics. As the node and link qualities are considered homogenous in this paper, the ranks should increase monotonically as the nodes get farther from the root, as shown in Fig. 6. It is worth noting that a DODAG node can have multiple parents as long as there are no loops in the graph, which is ensured by the objective function when calculating rank for new nodes. Consequently, routing can select preferred paths based on factors such as fewer hops or stronger nodes and links when dealing with distinct node and link qualities. An initial objective function is provided below for rank computation and parent selection.
While a DODAG is constantly updated according to the abovementioned rules (refer to Appendix B for information on loop avoidance), the routing process in the DODAG is as simple as moving up to the root and then descending to the intended destination by selecting the parent with the lowest rank value among all parents (or both source and destination ascend to the root). The maintenance of the DODAG is outlined in Protocol 1.1.
(N_{neighbor}: the node that the current node is communicating with) 
1: function NextHopDetermination(N_{c}, N_{dest}) 
2: return N_{c}.parent 
3: end function 
4: function GraphUpdate(QO, CO, N_{c}) 
5: $ C O . \u2009 DIS _ Handler \u2190 \u2009 DIS ( N neighbor , C O )$ 
6: $ C O . DIO _ Handler \u2190 \u2009 DIO ( N neighbor , Q O , C O )$ 
7: while true do 
8: if N_{c} is in DODAG then 
9: CO.BroadcastDIO(N_{c}) 
10: CO.Listen(‘DIS’, N_{neighbor}) 
11: else 
12: CO.BroadcastDIS(N_{c}) 
13: CO.Listen(‘DIO’, N_{neighbor}) 
14: end if 
15: end while 
16: end function 
17: function DIS(N_{neighbor}, CO) 
18: CO.SendDIO(N_{neighbor}) 
19: end function 
20: function DIO(N_{neighbor}, QO, CO) 
21: bool $ j \u2190 \u2009 C O . CheckMiniRank$ 
22: if j is true then 
23: CO.SendDAO(N_{neighbor}) 
24: bool $ k \u2190 false$ 
25: while $ ! k$ do 
26: $ k \u2190 \u2009 Q O . EntanglementGeneration ( N c , N neighbor )$ 
27: end while 
28: end if 
29: end function 
(N_{neighbor}: the node that the current node is communicating with) 
1: function NextHopDetermination(N_{c}, N_{dest}) 
2: return N_{c}.parent 
3: end function 
4: function GraphUpdate(QO, CO, N_{c}) 
5: $ C O . \u2009 DIS _ Handler \u2190 \u2009 DIS ( N neighbor , C O )$ 
6: $ C O . DIO _ Handler \u2190 \u2009 DIO ( N neighbor , Q O , C O )$ 
7: while true do 
8: if N_{c} is in DODAG then 
9: CO.BroadcastDIO(N_{c}) 
10: CO.Listen(‘DIS’, N_{neighbor}) 
11: else 
12: CO.BroadcastDIS(N_{c}) 
13: CO.Listen(‘DIO’, N_{neighbor}) 
14: end if 
15: end while 
16: end function 
17: function DIS(N_{neighbor}, CO) 
18: CO.SendDIO(N_{neighbor}) 
19: end function 
20: function DIO(N_{neighbor}, QO, CO) 
21: bool $ j \u2190 \u2009 C O . CheckMiniRank$ 
22: if j is true then 
23: CO.SendDAO(N_{neighbor}) 
24: bool $ k \u2190 false$ 
25: while $ ! k$ do 
26: $ k \u2190 \u2009 Q O . EntanglementGeneration ( N c , N neighbor )$ 
27: end while 
28: end if 
29: end function 
B. Distributed spanning tree
As a result of having access solely to local knowledge of the instant topology of a quantum network, constructing a spanning tree—a subgraph of a connected undirected graph that covers all vertices using the least number of edges—necessitates a distributed approach. Numerous distributed algorithms for spanning tree construction have been developed, including the renowned Gallagher–Humblet–Spira (GHS) algorithm.^{37} At the beginning of a GHS algorithm, each node is considered a fragment, and these fragments progressively fuse to form larger ones. To combine with another fragment, a fragment must locate its leastweight outgoing edge and work collaboratively with other nodes to find it in a distributed fashion. Over time, the number of fragments reduces until only one fragment remains, which is the minimum spanning tree (MST). A spanning tree guarantees the existence of a path between any two nodes. Nevertheless, using a path will disconnect parts of the tree, requiring all nodes to update it continuously. Our assumption of uniform p, q, and T_{co} implies that all edge weights are equal in our situation.
However, we must address the instant topology's probabilistic and decoherent entanglements (links). Figure 7 illustrates our modified version of the GHS algorithm. In short, it addresses the separation of a fragment caused by the decoherence of entanglements and continuous attempts to generate an outgoing edge due to the probabilistic nature of entanglement generation. We achieve this by incorporating a split event in addition to the merge and absorb processes of the GHS algorithm. The following paragraphs outline how the modified GHS algorithm operates within a quantum network.
In the physical topology G(V, E), each node starts as a fragment, and the objective is to connect all nodes with minimum weight (i.e., the least number of edges in our case) with no loop. In this context, an edge represents a directlink entanglement in a quantum network. A fragment F is a subset of V and is assigned a nondecreasing integer level Lv(F) that begins with 0. Each node in a fragment must have the same level value as its fragment, i.e., $ L v ( v ) = L v ( F ) \u2200 v \u2208 F$. Fragments with a nonzero level are assigned a unique name or fragment ID, denoted as $ FID ( v ) = FID ( F ) \u2200 v \u2208 F$. Every node chooses a neighbor node to form a core edge under certain constraints, such as the neighbor node with the minimum weight. Each fragment has only one core edge, and the core edge selection process is beyond this text's scope but can be found in Ref. 37. The two nodes connected by a core edge are responsible for broadcasting the fragment ID and level to all other nodes in the fragment. After receiving a broadcast message from the core, every node searches for its minimumweight outgoing incident edge. For instance, if node v receives a broadcast, it selects its minimum weight edge and sends a “test” message to node $ v \u2032$ on the other side (assuming $ v \u2032 \u2208 F \u2032$) with its fragment's ID and level. Then, node $ v \u2032$ determines whether the edge is an outgoing edge and sends a message back to inform node v of the result. The decision is based on the following criteria:

if $ FID ( v ) = FID ( v \u2032 )$, the edge is not outgoing because they are in the same fragment;

if $ FID ( v ) \u2260 FID ( v \u2032 )$ and $ L v ( v ) \u2264 L v ( v \u2032 )$, the edge is outgoing;

if $ FID ( v ) \u2260 FID ( v \u2032 )$ and $ L v ( v ) > L v ( v \u2032 )$, the algorithm cannot reach a conclusion because the two nodes may already belong to the same fragment, but node $ v \u2032$ has not yet discovered this due to the delay of a broadcast message. In this case, the algorithm allows node $ v \u2032$ to postpone its response until its level becomes higher than or equal to the level it received from node v. Refer to Appendix C for scenarios involving broadcast delay in the GHS algorithm.
When an outgoing edge is present, the fragments will begin to merge through the merge and absorb processes (directlink entanglement generation on the outgoing edge). If $ L v ( F ) = L v ( F \u2032 )$, the fragments will merge through the merge process, resulting in a new fragment with an increased level of $ L v ( F ) + 1$. On the other hand, if $ L v ( F ) < L v ( F \u2032 )$, the fragments will merge through the absorb process, and the combined fragment will have the same level as $ F \u2032$. When an edge within a fragment decoheres, it triggers a split event, where the two adjacent nodes generate new fragment IDs for their own fragments and broadcast them to the rest of the fragment. The levels of the new fragments remain the same. The increase in level during the merge process is to prevent the formation of an edge to a fragment that has already been combined by the other outgoing edge, which can cause a loop (see Appendix C). The split event does not combine fragments and thus does not affect the merge and absorb processes or the levels of any fragments.
As the rules dictate, a distributed spanning tree undergoes continuous updates. During the routing process within the spanning tree, the objective is to determine the correct direction toward the destination from the multiple available directions. Whenever an outgoing edge is detected, the relative position of each node in the tree, along with the new level and fragment ID, will be broadcast. This relative position is used to determine the correct direction toward the destination. Protocol 1.2 provides an outline of the distributed spanning tree's update process. To be concise, we have omitted the broadcasting and listening of events that update the fragment ID and level within a fragment.
(N_{neighbor}: the node that the current node is communicating with) 
1: function NextHopDetermination(N_{c}, N_{dest}) 
2: return N_{c}.next ⊳ relative position is updated when receiving a broadcast 
3: end function 
4: function GraphUpdate(QO, CO, N_{c}) 
5: CO.TestMessage_Handler ← TestMessage( $ N neighbor , Q O , C O )$ 
6: while true do 
7: CO.BroadcastTestMessage(N_{c}) 
8: CO.Listen(‘test’, N_{neighbor}) 
9: end while 
10: end function 
11: function TestMessage(N_{neighbor}, QO, CO) 
12: if $ C O . FID ( N neighbor ) ! = C O . FID ( N neighbor )$ then 
13: if $ C O . L v ( N c ) \u2264 C O . L v ( N neighbor )$ then 
14: bool $ r \u2190 false$ 
15: while $ ! r$ do 
16: r ← QO.EntanglementGeneration(N_{c}, N_{neighbor}) 
17: end while 
18: if $ C O . L v ( N c ) = = C O . L v ( N neighbor )$ then ⊳ merge 
19: char $ i d \u2190 \u2009 C O .$GenerateID 
20: int $ l v \u2190 C O . L v ( N c ) + 1$ 
21: CO.SetID(N_{c}, id) 
22: CO.SetID(N_{neighbor}, id) 
23: CO.SetLv(N_{c}, lv) 
24: CO.SetLv(N_{neighbor}, lv) 
25: else⊳ absorb 
26: char $ i d \u2190 C O . FID ( N neighbor )$ 
27: int $ l \u2190 C O . L v ( N neighbor )$ 
28: CO.SetID(N_{c}, id) 
29: CO.SetLv(N_{c}, lv) 
30: end if 
31: CO.BroadcastNewFragementInfo(N_{c}, id, lv) 
32: CO.BroadcastNewFragementInfo(N_{neighbor}, id, lv) 
33: else 
34: TestMessage(N_{neighbor}, QO, CO) 
35: end if 
36: end if 
37: end function 
(N_{neighbor}: the node that the current node is communicating with) 
1: function NextHopDetermination(N_{c}, N_{dest}) 
2: return N_{c}.next ⊳ relative position is updated when receiving a broadcast 
3: end function 
4: function GraphUpdate(QO, CO, N_{c}) 
5: CO.TestMessage_Handler ← TestMessage( $ N neighbor , Q O , C O )$ 
6: while true do 
7: CO.BroadcastTestMessage(N_{c}) 
8: CO.Listen(‘test’, N_{neighbor}) 
9: end while 
10: end function 
11: function TestMessage(N_{neighbor}, QO, CO) 
12: if $ C O . FID ( N neighbor ) ! = C O . FID ( N neighbor )$ then 
13: if $ C O . L v ( N c ) \u2264 C O . L v ( N neighbor )$ then 
14: bool $ r \u2190 false$ 
15: while $ ! r$ do 
16: r ← QO.EntanglementGeneration(N_{c}, N_{neighbor}) 
17: end while 
18: if $ C O . L v ( N c ) = = C O . L v ( N neighbor )$ then ⊳ merge 
19: char $ i d \u2190 \u2009 C O .$GenerateID 
20: int $ l v \u2190 C O . L v ( N c ) + 1$ 
21: CO.SetID(N_{c}, id) 
22: CO.SetID(N_{neighbor}, id) 
23: CO.SetLv(N_{c}, lv) 
24: CO.SetLv(N_{neighbor}, lv) 
25: else⊳ absorb 
26: char $ i d \u2190 C O . FID ( N neighbor )$ 
27: int $ l \u2190 C O . L v ( N neighbor )$ 
28: CO.SetID(N_{c}, id) 
29: CO.SetLv(N_{c}, lv) 
30: end if 
31: CO.BroadcastNewFragementInfo(N_{c}, id, lv) 
32: CO.BroadcastNewFragementInfo(N_{neighbor}, id, lv) 
33: else 
34: TestMessage(N_{neighbor}, QO, CO) 
35: end if 
36: end if 
37: end function 
C. Time complexity
The time complexity of asynchronous pathfinding algorithms can vary depending on the specifics of the algorithm and the nature of the network. Here, we analyze the time complexity of the asynchronous protocols in terms of link availability probability p, node availability probability q, and consider a grid network with node size n (i.e., $ n \xd7 n$ grid) where the root is at the center of the grid.
The time complexity of DODAG can be analyzed in two parts: the time complexity for constructing the DODAG and the time complexity of pathfinding within the DODAG. In the worst case, constructing a DODAG from a network can have a time complexity of O(n) if we consider all possible nodes and links. However, since each link and node has a probability p and q of being available, respectively, on average, we are dealing with $ p n$ nodes and $ q n$ links (assuming a full mesh). So, the complexity becomes O(pqn) for creating the DODAG. However, this decreases the probability of the pathfinding part of the protocol. In other words, the reduction of time complexity of DODAG construction of the algorithms (by the decrease in p and q) increases the success probability of pathfinding. For pathfinding, the paths from the source or destination to the root are planned by the rank values, which means the complexity corresponds to the length of the planned path. The worstcase time complexity of DODAG pathfinding is thus the summation of the furthest possible distance between source (i.e., $ n$) and root and that between destination and root (i.e., $ n$). Therefore, the overall complexity is $ O ( n )$. Note that these are the worstcase time complexities of the algorithm since we consider DODAG construction and pathfinding as separate steps, but they are happening simultaneously in practice.
The time complexity of the spanning tree protocol can be similarly analyzed in two parts: constructing the distributed spanning tree and pathfinding in the spanning tree. Generally, a distributed algorithm to construct a minimum spanning tree (like the GHS algorithm) can have a time complexity of $ O ( n \u2009 log \u2009 n )$.^{37} In the worst case, all fragments are combined with “Merge” operations, so the number of fragments decreases by half at each level. Therefore, the maximum number of levels is $ O ( log \u2009 n )$. Each level takes O(n) time (for information exchange in broadcast). Hence, the time complexity is $ O ( n \u2009 log \u2009 n )$. Since a spanning tree is a tree, and trees are acyclic and have only one path between any two nodes, locating a path in a tree (given pointers to the start and end nodes) can be done in O(n) in the worst case, as you may need to traverse the entire tree (in a skewed tree scenario). However, if it is reasonably balanced, the path could be found much faster, in $ O ( log \u2009 n )$ time. Note that the discussion of message complexity of both algorithms is out of the scope of this article but can be found in Ref. 38.
V. PERFORMANCE ANALYSIS
To assess the effectiveness of our asynchronous routing protocol, we utilize the entanglement rate (ξ) as a metric. To simplify matters, we focus on a 2D grid topology [as illustrated in Fig. 8(a)], denoted by G(V, E), and define an instant topology $ G \u2032 ( V \u2032 , E \u2032 )$ as a subset of this grid. Each node in G is only aware of the status of entanglements in the four direct links connected to it and has no knowledge of the larger instant topology beyond that.
In Sec. IV A, we used L(v) to denote the length (number of links) of a path from node v to the root of a DODAG. It is possible to extend this notation to represent the length of the path between any two nodes (e.g., source node s and target node t) as L(s, t), but this value only applies to a specific instance of the instant topology. To calculate the entanglement rate in a more general case, we can estimate this value by approximating the mean length of all paths between two nodes in the physical topology. Specifically, we use $ l s , t$ to represent the mean length of all possible paths between nodes s and t in G. $ l s , t$ is of interest in percolation theory for a 2D square lattice, but it cannot be determined analytically. However, an approximation is possible^{39,40} (see Appendix D).
A. Synchronous protocol analysis
B. Asynchronous protocol analysis
The worstcase upper bound of our approaches is represented by $ \xi DODAG U B ( s , t ) = 4 q l \u0302 s , r + l \u0302 r , t \u2212 1$. Initially, let us examine the case where p = q, then the upper bound of synchronous approaches is $ \xi syn U B ( s , t ) = 4 q 2 l \u0302 s , t \u2212 1$. Therefore, the difference between $ \xi DODAG U B ( s , t )$ and $ \xi syn U B ( s , t )$ is attributed to the difference between $ 2 l \u0302 s , t$ and $ l \u0302 s , r + l \u0302 r , t$. Let us denote the angle formed by s, r, and t with respect to r as θ, for instance, θ_{1}, θ_{2}, and θ_{3} in Fig. 9. As demonstrated in Fig. 9, we can infer the difference between $ 2 l \u0302 s , t$ and $ l \u0302 s , r + l \u0302 r , t$ by the relationship of sides in a triangle:

If θ is obtuse (e.g., θ_{3}), $ l \u0302 s , r + l \u0302 r , t < 2 l \u0302 s , t$ (i.e., the sum of the two sides adjacent to an obtuse triangle is less than twice the length of the other side. See Subsection V C).

If θ is a right angle and the three nodes form an isosceles right triangle (e.g., θ_{1} with s_{2} and t_{2}), $ l \u0302 s , r + l \u0302 r , t = 2 l \u0302 s , t$. If θ is a right angle and the three nodes do not form an isosceles right triangle (e.g., θ_{1} with s_{2} and t_{4}), $ l \u0302 s , r + l \u0302 r , t < 2 l \u0302 s , t$.

If θ is acute (e.g., θ_{2}), there are two cases depending on the relative position of the three nodes. Assuming s is the one closer to r (i.e., t is farther from the root. Note that these are also valid when treating t as the closer one to the root):

When $ l \u0302 s , r \u2264 \alpha l \u0302 s , t$ (see Subsection V C for the value of α with respect to θ), $ l \u0302 s , r + l \u0302 r , t \u2264 2 l \u0302 s , t$ (e.g., θ_{2} with s_{1} and t_{1}). That is, our approach is better when s is close to the root but far from t. In the case of equality, the three nodes form an equilateral triangle.

When $ l \u0302 s , r > \alpha l \u0302 s , t , \u2009 l \u0302 s , r + l \u0302 r , t < 2 l \u0302 s , t$ (e.g., θ_{2} with s_{4} and t_{1}). That is, when s is close to t but far from the root, our approach is not providing the optimal route.
In summary, only if the source and destination nodes are located in proximity and far from the root [only case 3(b) above], our worstcase upper bound is lower than $ \xi syn U B ( s , t )$. Nevertheless, in this scenario, they are likely to be on the same branch of the DODAG and thus have a higher probability of having a much greater rate since they do not need to pass through the root. This hypothesis is verified through simulation in Sec. VI. Additionally, in the case where the three nodes are aligned in a line, if r is between s and t, $ l \u0302 s , r + l \u0302 r , t = l \u0302 s , t$. If r is not in between, they can always establish communication without going through the root. When traveling toward the root, the node farther away from the root would reach the closer node before reaching the root. However, any entanglement swapping between the closer node and the root would be pointless. Therefore, we can apply $ l \u0302 s , r + l \u0302 r , t = l \u0302 s , t$ in this scenario as well.
With that, it is obvious that $ \xi DODAG U B ( s , t ) > \xi syn U B ( s , t )$ holds when p < q.
Now, let us see the case where p > q. From $ \xi syn U B ( s , t )$ and $ \xi DODAG U B ( s , t )$, we have the relationship between $ l \u0302$ and $ l \u0302 s , r + l \u0302 r , t$:

If $ l \u0302 s , t \u2265 \beta ( l \u0302 s , r + l \u0302 r , t )$ where $ \beta < 1$ (see Subsection V C for the value of β with respect to p and q), $ \xi syn U B ( s , t ) \u2264 \xi DODAG U B ( s , t )$.

If $ l \u0302 s , t < \beta ( l \u0302 s , r + l \u0302 r , t ) , \u2009 \xi syn U B ( s , t ) > \xi DODAG U B ( s , t )$.
Even though the second case seems to suggest that the synchronous method has a higher upper bound on the entanglement rate, the relationships are valid only because $ l \u0302 s , r + l \u0302 r , t \u2265 l \u0302 s , t$. However, we find that, in reality, it is most likely $ l \u0302 s , r + l \u0302 r , t \u2248 l \u0302 s , t$ when the distance between the source and destination is large. As shown in our simulation in Fig. 10, the paths' lengths (hops) tend to converge as the distance between the source and destination increases. That is, $ l s , r + l r , t \u2248 l s , t$ when the distance between source and destination is large, which means that our approach has a significantly larger upper bound than asynchronous approaches when the distance between source and destination is large. This phenomenon can be explained by Fig. 9 to some extent [i.e., as the distance between the two communicating nodes increases, the two nodes and the root tend to align in a linear configuration if the root is in the center of the network, that is, the three nodes are more likely to form a line as distance increases. It is important to note that although the mean path length tends to decrease with larger distances between nodes, it will not be lower than the actual distance for obvious reasons. The number of network nodes influences the observed trend in a grid network. When approaching the maximum achievable distance between the source and destination, the mean path lengths for both approaches always converge. This convergence is demonstrated in Figs. 10(a) and 10(b). Also, this distance value of the convergence point becomes smaller when T_{co} becomes larger. With this fact, Equations (4) and (6) imply $ \xi DODAG ( s , t ) \u2273 \xi syn ( s , t )$ when the distance between source and destination is large, which makes $ l s , r + l r , t \u2248 l s , t$.
Note that Fig. 10 only represents the average length of paths found by the two protocols in an instant topology. It does not take into account the probability of finding a path. Path length alone does not fully determine the entanglement rate. We must also consider the probability of finding a path in an instant topology to determine the entanglement rate. In our simulations, the number of successful path findings by asynchronous protocols is significantly higher than synchronous protocols, given the same number of simulation iterations. The averages in Fig. 10 are calculated by taking only the iterations with successful path findings. Therefore, despite potentially having longer paths, asynchronous protocols are more likely to find a path, leading to a higher entanglement rate in the end. Results pertaining to entanglement rate versus distances are presented in Sec. VI.
Additionally, the simulations presented in Fig. 10 only account for scenarios where the source and destination nodes must pass through the root to establish a connection. However, in reality (and in subsequent simulations), it is common for closely located source and destination nodes to bypass the root and instead traverse a common ancestor. As a result, the mean path length for our approach is expected to be considerably lower than depicted in the figure (as demonstrated in the simulation results in Subsection VI).
Moreover, if we assume that there is at least one available path (where p and q are sufficiently high to exceed the probability threshold in bond percolation, such as p > 0.5 and q = 1 for a 2D square lattice^{41}), we can establish lower bounds for $ \xi syn L B ( s , t ) = p l s , t q l s , t \u2212 1$ and $ \xi DODAG L B ( s , t ) = p l s , r + l r , t q l s , r + l r , t \u2212 1$. If no directlink entanglement is available in the instant topology, using a DODAG approach results in a worse lower bound since it requires two paths to achieve, the sum of which is often larger than the shortest path achievable in the existing synchronous approach. However, as the distance between the source and destination increases (network scale increases), the two approaches have similar lower bounds.
C. Relative positions of the three nodes in DODAG
1. Sides of an obtuse triangle
2. The value of α
3. The value of β
VI. SIMULATION RESULTS
We conduct network simulations on the two approaches to support our observation of the theoretical performance analysis. We conduct simulation with singlepath scenarios using NextworkX,^{42} where we only find one optimal path for the source and destination in each unit time. We did the singlepath scenarios since it is much faster to simulate in a large grid topology. A multipath scenario is also shown at the end. The locations of the source and destination are generated randomly. The root node for DODAG is set at the center of the grid. To simulate the probabilistic behaviors of directlink entanglement generation, we employ a grid network with edges that have assigned probabilities for availability. Subsequently, we simulate the entanglement swapping process within the probabilistic vertices of the network. Within this simulated grid network, we conduct 50 000 iterations of each protocol for random pairs located at the same distance, aiming to achieve endtoend entanglement.
As shown in Fig. 12, the entanglement rates of asynchronous protocols (both DODAG and spanning tree) decay slower than synchronous approaches. We can tell that DODAG and spanning tree approaches behave similarly (DODAG slightly better) in simulation. Both provide higher rates than synchronous approaches when the coherence time is greater than one unit time. We try different combinations of p and q in the simulation. In all combinations, asynchronous protocols have a higher entanglement rate and decay slower than synchronous ones when the coherence time is greater than one unit time. When coherence time is equal to one, asynchronous protocols perform similarly to synchronous protocols when the distance is small but slightly worse when the distance increases. The solid lines in the figure show the estimated upper bounds of the entanglement rates of an asynchronous protocol under the particular parameter settings, which is obtained by using infinite coherence time. The figure also shows that asynchronous protocol has a higher rate even in shortdistance scenarios. This verifies our speculation in Sec. V B that closeby node pairs have a high chance of not needing to go through the root but only through a common ancestor. Note that the simulation results represent the average rate across multiple iterations, which introduces some inherent noise. Additionally, intermediate entanglements (i.e., the intermediate entanglements established toward endtoend entanglements) set up through entanglement swapping will refresh the coherence time and are retained in asynchronous routing processes. Consequently, the rates in simulations at distance d may exceed q^{d} when using asynchronous protocols.
As shown in Fig. 13, the entanglement rate of asynchronous routing increases as coherence time increases. The performance of existing synchronous protocols, such as in Ref. 27, is independent of the coherence time. This indicates that when technology improves, asynchronous protocols will have a much more impact than synchronous protocols. Since the performance of DODAG and spanning tree protocols is similar in simulation, we only show the DODAG graph in this figure for conciseness. The plot also demonstrates the estimated upper bound of the asynchronous protocol under a particular q when the coherence time is infinite. For example, the upper bounds of the entanglement rate of an asynchronous protocol when q = 0.8 or q = 0.4 are shown with the solid line in Fig. 13. Nonetheless, we can see if we have $ p = q = 1$, we do not need any asynchronous or synchronous protocols running in the case of having local knowledge of the instant topology. With that, we can run any shortest path algorithm using the physical topology. However, asynchronous protocols will still be useful, considering a quantum mobile network with dynamic physical topology (i.e., nodes may be moving). Moreover, with T_{co} = 1, the curves of asynchronous and synchronous protocols look just like the percolation probability in percolation theory and get increasingly obvious (more and more rapid transition around the threshold) when q gets larger.
In this article, we equate quantum state lifetime with the coherence time of entanglement, considering them synonymous due to the dependency of entanglement coherence time on qubit lifetime. As entanglement is sustained by quantum states, its coherence period is determined by how long the states remain coherent. Additionally, we posit that the usable lifetime of qubit—its duration of reusability for entanglement generation—is sufficiently long. Utilizing unit time, which conveys a relative rather than absolute value, prevents us from specifying a minimum quantum state lifetime, prompting us to assume it to be suitably long.
Finally, we show the simulation results in multipath scenarios (Fig. 14). Multipath simulation means we search for more than one path (disjoint) for a pair of source and destination. We can tell asynchronous protocols have a higher entanglement rate than synchronous protocols in all scenarios when T_{co} > 1.
With the simulation results, we can establish the contributions of our asynchronous protocols, which are as follows:

The entanglement rate of asynchronous routing increases with the coherence time.

The entanglement rate of asynchronous routing decays slower than synchronous approaches.

The entanglement rate of asynchronous routing is larger than synchronous approaches in almost all scenarios.
VII. CONCLUSION
We envision quantumnative routing (i.e., routing for endtoend entanglement) as the key component of the Quantum Internet and identify the disadvantages of synchronization used in existing quantumnative routing schemes. Thus, we proposed the design of the asynchronous routing scheme and benchmarked its performance under different parameter settings. Here, we highlight the differences between our asynchronous routing protocols and existing asynchronous protocols. Under the condition that a node only knows the directlink entanglement states of its adjacent links, existing approaches use synchronized time slots, including two execution phases to collaborate all nodes to search for a path connecting the source and destination nodes. This method consumes all directlink entanglements, trying to find multiple paths between them. However, the consumption of all directlink entanglements counters the entanglement rate. Our method removes such synchronization of execution phases by introducing graph maintenance in a distributed manner. We treat all network nodes as vertices in a graph that try to connect their neighbors using directlink entanglements. No central control and no global knowledge of the directlink entanglements are needed in our method. Whenever a pair of nodes wants to create an endtoend entanglement, they go through the distributed graph that is continuously updated to find each other. With analysis and simulation, we found that the entanglement rate of our asynchronous protocols increases with the coherence time, decays slower than and is generally larger than that of asynchronous approaches. Furthermore, asynchronous protocols can simultaneously handle multiple user pairs, which remains an open problem in synchronous schemes.^{27} Exploring the performance of multiuser scenarios holds significant prospects for future research.
Moreover, existing approaches treat repeater nodes equally. However, repeaters have different performances (they can have weights for edges, e.g., transmissivity, for routing, but no preference for using competent nodes for more important purpose). Even though this is not the primary purpose, DODAG can reflect the node robustness by preferring to set robust nodes as root nodes. Also, DODAG roots can serve as wellfit gateways to connect multiple networks (i.e., networks of networks). Since DODAG has such benefits that a spanning tree does not have and has similar performance, we recommend DODAG to be the primary protocol for asynchronous routing, which is also wellstudied and standardized for lowcost wireless networks. Additionally, the scalability of the DODAG network can be enhanced by constructing hierarchical DODAGs, which involve creating trees of trees. This direction holds potential for future exploration.
There are other aspects of the protocol that warrant further investigation. For example, the center of a network is a good position for the root node, but the impact of different root positions remains future work. Moreover, the strategies to arrange multiple roots' positions and to determine how finegrain (the density) the partitioned networks should be (distance between adjacent root nodes) remain future work. Last but not least, other aspects of entanglementswappingbased routing are also important and under investigation, such as the use of untrusted repeaters, the minimal trust between networks (i.e., no knowledge of the internals of another network), the possible presence of malicious nodes, the order of entanglement swapping along a path, etc. Furthermore, exploring the performance of asynchronous protocols in nongrid networks is worthwhile. Through this work, we aim to raise awareness and foster advancements in networking techniques for the Quantum Internet.
ACKNOWLEDGMENTS
This work was supported in part by the Cisco University Research Program Fund, Gift No. 86944165.
AUTHOR DECLARATIONS
Conflict of Interest
The authors have no conflicts to disclose.
Author Contributions
Zebo Yang: Conceptualization (lead); Data curation (lead); Formal analysis (lead); Investigation (equal); Methodology (equal); Validation (equal); Visualization (lead); Writing – original draft (lead); Writing – review & editing (equal). Ali Ghubaish: Conceptualization (supporting); Data curation (supporting); Formal analysis (supporting); Investigation (equal); Methodology (equal); Project administration (supporting); Validation (equal); Writing – review & editing (equal). Raj Jain: Conceptualization (supporting); Funding acquisition (lead); Investigation (supporting); Methodology (supporting); Project administration (lead); Resources (lead); Supervision (lead); Writing – review & editing (equal). Hassan Shapourian: Formal analysis (supporting); Investigation (equal); Methodology (equal); Writing – review & editing (equal). Alireza Shabani: Investigation (equal); Writing – review & editing (equal).
DATA AVAILABILITY
The data that support the findings of this study are available within the article.
APPENDIX A: QUANTUM NETWORK STACK
We have identified seven layers within the technical framework for quantum research, providing a schematic to grasp the diverse elements essential to quantum technology, as illustrated in Fig. 15. At the foundational level, the stack is anchored by diverse technologies, which include photonbased and semiconductorbased approaches,^{3} critical for quantum states and operations. These technologies interact with diverse media, including optical fiber and freespace channels (e.g., satellites), serving as the physical medium for quantum communications. Nodes in the quantum network, which encompass end nodes and repeater nodes, form the fundamental infrastructure, facilitating quantum computation and communication processes. In the computation realm, universal quantum computing (i.e., gate model) and quantum annealing are the primary mechanisms that execute quantum algorithms and solve complex problems. Systems and protocols are the backbone of any quantum network. While TCP/IP represents conventional networking standards, the stack introduces quantumnative protocols with unique functionalities like entanglement swapping and asynchronous routing. At the applications layer, solutions such as quantum cloud services, quantum blockchains, quantum artificial intelligence (AI), and quantum cryptography showcase the potential realworld uses of quantum technologies.^{5,43–46} Finally, at the markets layer, the stack emphasizes the wideranging sectors that quantum technologies can influence, e.g., computing, networking, clouds, FinTech, medical, and sensing, underlining the vast impact quantum advancements can have across industries.
Our observation shows that while substantial progress has been made in the lower layers, the upper layers have received comparatively less attention. These layers reflect research initiatives in physics and electrical engineering.^{1,6} In contrast, the upper layers indicate endeavors in software, encompassing network protocols and applications. In particular, within the layer of systems and protocols, there are two distinct approaches: one involves using quantum repeaters that transmit quantum information (left of the red dashed line). The transmission of quantum information through repeaters requires error correction using a significant number of errorcorrecting qubits, which is restricted by the current capabilities of quantum computers. The other involves distributing entanglement as a communication resource (i.e., quantumnative routing), which is our primary interest and, in our view, deserves greater attention from the research community.
APPENDIX B: DODAG LOOP AVOIDANCE
When nodes select routes in a graph, loops can cause the routing process not to conclude, wasting time and resources. Therefore, they must be detected and avoided. While a directed acyclic graph (DAG) does not form closed loops, a DODAG may do so if a node is greedy and wants to select as many parents as possible. To prevent this, a rankbased nongreedy mechanism is used to detect loops before allowing a node to join the DODAG.
If a node in the DODAG is greedy and wants to move deeper (closer to the root) by increasing its number of parent nodes, there is a risk of creating a loop. Consider Fig. 16(a), which depicts the initial state of a branch of a DODAG, where node A has two children, B and C. Let us assume that A is the closest node to the root among the three, making it the preferred parent of B and C. If nodes B and C are both eager to select more parents, a loop may occur. For example, node C may want to choose both A and B as parents, making it deeper than both A and B, as shown in Fig. 16(b). Suppose node B is also greedy and decides to select C as a parent against the nongreedy rule. In this case, node B will intentionally leave the DODAG and then rejoin at a lower rank, taking both A and C as parents, as illustrated in Fig. 16(c). As a result, node B will become deeper than both A and C. Node C, which is also greedy, will then leave and rejoin at a lower rank to get two parents and have a lower rank than both of them. Node B will repeat the process by leaving and rejoining at a lower rank, which will cause the DODAG to alternate between Figs. 16(b) and 16(c), creating an infinite cycle. This situation can be prevented by ensuring nodes B and C do not select parents from deeper nodes or leave the DODAG intentionally to acquire more parents. Instead, they should maintain a reasonable rank relative to their preferred parent, A. Additionally, they should not process parenting requests from deeper nodes. In the example, as long as node B does not depart from the DODAG solely to acquire two parents, the branch of the DODAG will remain in the state depicted in Fig. 16(b).
APPENDIX C: GHS DELAY SCENARIOS
In Fig. 17(a), (1) node a sends a test message to node b, but they cannot determine which ID is the latest because $ L v ( a ) > L v ( b )$. (2) Consequently, they put the edge on hold. (3) Meanwhile, another node, k, initiates a test message to node n. (4) Since $ L v ( k ) < L v ( n )$, an outgoing edge is established. (5) Node k propagates the new level and ID to other nodes in the same fragment. (6) Node b now knows that its latest level is 2 and its latest ID is A. (7) Nodes a and b also realize they have the same ID and leave the edge alone. In Fig. 17(b), a similar process leads to finding an outgoing edge successfully. These processes use level increases to avoid broadcast delay, which may cause loops or unnecessary connections. Thus, fragment splitting while maintaining the level value will not affect the merge or absorb operations in the GHS algorithm. If a link breaks during broadcasting, the onhold edge will remain on hold until the adjacent nodes broadcast the breaking message. Then, it will release the onhold status and start the next test message. If edge “kf” breaks in Figs. 17(a) and 17(b), only process (2) will remain on hold until the node knows it is isolated. On the other hand, if edge “ij” breaks, fragment A splits into two fragments with different IDs, but it will not impact any operations from (1) to (7).