RFC 9340

RFC 9340: Architectural Principles for a Quantum Internet 🌈✨

Okay bestie, let's start with the vibe check on this doc 💅. It's an IRTF Informational RFC from the Quantum Internet Research Group (QIRG), published in March 2023 with ISSN 2070-1721. It's written by W. Kozlowski and S. Wehner (QuTech), R. Van Meter (Keio University), B. Rijsman (an individual author), A. S. Cacciapuoti and M. Caleffi (University of Naples Federico II), and S. Nagayama (Mercari, Inc.) 🫶. The header doesn't list anything it obsoletes or updates, so it's a fresh start 🌸.

Abstract ✨

So the big dream is a quantum internet, which basically means upgrading the internet we already have so that quantum communication can happen between any two points on Earth 🌍. To make that work, the quantum network stack should be built from the ground up around the weird new properties of quantum entanglement 🔮. The first entanglement networks are real now 😭, but nobody has a practical plan for how to organise, use, and manage them. This doc is our attempt to lay out the framework and a few basic architectural principles 📐. It's meant for general guidance and general interest, and it's also a foundation for physicists and network specialists to actually talk to each other 💬. The Quantum Internet Research Group (QIRG) produced it 🎀.

Status of This Memo

Okay, the legal-ish bit, but it matters 📜. This document is not an Internet Standards Track specification. It's published purely for informational purposes 🦋.

It's a product of the Internet Research Task Force (IRTF), which publishes the results of Internet-related research and development. Those results might not be suitable for deployment 🚧. This RFC represents the consensus of the Quantum Internet Research Group of the IRTF 🤝. Documents approved for publication by the IRSG are not candidates for any level of Internet Standard, see Section 2 of RFC 7841 🙈.

For the latest status, errata, and how to give feedback, check https://www.rfc-editor.org/info/rfc9340 🔗.

Copyright Notice

Copyright (c) 2023 IETF Trust and the persons identified as the document authors. All rights reserved. 💜

This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication. Please read those carefully, because they spell out your rights and restrictions for this document 📖.

Table of Contents

1.  Introduction
2.  Quantum Information
  2.1.  Quantum State
  2.2.  Qubit
  2.3.  Multiple Qubits
3.  Entanglement as the Fundamental Resource
4.  Achieving Quantum Connectivity
  4.1.  Challenges
    4.1.1.  The Measurement Problem
    4.1.2.  No-Cloning Theorem
    4.1.3.  Fidelity
    4.1.4.  Inadequacy of Direct Transmission
  4.2.  Bell Pairs
  4.3.  Teleportation
  4.4.  The Life Cycle of Entanglement
    4.4.1.  Elementary Link Generation
    4.4.2.  Entanglement Swapping
    4.4.3.  Error Management
    4.4.4.  Delivery
5.  Architecture of a Quantum Internet
  5.1.  Challenges
  5.2.  Classical Communication
  5.3.  Abstract Model of the Network
    5.3.1.  The Control Plane and the Data Plane
    5.3.2.  Elements of a Quantum Network
    5.3.3.  Putting It All Together
  5.4.  Physical Constraints
    5.4.1.  Memory Lifetimes
    5.4.2.  Rates
    5.4.3.  Communication Qubits
    5.4.4.  Homogeneity
6.  Architectural Principles
  6.1.  Goals of a Quantum Internet
  6.2.  The Principles of a Quantum Internet
7.  A Thought Experiment Inspired by Classical Networks
8.  Security Considerations
9.  IANA Considerations
10. Informative References
Acknowledgements
Authors' Addresses

---

1. Introduction 🚀

Quantum networks are distributed systems of quantum devices. They use fundamental quantum mechanical stuff like superposition, entanglement, and quantum measurement to do things that classical (non-quantum) networks just can't [Kimble08] 🌟. Depending on how far along a quantum network is [Wehner18], the devices can be anything from simple photonic gadgets that prepare and measure only one quantum bit (qubit) at a time, all the way up to huge future quantum computers 🖥️. A quantum network isn't meant to replace classical networks. It's meant to form a hybrid classical-quantum network that unlocks new capabilities that are otherwise impossible to pull off [VanMeterBook] 🫧.

The most famous quantum communication application is Quantum Key Distribution (QKD) [QKD] 🔑. It can create and distribute a pair of symmetric encryption keys where the security relies on the laws of physics, not on how hard certain maths problems are to crack. That means it can be mathematically proven unbreakable 🤯 [Bennett14] [Ekert91]. Small QKD-capable networks have already been deployed over short distances, roughly 100 kilometres 🛰️ [Elliott03] [Peev09] [Aguado19] [Joshi20].

Quantum networking also has promise way beyond cryptography 🌈. Think distributed quantum computation [Cirac99] [Crepeau02], secure quantum computing in the cloud [Fitzsimons17], quantum-enhanced measurement networks [Giovannetti04], or higher-precision, long-baseline telescopes [Gottesman12]. These apps are way more demanding than QKD, and the networks that could run them are still babies 👶. The first fully quantum, multinode network that can send, receive, and manipulate distributed quantum information was only recently realised [Pompili21.1] 😳.

Lots of effort has gone into physically building and connecting these devices and making them faster and more error-tolerant 💪. But at the time of writing, nobody has worked out proposals for how to actually run these networks 🙃. To put it in classical terms, we're at the stage where we can physically connect our devices and send data. However, all the sending, receiving, buffer management, connection synchronisation, and so on has to be handled by the application itself, using low-level, custom-built, hardware-specific interfaces. There's no network stack exposing a nice high-level interface like sockets 😩. The first-ever attempt at such a network stack was only just demonstrated experimentally in a lab [Pompili21.2]. And while physical mechanisms for transmitting quantum information exist, there are no robust protocols for managing those transmissions 💀.

This document, produced by the Quantum Internet Research Group (QIRG), introduces quantum networks and gives general guidelines for designing and building them 📚. Overall, it's meant as an introduction for network engineers and researchers. It should not be treated as a conclusive statement on how quantum networks should or will be implemented 🙅‍♀️. It was discussed on the QIRG mailing list and at several IETF meetings. It represents the consensus of QIRG members, including both experts from the quantum and networking domains and newcomers, who are the target audience 🫶.

2. Quantum Information 🧠

To get how quantum networking works, you need a basic grip on quantum information theory 🤓. The following sections cover the minimum you need to understand how a quantum network operates. This was written with a classical networking audience in mind, so it assumes you've never touched quantum physics before, and that's totally fine 🌸. For a deeper dive into quantum information systems, the doc points to [SutorBook] and [NielsenChuang] 📖.

2.1. Quantum State 🔮

A quantum mechanical system is described by its quantum state. This is an abstract object that gives a complete description of the system at one particular moment 🫧. Combine it with the rules for how the system evolves over time (like a quantum circuit), and it also gives a complete description of the system at all times ⏳. For computing and networking purposes, the classical equivalent of a quantum state is a string or stream of logical bit values. Those bits fully describe which values you can read out of the string at a given moment. Pair them with their rules for evolving over time (like a logical circuit) and you'll know the value at any other time too 🧮.

A quantum mechanical system can be as simple as a single classical-style bit, consisting of one particle like an atom or a photon of light ⚛️. In that case, the quantum state completely describes that one particle. Similarly, just as a string of bits is made of multiple bits, a single quantum state can describe an ensemble of many particles 🌌. But quantum states follow the laws of quantum mechanics, so how they behave is really different from a string of bits 😵‍💫. In this section, we'll summarise the key concepts behind those differences 💖. The rest of the document then explains what they mean for networking 🦋.

2.2. Qubit ✨

okay so this is where quantum computing gets totally different from classical 💅 A classical computer works with the binary alphabet { 0, 1 }. A quantum bit, called a qubit, lives in that same binary space, but unlike a classical bit it can be in a superposition of the two possibilities 🌈

|qubit⟩ = a |0⟩ + b |1⟩,

where |X⟩ is Dirac's ket notation for a quantum state (the value a qubit holds), so here that means the binary 0 and 1 🎀 The coefficients a and b are complex numbers called probability amplitudes. Physically, you can build this state with all kinds of technologies, like electron spin, photon polarisation, atomic energy levels, and so on 🦋

Now the plot twist 😭 When you measure a qubit, it loses its superposition and irreversibly collapses into one of the two basis states, either |0⟩ or |1⟩. Which one it lands on may not be deterministic, but you can figure it out from the readout of the measurement. The result is a classical bit, 0 or 1, matching |0⟩ and |1⟩ respectively. The probability of measuring |0⟩ is |a|^2, and the probability of measuring |1⟩ is |b|^2, where |a|^2 + |b|^2 = 1. And this randomness isn't because we're missing some hidden info about the mechanism. It's a fundamental feature of a quantum mechanical system [Aspect81] 🙈 literally wild

The superposition thing is a big deal for gate operations too 🔥 Since a qubit can be in a superposition of its basis states, elementary quantum gates can act on all the states of the superposition at the same time. For example, take the NOT gate:

NOT (a |0⟩ + b |1⟩) → a |1⟩ + b |0⟩.

Also, "qubit" can mean two things, and this is a very real source of confusion 💀 In the first meaning, "qubit" is a physical quantum system whose state can be written as a superposition of two basis states, which we often label |0⟩ and |1⟩. Here it's the physical hardware, kind of like what a flip-flop, switch, voltage, or current is for a classical bit. In the second meaning, "qubit" is the abstract quantum state of a system with those two basis states. This one is more like the logical value of a classical bit, "logical 0" or "logical 1" 🧚 The two are connected, because a physical "qubit" (first meaning) can be used to store the abstract "qubit" (second meaning). People use both meanings interchangeably in the literature, but you can usually tell which one they mean from context 🫶

---

2.3. Multiple Qubits 🌸

When you combine multiple qubits into a single quantum state, the space of possible states grows exponentially, and all of those states can coexist in a superposition 🤯 For example, the general form of a two-qubit register is

a |00⟩ + b |01⟩ + c |10⟩ + d |11⟩,

where the coefficients mean the same thing they did for the single-qubit state. Each state is a possible outcome when you measure the two-qubit register. So |01⟩ means the first qubit is in |0⟩ and the second is in |1⟩ 💜

Single-qubit gates hit the relevant qubit in every superposition state. Two-qubit gates also act on all the relevant superposition states, but what comes out is way more interesting 👑

Let's say a two-qubit register has its first qubit in the superposed state (|0⟩ + |1⟩)/sqrt(2) and the other qubit in |0⟩. The combined state looks like this:

(|0⟩ + |1⟩)/sqrt(2) x |0⟩ = (|00⟩ + |10⟩)/sqrt(2),

where x is the tensor product, which is basically the math mechanism for combining quantum states together 🧩

The constant 1/sqrt(2) is called the normalisation factor. It's there because the probabilities of measuring |0⟩ or |1⟩ for the first qubit add up to one ✨

Next up is the two-qubit Controlled NOT, or CNOT, gate 🦋 It takes two qubits as input, a control and a target, and applies NOT to the target if the control qubit is set. Its truth table looks like this:

                           +====+=====+
                           | IN | OUT |
                           +====+=====+
                           | 00 |  00 |
                           +----+-----+
                           | 01 |  01 |
                           +----+-----+
                           | 10 |  11 |
                           +----+-----+
                           | 11 |  10 |
                           +----+-----+

                     Table 1: CNOT Truth Table

Now let's run CNOT on the state where the first qubit is the control. We apply the two-qubit gate to all the superposition states:

CNOT (|00⟩ + |10⟩)/sqrt(2) → (|00⟩ + |11⟩)/sqrt(2).

This is where it gets spicy 🌶️ The final state is entangled. There's no way to write it as a product of two individual qubits, so they're no longer independent. You can't describe the state of either qubit on its own without the other one. Only the state of the whole two-qubit system gives a physically complete description. The two qubits are now correlated beyond anything you could get classically 😭 Neither qubit is definitely |0⟩ or |1⟩, but if you measure either one, the partner qubit will always give the exact same outcome. The final state, |00⟩ or |11⟩, is fundamentally random like before, but after a measurement the two qubits will always match. Think of flipping two coins where both always land on "heads" together, or both on "tails", which we know is impossible classically 🪙

After a measurement, though, the two qubits are independent again 💅 The final state is either |00⟩ or |11⟩, and both of those can easily be split into a product of two individual qubits. The entanglement is used up, so if you want it again, you have to prepare the entangled state again 🔁

---

3. Entanglement as the Fundamental Resource 💖

Entanglement is the fundamental building block of quantum networks 🕸️ Remember the state from the last section:

(|00⟩ + |11⟩)/sqrt(2).

Neither of the two qubits is in a definite |0⟩ or |1⟩ state, and you need to know the state of the entire register to fully describe how the two qubits behave 🫠

Entangled qubits have some seriously non-local properties 🌍 Say you send one of the qubits to another device. That device could be anywhere: across the room, in a different country, or even on a different planet 🚀 As long as not much noise has crept in, the two qubits stay entangled until someone measures them. Physical distance doesn't matter at all for entanglement 😤

This is the heart of quantum networking. You can use the non-classical correlations from entanglement to design brand-new kinds of application protocols that just aren't possible with classical communication alone 💜 Examples include quantum cryptography [Bennett14] [Ekert91], blind quantum computation [Fitzsimons17], and distributed quantum computation [Crepeau02] ✨

Entanglement has two very special features, and they give you some intuition about what kinds of applications a quantum network can enable 🎀

The first is that entanglement makes stronger-than-classical correlations possible, which opens the door to tasks that need coordination 🤝 As a simple example, take two nodes who want to agree on the value of a single bit. They can use the quantum network to prepare the state (|00⟩ + |11⟩)/sqrt(2), with each node holding one of the qubits. Once either node measures, the state collapses to either |00⟩ or |11⟩. So the outcome is random and doesn't exist until the measurement happens, but the two nodes will always measure the same value 🫶 You can also build the more general multi-qubit state (|00...⟩ + |11...⟩)/sqrt(2) and run the same algorithm across any number of nodes. These stronger-than-classical correlations also extend to more complicated measurement schemes 🧠

The second feature is that entanglement can't be shared. If two qubits are maximally entangled with each other, then it's physically impossible for either of them to also be entangled with a third qubit [Terhal04]. So once it's established, entanglement forms a private, inherently untappable connection between two nodes 🔐 main character energy

Entanglement gets created through local interactions between two qubits, or as a result of how the qubits were made (for example, entangled photon pairs) 🌈 To make a distributed entangled state, you can physically send one of the qubits to a remote node. You can also entangle qubits that are physically separated, but that still needs local interactions between some other qubits that the separated ones were initially entangled with 🧵 So it's the transmission of qubits that separates a real quantum network from a bunch of quantum computers connected over a classical network. That's the line 💅

A quantum network is a collection of nodes that can exchange qubits and distribute entangled states among themselves 👑 A quantum node that can only talk to another quantum node classically is not a member of a quantum network 🙅‍♀️

More complex services and applications can be built on top of the entangled states the network distributes. See [ZOO] for an example 🦋

---

4. Achieving Quantum Connectivity 🌸

This section explains what quantum connectivity means and the physical processes it needs, at an abstract level ✨

4.1. Challenges 😤

You can't build a quantum network by just taking every classical model and swapping in its quantum version. Sending qubits over a wire the way we send classical bits is simply not as easy 🥲 There are several technological and fundamental challenges that make classical approaches unsuitable in a quantum context 🚧

4.1.1. The Measurement Problem 🙈

In classical computers and networks, we can read out the bits stored in memory at any time. That's super useful for copying, error detection and correction, and so on. With qubits, that just isn't possible 💀

Measuring a qubit's state destroys its superposition, and with it any entanglement it was part of. Once a qubit is being processed, it can't be read out until the protocol handling it reaches a suitable point in the computation. So we can't use the classical methods for error detection and correction 😭 That said, quantum error detection and correction schemes do exist that account for this problem. How a network chooses to handle errors will have an impact on its architecture 🏗️🎀

4.1.2. No-Cloning Theorem ✨

okay so, we can't read a qubit's state directly, so you'd think we could just make a copy of it without peeking, right? 🙈 Sadly, nope. This is fundamentally not possible in quantum mechanics [Park70] [Wootters82]. 💀

The no-cloning theorem says it's impossible to make an identical copy of an arbitrary, unknown quantum state. So the classical network tricks for signal amplification, retransmission, and so on are off the table too, because they all depend on being able to copy the data 😭. And since any physical channel is always going to be lossy, hooking nodes together in a quantum network is a real challenge, and the architecture has to be built around dealing with exactly that 🫶.

4.1.3. Fidelity

Classically, we expect a packet to show up at its destination without any errors from hardware noise along the way. We check that at different levels with all sorts of error detection and correction mechanisms 💅. But since we can't read or copy a quantum state, error detection and correction are a lot more involved, bestie 😤.

To describe how good a quantum state is, we use a physical quantity called fidelity [NielsenChuang] 🦋. Fidelity takes a value between 0 and 1. Higher is better, and anything under 0.5 means the state is unusable 🚫. It measures how close a quantum state is to the state we tried to create, and it expresses the probability that the state will behave exactly like our desired state ✨. It's an important property because it lets us quantify how much a state has been messed with by noise from different sources: gate errors, channel losses, environment noise 🌧️.

Here's the interesting part: quantum applications don't need perfect fidelity to run 👑. As long as the fidelity is above some application-specific threshold, they'll just operate at lower rates. So instead of trying to always deliver perfect states (which is a technologically challenging task, lowkey a nightmare 😭), applications specify a minimum threshold for fidelity, and the network tries its best to deliver it 🌸. You can get higher fidelity by having the hardware produce better-fidelity states (sometimes you can trade rate for fidelity), or by using quantum error detection and correction mechanisms (see [Mural16] and Chapter 11 of [VanMeterBook]) 🎀.

4.1.4. Inadequacy of Direct Transmission

The most straightforward idea for distributing an entangled state is to just send one of the qubits directly to the other end across a series of nodes, while doing enough forward Quantum Error Correction (QEC) (Section 4.4.3.2) to bring losses down to an acceptable level 🧚. Even with the no-cloning theorem and the fact that we can't directly measure a quantum state, error-correcting mechanisms for quantum communication do exist [Jiang09] [Fowler10] [Devitt13] [Mural16] 💜. But QEC is extremely demanding on both resources (the physical qubits needed) and the initial fidelity 😩. It's very challenging to implement, and QEC isn't expected to be used until later generations of quantum networks are possible (see Figure 2 of [Mural16] and Section 4.4.3.3 of this document) ⭐.

So until then, quantum networks rely on entanglement swapping (Section 4.4.2) and teleportation (Section 4.3) 🦋. This alternative works because we don't actually need to distribute any arbitrary entangled quantum state. We only need to be able to distribute any one of what are known as the Bell pair states [Briegel98] 🌈. Main character energy for Bell pairs, honestly 👑.

4.2. Bell Pairs

Bell pair states are the entangled two-qubit states:

|00⟩ + |11⟩,
|00⟩ - |11⟩,
|01⟩ + |10⟩,
|01⟩ - |10⟩,

We drop the constant 1/sqrt(2) normalisation factor here, just for clarity 🍓. Any of the four Bell pair states above will do, because you can transform any Bell pair into another Bell pair using local operations on only one of the qubits 🫶. When each qubit in a Bell pair is held by a separate node, either node can apply a series of single-qubit gates to its own qubit alone to switch the state between the different variants 💅.

Distributing a Bell pair between two nodes is way easier than transmitting an arbitrary quantum state over a network 🙌. Since the state is known, handling errors gets easier too. Small-scale error correction (like entanglement distillation, which we'll get to in Section 4.4.3.1), combined with reattempts, becomes a valid strategy ✨.

So why Bell pairs specifically, and not some other two-qubit state? Because they're the maximally entangled two-qubit set of basis states 🔥. Maximal entanglement means these states have the strongest non-classical correlations of all possible two-qubit states. Also, single-qubit local operations can never increase entanglement, so states that are less entangled would put some constraints on distributed quantum algorithms 😬. That's what makes Bell pairs such a useful generic building block for distributed quantum applications 💖.

4.3. Teleportation

The idea that we only need to distribute Bell pairs works because it lets us distribute any other arbitrary entangled state 🧚‍♀️. This can be done with quantum state teleportation [Bennett93] ✨. Quantum state teleportation consumes an unknown qubit state that we want to send and recreates it at the desired destination 🦋. This doesn't break the no-cloning theorem, because the original state gets destroyed in the process 💀.

Here's how it goes. An entangled pair has to be distributed between the source and destination before teleportation can start 🌸. The source then entangles the transmission qubit with its end of the pair and reads out both qubits (all of these operations together are called a Bell state measurement) 📸. This consumes the Bell pair's entanglement, which turns the source and destination qubits into independent states 🫠. The measurement gives two classical bits, which the source sends to the destination over a classical channel 📡. Based on those two bits, the destination performs one of four possible corrections (called the Pauli corrections) on its end of the pair, and that turns it into the unknown qubit state we wanted to send 🎀. The catch is that the measurement results have to be communicated over a classical channel, so entanglement can't be used to transmit information faster than the speed of light 🥲.

The unknown quantum state that was transmitted never actually went into the network itself. So the network only needs to be able to reliably produce Bell pairs between any two nodes 💜. This is the big difference between a classical data plane and a quantum data plane: a classical data plane carries user data, but a quantum data plane provides the resources for users to send their own user data without the network getting involved any further 👑.

4.4. The Life Cycle of Entanglement

Reducing quantum connectivity to generating a Bell pair made the problem simpler and more fundamental, but it didn't solve it yet 😅. In this section, we talk about how these entangled pairs get generated in the first place, and how their two qubits get delivered to the end-points 🧚.

4.4.1. Elementary Link Generation

In a quantum network, entanglement is always generated locally first (at a node or an auxiliary element), and then one or both of the entangled qubits move across the link through quantum channels 🌈. Photons (particles of light) are the natural candidates for entanglement carriers here. Because these photons carry quantum states from place to place at high speed, we call them flying qubits 🦋. The reasons photons are such good picks are their moderate interaction with the environment (which leads to moderate decoherence), convenient control with standard optical components, and high-speed, low-loss transmissions ✨. The catch is that photons are hard to store, so a transducer has to transfer the flying qubit's state to a qubit suitable for information processing and/or storage (often called a matter qubit) 🫶.

Since this process can fail, we have to be able to tell successful attempts apart from failures if we want to generate and store entanglement efficiently 🔍. Entanglement generation schemes that can announce successful generation are called heralded entanglement generation schemes 📣.

There are three basic schemes for heralded entanglement generation on a link, through coordinated action of the two nodes at the ends of the link [Cacciapuoti19] 💅:

• "At mid-point": In this scheme, an entangled photon pair source sitting midway between the two nodes, with matter qubits, sends an entangled photon through a quantum channel to each of the nodes 🌟. There, transducers are invoked to transfer the entanglement from the flying qubits to the matter qubits. In this scheme, the transducers know if the transfers succeeded, and they're able to herald successful entanglement generation via a message exchange over the classical channel 📨.
• "At source": In this scheme, one of the two nodes sends a flying qubit that is entangled with one of its matter qubits 🛸. A transducer at the other end of the link transfers the entanglement from the flying qubit to one of its matter qubits. Just like in the previous scheme, the transducer knows if its transfer succeeded and can herald successful entanglement generation with a classical message sent to the other node 💌.
• "At both end-points": In this scheme, both nodes send a flying qubit that is entangled with one of their matter qubits 🌠. A detector somewhere in between the nodes performs a joint measurement on the flying qubits, which stochastically projects the remote matter qubits into an entangled quantum state 🎲. The detector knows if the entanglement succeeded and can herald successful entanglement generation by sending a message to each node over the classical channel 📬.

The "mid-point source" scheme is more robust to photon loss, but with the other schemes, the nodes keep more control over how the entangled pairs get generated 🎀.

Also, note that even though photons travel in a particular direction through the quantum channel, the resulting entangled pair of qubits doesn't have a direction associated with it 🌀. Physically, there's no upstream or downstream end of the pair, which is honestly so iconic 😭✨.

4.4.2. Entanglement Swapping ✨

okay so the big problem with making entangled pairs directly across a link is that the efficiency drops as the channel gets longer 📉. Beyond a few tens of kilometres in optical fibre, or 1000 kilometres in free space via satellite, the rate is basically zero 💀. And because of the no-cloning theorem, we can't just amplify the signal like we would with a classical one 🙅‍♀️. So what's the fix? Entanglement swapping [Briegel98] 🦋

A Bell pair between any two nodes in the network can be built by combining the pairs generated along each individual link on a path between the two endpoints 🧚. Each node along the path consumes the two pairs on the two links it's connected to, and that produces a new entangled pair between the two remote ends. This whole process is called entanglement swapping, and it looks like this 👇

+---------+      +---------+      +---------+
|    A    |      |    B    |      |    C    |
|         |------|         |------|         |
|      X1~~~~~~~~~~X2   Y1~~~~~~~~~~Y2      |
+---------+      +---------+      +---------+

Here X1 and X2 are the qubits of the entangled pair X, and Y1 and Y2 are the qubits of the entangled pair Y. The ~~ marks the entanglement. In the diagram, nodes A and B share the pair X, and nodes B and C share the pair Y, but what we actually want is entanglement between A and C 🎯.

So here's the move: we teleport the qubit X2 using the pair Y 💅. This means node B has to do a Bell state measurement on the qubits X2 and Y1, and that destroys the entanglement between Y1 and Y2. BUT (and this is the iconic part) X2 gets recreated in Y2's place, and it takes its entanglement with X1 along with it 🤯. The end result looks like this:

+---------+      +---------+      +---------+
|    A    |      |    B    |      |    C    |
|         |------|         |------|         |
|      X1~~~~~~~~~~~~~~~~~~~~~~~~~~~X2      |
+---------+      +---------+      +---------+

Depending on what the network and/or application needs, a final Pauli correction at the recipient node may not be necessary, since the result is also a Bell pair ✨. However, the two classical bits from node B's measurement readout still have to be communicated, because they carry the information about which of the four Bell pairs was actually produced 📬. If there's no correction, the recipient has to be told which Bell pair they received. No skipping the memo, bestie 🫶.

This process of teleporting Bell pairs using other entangled pairs is what we call entanglement swapping. Quantum nodes that create long-distance entangled pairs this way are called quantum repeaters in the academic literature [Briegel98]. We'll use the same terminology in this document 🌈.

4.4.3. Error Management

4.4.3.1. Distillation

Okay, real talk: neither generating Bell pairs nor doing swaps is noiseless 😭. So with every link and every swap, the fidelity of the state degrades. The good news is you can create higher-fidelity Bell pair states from two or more lower-fidelity pairs, through a process called distillation (also sometimes called purification) [Dur07] 💖.

Here's how distillation works. A second (and sometimes a third) quantum state gets used as a "test tool" to check a proposition about the first state, like "the parity of the two qubits in the first state is even." 🧪 When the test succeeds, confidence in the state goes up, and so the fidelity goes up too 📈. The test tool states get destroyed in the process, so resource demands increase a lot when distillation is used 💸. And when the test fails, the tested state has to be thrown out too 🗑️. Distillation has lowish demands on fidelity and resources compared to QEC, but distributed protocols take round-trip delays because of classical communication [Bennett96] 🐢.

4.4.3.2. Quantum Error Correction (QEC)

Just like classical error correction, QEC encodes logical qubits using several physical (raw) qubits, so they're protected from the errors described in Section 4.1.3 [Jiang09] [Fowler10] [Devitt13] [Mural16] 🛡️. And similar to its classical cousin, QEC can not only correct state errors but also account for lost qubits 🙌. Also, if all the physical qubits encoding a logical qubit sit at the same node, the correction procedure can run locally, even if the logical qubit is entangled with remote qubits 🏠.

QEC was originally proposed to protect a qubit from noise, but it can also be applied to entanglement distillation. This QEC-applied distillation is cost effective, but it needs a higher base fidelity 💅.

4.4.3.3. Error Management Schemes

Quantum networks have been sorted into three "generations" based on the error management scheme they use [Mural16]. Heads up, these "generations" are really more like categories 📂. They don't necessarily imply a time progression, and they don't obsolete each other, although the later generations do need more advanced technologies 🚀. Which generation gets used depends on the hardware platform and the network design choices 🔧.

Table 2 sums up the generations 👀.

+===========+================+=======================+=============+
|           |     First      |   Second generation   |    Third    |
|           |   generation   |                       |  generation |
+===========+================+=======================+=============+
|    Loss   |    Heralded    | Heralded entanglement |   QEC (no   |
| tolerance |  entanglement  |       generation      |  classical  |
|           |   generation   |     (bidirectional    | signalling) |
|           | (bidirectional | classical signalling) |             |
|           |   classical    |                       |             |
|           |  signalling)   |                       |             |
+-----------+----------------+-----------------------+-------------+
+-----------+----------------+-----------------------+-------------+
|   Error   |  Entanglement  |      Entanglement     |   QEC (no   |
| tolerance |  distillation  |      distillation     |  classical  |
|           | (bidirectional |    (unidirectional    | signalling) |
|           |   classical    | classical signalling) |             |
|           |  signalling)   |  or QEC (no classical |             |
|           |                |      signalling)      |             |
+-----------+----------------+-----------------------+-------------+

              Table 2: Classical Signalling and Generations

The generations are defined by the directions of classical signalling their distributed protocols need, both for loss tolerance and for error tolerance 🧭. Classical signalling carries the classical bits, and it comes with round-trip delays ⏳. As we covered in Section 4.4.3.1, those delays hurt quantum network performance, especially as the distance between communicating nodes grows 📏.

Loss tolerance is about tolerating qubit transmission losses between nodes 📦. Heralded entanglement generation, which we met in Section 4.4.1, confirms that an entangled qubit was received by using a heralding signal 🔔. A pair of directly connected quantum nodes keeps trying to generate an entangled pair until the heralding signal arrives 🔁. As described in Section 4.4.3.2, QEC can be applied to make up for lost qubits, which means there's no need for reattempts 🙅‍♀️. Also, since the correction procedure is made of local operations, it doesn't need a heralding signal. BUT, this only works when the photon loss rate from transmission to measurement is less than 50% ⚠️.

Error tolerance is about tolerating quantum state errors 🧼. Entanglement distillation is the easiest mechanism to implement for better error tolerance, but it has round-trip delays because it needs bidirectional classical signalling 🐌. The alternative, QEC, can correct state errors locally, so it doesn't need any classical signalling between the quantum nodes ✨. Somewhere in between those two extremes sits QEC-applied distillation, which needs unidirectional classical signalling 🌸.

Here are the three "generations," summarised:

1. First-generation quantum networks use heralding for loss tolerance and entanglement distillation for error tolerance. These networks can be built even with a limited set of available quantum gates 🧱.
2. Second-generation quantum networks level up from the first generation with QEC codes for error tolerance (but not for loss tolerance) 💜. At first, QEC gets applied to entanglement distillation only, which needs unidirectional classical signalling. Later, QEC codes get used to create logical Bell pairs that no longer need any classical signalling for error tolerance. Heralding is still used to make up for transmission losses 🔔.
3. Third-generation quantum networks directly transmit QEC-encoded qubits to adjacent nodes, as discussed in Section 4.1.4 🚀. Elementary link Bell pairs can now be created without heralding or any other classical signalling 🙌. This also makes direct transmission architectures possible, where qubits get forwarded end to end like classical packets, rather than relying on Bell pairs and entanglement swapping 📨. It's giving future 🔮.

Even though the generations handle errors in importantly different ways, it's unlikely that all quantum networks will consistently use the same method 🤷‍♀️. That's because the generations have different hardware requirements, and because of the practical reality of network upgrades 🛠️. So it's unavoidable that eventually boundaries between different error management schemes start forming 🧩. Those boundaries will affect the content and semantics of the messages that have to cross them, both for connection setup and for real-time operation [Nagayama16] 💬.

4.4.4. Delivery

Eventually, the Bell pairs have to be delivered to an application (or higher-layer protocol) at the two end nodes 🎁. A detailed list of those requirements is beyond the scope of this document, so we're not going there today 🙈. At minimum, the end nodes need information that maps a particular Bell pair to the qubit in their local memory that's part of that entangled pair 🗺️.

---

5. Architecture of a Quantum Internet 🌐

It's evident from the previous sections that the fundamental service a quantum network provides is really different from what a classical network does 🤯. So it's not surprising at all that the architecture of a quantum internet will be very different from the classical Internet 💜✨.

5.1. Challenges 🌸

okay bestie, this part is about the big fundamental challenges of building quantum networks 🧠 we're only looking at the fundamental differences here. the technology limits (the "our hardware is still kinda struggling" stuff) get their own spot in Section 5.4 💅

1. Bell pairs are not equivalent to packets that carry payload. ✨

in most classical networks, like Ethernet, Internet Protocol (IP), and Multi-Protocol Label Switching (MPLS) networks, user data gets bundled into packets 📦 on top of the user data, every packet also has a stack of headers with the control info that lets routers and switches forward it toward its destination. packets are the fundamental unit in a classical network, full stop.

in a quantum network, the entangled pairs of qubits are the basic unit of networking 🦋 the qubits themselves don't carry any headers 🙃 so quantum networks will have to send all their control info over separate classical channels, and the repeaters will have to correlate that info with the qubits they're holding in memory. and it gets more complicated: unlike a classical packet, which lives at a single node, a Bell pair is two qubits spread across two nodes 🫨 this has a fundamental impact on how quantum networks get managed and how protocols need to be designed. to make long-distance Bell pairs, the nodes may have to keep their qubits in quantum memory and wait until the control info is exchanged before they do the next operation. that waiting means extra latency, and it depends on how far apart the nodes holding the two ends of the pair are 😭 error management, like entanglement distillation, is a classic example of this control info exchange [Nagayama21] (see also Section 4.4.3.3).

2. "Store and forward" and "store and swap" quantum networks require different state management techniques. 🔥

as we covered in Section 4.4.1, quantum links give you Bell pairs that are undirected network resources. classical frames are directed, so this is a big "phenomenological" difference 👀 and it leads to real architectural differences between quantum and classical networks. quantum networks combine multiple elementary link Bell pairs together to create one end-to-end Bell pair, whereas classical networks deliver messages from one end to the other, hop by hop.

classical networks receive data on one interface, store it in local buffers, and then forward it out another appropriate interface. quantum networks store Bell pairs and then execute entanglement swapping instead of forwarding in the data plane 💅 those are "store and swap" networks. in "store and swap" networks, we don't need to care about the order the Bell pairs were generated in, since they're undirected. BUT (okay, I'm yelling, sorry 🙈) the ordering not mattering doesn't mean it's not important that the right entangled pairs get swapped. the intermediate measurement outcomes (see Section 4.4.2) also need to be signalled to, and correlated with, the correct qubits at the other nodes. otherwise the final end-to-end entangled pair won't be created between the expected end-points, or it'll be in a different quantum state than expected 💀 for example, instead of Alice getting a qubit entangled with Bob's qubit, her qubit ends up entangled with Charlie's qubit. this difference makes control algorithms and optimisation for quantum networks totally different from classical ones, because swapping is stateful, unlike stateless packet-by-packet forwarding 🧚 and as described in Section 4.4.3.3, third-generation quantum networks will be able to support a "store and forward" architecture in addition to "store and swap" 🌈

3. An entangled pair is only useful if the locations of both qubits are known. 📍

a classical network packet logically exists in only one location at any point in time. if a packet gets modified in some way, whether headers or payload, nobody else in the network needs to hear about it. the packet can just be forwarded as before 😌

entanglement, on the other hand, is a phenomenon where two or more qubits exist in a physically distributed state 🤯 operations on one of the qubits change the mutual state of the pair. since the owner of a particular qubit can't just read out its state, they have to coordinate all their actions with the owner of the pair's other qubit. so the owner of any qubit that's part of an entangled pair must know where its counterpart is 🫶 and "location" here doesn't have to mean an explicit spatial location. a relevant pair identifier, a way for the pair owners to communicate, and an association between the pair ID and the individual qubits is enough ✨

4. Generating entanglement requires temporary state. 🧸

packet forwarding in a classical network is pretty much a stateless operation. when a packet comes in, the router does a lookup in its forwarding table and sends the packet out the right output. then there's no need to remember the packet anymore, bye 👋

a quantum node has to be able to make decisions about the qubits it receives and is holding in memory 🧐 since qubits don't carry headers, receiving an entangled pair doesn't come with any control info the repeater can use to make a decision. the relevant control info arrives separately over a classical channel. so a repeater has to store temporary state, because the control info and the qubit it applies to won't, in general, show up at the same time 🙃

5.2. Classical Communication 📡

in this document we've already covered two roles that classical communication has to play 💜 here they are:

• Communicate classical bits of information as part of distributed protocols such as entanglement swapping and teleportation.
• Communicate control information within a network, including background protocols such as routing, as well as signalling protocols to set up end-to-end entanglement generation.

classical communication is a crucial building block of any quantum network 🌸 all nodes in a quantum network are assumed to have classical connectivity with each other (within typical administrative domain limits). so quantum nodes will need to manage two data planes in parallel: a classical data plane and a quantum data plane 👑 on top of that, a node must be able to correlate information between the two planes, so that control information received on a classical channel can be applied to the qubits managed by the quantum data plane. this is the teamwork moment, lol 🫶

5.3. Abstract Model of the Network 🗺️

5.3.1. The Control Plane and the Data Plane 🎀

control plane protocols for quantum networks will have a lot of the same responsibilities as their classical counterparts: discovering the network topology, resource management, populating data plane tables, etc. most of these protocols don't need to touch quantum data and can just run by exchanging classical messages 📨 there may also be some control plane functionality that does need to handle quantum data [QI-Scenarios]. since it isn't clear there's much benefit in defining a separate quantum control plane, given how much it overlaps with the classical one, whether there should be a separate quantum control plane is beyond the scope of this document 🤷‍♀️

the data plane separation, though, is much more distinct 🔥 there will be two data planes: a classical data plane and a quantum data plane. the classical data plane processes and forwards classical packets. the quantum data plane processes and swaps entangled pairs. third-generation quantum networks may also forward qubits, on top of swapping Bell pairs 🌈

on top of control plane messages, there will also be control information messages that work at the granularity of individual entangled pairs, like the heralding messages used for elementary link generation (Section 4.4.1) 🦋 in terms of what they do, these messages are closer to classical packet headers than to control plane messages, so we count them as part of the quantum data plane. which means a quantum data plane also includes exchanging classical control info at the granularity of individual qubits and entangled pairs 💖

5.3.2. Elements of a Quantum Network ✨

okay so quantum repeaters are the core building block, but bestie, a repeater has to do way more than just entanglement swapping to make a working quantum network 💅 Its main jobs are:

1. Creating link-local entanglement between neighbouring nodes 🔗
2. Extending entanglement from link-local pairs to long-range pairs through entanglement swapping 🌉
3. Performing distillation to manage the fidelity of the produced pairs 💎
4. Participating in the management of the network (routing, etc.) 🧠

not all repeaters are the same tho 🦋 so here's how they break down:

• Quantum routers (controllable quantum nodes): a quantum router is a quantum repeater with a control plane. it helps run the network and decides which qubits to swap to generate the requested end-to-end pairs. main character energy 👑
• Automated quantum nodes: an automated quantum node is a data-plane-only quantum repeater. it does not take part in the network control plane. the no-cloning theorem rules out amplification, so long-range links get built by chaining lots of these nodes together 🔗✨
• End nodes: end nodes have to be able to receive and handle an entangled pair, but they don't need to do entanglement swaps (so they aren't necessarily quantum repeaters). they also don't need any quantum memory, since some quantum applications work fine if the end node just measures its qubit the moment it arrives 🙈
• Non-quantum nodes: not every node in a quantum network needs a quantum data plane. a non-quantum node is any device that can handle classical network traffic 💜

we also need to name two kinds of links 🌈

• Quantum links: a quantum link can generate an entangled pair between two directly connected quantum repeaters. it may include extra mid-point elements, as described in Section 4.4.1. it may also include a dedicated classical channel, used only to coordinate entanglement generation on that quantum link 🎀
• Classical links: a classical link connects any two nodes in the network that can carry classical network traffic 📡

ngl this next bit is so cool 🫶 passive elements like optical switches don't destroy the quantum state. so you can connect multiple quantum nodes over an optical network and do optical switching, instead of routing through entanglement swapping at the quantum routers. this does need coordination with the elementary link entanglement generation process, and repeaters are still needed to get past the short-distance limits. still, it's a potentially feasible setup for local area networks 🏠✨

5.3.3. Putting It All Together 🧩

okay here's a two-hop path in a generic quantum network, bestie 👇

   +-----+                                        +-----+
   | App |- - - - - - - - - -CC- - - - - - - - - -| App |
   +-----+                +------+                +-----+
   | EN  |------ CL ------|  QR  |------ CL ------| EN  |
   |     |------ QL ------|      |------ QL ------|     |
   +-----+                +------+                +-----+

and the key:

   App - user-level application
   EN - End Node
   QL - Quantum Link
   CL - Classical Link
   CC - Classical Channel (traverses one or more CLs)
   QR - Quantum Repeater

so an application (App) running on two End Nodes (ENs) attached to the network will eventually need the network to generate entangled pairs for it 💖 that might take some negotiation between the ENs, maybe even ahead of time, because they both have to open a communication end-point the network can use to identify the two ends of the connection. the two ENs use a Classical Channel (CC) in the network to sort this out 🤝

once the network gets a request for end-to-end entangled pairs, it uses the Classical Links (CLs) to coordinate and claim the resources it needs 📋 this could be some mix of prior control information (like routing tables) and signalling protocols, but how exactly that works is still an active research question 🔬 a thought experiment on what this might look like can be found in Section 7 🧪

during or after the control information gets distributed, the network does the quantum work: generating entanglement over the individual Quantum Links (QLs), performing entanglement swaps at the Quantum Repeaters (QRs), and sending more signalling to pass along swap outcomes and other control info ⚡ since Bell pairs don't carry any user data, some of these operations can happen before the request even shows up, in anticipation of demand 🔮

quick note: "signalling" is used super broadly here 💅 it covers lots of different messaging needed to control entanglement generation. for example, heralded entanglement generation needs really precise timing sync between neighbouring nodes, so the triggering and heralding might run over its own CL, possibly a physically separate one. that's what happened in the network stack demonstration in [Pompili21.2]. higher-level signalling with looser timing needs (like control plane signalling) can then run over its own CL 🎀

the entangled pair gets delivered to the application once it's ready, along with the relevant pair identifier 🎁 but "ready" doesn't always mean every link pair and entanglement swap is finished, because some applications can start running on an incomplete pair 🏃‍♀️ in that case, the remaining swaps carry the actions across the network to the other end, and sometimes the EN has to do fixup operations afterwards 🛠️

5.4. Physical Constraints 🧲

the model above basically skips over the messy hardware details 🙈 but some physical constraints have to be considered before you can build a practical network. some are fundamental and will always need handling, no matter how much the technology improves. others are just growing pains of a new technology 🌱 here we look at a highly abstract scenario, and refer to [Wehner18] for pointers into the physics literature 📚

5.4.1. Memory Lifetimes ⏳

discrete operations aren't perfect, and storing a qubit in memory is also super tricky 😭 the main problem with persistent storage is that it's extremely hard to isolate a quantum system from its environment. the environment brings in uncontrollable noise, which hurts the fidelity of the state. this process is called decoherence 🌫️ eventually the state has to be thrown out once its fidelity drops too far 💀

how long a memory lasts depends on the physical setup. as of 2020, the highest achievable lifetimes in quantum network hardware are on the order of seconds [Abobeih18]. a lifetime of a minute has been shown for qubits that aren't connected to a quantum network, though [Bradley19] ⏱️ these numbers have jumped massively over the life of the different technologies and will keep going up 📈 but if quantum networks are going to happen in the near future, they need to cope with short memory lifetimes, for example by cutting latency on critical paths 🏎️

5.4.2. Rates 🐌

entanglement generation on a link between two connected nodes isn't very efficient 😤 it takes lots of attempts to succeed [Hensen15] [Dahlberg19]. for example, the best success rates between nitrogen-vacancy center nodes (which can also store and process the resulting qubits, not just generate entanglement) are on the order of 10 Hz 🐝 combine that with short memory lifetimes and you get really tight timing windows for building up network-wide connectivity ⏰

other platforms hit higher entanglement rates, but that usually costs other hardware capabilities, like having no quantum memory and/or limited processing [Wei22] 😬 still, current rates aren't good enough for practical applications beyond simple experimental proofs of concept. they're expected to get better as quantum network technology evolves [Wei22] 🌟

5.4.3. Communication Qubits 📱

most physical architectures that can store qubits can only generate entanglement using a subset of their available qubits, called communication qubits [Dahlberg19] 📞 once a Bell pair has been made with a communication qubit, its state can be moved into memory. this can put extra limits on the network. in particular, if a node has only one communication qubit, it can't generate Bell pairs over two links at the same time. it has to generate entanglement over the links one at a time 🚦

5.4.4. Homogeneity 🧬

right now, all existing quantum network implementations are homogeneous, and they don't interface with each other 🙃 in general, combining different quantum information processing technologies is really challenging 😵‍💫

there are many different physical hardware platforms for quantum networking hardware, and they differ in how they store and manipulate qubits in memory and how they generate entanglement across a link with their neighbours 🌐 for example, hardware built on optical elements and atomic ensembles [Sangouard11] is super efficient at generating entanglement at high rates, but it offers limited processing once the entanglement exists ⚡ nitrogen-vacancy platforms [Hensen15] and trapped ion platforms [Moehring07] are the opposite: much more control over the qubits, but they have a harder time generating entanglement at high rates 🎢

to get past each platform's weaknesses, coupling the different technologies will help build fully functional networks 🧩 for example, end nodes might use technology with good qubit processing to run complex applications, while automated quantum nodes that just "repeat" along a linear chain, where the logic is much simpler, can use technologies that trade processing power for higher entanglement rates over long distances [Askarani21] 🪄

this gets worse because quantum computers (aka the end nodes in a quantum network) are often built on different hardware platforms from quantum repeaters, so the two need coupling (transduction) between them 🔌 that's especially true for superconducting quantum computers, which are hard to connect to optical networks 🥲 even trapped ion quantum computers, a platform that's shown promise for quantum networking, will still need to connect to other platforms that are better at making entanglement at high rates over long distances (hundreds of kilometres) 🌍✨

6. Architectural Principles ✨

okay so bestie, this is where it gets fun 🦋. The most practical way to actually connect quantum nodes is Bell pair and entanglement-swapping repeater technology, so what principles should guide us when we build these networks? We want them to be functional, robust, efficient, and most importantly, to actually work 💅. And how do we design things that work under today's hardware constraints without making life miserable for future tech? 😭

quantum networking is a brand new tech that's gonna get reinvented like a million times, so this doc is not a definitive rulebook 🙅 it's just a set of recommended guidelines for the first generations of quantum networks, based on principles and observations the community has made 🌸. The cool part of a community-built doc at this stage is that building a quantum internet takes experts in quantum information and network architecture, so we all need to be in the group chat together 🫶.

6.1. Goals of a Quantum Internet

When we outline any set of principles, we have to ask what goals we're going for, because trade-offs are inevitable 😬. So what goals should drive a quantum network architecture? This list is inspired by the history of computer networking, so it's super similar to what you'd come up with for the classical Internet [Clark88]. BUT, even if the goals look alike, the challenges are often fundamentally different 👀. The list will also probably evolve over time with the needs of its users ✨.

1. Support distributed quantum applications.

This goal seems trivially obvious, but it makes a subtle, important point that highlights a key difference between quantum and classical networks 🔥. Quantum data transmission is not actually the goal of a quantum network -- it's only one possible component of more advanced quantum application protocols [Wehner18]. Transmission could totally be a building block for all quantum apps, but it's not the most basic one possible. For example, entanglement-based QKD, the most well-known quantum application protocol, only relies on the stronger-than-classical correlations and inherent secrecy of entangled Bell pairs, and it doesn't have to transmit arbitrary quantum states [Ekert91].

The primary purpose of a quantum internet is to support distributed quantum application protocols, and it's super important that they run well and efficiently 💖. So it's important to develop performance metrics that actually mean something to applications, to drive the development of quantum network protocols. For example, the Bell pair generation rate is meaningless if you don't also consider fidelity 🙃. Generating lower-fidelity pairs is generally way easier, but quantum apps may have to make multiple reattempts or even abort if the fidelity is too low 💀. You can find a review of the requirements for different known quantum applications in [Wehner18], and an overview of use cases in [QI-Scenarios] 📚.

2. Support tomorrow's distributed quantum applications.

The only principle of the Internet that should survive indefinitely is the principle of constant change [RFC1958] 🌈. Tech change is continuous, and the size and capabilities of the quantum internet will change by orders of magnitude 🚀. So it's an explicit goal that a quantum internet architecture can embrace that change. We've been witnesses to the classical Internet evolving over several decades, and we've seen what worked and what didn't 🍓. A quantum internet has to avoid needing flag days (e.g., NCP to TCP/IP) or upgrades that take decades to roll out (e.g., IPv4 to IPv6) 😩.

So it's important that any proposed architecture for general-purpose quantum repeater networks can plug in new devices and solutions as they become available 🧚. The architecture should not be constrained by considerations for early-stage hardware and applications. For example, it's already possible to run QKD efficiently on metropolitan-scale networks, and those are already commercially available 🎀. However, they're not based on quantum repeaters, so they won't be able to easily transition to more sophisticated applications 🥲.

3. Support heterogeneity.

There are multiple proposals for realizing practical quantum repeater hardware, and they all have their advantages and disadvantages 🧩. Some may offer higher Bell pair generation rates on individual links at the cost of entanglement swap operations that are more difficult. Other platforms may be good all around but are harder to build 🛠️.

In addition to physical boundaries, there may be differences in how errors are managed (Section 4.4.3.3) 🙈. These differences will affect the content and semantics of messages that cross these boundaries -- for both connection setup and real-time operation 📨.

The optimal network configuration will likely leverage the advantages of multiple platforms to optimize the provided service ⭐. So it's an explicit goal to incorporate varied hardware and technology support from the beginning 🌸.

4. Ensure security at the network level.

The question of security in quantum networks is just as critical as it is in the classical Internet, especially since the enhanced security offered by quantum entanglement is one of the key driving factors 🔐.

Good news: from an application's point of view, as long as the underlying implementation corresponds to (or sufficiently approximates) theoretical models of quantum cryptography, quantum cryptographic protocols don't need the network to provide any guarantees about the confidentiality or integrity of the transmitted qubits or the generated entanglement (though they may impose requirements on the classical channel, e.g., to be authenticated [Wang21]). Instead, applications will lean on the classical networks to establish the end-to-end security of the results obtained from processing entangled qubits 💅. However, it's important to note that while classical networks are necessary to establish these end-to-end guarantees, the security relies on the properties of quantum entanglement ✨. For example, QKD uses classical information reconciliation [Tang19] for error correction and privacy amplification [Elkouss11] to generate the final secure key, but the raw bits that are fed into these protocols must come from measuring entangled qubits [Ekert91]. In another application, secure delegated quantum computing, the client hides its computation from the server by sending qubits to the server and then requesting (in a classical message) that the server measure them in an encoded basis. The client then decodes the results it receives from the server to obtain the result of the computation [Broadbent10]. Once again, while a classical network is used to achieve the goal of secure computation, the remote computation is strictly quantum 🤯.

Nevertheless, while applications can ensure their own end-to-end security, network protocols themselves should be security aware in order to protect the network itself and limit disruption 🛡️. While the applications remain secure, they aren't necessarily operational or as efficient in the presence of an attacker. For example, if an attacker can measure every qubit between two parties trying to establish a key using QKD, no secret key can be generated 😱. Security concerns in quantum networks are described in more detail in [Satoh17] and [Satoh20] 📖.

5. Make them easy to monitor.

In order to manage, evaluate the performance of, or debug a network, you need to be able to monitor it, while making sure there are mechanisms in place to protect the confidentiality and integrity of the devices connected to it 👀. Quantum networks bring new challenges in this area, so it should be a goal of a quantum network architecture to make this task easy 🦋.

The fundamental unit of quantum information, the qubit, cannot be actively monitored, because any readout irreversibly destroys its contents 💔. One implication is that measuring an individual pair's fidelity is impossible. Fidelity is only meaningful as a statistical quantity, which requires constant monitoring of generated Bell pairs, achieved by sacrificing some Bell pairs for use in tomography or other methods 🧪.

Furthermore, given one end of an entangled pair, it's impossible to tell where the other qubit is without any additional classical metadata. It's impossible to extract this information from the qubits themselves 🙅. This implies that tracking entangled pairs necessitates some exchange of classical information. This information might include (i) a reference to the entangled pair that allows distributed applications to coordinate actions on qubits of the same pair and (ii) the two bits from each entanglement swap necessary to identify the final state of the Bell pair (Section 4.4.2) 📬.

6. Ensure availability and resilience.

Any practical and usable network, classical or quantum, must be able to keep operating despite losses and failures, and be robust to malicious actors trying to disable connectivity 💪. A difference between quantum and classical networks is that quantum networks are composed of two types of data planes (quantum and classical) and two types of channels (quantum and classical) that must be considered 🌀. Therefore, availability and resilience will most likely require a more advanced treatment than they do in classical networks 🫶.

Note that privacy, whilst related to security, isn't listed as an explicit goal, because the privacy benefits will depend on the use case 🤫. For example, QKD only provides increased security for the distribution of symmetric keys [Bennett14] [Ekert91]. The handling, manipulation, sharing, encryption, and decryption of data will remain entirely classical, which limits the privacy benefits that can be gained from using a quantum network. On the other hand, there are applications like blind quantum computation, which lets the user run a quantum computation on a remote server without the server knowing what the computation was or its input and output [Fitzsimons17]. Therefore, privacy must be considered on a per-application basis 💜. An overview of quantum network use cases can be found in [QI-Scenarios] 🌈.

6.2. The Principles of a Quantum Internet ✨

Okay bestie, the principles support the goals, but they are not goals themselves 💅 The goals say what we want to build, and the principles are the guideline for how we might actually get there 🧚 The goals are also the foundation for any metric of success for a network architecture. The principles on their own don't tell you success from failure 🙈 For more tea on design considerations for quantum networks, check out [VanMeter13.1] and [Dahlberg19] 📚

1. Entanglement is the fundamental service. The key service a quantum network provides is distributing entanglement between the nodes in the network 🫶 Every distributed quantum application is built on top of this key resource. Clustered quantum computing, distributed quantum computing, distributed quantum sensing networks, and certain kinds of quantum secure networks all consume quantum entanglement as a resource 🔥 Some applications (e.g., QKD) just measure the entangled qubits to get a shared secret key [QKD]. Other applications (e.g., distributed quantum computing) build more complex abstractions and operations on the entangled qubits, like distributed CNOT gates [DistCNOT] or teleportation of arbitrary qubit states [Teleportation] ✨

A quantum network may also distribute multipartite entangled states (entangled states of three or more qubits) [Meignant19] 🌈 These are useful for things like conference key agreement [Murta20], distributed quantum computing [Cirac99], secret sharing [Qin17], and clock synchronisation [Komar14]. Worth noting though: multipartite entangled states can also be built from multiple entangled pairs distributed between the end nodes 🤓

2. Bell pairs are indistinguishable. Any two Bell pairs between the same two nodes are indistinguishable for an application, as long as they both meet its required fidelity threshold 💖 This is likely to be key for a more optimal allocation of resources in a network, e.g., when provisioning resources to meet application demand 👑 BUT, the qubits that make up the pair are not indistinguishable themselves 🙈 The two nodes operating on a pair have to coordinate so they're working on qubits that belong to the same Bell pair 🎀
3. Fidelity is part of the service. Delivering Bell pairs to the communication end-points isn't enough on its own. The Bell pairs also have to be of sufficient fidelity 💅 Unlike in classical networks, where most errors are basically eliminated before they reach the application, many quantum applications only need imperfect entanglement to work 🦋 Still, quantum applications generally have a fidelity threshold below which they can no longer operate, and different applications have different requirements for what fidelity they can handle 😭 Balancing resource usage against those requirements is the network's responsibility 🧚 It may actually be cheaper for the network to provide lower-fidelity pairs that are just above an application's threshold than to guarantee high-fidelity pairs to everyone, no matter what they need 🍓
4. Time is an expensive resource. Time isn't the only thing in short supply (communication qubits and memory are too), but the lifetime of quantum memories is what creates some of the hardest conditions for running an extended network of quantum nodes 💀 Current hardware has low rates of Bell pair generation, short memory lifetimes, and access to only a limited number of communication qubits 😭 All of this together means even a short waiting queue at some node could be enough for a Bell pair to decohere, or end up with an end-to-end pair below an application's fidelity threshold 💔 So managing the idle time of qubits holding live quantum states should be done carefully. Ideally you minimise the idle time, but you could also move the quantum state into a quantum memory with a longer lifetime for temporary storage 🌸
5. Be flexible with regards to capabilities and limitations. This goal has two big points 👑
   • First, the architecture should be able to function under the physical constraints of current-generation hardware. Near-future hardware will have low entanglement generation rates, quantum memories that can hold a handful of qubits at best, and decoherence rates that will make many generated pairs unusable 🥲
   • Second, the architecture should not make it hard to run the network over any hardware that may come along in the future. Repeater capabilities will improve, and redeploying a technology is extremely challenging 🚀

---

7. A Thought Experiment Inspired by Classical Networks 🧪

To wrap up, we discuss a plausible quantum network architecture inspired by MPLS 🦋 This is not an architecture proposal. It's a thought experiment to give you an idea of what components are necessary for a functional quantum network 💅 We use classical MPLS as a basis because it's well known and understood in the networking community 🫶

Creating end-to-end Bell pairs between remote end-points is a stateful distributed task that needs a lot of a priori coordination 😤 So a connection-oriented approach seems like the most natural fit for quantum networks 👑 In connection-oriented quantum networks, when two quantum application end-points want to start creating end-to-end Bell pairs, they must first create a Quantum Virtual Circuit (QVC) ✨ As an analogy, in MPLS networks, end-points have to establish a Label Switched Path (LSP) before they exchange traffic 🎀 Connection-oriented quantum networks may also support virtual circuits with multiple end-points for creating multipartite entanglement 🌈 As an analogy, MPLS networks have the concept of multipoint LSPs for multicast 🧚

When a quantum application creates a QVC, it can indicate Quality of Service (QoS) parameters, like the required capacity in end-to-end Bell Pairs Per Second (BPPS) and the required fidelity of the Bell pairs 📊 As an analogy, in MPLS networks, applications specify the required bandwidth in Bits Per Second (BPS) and other constraints when they create a new LSP 💖

Different applications have different QoS requirements 💅 For example, applications like QKD don't need to process the entangled qubits. They only measure them and store the resulting outcome. So they may need a large volume of entanglement, but they're tolerant of delay and jitter for individual pairs 🦋 On the other hand, distributed or cloud quantum computing applications may need fewer entangled pairs, but they may need all of them generated in one go, so they can all be processed together before any of them decohere 😭

Quantum networks need a routing function to compute the optimal path (i.e., the best sequence of routers and links) for each new QVC 🗺️ The routing function may be centralised or distributed. In the distributed case, the quantum network needs a distributed routing protocol 🫶 As an analogy, classical networks use routing protocols like Open Shortest Path First (OSPF) and Intermediate System to Intermediate System (IS-IS) 🌸 But heads up: the definition of "shortest path" / "least cost" may be different in a quantum network to account for its non-classical features, such as fidelity [VanMeter13.2] 🤓

Given how scarce resources are in early quantum networks, a Traffic Engineering (TE) function is likely to be beneficial 🔥 Without TE, QVCs always use the shortest path. In that case, the quantum network can't guarantee that each quantum end-point gets its Bell pairs at the required rate or fidelity 😬 This is analogous to "best effort" service in classical networks 🙈

With TE, QVCs choose a path that is guaranteed to have the requested resources (e.g., bandwidth in BPPS) available. This takes into account the capacity of the routers and links, and also the resources already consumed by other virtual circuits 👑 As an analogy, both OSPF and IS-IS have TE extensions to keep track of used and available resources, and they can use Constrained Shortest Path First (CSPF) to factor in resource availability and other constraints when computing the optimal path 💅

TE implies the use of Call Admission Control (CAC): the network denies any virtual circuits for which it cannot guarantee the requested quality of service a priori 🚫 Alternatively, the network can preempt lower-priority circuits to make room for a new circuit 🥊

Quantum networks need a signalling function. Once the path for a QVC has been computed, signalling installs the "forwarding rules" into the data plane of each quantum router on the path 📡 The signalling may be distributed, analogous to the Resource Reservation Protocol (RSVP) in MPLS 🫶 Or, it may be centralised, similar to OpenFlow ✨

Quantum networks also need an abstraction of the hardware for specifying the forwarding rules 🧠 This lets us decouple the control plane (routing and signalling) from the data plane (the actual creation of Bell pairs) 🦋 The forwarding rules are specified using abstract building blocks like "creating local Bell pairs", "swapping Bell pairs", or "distillation of Bell pairs" 🧩 As an analogy, classical networks use abstractions based on match conditions (e.g., looking up header fields in tables) and actions (e.g., modifying fields or forwarding a packet to a specific interface) 🌈 The data plane abstractions in quantum networks will be very different from those in classical networks, because of the fundamental differences in technology and the stateful nature of quantum networks 😵‍💫 In fact, choosing the right abstractions will be one of the biggest challenges when designing interoperable quantum network protocols 🥲

In quantum networks, control plane traffic (routing and signalling messages) is exchanged over a classical channel, while data plane traffic (the actual Bell pair qubits) is exchanged over a separate quantum channel 🧚 This is different from most classical networks, where control and data plane traffic share the same channel and a single packet contains both user fields and header fields 🙃 There is, however, a classical analogy to how quantum networks work: generalised MPLS (GMPLS) networks use separate channels for control plane traffic and data plane traffic 💜 And GMPLS networks support data planes where there is no such thing as data plane headers (e.g., Dense Wavelength Division Multiplexing (DWDM) or Time-Division Multiplexing (TDM) networks) 🌟

---

8. Security Considerations 🔐

Okay, bestie, pay attention 🚨 Security is listed as an explicit goal for this architecture. This issue is addressed in Section 6.1 💀 However, as this is an Informational document, it does not propose any concrete mechanisms to achieve these goals 😭 So the goal is on the list, but the how is still up to whoever builds it 🙏

---

9. IANA Considerations 📋

This document has no IANA actions. 💖

---

10. Informative References 📚

[Abobeih18] Abobeih, M.H., Cramer, J., Bakker, M.A., Kalb, N., Markham, M., Twitchen, D.J., and T.H. Taminiau, "One-second coherence for a single electron spin coupled to a multi-qubit nuclear-spin environment", Nature communications Vol. 9, Iss. 1, pp. 1-8, DOI 10.1038/s41467-018-04916-z, June 2018, <https://www.nature.com/articles/s41467-018-04916-z>.

[Aguado19] Aguado, A., Lopez, V., Lopez, D., Peev, M., Poppe, A., Pastor, A., Folgueira, J., and V. Martin, "The Engineering of Software-Defined Quantum Key Distribution Networks", IEEE Communications Magazine Vol. 57, Iss. 7, pp. 20-26, DOI 10.1109/MCOM.2019.1800763, July 2019, <https://ieeexplore.ieee.org/document/8767074>.

[Askarani21] Askarani, M.F., Chakraborty, K., and G.C. do Amaral, "Entanglement distribution in multi-platform buffered-router-assisted frequency-multiplexed automated repeater chains", New Journal of Physics Vol. 23, Iss. 6, 063078, DOI 10.1088/1367-2630/ac0a35, June 2021, <https://iopscience.iop.org/article/10.1088/1367-2630/ac0a35>.

[Aspect81] Aspect, A., Grangier, P., and G. Roger, "Experimental Tests of Realistic local Theories via Bell's Theorem", Physical Review Letters Vol. 47, Iss. 7, pp. 460-463, DOI 10.1103/PhysRevLett.47.460, August 1981, <https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.47.460>.

[Bennett14] Bennett, C.H. and G. Brassard, "Quantum cryptography: Public key distribution and coin tossing", Theoretical Computer Science Vol. 560 (Part 1), pp. 7-11, DOI 10.1016/j.tcs.2014.05.025, December 2014, <https://www.sciencedirect.com/science/article/pii/S0304397514004241?via%3Dihub>.

[Bennett93] Bennett, C.H., Brassard, G., Crépeau, C., Jozsa, R., Peres, A., and W.K. Wootters, "Teleporting an unknown quantum state via dual classical and Einstein-Podolsky-Rosen channels", Physical Review Letters Vol. 70, Iss. 13, pp. 1895-1899, DOI 10.1103/PhysRevLett.70.1895, March 1993, <https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.70.1895>.

[Bennett96] Bennett, C.H., DiVincenzo, D.P., Smolin, J.A., and W.K. Wootters, "Mixed-state entanglement and quantum error correction", Physical Review A Vol. 54, Iss. 5, pp. 3824-3851, DOI 10.1103/PhysRevA.54.3824, November 1996, <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.54.3824>.

[Bradley19] Bradley, C.E., Randall, J., Abobeih, M.H., Berrevoets, R.C., Degen, M.J., Bakker, M.A., Markham, M., Twitchen, D.J., and T.H. Taminiau, "A Ten-Qubit Solid-State Spin Register with Quantum Memory up to One Minute", Physical Review X Vol. 9, Iss. 3, 031045, DOI 10.1103/PhysRevX.9.031045, September 2019, <https://journals.aps.org/prx/abstract/10.1103/PhysRevX.9.031045>.

[Briegel98] Briegel, H.-J., Dür, W., Cirac, J.I., and P. Zoller, "Quantum Repeaters: The Role of Imperfect Local Operations in Quantum Communication", Physical Review Letters Vol. 81, Iss. 26, pp. 5932-5935, DOI 10.1103/PhysRevLett.81.5932, December 1998, <https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.81.5932>.

[Broadbent10] Broadbent, A., Fitzsimons, J., and E. Kashefi, "Measurement-Based and Universal Blind Quantum Computation", Springer-Verlag 978-3-642-13678-8, DOI 10.1007/978-3-642-13678-8_2, June 2010, <https://link.springer.com/chapter/10.1007/978-3-642-13678-8_2>.

[Cacciapuoti19] Cacciapuoti, A.S., Caleffi, M., Van Meter, R., and L. Hanzo, "When Entanglement Meets Classical Communications: Quantum Teleportation for the Quantum Internet", IEEE Transactions on Communications Vol. 68, Iss. 6, pp. 3808-3833, DOI 10.1109/TCOMM.2020.2978071, June 2020, <https://ieeexplore.ieee.org/document/9023997>.

[Cirac99] Cirac, J.I., Ekert, A.K., Huelga, S.F., and C. Macchiavello, "Distributed quantum computation over noisy channels", Physical Review A Vol. 59, Iss. 6, 4249, DOI 10.1103/PhysRevA.59.4249, June 1999, <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.59.4249>.

[Clark88] Clark, D., "The design philosophy of the DARPA internet protocols", SIGCOMM '88: Symposium proceedings on Communications architectures and protocols, pp. 106-114, DOI 10.1145/52324.52336, August 1988, <https://dl.acm.org/doi/abs/10.1145/52324.52336>.

[Crepeau02] Crépeau, C., Gottesman, D., and A. Smith, "Secure multi-party quantum computation", STOC '02: Proceedings of the thiry-fourth [sic] annual ACM symposium on Theory of computing, pp. 643-652, DOI 10.1145/509907.510000, May 2002, <https://dl.acm.org/doi/10.1145/509907.510000>.

[Dahlberg19] Dahlberg, A., Skrzypczyk, M., Coopmans, T., Wubben, L., Rozpędek, F., Pompili, M., Stolk, A., Pawełczak, P., Knegjens, R., de Oliveira Filho, J., Hanson, R., and S. Wehner, "A link layer protocol for quantum networks", SIGCOMM '19 Proceedings of the ACM Special Interest Group on Data Communication, pp. 159-173, DOI 10.1145/3341302.3342070, August 2019, <https://dl.acm.org/doi/10.1145/3341302.3342070>.

[Devitt13] Devitt, S.J., Munro, W.J., and K. Nemoto, "Quantum error correction for beginners", Reports on Progress in Physics Vol. 76, Iss. 7, 076001, DOI 10.1088/0034-4885/76/7/076001, June 2013, <https://iopscience.iop.org/article/10.1088/0034-4885/76/7/076001>.

[DistCNOT] "Distributed CNOT", Quantum Network Explorer by QuTech, 2023, <https://www.quantum-network.com/applications/7/>.

[Dur07] Dür, W. and H.J. Briegel, "Entanglement purification and quantum error correction", Reports on Progress in Physics Vol. 70, Iss. 8, pp. 1381-1424, DOI 10.1088/0034-4885/70/8/R03, July 2007, <https://iopscience.iop.org/article/10.1088/0034-4885/70/8/R03>.

[Ekert91] Ekert, A.K., "Quantum cryptography based on Bell's theorem", Physical Review Letters Vol. 67, Iss. 6, pp. 661-663, DOI 10.1103/PhysRevLett.67.661, August 1991, <https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.67.661>.

[Elkouss11] Elkouss, D., Martinez-Mateo, J., and V. Martin, "Information Reconciliation for Quantum Key Distribution", Quantum Information and Computation Vol. 11, No. 3 and 4, pp. 0226-0238, DOI 10.48550/arXiv.1007.1616, March 2011, <https://arxiv.org/abs/1007.1616>.

[Elliott03] Elliott, C., Pearson, D., and G. Troxel, "Quantum cryptography in practice", SIGCOMM 2003: Proceedings of the 2003 conference on Applications, technologies, architectures, and protocols for computer communications, pp. 227-238, DOI 10.1145/863955.863982, August 2003, <https://dl.acm.org/doi/abs/10.1145/863955.863982>.

[Fitzsimons17] Fitzsimons, J.F. and E. Kashefi, "Unconditionally verifiable blind quantum computation", Physical Review A Vol. 96, Iss. 1, 012303, DOI 10.1103/PhysRevA.96.012303, July 2017, <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.96.012303>.

[Fowler10] Fowler, A.G., Wang, D.S., Hill, C.D., Ladd, T.D., Van Meter, R., and L.C.L. Hollenberg, "Surface Code Quantum Communication", Physical Review Letters Vol. 104, Iss. 18, 180503, DOI 10.1103/PhysRevLett.104.180503, May 2010, <https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.104.180503>.

[Giovannetti04] Giovannetti, V., Lloyd, S., and L. Maccone, "Quantum-Enhanced Measurements: Beating the Standard Quantum Limit", Science Vol. 306, Iss. 5700, pp. 1330-1336, DOI 10.1126/science.1104149, November 2004, <https://www.science.org/doi/10.1126/science.1104149>.

[Gottesman12] Gottesman, D., Jennewein, T., and S. Croke, "Longer-Baseline Telescopes Using Quantum Repeaters", Physical Review Letters Vol. 109, Iss. 7, 070503, DOI 10.1103/PhysRevLett.109.070503, August 2012, <https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.109.070503>.

[Hensen15] Hensen, B., Bernien, H., Dréau, A.E., Reiserer, A., Kalb, N., Blok, M.S., Ruitenberg, J., Vermeulen, R.F.L., Schouten, R.N., Abellán, C., Amaya, W., Pruneri, V., Mitchell, M.W., Markham, M., Twitchen, D.J., Elkouss, D., Wehner, S., Taminiau, T.H., and R. Hanson, "Loophole-free Bell inequality violation using electron spins separated by 1.3 kilometres", Nature Vol. 526, pp. 682-686, DOI 10.1038/nature15759, October 2015, <https://www.nature.com/articles/nature15759>.

[Jiang09] Jiang, L., Taylor, J.M., Nemoto, K., Munro, W.J., Van Meter, R., and M.D. Lukin, "Quantum repeater with encoding", Physical Review A Vol. 79, Iss. 3, 032325, DOI 10.1103/PhysRevA.79.032325, March 2009, <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.79.032325>.

[Joshi20] Joshi, S.K., Aktas, D., Wengerowsky, S., Lončarić, M., Neumann, S.P., Liu, B., Scheidl, T., Currás-Lorenzo, G., Samec, Z., Kling, L., Qiu, A., Razavi, M., Stipčević, M., Rarity, J.G., and R. Ursin, "A trusted node-free eight-user metropolitan quantum communication network", Science Advances Vol. 6, no. 36, eaba0959, DOI 10.1126/sciadv.aba0959, September 2020, <https://www.science.org/doi/10.1126/sciadv.aba0959>.

[Kimble08] Kimble, H.J., "The quantum internet", Nature Vol. 453, Iss. 7198, pp. 1023-1030, DOI 10.1038/nature07127, June 2008, <https://www.nature.com/articles/nature07127>.

[Komar14] Kómár, P., Kessler, E.M., Bishof, M., Jiang, L., Sørensen, A.S., Ye, J., and M.D. Lukin, "A quantum network of clocks", Nature Physics Vol. 10, Iss. 8, pp. 582-587, DOI 10.1038/nphys3000, June 2014, <https://www.nature.com/articles/nphys3000>.

[Meignant19] Meignant, C., Markham, D., and F. Grosshans, "Distributing graph states over arbitrary quantum networks", Physical Review A Vol. 100, Iss. 5, 052333, DOI 10.1103/PhysRevA.100.052333, November 2019, <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.100.052333>.

• [Moehring07] Moehring, D.L., Maunz, P., Olmschenk, S., Younge, K.C., Matsukevich, D.N., Duan, L.-M., and C. Monroe, "Entanglement of single-atom quantum bits at a distance", Nature Vol. 449, Iss. 7158, pp. 68-71, DOI 10.1038/nature06118, September 2007, <https://www.nature.com/articles/nature06118>.
• [Mural16] Muralidharan, S., Li, L., Kim, J., Lütkenhaus, N., Lukin, M.D., and L. Jiang, "Optimal architectures for long distance quantum communication", Scientific Reports Vol. 6, pp. 1-10, DOI 10.1038/srep20463, February 2016, <https://www.nature.com/articles/srep20463>.
• [Murta20] Murta, G., Grasselli, F., Kampermann, H., and D. Bruß, "Quantum Conference Key Agreement: A Review", Advanced Quantum Technologies Vol. 3, Iss. 11, 2000025, DOI 10.1002/qute.202000025, September 2020, <https://onlinelibrary.wiley.com/doi/10.1002/qute.202000025>.
• [Nagayama16] Nagayama, S., Choi, B.-S., Devitt, S., Suzuki, S., and R. Van Meter, "Interoperability in encoded quantum repeater networks", Physical Review A Vol. 93, Iss. 4, 042338, DOI 10.1103/PhysRevA.93.042338, April 2016, <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.93.042338>.
• [Nagayama21] Nagayama, S., "Towards End-to-End Error Management for a Quantum Internet", arXiv 2112.07185, DOI 10.48550/arXiv.2112.07185, December 2021, <https://arxiv.org/abs/2112.07185>.
• [NielsenChuang] Nielsen, M.A. and I.L. Chuang, "Quantum Computation and Quantum Information", Cambridge University Press, 2010, <http://mmrc.amss.cas.cn/tlb/201702/W020170224608149940643.pdf>.
• [Park70] Park, J.L., "The concept of transition in quantum mechanics", Foundations of Physics Vol. 1, Iss. 1, pp. 23-33, DOI 10.1007/BF00708652, March 1970, <https://link.springer.com/article/10.1007/BF00708652>.
• [Peev09] Peev, M., Pacher, C., Alléaume, R., Barreiro, C., Bouda, J., Boxleitner, W., Debuisschert, T., Diamanti, E., Dianati, M., Dynes, J.F., Fasel, S., Fossier, S., Fürst, M., Gautier, J.-D., Gay, O., Gisin, N., Grangier, P., Happe, A., Hasani, Y., Hentschel, M., Hübel, H., Humer, G., Länger, T., Legré, M., Lieger, R., Lodewyck, J., Lorünser, T., Lütkenhaus, N., Marhold, A., Matyus, T., Maurhart, O., Monat, L., Nauerth, S., Page, J.-B., Poppe, A., Querasser, E., Ribordy, G., Robyr, S., Salvail, L., Sharpe, A.W., Shields, A.J., Stucki, D., Suda, M., Tamas, C., Themel, T., Thew, R.T., Thoma, Y., Treiber, A., Trinkler, P., Tualle-Brouri, R., Vannel, F., Walenta, N., Weier, H., Weinfurter, H., Wimberger, I., Yuan, Z.L., Zbinden, H., and A. Zeilinger, "The SECOQC quantum key distribution network in Vienna", New Journal of Physics Vol. 11, Iss. 7, 075001, DOI 10.1088/1367-2630/11/7/075001, July 2009, <https://iopscience.iop.org/article/10.1088/1367-2630/11/7/075001>.
• [Pompili21.1] Pompili, M., Hermans, S.L.N., Baier, S., Beukers, H.K.C., Humphreys, P.C., Schouten, R.N., Vermeulen, R.F.L., Tiggelman, M.J., dos Santos Martins, L., Dirkse, B., Wehner, S., and R. Hanson, "Realization of a multinode quantum network of remote solid-state qubits", Science Vol. 372, No. 6539, pp. 259-264, DOI 10.1126/science.abg1919, April 2021, <https://www.science.org/doi/10.1126/science.abg1919>.
• [Pompili21.2] Pompili, M., Delle Donne, C., te Raa, I., van der Vecht, B., Skrzypczyk, M., Ferreira, G., de Kluijver, L., Stolk, A.J., Hermans, S.L.N., Pawełczak, P., Kozlowski, W., Hanson, R., and S. Wehner, "Experimental demonstration of entanglement delivery using a quantum network stack", npj Quantum Information Vol. 8, 121, DOI 10.4121/16912522, October 2022, <https://www.nature.com/articles/s41534-022-00631-2>.
• [QI-Scenarios] Wang, C., Rahman, A., Li, R., Aelmans, M., and K. Chakraborty, "Application Scenarios for the Quantum Internet", Work in Progress, Internet-Draft, draft-irtf-qirg-quantum-internet-use-cases-15, 10 March 2023, <https://datatracker.ietf.org/doc/html/draft-irtf-qirg-quantum-internet-use-cases-15>.
• [Qin17] Qin, H. and Y. Dai, "Dynamic quantum secret sharing by using d-dimensional GHZ state", Quantum information processing Vol. 16, Iss. 3, 64, DOI 10.1007/s11128-017-1525-y, January 2017, <https://link.springer.com/article/10.1007/s11128-017-1525-y>.
• [QKD] "Quantum Key Distribution", Quantum Network Explorer by QuTech, 2023, <https://www.quantum-network.com/applications/5/>.
• [RFC1958] Carpenter, B., Ed., "Architectural Principles of the Internet", RFC 1958, DOI 10.17487/RFC1958, June 1996, <https://www.rfc-editor.org/info/rfc1958>.
• [Sangouard11] Sangouard, N., Simon, C., de Riedmatten, H., and N. Gisin, "Quantum repeaters based on atomic ensembles and linear optics", Reviews of Modern Physics Vol. 83, Iss. 1, pp. 33-80, DOI 10.1103/RevModPhys.83.33, March 2011, <https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.83.33>.
• [Satoh17] Satoh, T., Nagayama, S., Oka, T., and R. Van Meter, "The network impact of hijacking a quantum repeater", Quantum Science and Technology Vol. 3, Iss. 3, 034008, DOI 10.1088/2058-9565/aac11f, May 2018, <https://iopscience.iop.org/article/10.1088/2058-9565/aac11f>.
• [Satoh20] Satoh, T., Nagayama, S., Suzuki, S., Matsuo, T., Hajdušek, M., and R. Van Meter, "Attacking the Quantum Internet", IEEE Transactions on Quantum Engineering, vol. 2, pp. 1-17, DOI 10.1109/TQE.2021.3094983, September 2021, <https://ieeexplore.ieee.org/document/9477172>.
• [SutorBook] Sutor, R.S., "Dancing with Qubits", Packt Publishing, November 2019, <https://www.packtpub.com/product/dancing-with-qubits/9781838827366>.
• [Tang19] Tang, B.-Y., Liu, B., Zhai, Y.-P., Wu, C.-Q., and W.-R. Yu, "High-speed and Large-scale Privacy Amplification Scheme for Quantum Key Distribution", Scientific Reports Vol. 9, DOI 10.1038/s41598-019-50290-1, October 2019, <https://www.nature.com/articles/s41598-019-50290-1>.
• [Teleportation] "State teleportation", Quantum Network Explorer by QuTech, 2023, <https://www.quantum-network.com/applications/1/>.
• [Terhal04] Terhal, B.M., "Is entanglement monogamous?", IBM Journal of Research and Development Vol. 48, Iss. 1, pp. 71-78, DOI 10.1147/rd.481.0071, January 2004, <https://ieeexplore.ieee.org/document/5388928>.
• [VanMeter13.1] Van Meter, R. and J. Touch, "Designing quantum repeater networks", IEEE Communications Magazine Vol. 51, Iss. 8, pp. 64-71, DOI 10.1109/MCOM.2013.6576340, August 2013, <https://ieeexplore.ieee.org/document/6576340>.
• [VanMeter13.2] Van Meter, R., Satoh, T., Ladd, T.D., Munro, W.J., and K. Nemoto, "Path selection for quantum repeater networks", Networking Science Vol. 3, Iss. 1-4, pp. 82-95, DOI 10.1007/s13119-013-0026-2, December 2013, <https://link.springer.com/article/10.1007/s13119-013-0026-2>.
• [VanMeterBook] Van Meter, R., "Quantum Networking", ISTE Ltd/John Wiley and Sons. Inc., Print ISBN 978-1-84821-537-5, DOI 10.1002/9781118648919, April 2014, <https://onlinelibrary.wiley.com/doi/book/10.1002/9781118648919>.
• [Wang21] Wang, L.-J., Zhang, K.-Y., Wang, J.-Y., Cheng, J., Yang, Y.-H., Tang, S.-B., Yan, D., Tang, Y.-L., Liu, Z., Yu, Y., Zhang, Q., and J.-W. Pan, "Experimental authentication of quantum key distribution with post-quantum cryptography", npj Quantum Information Vol. 7, pp. 1-7, DOI 10.1038/s41534-021-00400-7, May 2021, <https://www.nature.com/articles/s41534-021-00400-7>.
• [Wehner18] Wehner, S., Elkouss, D., and R. Hanson, "Quantum internet: A vision for the road ahead", Science Vol. 362, Iss. 6412, DOI 10.1126/science.aam9288, October 2018, <https://www.science.org/doi/full/10.1126/science.aam9288>.
• [Wei22] Wei, S.-H., Jing, B., Zhang, X.-Y., Liao, J.-Y., Yuan, C.-Z., Fan, B.-Y., Lyu, C., Zhou, D.-L., Wang, Y., Deng, G.-W., Song, H.-Z., Oblak, D., Guo, G.-C., and Q. Zhou, "Towards Real-World Quantum Networks: A Review", Laser and Photonics Reviews Vol. 16, 2100219, DOI 10.1002/lpor.202100219, January 2022, <https://onlinelibrary.wiley.com/doi/10.1002/lpor.202100219>.
• [Wootters82] Wootters, W.K. and W.H. Zurek, "A single quantum cannot be cloned", Nature Vol. 299, Iss. 5886, pp. 802-803, DOI 10.1038/299802a0, October 1982, <https://www.nature.com/articles/299802a0>.
• [ZOO] "The Quantum Protocol Zoo", November 2019, <https://wiki.veriqloud.fr/>.

Acknowledgements 🫶

okay the authors literally want to thank Carlo Delle Donne, Matthew Skrzypczyk, Axel Dahlberg, Mathias van den Bossche, Patrick Gelard, Chonggang Wang, Scott Fluhrer, Joey Salazar, Joseph Touch, and the whole QIRG community for their super useful reviews and comments on this doc 💖

WK and SW acknowledge funding received from the EU Flagship on Quantum Technologies, Quantum Internet Alliance (No. 820445). ✨

rdv acknowledges support by the Air Force Office of Scientific Research under award number FA2386-19-1-4038. 🎀

Authors' Addresses 🌸

Wojciech Kozlowski
QuTech
Building 22
Lorentzweg 1
2628 CJ Delft
Netherlands
Email: w.kozlowski@tudelft.nl


Stephanie Wehner
QuTech
Building 22
Lorentzweg 1
2628 CJ Delft
Netherlands
Email: s.d.c.wehner@tudelft.nl


Rodney Van Meter
Keio University
5322 Endo, Fujisawa, Kanagawa
252-0882
Japan
Email: rdv@sfc.wide.ad.jp


Bruno Rijsman
Individual
Email: brunorijsman@gmail.com


Angela Sara Cacciapuoti
University of Naples Federico II
Department of Electrical Engineering and Information Technologies
Claudio 21
80125 Naples
Italy
Email: angelasara.cacciapuoti@unina.it


Marcello Caleffi
University of Naples Federico II
Department of Electrical Engineering and Information Technologies
Claudio 21
80125 Naples
Italy
Email: marcello.caleffi@unina.it


Shota Nagayama
Mercari, Inc.
Roppongi Hills Mori Tower 18F
6-10-1 Roppongi, Minato-ku, Tokyo
106-6118
Japan
Email: shota.nagayama@mercari.com