⚛️ quantum physics

Dimensioning of Quantum Memories for Distilled Quantum EPR Packets

This paper proposes a Markov chain-based framework for dimensioning quantum memories to store distilled EPR pairs, providing analytical tools and design principles to optimize memory architectures for preserving high-fidelity entanglement in future quantum Internet infrastructures.

Original authors: Lorenzo Valentini, Diego Forlivesi, Andrea Talarico, Marco Chiani

Published 2026-04-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Lorenzo Valentini, Diego Forlivesi, Andrea Talarico, Marco Chiani

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: Building a Quantum Internet

Imagine the future Quantum Internet. Unlike our current internet, which sends bits (0s and 1s) like letters in a postcard, the Quantum Internet sends qubits. These are like magical, spinning coins that can be heads, tails, or both at the same time.

To make this work, we need Entanglement. Think of entanglement as a "telepathic link" between two coins. If you flip one in New York, the other instantly knows what happened in Tokyo, no matter the distance. These linked pairs are called EPR pairs.

However, there's a problem:

They are fragile: Like a soap bubble, these links break easily due to noise and interference.
They are imperfect: When we create them, they aren't 100% perfect. They are "dirty."
We need them in bulk: To do complex tasks (like secure banking or super-fast computing), we don't just need one link; we need a whole packet of them, ready to go at the same time.

The Core Problem: The "Dirty" Warehouse

The authors are asking a very practical question: How big does our "Quantum Warehouse" (Memory) need to be?

Imagine you are running a factory that makes high-quality glass (perfect entangled pairs).

The Input: You receive raw, cloudy glass (imperfect EPR pairs) from a supplier.
The Process: You have a machine that can polish two cloudy pieces of glass to make one clear piece. This is called Distillation.
- Catch 1: The machine isn't perfect. Sometimes it fails, and you lose the glass.
- Catch 2: You can only polish them in pairs. If you have 7 cloudy pieces, you can only polish 6 of them, leaving 1 behind.
The Output: You need to send out a specific number of clear, perfect glasses (consumption) every hour to keep your customers happy.
The Goal: You need to figure out how many shelves (memory size) you need in your warehouse to ensure you never run out of clear glass, even when the polishing machine has a bad day.

The Solution: A "Crystal Ball" for the Warehouse

The authors created a mathematical model (a Markov Chain) to act as a crystal ball. Instead of guessing, they can calculate the exact probability of running out of stock.

Here is how their model works, step-by-step:

1. The Three-Step Dance (Every Round)

Every time the system takes a "breath" (a time round), three things happen:

Polishing (Distillation): They take pairs of cloudy glass and try to polish them into clear glass. Some succeed, some fail.
Shipping (Consumption): They take the best, clearest glass available and ship it out to the customer.
Restocking (Refilling): They immediately fill the empty shelves with new raw, cloudy glass so the warehouse is always full.

2. The "Bootstrap" Strategy (The Waiting Game)

What if you need to ship out 13 perfect glasses at once, but your warehouse is small?

The Problem: If you start shipping immediately, you might run out of clear glass before you can polish enough new ones.
The Solution: The authors suggest a Bootstrap Protocol. This is like telling your factory: "Stop shipping for a few days. Just keep polishing and restocking."
The Trade-off: You wait a little longer (latency), but you build up a huge stockpile. This means you can use a smaller warehouse to achieve the same reliability. It's the difference between having a tiny pantry and cooking every night vs. having a small pantry but meal-prepping for the whole week on Sunday.

Why Does This Matter?

This paper provides the blueprint for engineers building the Quantum Internet.

Without this: Engineers might build a warehouse that is too small (causing the network to crash when they run out of links) or way too big (wasting billions of dollars on expensive quantum memory).
With this: They can calculate the exact number of "shelves" needed based on how good their raw materials are and how fast they need to ship products.

The Takeaway Metaphor

Think of the Quantum Internet as a high-end coffee shop.

Raw EPR Pairs are unroasted coffee beans (they taste bad).
Distillation is the roasting process (turning bad beans into good coffee).
Quantum Memory is the storage bin for the beans.
The Paper is the manager's manual that says: "If your roaster is 90% efficient and you need to serve 13 cups of coffee every minute, you need a bin that holds exactly 49 bags of beans. If you are willing to wait 3 minutes before opening the shop to let the beans pile up, you can get away with a smaller bin of 32 bags."

The authors have given us the math to ensure the coffee shop never runs out of coffee, no matter how chaotic the roasting process gets.

1. Problem Statement

The emerging Quantum Internet relies on the distribution and storage of Einstein-Podolsky-Rosen (EPR) pairs (entangled qubits) to enable quantum teleportation, distributed computing, and quantum error correction (QEC). However, entanglement generation is imperfect, resulting in mixed states with reduced fidelity. To be useful for high-level protocols (like QEC), these pairs must undergo entanglement distillation to improve fidelity.

The core challenge addressed in this paper is the dimensioning of quantum memories. Unlike classical networks where bits are processed immediately, quantum systems must store entangled pairs while they undergo distillation, consumption, and refilling. The authors identify a gap in existing literature: while previous works studied simple two-qubit memories or fidelity/availability trade-offs, there is a lack of frameworks for dimensioning memories that store packets of EPR pairs (multiple pairs) required for quantum error-correcting codes (which often require consuming $c$ pairs simultaneously). The problem is to determine the optimal memory size ( $M$ ) and operational protocols to ensure a high probability of having enough high-fidelity pairs available when needed, despite the stochastic nature of distillation failures and decoherence.

2. Methodology

The authors propose a comprehensive framework based on Markov Chain modeling to analyze the stochastic evolution of quantum memory states over time.

A. System Model

EPR Packets: The system assumes the availability of "EPR packets" containing raw entangled pairs with initial fidelity $F_0$ (modeled as Werner states).
Memory Capacity: The memory holds $M$ entangled pairs.
Distillation: The system uses the DEJMPS algorithm (Deutsch–Ekert–Jozsa–Macchiavello–Popescu–Sanpera). This algorithm takes two pairs of fidelity $F_i$ and attempts to produce one pair of higher fidelity $F_{i+1}$ . This process is probabilistic; it succeeds with probability $p_{i \to i+1}$ and fails (converting the pair back to a lower fidelity state or discarding it).
Operational Rounds: Time is divided into discrete rounds, each consisting of three phases:
1. Distillation: Pairs are processed in parallel to upgrade fidelity levels.
2. Consumption: $c$ pairs of the highest fidelity ( $F_d$ ) are consumed for QEC or communication.
3. Refilling: The memory is replenished with raw pairs ( $F_0$ ) to maintain full capacity ( $M$ ).

B. Mathematical Formulation

State Space: The state of the system is defined by the vector $(n_0, n_1, \dots, n_d)$ , where $n_i$ is the number of pairs at distillation level $i$ (fidelity $F_i$ ).
Markov Chain: The evolution of the system is modeled as a finite-state Markov chain.
- Transitions: The transition probabilities are derived from binomial distributions representing the success/failure of the distillation steps.
- Stationary Distribution: The authors prove that for $c > 0$ and non-deterministic distillation, the system converges to a unique stationary distribution ( $v_\infty$ ).
Outage Probability ( $P_{out}$ ): A key metric is defined as the probability that the system is in a state where the number of high-fidelity pairs ( $n_d$ ) is less than the required consumption $c$ ( $n_d < c$ ). This represents a failure to perform the necessary operation.

C. Bootstrap Protocol

To address scenarios with high consumption rates or limited memory, the authors propose a Bootstrap Protocol. This involves an initial waiting phase ( $W$ rounds) where no consumption occurs, allowing the system to accumulate and distill resources before entering the steady-state consumption phase. This trades increased latency for reduced memory requirements.

3. Key Contributions

Markov Chain Framework for EPR Packets: The paper introduces a novel stochastic model that captures the joint evolution of multiple entangled pairs undergoing parallel distillation, consumption, and refilling. This moves beyond single-pair analysis to packet-based quantum networking.
Analytical Design Tools: The authors derive analytical tools to calculate the stationary distribution of memory states, enabling the precise calculation of outage probabilities based on system parameters ( $M, c, F_0, d$ ).
Optimization of Memory Dimensioning: The framework provides a method to determine the minimum memory size ( $M$ ) required to meet specific reliability targets (e.g., $P_{out} = 10^{-4}$ ) for given entanglement generation fidelities and consumption rates.
Latency-Memory Trade-off Analysis: The introduction of the Bootstrap Protocol offers a systematic way to analyze the trade-off between storage capacity and operational latency, showing how waiting rounds can significantly reduce the required memory size.

4. Numerical Results

The authors validate their framework through numerical simulations:

Memory vs. Outage Probability: Simulations show that increasing memory size ( $M$ ) exponentially reduces the outage probability. For a target $P_{out} = 10^{-3}$ , a system with initial fidelity $F_0 = 0.99$ requires $M=10$ , whereas $F_0 = 0.9$ requires $M=13$ (for $c=1$ ).
Impact of Consumption Rate: Higher consumption rates ( $c$ ) significantly increase the required memory size.
Bootstrap Efficiency: In a scenario requiring $c=13$ $c = 13$ pairs (simulating a surface code operation), the authors demonstrate a massive reduction in required memory by using the bootstrap protocol:
- Without bootstrap ( $W=0$ ): Requires $M \ge 123$ .
- With $W=3$ waiting rounds: Requires $M \ge 49$ .
- With $W=12$ waiting rounds: Requires $M \ge 32$ .
  This highlights that a small increase in latency can drastically reduce hardware costs (memory size).

5. Significance and Future Work

Scalability: This work is crucial for the design of modular quantum computers and distributed quantum data centers, where entanglement links between modules must be reliable and synchronized.
Resource Management: It provides the first systematic approach to sizing quantum memories for Quantum Error Correction (QEC) applications, which are resource-intensive and require simultaneous access to multiple high-fidelity pairs.
Practical Design Guidelines: The derived relationships allow network architects to make informed decisions on the trade-offs between hardware complexity (memory size), network latency, and the quality of the underlying entanglement distribution technology.
Future Directions: The authors note that future work will incorporate decoherence (time-dependent fidelity loss) into the model to further refine the dimensioning for real-world physical implementations.

In summary, this paper bridges the gap between theoretical quantum communication protocols and practical hardware engineering by providing a rigorous mathematical framework to dimension quantum memories for the next generation of entanglement-based networks.