This section explains the meaning of quantum connectivity and the necessary physical processes at an abstract level.
A quantum network cannot be built by simply extrapolating all the classical models to their quantum analogues. Sending qubits over a wire like we send classical bits is simply not as easy to do. There are several technological as well as fundamental challenges that make classical approaches unsuitable in a quantum context.
In classical computers and networks, we can read out the bits stored in memory at any time. This is helpful for a variety of purposes such as copying, error detection and correction, and so on. This is not possible with qubits.
A measurement of a qubit's state will destroy its superposition and with it any entanglement it may have been part of. Once a qubit is being processed, it cannot be read out until a suitable point in the computation, determined by the protocol handling the qubit, has been reached. Therefore, we cannot use the same methods known from classical computing for the purposes of error detection and correction. Nevertheless, quantum error detection and correction schemes exist that take this problem into account, and how a network chooses to manage errors will have an impact on its architecture.
Since directly reading the state of a qubit is not possible, one could ask if we can simply copy a qubit without looking at it. Unfortunately, this is fundamentally not possible in quantum mechanics [
Park70] [
Wootters82].
The no-cloning theorem states that it is impossible to create an identical copy of an arbitrary, unknown quantum state. Therefore, it is also impossible to use the same mechanisms that worked for classical networks for signal amplification, retransmission, and so on, as they all rely on the ability to copy the underlying data. Since any physical channel will always be lossy, connecting nodes within a quantum network is a challenging endeavour, and its architecture must at its core address this very issue.
In general, it is expected that a classical packet arrives at its destination without any errors introduced by hardware noise along the way. This is verified at various levels through a variety of error detection and correction mechanisms. Since we cannot read or copy a quantum state, error detection and correction are more involved.
To describe the quality of a quantum state, a physical quantity called fidelity is used [
NielsenChuang]. Fidelity takes a value between 0 and 1 -- higher is better, and less than 0.5 means the state is unusable. It measures how close a quantum state is to the state we have tried to create. It expresses the probability that the state will behave exactly the same as our desired state. Fidelity is an important property of a quantum system that allows us to quantify how much a particular state has been affected by noise from various sources (gate errors, channel losses, environment noise).
Interestingly, quantum applications do not need perfect fidelity to be able to execute -- as long as the fidelity is above some application-specific threshold, they will simply operate at lower rates. Therefore, rather than trying to ensure that we always deliver perfect states (a technologically challenging task), applications will specify a minimum threshold for the fidelity, and the network will try its best to deliver it. A higher fidelity can be achieved by either having hardware produce states of better fidelity (sometimes one can sacrifice rate for higher fidelity) or employing quantum error detection and correction mechanisms (see [
Mural16] and Chapter 11 of [
VanMeterBook]).
Conceptually, the most straightforward way to distribute an entangled state is to simply transmit one of the qubits directly to the other end across a series of nodes while performing sufficient forward Quantum Error Correction (QEC) (
Section 4.4.3.2) to bring losses down to an acceptable level. Despite the no-cloning theorem and the inability to directly measure a quantum state, error-correcting mechanisms for quantum communication exist [
Jiang09] [
Fowler10] [
Devitt13] [
Mural16]. However, QEC makes very high demands on both resources (physical qubits needed) and their initial fidelity. Implementation is very challenging, and QEC is not 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). Until then, quantum networks rely on entanglement swapping (
Section 4.4.2) and teleportation (
Section 4.3). This alternative relies on the observation that we do not need to be able 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].
Bell pair states are the entangled two-qubit states:
|00⟩ + |11⟩,
|00⟩ - |11⟩,
|01⟩ + |10⟩,
|01⟩ - |10⟩,
where the constant 1/sqrt(2) normalisation factor has been ignored for clarity. Any of the four Bell pair states above will do, as it is possible to transform any Bell pair into another Bell pair with local operations performed 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 their qubit alone in order to transform the state between the different variants.
Distributing a Bell pair between two nodes is much easier than transmitting an arbitrary quantum state over a network. Since the state is known, handling errors becomes easier, and small-scale error correction (such as entanglement distillation, as discussed in
Section 4.4.3.1), combined with reattempts, becomes a valid strategy.
The reason for using Bell pairs specifically as opposed to any other two-qubit state is that they are the maximally entangled two-qubit set of basis states. Maximal entanglement means that these states have the strongest non-classical correlations of all possible two-qubit states. Furthermore, since single-qubit local operations can never increase entanglement, states that are less entangled would impose some constraints on distributed quantum algorithms. This makes Bell pairs particularly useful as a generic building block for distributed quantum applications.
The observation that we only need to be able to distribute Bell pairs relies on the fact that this enables the distribution of any other arbitrary entangled state. This can be achieved via quantum state teleportation [
Bennett93]. Quantum state teleportation consumes an unknown qubit state that we want to transmit and recreates it at the desired destination. This does not violate the no-cloning theorem, as the original state is destroyed in the process.
To achieve this, an entangled pair needs to be distributed between the source and destination before teleportation commences. The source then entangles the transmission qubit with its end of the pair and performs a readout of the two qubits (the sum of these operations is called a Bell state measurement). This consumes the Bell pair's entanglement, turning the source and destination qubits into independent states. The measurement yields two classical bits, which the source sends to the destination over a classical channel. Based on the value of the received two classical bits, the destination performs one of four possible corrections (called the Pauli corrections) on its end of the pair, which turns it into the unknown qubit state that we wanted to transmit. This requirement to communicate the measurement readout over a classical channel unfortunately means that entanglement cannot be used to transmit information faster than the speed of light.
The unknown quantum state that was transmitted was never fed into the network itself. Therefore, the network needs to only be able to reliably produce Bell pairs between any two nodes in the network. Thus, a key difference between a classical data plane and a quantum data plane is that a classical data plane carries user data but a quantum data plane provides the resources for the user to transmit user data themselves without further involvement of the network.
Reducing the problem of quantum connectivity to one of generating a Bell pair has reduced the problem to a simpler, more fundamental case, but it has not solved it. In this section, we discuss how these entangled pairs are generated in the first place and how their two qubits are delivered to the end-points.
In a quantum network, entanglement is always first generated locally (at a node or an auxiliary element), followed by a movement of one or both of the entangled qubits across the link through quantum channels. In this context, photons (particles of light) are the natural candidate for entanglement carriers. Because these photons carry quantum states from place to place at high speed, we call them flying qubits. The rationale for this choice is related to the advantages provided by photons, such as moderate interaction with the environment leading to moderate decoherence; convenient control with standard optical components; and high-speed, low-loss transmissions. However, since photons are hard to store, a transducer must transfer the flying qubit's state to a qubit suitable for information processing and/or storage (often referred to as a matter qubit).
Since this process may fail, in order to generate and store entanglement efficiently, we must be able to distinguish successful attempts from failures. Entanglement generation schemes that are able to announce successful generation are called heralded entanglement generation schemes.
There exist three basic schemes for heralded entanglement generation on a link through coordinated action of the two nodes at the two 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 are 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 will transfer 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 is able to 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 is able to 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 in the other schemes, the nodes retain greater control over the entangled pair generation.
Note that whilst photons travel in a particular direction through the quantum channel the resulting entangled pair of qubits does not have a direction associated with it. Physically, there is no upstream or downstream end of the pair.
The problem with generating entangled pairs directly across a link is that efficiency decreases with channel length. Beyond a few tens of kilometres in optical fibre or 1000 kilometres in free space (via satellite), the rate is effectively zero, and due to the no-cloning theorem we cannot simply amplify the signal. The solution is entanglement swapping [
Briegel98].
A Bell pair between any two nodes in the network can be constructed by combining the pairs generated along each individual link on a path between the two end-points. Each node along the path can consume the two pairs on the two links to which it is connected, in order to produce a new entangled pair between the two remote ends. This process is known as entanglement swapping. It can be represented pictorially as follows:
+---------+ +---------+ +---------+
| A | | B | | C |
| |------| |------| |
| X1~~~~~~~~~~X2 Y1~~~~~~~~~~Y2 |
+---------+ +---------+ +---------+
where X1 and X2 are the qubits of the entangled pair X and Y1 and Y2 are the qubits of entangled pair Y. The entanglement is denoted with ~~. In the diagram above, nodes A and B share the pair X and nodes B and C share the pair Y, but we want entanglement between A and C.
To achieve this goal, we simply teleport the qubit X2 using the pair Y. This requires node B to perform a Bell state measurement on the qubits X2 and Y1 that results in the destruction of the entanglement between Y1 and Y2. However, X2 is recreated in Y2's place, carrying with it its entanglement with X1. The end result is shown below:
+---------+ +---------+ +---------+
| A | | B | | C |
| |------| |------| |
| X1~~~~~~~~~~~~~~~~~~~~~~~~~~~X2 |
+---------+ +---------+ +---------+
Depending on the needs of the network and/or application, a final Pauli correction at the recipient node may not be necessary, since the result of this operation is also a Bell pair. However, the two classical bits that form the readout from the measurement at node B must still be communicated, because they carry information about which of the four Bell pairs was actually produced. If a correction is not performed, the recipient must be informed which Bell pair was received.
This process of teleporting Bell pairs using other entangled pairs is called entanglement swapping. Quantum nodes that create long-distance entangled pairs via entanglement swapping are called quantum repeaters in academic literature [
Briegel98]. We will use the same terminology in this document.
Neither the generation of Bell pairs nor the swapping operations are noiseless operations. Therefore, with each link and each swap, the fidelity of the state degrades. However, it is possible to create higher-fidelity Bell pair states from two or more lower-fidelity pairs through a process called distillation (sometimes also referred to as purification) [
Dur07].
To distil a quantum state, a second (and sometimes third) quantum state is used as a "test tool" to test a proposition about the first state, e.g., "the parity of the two qubits in the first state is even." When the test succeeds, confidence in the state is improved, and thus the fidelity is improved. The test tool states are destroyed in the process, so resource demands increase substantially when distillation is used. When the test fails, the tested state must also be discarded. Distillation makes low demands on fidelity and resources compared to QEC, but distributed protocols incur round-trip delays due to classical communication [
Bennett96].
Just like classical error correction, QEC encodes logical qubits using several physical (raw) qubits to protect them from the errors described in
Section 4.1.3 [
Jiang09] [
Fowler10] [
Devitt13] [
Mural16]. Furthermore, similarly to its classical counterpart, QEC can not only correct state errors but also account for lost qubits. Additionally, if all physical qubits that encode a logical qubit are located at the same node, the correction procedure can be executed locally, even if the logical qubit is entangled with remote qubits.
Although QEC was originally a scheme proposed to protect a qubit from noise, QEC can also be applied to entanglement distillation. Such QEC-applied distillation is cost effective but requires a higher base fidelity.
Quantum networks have been categorised into three "generations" based on the error management scheme they employ [
Mural16]. Note that these "generations" are more like categories; they do not necessarily imply a time progression and do not obsolete each other, though the later generations do require technologies that are more advanced. Which generation is used depends on the hardware platform and network design choices.
Table 2 summarises the generations.
|
First generation |
Second generation |
Third generation |
Loss tolerance |
Heralded entanglement generation (bidirectional classical signalling) |
Heralded entanglement generation (bidirectional classical signalling) |
QEC (no classical signalling) |
|
|
|
|
Error tolerance |
Entanglement distillation (bidirectional classical signalling) |
Entanglement distillation (unidirectional classical signalling) or QEC (no classical signalling)
|
QEC (no classical signalling) |
Table 2: Classical Signalling and Generations
Generations are defined by the directions of classical signalling required in their distributed protocols for loss tolerance and error tolerance. Classical signalling carries the classical bits, incurring round-trip delays. As described in
Section 4.4.3.1, these delays affect the performance of quantum networks, especially as the distance between the communicating nodes increases.
Loss tolerance is about tolerating qubit transmission losses between nodes. Heralded entanglement generation, as described in
Section 4.4.1, confirms the receipt of an entangled qubit using a heralding signal. A pair of directly connected quantum nodes repeatedly attempt to generate an entangled pair until the heralding signal is received. As described in
Section 4.4.3.2, QEC can be applied to complement lost qubits, eliminating the need for reattempts. Furthermore, since the correction procedure is composed of local operations, it does not require a heralding signal. However, it is possible only 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 improved error tolerance, but it incurs round-trip delays due to the requirement for bidirectional classical signalling. The alternative, QEC, is able to correct state errors locally so that it does not need any classical signalling between the quantum nodes. In between these two extremes, there is also QEC-applied distillation, which requires unidirectional classical signalling.
The three "generations" summarised:
-
First-generation quantum networks use heralding for loss tolerance and entanglement distillation for error tolerance. These networks can be implemented even with a limited set of available quantum gates.
-
Second-generation quantum networks improve upon the first generation with QEC codes for error tolerance (but not loss tolerance). At first, QEC will be applied to entanglement distillation only, which requires unidirectional classical signalling. Later, QEC codes will be used to create logical Bell pairs that no longer require any classical signalling for the purposes of error tolerance. Heralding is still used to compensate for transmission losses.
-
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. Furthermore, this also enables direct transmission architectures in which qubits are forwarded end to end like classical packets rather than relying on Bell pairs and entanglement swapping.
Despite the fact that there are important distinctions in how errors will be managed in the different generations, it is unlikely that all quantum networks will consistently use the same method. This is due to different hardware requirements of the different generations and the practical reality of network upgrades. Therefore, it is unavoidable that eventually boundaries between different error management schemes start forming. This will affect the content and semantics of messages that must cross those boundaries -- for both connection setup and real-time operation [
Nagayama16].
Eventually, the Bell pairs must be delivered to an application (or higher-layer protocol) at the two end nodes. A detailed list of such requirements is beyond the scope of this document. At minimum, the end nodes require information to map a particular Bell pair to the qubit in their local memory that is part of this entangled pair.