Resource Estimation for Delayed Choice Quantum Entanglement Based Sneakernet Networks Using Neutral Atom qLDPC Memories

The second Quantum Revolution refers to a future technological period when all the features of quantum mechanics are harnessed for information processing devices, expanding beyond the limited application of quantum mechanics in current computers, communication systems, and sensors Dowling and Milburn (2003); Deutsch (2020); Jaeger (2018); Atzori and Sessoli (2019); Rohde (2021a). The ultimate achievement of this revolution is embodied by quantum computers that are capable of operating on a vast scale, with the ability to tolerate faults and fix errors. These computers would need millions or more logical qubits Riel (2021) to tackle complex cryptographic tasks. While the creation of such devices remains in its early stages, there are compelling grounds to anticipate that scalable quantum computers will become tangible at some point within this century Gambetta (2020).

While there is reason to be hopeful about the progress of large-scale quantum computers, it remains uncertain if quantum computers for everyday consumers, such as a quantum smartphone, will ever become feasible. This refers to a compact and powerful computational device that is connected to a quantum network, possibly on a global scale. Possible constraints that could prevent the development of quantum smartphones include the requirement for extremely low temperatures to cool down qubits Gardiner and Zoller (2015), or the necessity for optical communication channels O’brien (2007) instead of microwave ones to connect to the quantum internet, the vulnerability of qubits to mechanical vibrations and the impact of the Earth’s magnetic field Körber et al. (2018). Suppose we accept the possibility of large-scale quantum computers and a quantum internet. In that case, it is logical to enquire how a customer, who has no access to a quantum memory, but only has access to conventional gear such as classical detectors, classical memory, and classical computing, can participate in and perform complex quantum protocols.

One way is to do this by the use of distributed quantum entanglement Perseguers et al. (2013). Quantum entanglement is a pivotal phenomenon that forms the basis of various protocols in quantum communications and quantum computing Rohde (2021b); Nielsen and Chuang (2001); Horodecki et al. (2009); Wehner et al. (2018); Kimble (2008); Cacciapuoti et al. (2019). Due to it being a major primitive for most quantum tasks, it would be natural to consider quantum entanglement as a tradeable commodity, such that users can purchase it to establish connections with other users in the network to perform quantum tasks such as quantum key distribution, distributed quantum computing, quantum authentication, etc. Commoditizing entanglement is an essential step toward large-scale commercial quantum networks.

To better demonstrate the above-mentioned ideas of entanglement commercialization and quantum access to common users with classical hardware, we design and analyse an entanglement one-time-pad QKD Sharma and Kumar (2019) based quantum network model networked using delayed-choice entanglement swapping Peres (2000). In this study, we demonstrate that delayed-choice entanglement swapping enables customers, who only own classical hardware, to use the offerings of a hypothetical future quantum memory company for the purpose of generating secure quantum keys. These keys are based on the E91 protocol Ekert (1991). Our design employs a central party Charlie, who generates Bell-pairs, loads the halves separately onto different qLDPC codes, and distributes one set of the halves via sneakernet Devitt et al. (2016); Zhong et al. (2015) to multiple endpoints where it is immediately measured upon arrival while keeping the other set of halves to himself on which he later performs Bell measurements to generate correlations between the endpoint measurements of any pair of users. This enables the users to execute this task in a versatile manner by pre-purchasing their key bits prior to selecting their communication partners. This protocol is beneficial for creating secure connections between networks of devices that have minimal hardware needs but can interact with a single, advanced quantum node or several nodes.

We design our protocol on quantum Hyper Graph Product (HGP) codes Tillich and Zémor (2013), which are a class of Low-Density Parity-Check (qLDPC) codes Breuckmann and Eberhardt (2021) for quantum error correction Lidar and Brun (2013), implemented on a neutral atom architecture Henriet et al. (2020); Xu et al. (2024). These codes offer significant advantages over traditional surface codes Fowler et al. (2012) in terms of encoding rate and resource efficiency Bravyi et al. (2024); Xu et al. (2024). Our analysis provides a detailed comparison between qLDPC and surface codes, demonstrating that qLDPC codes allow us to achieve higher logical qubit counts with fewer physical qubits as they have constant encoding rates regardless of patch size. This property potentially reduces the hardware requirements and improves the scalability of our proposed system. We have selected neutral atoms as our physical platform, as their ability to shuttle and rearrange within the lattice enables selective qubit unloading and efficient syndrome extraction Xu et al. (2024). This capability also allows us to use only one set of ancilla qubits and a single surface code patch, positioned adjacent to the qLDPC code block, for both loading and unloading operations via teleportation Xu et al. (2024).

The foundation of our study is based on the research conducted on consumer-level quantum key distribution Zhang et al. (2018); Lowndes et al. (2021); Duligall et al. (2006), as well as the research on quantum sneakernet Devitt et al. (2016), which explores the spread of entanglement across long distances with high bandwidth and low latency. While our primary focus is on secure communication protocols, it is feasible to adapt our methodology for many applications such as quantum voting Vaccaro et al. (2007), clock synchronization Giovannetti et al. (2001), and reference frame alignment Bagan et al. (2004).

This study is organized as follows: In section II, we briefly describe the phenomenon of delayed choice entanglement swapping. In section III, we describe our design. Section IV derives the closed-form mathematical expressions necessary for our resource estimations. In section V we discuss our findings, and finally conclude our study in section VI. Link to the python code of our analysis is here: https://shorturl.at/QZ9v7.

To describe our protocol, we start by providing a concise overview of the initial delayed-choice entanglement-swapping technique, as explained by Peres Peres (2000). In accordance with Peres, we examine the most basic iteration of this protocol. This protocol aims to establish entanglement and eventually generate correlated bits between two parties, Alice and Bob, who choose a third party, Charlie, to mediate the entanglement generation. Consider three individuals, namely Alice, Bob, and Charlie, as seen in the circuit diagram in Figure 1.

Two Bell Pairs $q_{1}q_{2}$ and $q_{3}q_{4}$ are present such that $q_{1}$ is in the custody of Alice, $q_{4}$ with Bob, and $q_{2}$ and $q_{3}$ with Charlie. Qubits $q_{1}$ of Alice and $q_{4}$ of Bob get entangled when Charlie performs a joint Bell-measurement on his qubits $q_{2}$ and $q_{3}$. However, the specific relationship between Alice and Bob’s qubits cannot be known until Charlie reveals the outcome of his Bell state measurement. Alice and Bob’s photons are perfectly entangled, disregarding any errors or decoherence. This exact entanglement allows them to be used for various entanglement-based protocols, such as cryptography using the E91 protocol Ekert (1991).

Alternatively, Charlie has the option to measure his photons separately. By adopting this approach, there would be a complete absence of entanglement between the photons belonging to Alice and Bob. Consequently, any correlations seen would be purely coincidental and not indicative of any underlying connection. If Charlie attempted to conceal his independent measurements, Alice and Bob might easily expose the deceit by using the conventional method of conducting measurements and announcing certain findings subsequent to receiving Charlie’s ’correction’ signals.

Peres’ idea goes beyond entanglement swapping by recognizing that Alice, Bob, and Charlie might potentially be space-like separated. This suggests that one can discover a frame of reference when the sequence of qubit measurement is modified, as shown by the Gisin group Zbinden et al. (2001). In the preceding discourse, we used the assumption that Charlie conducted his measurement before Alice and Bob did. Alternatively, it is possible for Alice and Bob to conduct their measurements prior to Charlie (Figure 1(b)). In this scenario, the outcome of their measurements itself is not affected by whether or not Charlie performed either the Bell state or independent measurement, but the degree of correlation between Alice and Bob’s measured bits is dependent upon the kind of measurement performed by Charlie. This serves as the foundation for the delayed-choice entanglement-swapping protocol and is crucial for the advancement of our ideas. In the delayed-choice entanglement swapping technique, Alice and Bob perform measurements on their qubits and record the outcomes using classical storage. At a later point, Charlie has a decision to either measure his qubits separately or do a Bell state measurement. The measurement outputs are either associated in a known manner or wholly uncorrelated, depending on the measurement option chosen by Charlie and the random basis choice of Alice and Bob.

We now assume that Charlie is replaced by a company Charlie Inc. whose business is to store and distribute entangled states. This requires Charlie Inc. to have large-scale long-lived quantum memory and a means of distributing entangled states. Our protocol is detailed in Figure 2.

and is also described concisely in pseudocode 1. Charlie Inc., acting as a central node, first prepares Bell pairs in surface codes and teleports each half into separate qLDPC code blocks. This is done because direct computations and measurements for qLDPC codes are not yet well defined at the time of this writing. Charlie Inc. then keeps one set of neutral-atom encoded qLDPC blocks and sends the other set to an end-user via physical transport, like a train or a truck. This process is done for several such end-users at different destinations. This is called the ”sneakernet” method. At the user’s end, the user purchases a certain number of bits based on their needs. At the user’s end, a quantum ATM (qATM) “unloads” the incoming qLDPC blocks by sequentially teleporting the constituent qubits onto a surface code, followed by measuring the surface code randomly in X or Z bases, and commercially selling the resulting classical bits to users, which is in turn stored in a device belonging to the user, such as a smartphone. For our analysis, we assume that the process of transferring classical bits onto the end-users’ classical devices is secure. The measurement bases are then made public.

Among several end-users in the network, let’s say two of them, namely Alice and Bob, want to connect at a later time. They decide upon how many bits they need to correlate for their requirement. Charlie Inc. then converts the corresponding logical qubits in the qLDPC blocks on his end into surface code patches and performs Bell measurements on those patches, thereby correlating Alice and Bob’s bits. Finally, Alice and Bob use their correlated bits to generate a draft encryption key. Depending on their security requirement, they can enhance the key’s security using CHSH tests Clauser et al. (1969) and privacy amplification, sacrificing some bits in the process. The remaining bits form a secure encryption key for end-to-end message encryption. This approach turns entanglement into a tradeable commodity and allows users with only classical hardware to participate in quantum cryptography protocols. For example, Alice measures a number of qubits, labeled ${A_{1},A_{2},...,A_{n}}$ and informs Charlie Inc. which qubit measurement results she now owns. Charlie Inc. then records the owner of the qubits and stores the other half of the Bell pairs in long-term quantum storage. Similarly, Bob buys the rights to measure qubits ${B_{1},B_{2},...,B_{n}}$ and Dave buys the rights to measure qubits ${D1,D_{2},...,D_{n}}$. At this stage, neither participant has decided who they wish to exchange correlations with, they have simply ‘topped up’ their future quantum potential i.e. the bits with which they can perform an unconditionally secure one-time-pad with another user of their choice in the future. If Alice and Dave wish to generate entangled data for some protocol, then they need to publicly declare to Charlie Inc. how many topped up bits they want to have correlated, then Charlie Inc. performs the entanglement swap between the appropriate (stored) Bell pairs and broadcasts the measurement results. If Alice and Dave wish to check Charlie Inc.’s fidelity, they may sacrifice some of their bits, and assuming they are satisfied, can proceed with standard key distillation and privacy amplification Bennett et al. (1995). If Alice then wishes to share secrets with Bob, then again, she need only declare to Charlie Inc. how many bits she wants to correlate (of course, she cannot use measurement results that have previously been used with Dave), and proceed as before.

In this section, we derive closed-form expressions for logical failure rates, time scales, and logistics concerning the protocol. For our analysis, we consider city-wide and district-wide distances, hence we will be considering trucks or train cars for transport of quantum memories. We consider both trucks and train cars to be equivalent in carrying capacity, transport speeds, etc., and may tend to use the terms interchangeably. Throughout this section, we consider the processes and operations occurring in the quantum error-corrected qLDPC memories as they go through all the stages (loading, transport, and unloading) of the protocol.

For our encoding, we select the quantum codes constructed from the hypergraph product of classical codes based on (3, 4)-regular bipartite graphs with strong expansion properties Xu et al. (2024). These graphs are selected randomly, and the resulting quantum codes exhibit a minimum encoding rate of 1/25.

Rearrangement of atoms: For a $\big{[}[n,k,d]\big{]}$ hypergraph product (HGP) code where $n$ is the number of physical qubits, $k$ is the number of logical qubits, and $d$ is the code distance, each syndrome extraction (SE) cycle takes $8t_{r}$ seconds Xu et al. (2024), where the factor 8 represents the number of atomic rearrangements needed to complete one error correction cycle, and $t_{r}$ is the time required to move the atomic qubits around for one rearrangement Xu et al. (2024). We express $t_{r}$ as a function of $n$, given by:

where $\tau_{t}=50\mu s$, $a_{p}=0.02\mu m\mu s^{-2}$, $d_{p}=5\mu m$, and $L\approx\sqrt{n}$. The gate times of neutral atom architectures are in the order of microseconds Wintersperger et al. (2023) while $t_{r}$ is in the order of several milliseconds. Therefore $t_{r}$ becomes the dominant rate-limiting time scale and the gate times can be ignored while computing neutral atom qLDPC cycle times.

Logical Failure Rates (LFRs):The Logical Failure Rate (LFR) $R_{L}$ per error correction cycle for a [$n$, $k=n/25$, $d=\sqrt{k}$] HGP code is given by Xu et al. (2024):

where $p_{g}$ is the physical gate error and $n$ is the number of physical qubits, $k=n/25$ is the number of logical qubits, and $d=\sqrt{k}$ is the code distance. RefXu et al. (2024) considers HGP codes such that $k=n/25$ and $d=\sqrt{k}=\sqrt{n}/5$. We consider this configuration as well in our analysis. Similarly, the Logical Failure Rate (LFR) $R_{S}$ per error correction cycle for a surface code of distance $d_{sc}$ is given by Devitt et al. (2016):

Let $n_{a}$ be the number of physical qubits in the ancilla HGP code. Let $n_{t}$ be the number of physical qubits in the qLDPC memory to be transported. Let $n_{c}$ be the number of physical qubits in the qLDPC memory of Charlie Inc.. We make two key assumptions in our analysis. First, we consider the number of physical qubits in Charlie Inc.’s qLDPC memory ($n_{c}$) and the transported qLDPC memory ($n_{t}$) to be equal, denoting both as $n_{m}$, where ’m’ stands for memory. Secondly, we consider the distance of the computational surface code ($d_{sc}$) as a function of the qLDPC memory size, specifically $d_{sc}=\sqrt{n_{m}}/5$, as used by the analysis in Xu et al. (2024).

Throughout our derivations, we use the following binomial approximation:

This approximation is valid due to the logical failure rates being much lower than 1, due to which logical errors can be propagated via simple addition.

Initialization of qLDPC code patches: First, Charlie Inc. needs to initialize two qLDPC patches, one ($C$) for his memory and the other ($T$) for transporting to the destination node. The Logical Failure Rate (LFR) $R_{0}$ for this is given by:

Here $d=\sqrt{n_{m}}/5$ is the code distance, which is also the number of error-correction cycles, and $R_{L}(n_{m})$ is the LFR per error correction cycle. We assume that these memories are initialized in parallel with the previous memory batch being loaded onto the truck. Therefore, we do not count it into our time scales.

Bell Pair Creation: Next step, we need to create a Bell-pair. Now, For creating a single Bell Pair, we need two surface codes and $2\frac{\sqrt{n_{m}}}{5}$ error-correction cycles. The Logical Failure Rate (LFR) $R_{1}$ for this is given by Leone et al. (2023); Devitt et al. (2016):

Since loading the current bell pair and creating the next bell pair are done simultaneously, we don’t count this time scale.

Loading of the Bell Pair: For the loading of both halves of the surface-coded Bell-Pair onto their respective qLDPC patches $C$ and $T$, we need to teleport it from the surface code to the HGP patch via an ancilla HGP. The ancilla HGP is of the configuration $\big{[}[n_{a}=n_{m}/25,k=1,d=\sqrt{n_{a}}]\big{]}$. For the teleportation, we need first to initialize the ancillae. then we need to do two lattice surgery procedures, one merge-and-split between the surface code and the ancilla HGP patch, and another between the ancilla HGP and the qLDPC patches. the LFR for loading onto the transport qLDPC is given by:

where the first term is for the ancilla initialization involving $d=\sqrt{n_{a}}$ rounds of error correction, the second term is for lattice surgery between surface code and ancilla involving $d=\frac{\sqrt{n_{m}}}{5}$ error correction cycles, with LFR per cycle for the surface code being $R_{S}$ and that of the ancilla HGP being $R_{L}(n_{a})$, and the third term is for that of ancilla and the memory patch. The patch sizes are chosen in such a way that all three patches (memory, ancilla, and the surface code) have the same code distance, and hence require the same number of error correction cycles. Here the $\frac{n_{m}}{25}$ factor appears since the first loaded qubit will undergo these sets of loading QEC cycles $\frac{n_{m}}{25}$ times, which propagates its error. The term 2 arises because we need to teleport two halves of the Bell-pair, one to the transport memory $T$ and the other one to Charlie Inc.’s memory $C$. The time $T_{2}$ required for this is given by:

where $t_{cyc}=8t_{r}$ is the time taken to complete one error correction cycle. Here we combine parallel cycles, such as that happening simultaneously on surface code and ancilla, and on the ancilla and the qLDPC memory.

Storage and Transport: Let’s say the destination node is $T_{3}$ units of time drive from Charlie Inc.. Throughout the transit, $M_{t}=\frac{T_{3}}{T_{cyc}(n_{m})}$ number of error correction cycles happen on the transport memory $T$. The LFR $R_{3}$ occurring during the transport is given by:

Unload and Measure at qATM: Once the transport memory arrives at a qATM in the destination node, we need to initialize the surface code and the ancilla, and then sequentially teleport the logical qubits from the qLDPC to the surface code via the ancilla, and measure the surface code qubit. The LFR for this is given by:

This is similar to Eq. IV, with an additional term $R_{S}$ in the end which is the 1-round LFR that occurs due to measurement. The time taken for this is:

Measuring a surface-code logical qubit involves one round of error correction. The depth of a surface-code syndrome extraction is 6 and the physical gate time of the architecture is given by $t_{g}$. Hence the last term.

Now, the total network LFR $R_{net}$ of the processes so far, and the total time $T_{tot}$ taken for generating this correlation is:

Unload and Bell-measure at Charlie Inc.’s end: Now we have two such half-measured Bell-Pairs distributed between the network pairs Charlie Inc.-Alice and Charlie Inc.-Bob. So we have two memory drives, one each for each network pair. Let’s say at a later time $T_{later}$, Alice and Bob decide to correlate their bits. For calculation purposes, we assume that this decision has been made by the time $T_{later}=T_{tot}$. We assume that by this time, the end users Alice and Bob have decided to communicate with Charlie Inc. and have informed him accordingly. Let the total number of error correction cycles $M_{tot_{c}}$ be done by Charlie Inc.’s memory drives during this time. This is given by $M_{tot_{c}}=T_{later}/t_{cyc}(n_{m})$. Since we have two drives, the LFR $R_{store}$ is given by:

The factor of 2 occurs because there are two memory drives. Now the qubits need to be teleported onto surface code via an ancilla. The LFR $R_{unload}$ of that is given by:

Now for Bell-Measurement, we require $4\frac{\sqrt{n_{m}}}{5}$ QEC cycles Horsman et al. (2012). The LFR $R_{BM}$ for this is given by:

This generates a correlation between Alice and Bob.

Total LFR: So, therefore, the LFR $R_{tot}$ of the overall final correlation between end users Alice and Bob is given by:

And the fidelity $F_{final}$ of this correlation is given by:

Logistics: Logical Bit-rate $r_{L}$ per qLDPC block is given by:

This is the number of logical qubits from the qLDPC block unloaded and measured per unit time. It takes $T_{4}$ amount of time to unload one entire qLDPC patch consisting of $\frac{n_{m}}{25}$ logical qubits.

Let $r_{e}$ be the desired target E-Bit rate. Then, the number $N$ of parallel qLDPC blocks required to achieve $r_{e}$ is given by $N=r_{e}/r_{L}$. The blocks get depleted every $T_{4}$ units of time. Therefore, we need to replace $N$ blocks every $T_{4}$ units of time. Let’s say a truck or a train car has the carrying capacity of $B$ blocks, where $B=n_{t}/n_{m}$ where $n_{t}$ is the total number of physical qubits the truck or train car can carry. We need $N/B$ trucks to be released by Charlie Inc. every $T_{4}$ units of time, for one qATM destination. if we are assuming $S$ number of qATM destinations, then the number of trucks $n_{truck}$ released by Charlie Inc. every $T_{4}$ units of time is given by $n_{truck}=SN/B$.

The life-cycle of a truck involves $T_{2}$ units of time to load the qLDPC patches, $T_{3}$ time to transit, $T_{4}$ time to unload and get the logical qubits measured, and $T_{3}$ again to move back to Charlie Inc.’s hub for the next round. So, the total number of trucks $N_{truck_{tot}}$ required for the whole network to run continuously is given by:

The required E-bit rate ($r_{e}$), or bandwidth, is a critical parameter in our system design. Contemporary communication standards provide context for our bandwidth requirements. For instance, voice communications necessitate 87 kbps, standard definition video conferencing requires 128 kbps, and high-definition video conferencing demands up to 4 Mbps voi . In the realm of text messaging, an average SMS of 120-160 characters consumes approximately 16,000 bits sms , which we consider for our analysis. Note that this is somewhat contrived, but it gives us an anchor to do our analysis. To determine $r_{e}$, we consider several factors: the frequency of one-time pad recharging, the practical time a user might wait at a quantum ATM while recharging ($t_{wait}$), and the average number of bits needed between refills ($b_{req}$). The number of end-users at a destination ($n_{users}$) is constrained by the number of available time slots in a day, calculated as 86,400 seconds divided by $t_{wait}$. Consequently, we express $r_{e}$ as $b_{req}/t_{wait}$.

We estimate $r_{e}$ for SMS usage as an illustrative example. Assuming an average person sends 85 texts daily avg , each requiring 16,000 bits, we calculate $b_{req}$ as $85\times 16,000=1,360,000$ bits. With a $t_{wait}$ of 10 minutes (600 seconds) every day, $r_{e}$ equals 1,360,000/600 = 2.3 kbps or 2.3 KHz.

The gate error rate $p_{g}$ for neutral atom architectures varies from $0.01$ to $0.05$. We take $p_{g}=0.01$ as a near-term realizable optimistic estimate. Unlike most other architectures, neutral atoms have significantly slower 1-qubit gates than 2-qubit gates. Hence we take the 1-qubit gate time $t_{g}=2\mu s$ Wintersperger et al. (2023). Considering the form factor of Pasqal’s processor pas and their claim of producing a $10^{4}$ qubit unit by 2026, we take a rough estimate for our calculations that any truck or train car in the near future can carry a total of $n_{t}=1,000,000$ physical qubits. We also set the number of qATM destinations $S=5$. In this article, we assume intra-metropolitan distances, with typical transport times ranging from one to three hours. We take the teleportation ancilla HGP patch size $n_{a}=\frac{n_{m}}{25}$ because it maintains the same distance as the qLDPC code and the surface code, and its edge is as wide as the size of the logical operators in the qLDPC code Xu et al. (2024).

From Figure 3,

we can see that to achieve a lower total logical error rate $R_{tot}$, we need larger qLDPC patches. Larger patches have greater code-distance, hence higher tolerance to errors. To achieve greater than 80% fidelity (i.e. $R_{tot}<0.2$), we need patch sizes of at least about 35,000 physical qubits (1400 logical qubits). Patch sizes over 53,000 physical qubits (2120 logical qubits) can achieve fidelities of over 90% while 80,000-qubit-sized patches (3200 logical qubits) can give greater than 95% fidelity. Higher the fidelity, lower is the number of bits wasted for standard reconciliation and privacy amplification, and with fidelities over 95%, this number becomes negligible Bennett et al. (1992). Pasqal, an enterprise dealing with neutral atom quantum architectures, claims that devices with a capacity of 10,000 physical qubits will be a reality in the next couple of years pas , so it would be reasonable to assume larger patch sizes of the order of high $10^{4}$ physical qubits to be achievable in the next few years.

From Figure 4,

we can observe that the protocol can tolerate longer transport times $T_{3}$ with larger patch sizes. This is because larger patch sizes have greater logical error tolerance, and hence can be transported to longer distances. It can also be observed that the plot truncates below a certain patch size when the value of $T_{3}$ comes down to zero. This is because, for any $n_{m}$ below that patch size, all terms in $R_{tot}$ except the $R_{3}$ term push the $R_{tot}$ greater than the target error rate. Due to this, the solver function in our plot code plugs in a negative $T_{3}$ to pull down the $R_{tot}$ to match the target. This means that the target $R_{tot}$ is not achievable for patch sizes below this cutoff size. From both protocols, we see that the error rate $R_{tot}$ increases with an increase in transport time due to a greater number of error correction cycles.

From Figure 5,

we can see that for a given transport time (90 minutes here), the number of trucks or train cars required reduces with an increase in the tolerable error rate $R_{tot}$ of the network. This is because the greater the tolerable error rate $R_{tot}$, the smaller the patch size. Smaller patch sizes are of lower code distances and hence require fewer rounds of error correction. This translates to faster unloading times, requiring a lesser number of patches in parallel, and ultimately requiring a lower number of trucks. For fidelities below 95% (i.e. $R_{tot}>0.05$), we can run this network with under 10,000 trucks for 2300 Hz bandwidth. This is comparable to the total number of buses or train cars in an average city public transport.

Figure 6

compares the qLDPC network with the corresponding surface-code network, in terms of number of trucks, and additionally, table 1 also lists the operational unit economics $C_{o}$ in terms of the cost per bit, which is a combination of transportation cost $C_{t}$ and the cost $C_{q}$ of maintaining the quantum infrastructure i.e.:

The transport cost $C_{t}$ calculated as follows:

where $R_{h}$ is the hourly rent of one truck, which we assume to be USD $150, $N_{truck_{tot}}$ is as described in Eq. 19, $r_{e}$ is the E-bit rate or the bandwidth of the network, and $S$ is the number of network nodes or end-stations. Next, the total cost $C_{q}$ of maintaining the quantum infrastructure is given by:

where $C_{m}$ is the yearly cost of maintaining a single qLDPC memory patch containing $n_{m}$ physical qubits. The numerator represents the yearly cost of maintaining all the qLDPC memory patches in the network, where the factor 2 arises from the fact that we are dealing with Bell-pairs, and $n_{t}/n_{m}$ is the number of quantum computer units on a truck. The denominator represents the number of bits emenated per year by the network. We consider an estimate of $C_{m}=\$2,000,000$ per year per quantum device unit qub . For surface codes, the quantity $n_{m}$ would represent the number of physical qubits in a single quantum device, which would contain multiple surface code patches. We keep $n_{m}$ same for both qLDPC and surface codes.

The number of transport vehicles required by the qLDPC network is one order of magnitude lower than the number of vehicles required by the surface code protocol, and so is the cost. For example, for a minimum fidelity of $0.92$, patch size $n_{m}=60,000$, and a transit time of 90 minutes, the qLDPC network requires 7444 vehicles to run and costs $C_{o}=$USD $1.40 per bit, whereas an equivalent surface code requires 31920 vehicles and costs $C_{o}=$USD $5.99 per bit, about 4 times more. This is due to the constant encoding rates of qLDPC codes regardless of the tolerable logical error rate, unlike surface codes whose encoding rate worsens with the required tolerable logical error rate.

High number of trucks and consequently high costs per qubit are both mainly attributable to the fact that neutral atom architectures have their physical qubits sparsely spaced in the lattice, and their gate execution times are relatively slow. If we can implement qLDPC codes on faster, more condensed architectures in the future, such as the silicon quantum dot qubits for example Eriksson et al. (2013), we can potentially reduce the number of trucks and consequently the cost per bit by about 3 orders of magnitude.

Our analysis shows that in the near term, it is possible to build a multi-node Delayed-choice network, all separated by intra-metropolitan distances (with transport times of one to three hours), with a central Charlie Inc. who uses $O(10^{3})$ vehicles to transport and sell entanglement-based correlations to end-users with classical hardware (such as a smartphone) at the end nodes. Assuming that Charlie Inc. has the requisite quantum memory and storage, and it is possible to distribute entanglement at a rate faster than the entanglement consumption, then many end-users can top up their results on classical storage devices, and use them at their convenience, topping up as required. This commodifies entanglement, paving the way to large-scale commercial quantum networks catering to users with non-quantum hardware. The qLDPC codes, with their compact constant encoding rates, play a major role in establishing this feasibility.

In our analysis, we adopt certain conventions and assumptions based on recent research in quantum error correction codes. The relationship between the number of physical qubits in Low-Density Parity-Check (qLDPC) memory and Surface Code is a key consideration. We assume that a qLDPC memory with $n_{m}$ physical qubits is connected to a surface code with $n_{m}/25$ physical qubits for teleportation. This ratio is consistent with the simulations presented in ref. Xu et al. (2024), although it is not explicitly stated as a requirement. While it is theoretically possible to use surface codes of various sizes, we adhere to this ratio for consistency with existing literature.

Regarding the teleportation scheme for transferring logical qubits between qLDPC and surface codes, our analysis focuses on Hypergraph Product (HGP) codes. RefXu et al. (2024) specifically defines this teleportation scheme for HGP codes, but not for Lifted Product (LP) codes. While it may be possible to extend this scheme to LP codes, such an extension would require additional assumptions about the ability to generate logical X operators at the edge of the patch. To maintain rigor and avoid unsubstantiated claims, we restrict our analysis to HGP codes, for which the teleportation scheme is well-defined. This decision ensures that our results are based on established protocols and avoids potential inaccuracies that could arise from extrapolating beyond the current state of knowledge in the field. Designing a teleportation protocol for these other non-HGP qLDPC code families can reduce patch sizes by a factor of two to four, reducing our resource requirements.

Another caveat is that of classically transferring measurement results onto the users’ smartphones. In future research, if a protocol can be devised to teleport the logical qubits of a quantum error-correcting code patch onto a single photon, then photon measurement device can be built into smartphones, which makes the transfer quantum-secure. An alternate way, as outlined in the pseudocode 2 is to perform a heralded qubit transfer from each atomic physical qubit on the surface code to a photon Kalb et al. (2015); Covey et al. (2023) and measure those photons on the end-user’s smartphone Lowndes et al. (2021) in a pre-defined sequence and decode to extract the logical surface-code measurement, but this method has only 0.88 fidelity and 0.69 efficiency Kalb et al. (2015), which when propagated over all the atoms of a single surface code, would lead to high failure rates and high resource overheads. Therefore, development of a more efficient method of performing atom-to-photon qubit transfer would be beneficial towards a highly secure network with minimal resource overhead.

With this kind of network, one can easily imagine creating new symmetric keys between multiple users, for example, a consumer who wishes to secretly share her banking details with a large number of different vendors, all via guaranteed entanglement-generated quantum keys. We have so far considered a single Charlie Inc., with one long-term mass storage and qATMs distributed in the field. However, as long as Charlie Inc. has set up pre-existing and refreshed entanglement, there is no reason why it is not possible for Charlie Inc. to have multiple long-term quantum memory sites in geographically distinct locations, which we term quantum hubs. With a constant refresh of entanglement between Charlie Inc.’s hubs, in principle, global scale links could be achieved with additional entanglement-swapping operations.