# Quantum Memory: A Missing Piece in Quantum Computing Units

Chenxu Liu  Physical and Computational Sciences, Pacific Northwest National
Laboratory, Richland, WA, 99354, USA  Meng Wang  Physical and Computational
Sciences, Pacific Northwest National Laboratory, Richland, WA, 99354, USA
Samuel A. Stein  Physical and Computational Sciences, Pacific Northwest
National Laboratory, Richland, WA, 99354, USA  Yufei Ding  Computer Science
and Engineering, University of California San Diego, La Jolla, CA, 92093, USA
Ang Li  Physical and Computational Sciences, Pacific Northwest National
Laboratory, Richland, WA, 99354, USA

###### Abstract

Memory is an indispensable component in classical computing systems. While the
development of quantum computing is still in its early stages, current quantum
processing units mainly function as quantum registers. Consequently, the
actual role of quantum memory in future advanced quantum computing
architectures remains unclear. With the rapid scaling of qubits, it is
opportune to explore the potential and feasibility of quantum memory across
different substrate device technologies and application scenarios. In this
paper, we provide a full design stack view of quantum memory. We start from
the elementary component of a quantum memory device, quantum memory cells. We
provide an abstraction to a quantum memory cell and define metrics to measure
the performance of physical platforms. Combined with addressing functionality,
we then review two types of quantum memory devices: random access quantum
memory (RAQM) and quantum random access memory (QRAM). Building on top of
these devices, quantum memory units in the computing architecture, including
building a quantum memory unit, quantum cache, quantum buffer, and using QRAM
for the quantum input-output module, are discussed. We further propose the
programming model for the quantum memory units and discuss their possible
applications. By presenting this work, we aim to attract more researchers from
both the Quantum Information Science (QIS) and classical memory communities to
enter this emerging and exciting area.

##  I Introduction

Emergence of quantum computing and quantum networking has sparked tremendous
excitement in the scientific and technological communities due to their
potential to revolutionize various fields. Quantum computing harnesses the
principles of quantum mechanics to perform computations exponentially faster
than classical computers, offering the possibility of solving complex problems
in cryptography Shor (1999); Gisin  _et al._ (2002a), optimization Farhi  _et
al._ (2014); Han and Kim (2002), quantum chemistry Georgescu  _et al._ (2014);
Kandala  _et al._ (2017), and finance Rebentrost  _et al._ (2018); Woerner and
Egger (2019), etc. Furthermore, quantum networks enable the transmission of
quantum information across long distances Hensen  _et al._ (2015); Ren  _et
al._ (2017); Chen  _et al._ (2021a); Liu  _et al._ (2023a), facilitating
secure communication Bennett and Brassard (1984); Gisin  _et al._ (2002b); Xu
_et al._ (2020); Portmann and Renner (2022) and the creation of sophisticated
quantum network protocols and quantum internet Kimble (2008); Cacciapuoti  _et
al._ (2020); Wei  _et al._ (2022). The usefulness of quantum computing systems
and their connected networks lies in their ability to tackle computational
challenges that are currently intractable, paving the way for significant
advancements in science, industry, and society as a whole.

One of the main goals of quantum computing research is to scale up the quantum
computing systems and build a fault-tolerant large-scale quantum computer. In
recent years, a lot of efforts have been demonstrated. IBM-Q demonstrates the
Eagle device featuring 127 physical qubits Chow  _et al._ (2021) and the
Osprey device with 433 qubits IBM (2022), Google’s Sycamore consists of 54
qubits Arute  _et al._ (2019), Quantinuum has its ‘H2’ device with 32 trapped
ion qubits Moses  _et al._ (2023), IonQ devices can hold more than 20 qubits
IonQ Staff (2023), QuEra also demonstrated its 256-qubit quantum simulator
Ebadi  _et al._ (2021); Wurtz  _et al._ (2023), etc. Although integrating
thousands of qubits into a single quantum chip is possible Gambetta (2022) in
the near future, there are still challenges in building such a large-scale
fault-tolerant quantum computer along the current route.

In the current route to reach this goal, one of the main challenges comes from
the physical difficulty of integrating a huge number of physical qubits as
quantum registers into a single quantum device. For example, the physical size
of the quantum chip limits the number of superconducting qubits on the same
chip Gambetta (2022); Kaushal  _et al._ (2020), while the electromagnetic trap
size limits the number of ions living inside a single trap Krinner  _et al._
(2019). Meanwhile, cross-talk also hinders fast gate operations in largely
integrated quantum systems. However, using Shor’s algorithm to break RSA may
require thousands of logical qubits made by millions of physical qubits
Gheorghiu and Mosca (2019); Roetteler  _et al._ (2017); Gidney and Ekerå
(2021).

On the other hand, integrating a large number of quantum registers usually has
a trade-off with fast and reliable gate operations on any pair of computing
registers. In the ‘noisy intermediate-scale quantum’ (NISQ) era Preskill
(2018), where quantum registers are made by physical qubits, the limitation is
mainly reflected by slow gate operations and limited communication fidelity.
For example, in superconducting devices, the coupling between qubits on
different chips hinders fast and precise gate operations Gambetta (2022). In
trapped ion systems, increasing the number of ions in a single trap prolongs
the two-qubit gate operations Monroe and Kim (2013); Kaushal  _et al._ (2020).
In the fault-tolerant quantum computing (FTQC) era, where logical qubits are
protected by quantum error correction (QEC) codes Nielsen and Chuang (2010);
Calderbank and Shor (1996); Fowler  _et al._ (2012); Acharya  _et al._ (2023),
maintaining gate speed between remote logical qubits is even more challenging
compared to the NISQ devices, due to the limited number of physical qubits
allowed in a single device. Furthermore, the limited connectivity of the
physical platforms requires a large number of SWAP gates to perform a gate
between two remote qubits. The SWAP gate number is also proportional to the
size of the quantum computing device, which further prolongs the gate
operations.

Figure 1: The usage of quantum memory and the stack of our consideration of
quantum memory. In (a), we show the outline of the classical quantum computing
systems, while in (b), we show our vision of quantum computing systems, where
quantum memory plays the centered role in the quantum computing system. The
stack of our discussion on the role of quantum memory in future quantum
computing is shown in (c). This paper’s structure is aligned with the design
stacks.

To resolve these issues, we take inspiration from classical computing systems,
where classical memory plays the central role Hennessy and Patterson (2011);
Patterson and Hennessy (2016). The key insight is the CPU-memory separation in
the von Neumann architecture (see Fig. 1a). Similarly, in the quantum
computing system design, the separation of the computing and memory devices is
also desired (see Fig. 1b). With this separation, future quantum computing
devices can contain two main units: a quantum processing unit for computing
and a quantum memory unit for information storage. The quantum processing unit
contains a small number of computing registers, which can support a set of
fast and reliable universal gates. The quantum memory unit, in constant, is
designed for storing quantum information. It can contain a large number of
quantum registers, which do not necessarily support a universal gate set.

In addition, due to the computing-storage separation, the issue of maintaining
both fast gate and large-scale integration of qubits in quantum computing
devices is avoided. The quantum memory unit only needs to have reliable
communication with the QPU to store and load the quantum information. By
separating the requirements on computing and information storage, the QPU and
the quantum memory can be realized using different physical techniques, one
with fast gate operations for QPU and one with a long coherence time for
quantum memory. In addition, this design can benefit more in the FTQC systems.
Because of the Eastin–Knill theorem, where a transversal universal gate set is
not possible Eastin and Knill (2009), implementing a universal QEC gate set
requires techniques like magic state injection Nielsen and Chuang (2010);
Bravyi and Kitaev (2005), code deformation Bombin and Martin-Delgado (2009);
Horsman  _et al._ (2012); Brown  _et al._ (2017); Litinski (2019), code
switching Jochym-O’Connor and Laflamme (2014); Anderson  _et al._ (2014),
etc., which further increases the complexity. However, these techniques are
not necessary in quantum memory as a universal gate set is not required. It is
also possible to help reduce the complexity of the QEC code itself Terhal
(2015); Kovalev and Pryadko (2013); Gidney  _et al._ (2021); Bravyi  _et al._
(2023).

The main focus of the current development of quantum computing systems is to
build a fault-tolerant and fast quantum processing unit. The discussion and
demonstration of building quantum memory devices have attracted lots of
attention in the physical community Lvovsky  _et al._ (2009); Hedges  _et al._
(2010); Heshami  _et al._ (2016); Terhal (2015). However, the systematic
discussion of the role of quantum memory in the quantum computing system
architecture, whether a quantum memory unit should be considered, and how it
should be utilized in quantum programs is still lacking. Therefore, in this
paper, we attempt to follow a bottom-up manner through the design stack of
quantum memory shown in Fig. 1c. We not only survey the current quantum
technologies and their possible usage in building quantum memory devices, but
also consider how the quantum memory modules can be utilized in higher stacks,
e.g., in quantum programs and software. We hope our paper can fill the gap
between the physical layer and software layer of the development of quantum
memory and provide useful insights for research on both frontiers.

Specifically, at the bottom of the design stack, in Sec. II, we survey the
existing quantum technologies for building quantum registers and discuss their
suitability of building the most elementary units of quantum memory, which is
named ‘quantum memory cells’ (QMCs). In order to unify the discussion across
various physical platforms, we abstract the quantum memory cell concepts and
explore the metrics that describe the essential properties of the QMCs. We
then discuss quantum memory devices that are built on QMCs in Sec. III. We
specifically introduce two quantum memory devices, a random access quantum
memory (RAQM) and a quantum random access memory (QRAM). We highlight their
abstract models and their possible applications. These quantum memory devices
can then be utilized to construct quantum memory modules in the future design
of quantum computing architectures, which is discussed in Sec. IV. We
specifically give four examples, including the main quantum memory unit,
quantum cache, quantum buffers, and QRAMs in quantum input-output modules.
With the quantum memory modules available, we then discuss how the quantum
memory can be utilized in the quantum program design. We discuss the quantum
memory programming model in Sec. V. We discuss their possible application in
Sec. VI. We conclude our paper in Sec. VII.

##  II Quantum Memory Cells

A quantum memory cell (QMC) is the fundamental element in quantum memory
devices, analogous to classical memory cells consisting of one or a few
transistors for storing a single classical bit. QMCs can be made using a
quantum register or a qubit. However, they have unique requirements distinct
from qubits used in quantum computing. Despite variations in physical systems
for QMCs, we establish an abstract model to evaluate their performance
uniformly and distinguish them from computing registers. Additionally, we
introduce two metrics for quantitatively comparing different physical systems
for quantum memory cells.

In Sec. II.1, we define the QMC abstract model along with the performance
metrics. Subsequently, we summarize the main results and discussions comparing
various physical systems in quantum computing and quantum information
processing in Sec. II.2. A concise summary of key properties and metrics can
be found in Table 1 and Fig. 3. For completeness of this section, we briefly
survey the physical systems one by one in the rest of the section from Sec.
II.3 to Sec. II.11. These subsections are intended for readers with a
particular interest in the specific quantum technologies and seeking an in-
depth exploration of the references to the experiments included in our
comparison. Readers who are not directly engaged with the specific physical
realization or desire to focus on the broader context may choose to omit these
subsections without compromising the overall coherence of the paper.

###  II.1 Define a QMC

A QMC can be made of a single qubit or quantum register to store one bit of
quantum information. Unlike quantum computing registers, entangling gates
between QMCs are not necessary. Instead, the core functionality of a QMC only
includes (1) storing quantum information, (2) controlled operations to save
quantum information to the QMC, and (3) load the quantum information from
QMCs.

The basic structure of a QMC and its related components are shown in Fig. 2.
The QMC (blue box) has an interaction interface to transfer quantum
information, which is the bus qubit (red). Due to the quantum no-cloning
theorem, reading and writing (RW) processes cannot copy information and hence
can only be realized using quantum operations. For example, in optical
systems, RW operations can be realized by photon emission and absorption,
while in gate-based systems, SWAP gates or iSWAP gates between the QMC and the
bus qubit can be utilized. Using SWAP gates as an example, the RW process of a
QMC can be described as

$\displaystyle
f_{\text{QMC}}(\ket{\psi}^{(\text{b})},\ket{\phi}^{(\text{QMC})})$
$\displaystyle=\text{SWAP}_{\text{b},\text{QMC}}\ket{\psi}^{(\text{b})}\otimes\ket{\phi}^{(\text{QMC})}$
$\displaystyle=\ket{\phi}^{(\text{b})}\otimes\ket{\psi}^{(\text{QMC})}$ (1)

where the super-indices are for the physical qubits, ‘b’ stands for bus qubits
and SWAP is a swap gate. Although we show both qubits in pure states, if the
bus (memory) qubit is already entangled with other qubits, the entanglement
will be swapped to the memory (bus) qubit after the SWAP gate.

The difference between the reading and writing processes of QMC lies in which
part carries nontrivial quantum information. In the memory writing process,
the bus qubit is in a useful quantum state to be stored, while in the memory
reading process, the state of the QMC is important. One of the unique features
of a QMC using SWAP gates as its RW operations is that reading and writing
processes can be completed in a single SWAP, which is unlike the classical
counterpart where an extra register and two separate operations are typically
needed.

Figure 2: Demonstration of a QMC and its functionality. The QMC itself is
shown as the blue cubic. It requires a bus qubit (red) which can be
classically controlled to perform SWAP gates to the QMC. The read and write
functionality is realized by applying a SWAP gate between a bus qubit to store
and retrieve the quantum state into/out of the QMC.

A QMC should satisfy the following requirements in terms of its
functionalities.

  1. 1.

Quantum information storage: A QMC can store quantum information for an
extended period of time. A good QMC should have a long storage time to
preserve the quantum information. For NISQ devices, long storage time
necessitates the physical qubit itself to have long coherence times, while in
the FTQC era, it requires the logical qubit to have a small enough logical
error rate.

  2. 2.

Reading and Writing (RW) operations: A good QMC requires to have fast and
accurate RW operations.

  3. 3.

Integration capability: As QMCs are employed to construct large quantum memory
devices, integrating a large number of QMCs becomes essential. Therefore, a
promising candidate of QMCs should have large integration capabilities.

There usually are tradeoffs between achieving a long storage time and fast RW
operations while maintaining good integration capability. For a physical
qubit, improving the coherence time involves isolating it from its
environment, while fast quantum operations require strong coupling to other
physical degrees of freedom to perform fast quantum gates. For a logical qubit
encoded in some QEC codes, it can have smaller error rates by increasing its
code distance, which may increase the number of physical qubits and complicate
the coupling operations with other logical qubits.

In order to evaluate the performance of a QMC by considering all three
requirements together, we define a metric, $\alpha_{\text{in}}$, named
internal storage ratio, as

$\text{Internal storage ratio:
}\alpha_{\text{in}}=\frac{T_{\text{storage}}}{T_{\text{RW}}},$ (2)

where $T_{\text{storage}}$ is the storage time of the QMC, while
$T_{\text{RW}}$ is the time for a read or write operation. To account for the
imperfection, $T_{\text{RW}}$ can be estimated by,

$T_{\text{RW}}=\tau/F_{\text{RW}}\sim\tau/p_{\text{suc}}\sim\tau/\eta,$ (3)

where $\tau$ is the raw gate time, $F_{\text{RW}}$ is the fidelity of the
quantum gate, $p_{\text{suc}}$ is the success probability of performing the
gate, while $\eta$ is the efficiency of the information storage or information
retrieval. The metric $\alpha_{\text{in}}$ represents an estimation of the
storage time of the QMC scaled by its RW speed. Large $\alpha_{\text{in}}$
means the QMC has faster RW operations in terms of its storage time, which is
preferred. It also means that the QMC only needs to be reset after a large
number of RW operations.

Meanwhile, we consider another metric named external storage ratio as,

$\text{External storage ratio: }\alpha_{\text{ex}}=\frac{T_{\text{net,
storage}}}{T_{\text{op}}}\eta,$ (4)

where $T_{\text{op}}$ is the time for a quantum operation on the possible
connected computing devices, and $\eta$ is the QMC RW efficiency or fidelity.
This metric measures the storage time of the QMC relative to the external
essential operations, taking the imperfection of RW operations into account.
Note that in Eq. (4), $T_{\text{net, storage}}$ is the net storage time,
$T_{\text{net, storage}}=T_{\text{storage}}-2T_{\text{RW}}$. Therefore, when
the internal storage ratio $\alpha_{\text{in}}<2$, the external storage ratio
will be negative, which means that this QMC construction still needs to be
further improved.

###  II.2 Comparing physical platforms for QMCs

Table 1:  Comparison of physical techniques that can be utilized to implement quantum memory cells. We consider the physical platforms that have been surveyed in the main text. Details about our calculation and the corresponding references can be found in the main text. We consider the QMC storage time $T_{\text{storage}}$, possible bus qubits, the RW time $T_{\text{RW}}$ and its efficiency $\eta$, and the internal storage ratio $\alpha_{\text{in}}$ [Eq. (2)], and the external storage ratio $\alpha_{\text{ex}}$ [Eq. (4)]. The transmon and fluxonium systems are used for homogenous computing systems, and hence $\alpha_{\text{ex}}=\alpha_{\text{in}}$. ‘MW’: microwave photons, ‘SC’: superconducting qubits. We use transmon to estimate the external storage ratio when the QMC can connect to superconducting qubits. QMC |  $T_{\text{storage}}$ |  Bus |  RW speed ($T_{\text{RW}}$) |  Efficiency ($\eta$) |  $\alpha_{\text{in}}$ |  $\alpha_{\text{ex}}$
---|---|---|---|---|---|---
Transmon |  $557.00~{}\mu$s |  N.A |  $40.00$ ns |  $0.998$ |  $1.39\times 10^{4}$ |
Fluxonium |  $1.48$ ms |  N.A |  $100.00$ ns |  $0.999$ |  $1.48\times 10^{4}$ |
MW (3D) |  $34.00$ ms |  SC |  $1000.00$ ns |  $0.994$ |  $3.38\times 10^{4}$ |  $8.44\times 10^{5}$
Trapped ions |  $300$ ms (Ca) |  Optical |  $29.94$ ns |  $0.509$ |  $5.10\times 10^{6}$ |  $8.00\times 10^{3}$
|  $5500.00$ s (Yb) |  Optical (herald) |  $16.13$ ms |  $0.901$ |  $3.07\times 10^{5}$ |  $2.59\times 10^{8}$
Neutral atoms |  $800.00~{}\mu$s (Rb) |  Optical |  $8.00~{}\mu$s |  $0.510$ |  $51.0$ |  $20.5$
|  $7.90$ s (Yb) |  Optical |  |  |  $5.04\times 10^{5}$ |  $2.11\times 10^{5}$
|  |  Optical (expect) |  $182.48$ ns |  |  $2.21\times 10^{7}$ |  $2.11\times 10^{5}$
Atomic cloud |  $16.00$ s |  Optical |  $1.04~{}\mu$s |  $0.510$ |  $7.84\times 10^{6}$ |  $4.27\times 10^{5}$
|  |  Optical (expect) |  |  $0.9518$ |  $1.46\times 10^{7}$ |  $7.97\times 10^{5}$
|  $800.00~{}\mu$s |  MW/SC |  $25.00~{}\mu$s |  $0.6$ |  $19.2$ |  $1.06\times 10^{4}$
REIDC |  $52.9$ min |  Optical |  $400.00$ ms |  $0.0608$ |  $4.83\times 10^{2}$ |  $1.01\times 10^{7}$
|  |  Optical (expect) |  |  $0.5187$ |  $4.12\times 10^{3}$ |  $8.62\times 10^{7}$
NV Nuclear spin |  $12.90$ s (C) |  NV (e) |  $419.00~{}\mu$s |  $0.99$ |  $3.05\times 10^{4}$ |
|  $63.00$ s (N) |  |  $389.00~{}\mu$s |  $0.94$ |  $1.52\times 10^{5}$ |
NV ensemble |  $200$ ns |  MW/SC |  $58.0$ ns |  $0.3742$ |  $1.29$ |  $<0$
|  $1.80$ ms |  MW (expect) |  |  |  $1.16\times 10^{4}$ |  $1.67\times 10^{4}$
QD |  $58.95$ ns |  SC |  $23.81$ ns |  $0.80$ |  $1.98$ |  $<0$
|  $102.00~{}\mu$s |  SC (expect) |  |  |  $3.43\times 10^{3}$ |  $2.03\times 10^{3}$
Phonons |  $130.00~{}\mu$s (GHz) |  MW/SC |  $25.00$ ns |  $0.95$ |  $4.94\times 10^{3}$ |  $3.02\times 10^{3}$
|  |  Optical |  $714.29$ ns |  $1$ (assume) |  $1.82\times 10^{2}$ |  $6.73$
|  $100$ ms (MHz) |  Optical |  $714.29$ ns |  $1$ (assume) |  $1.40\times 10^{5}$ |  $5.24\times 10^{3}$

The discussion of QMCs and their abstract model applies to both NISQ- and
FTQC-era quantum memory devices. However, the requirements on the physical
platforms differ in these two scenarios.

In the NISQ memory devices, both the QMCs and the computing qubits are made by
single physical qubits. The storage time can be estimated by the coherence
time of a single physical qubit $T_{\text{coh}}$. However, as the requirements
of two kinds of qubits are different, in the spirit of separating the
computing and memory requirements, the quantum memory devices should consist
of different types of physical qubits compared to the computing devices.
Reflected in our abstracted QMC model shown in Fig. 2, the bus qubit can be a
type of qubit different from the QMC, and the SWAP gates for RW operations are
implemented between two physical platforms. Therefore, the RW time
$T_{\text{RW}}$ is not the two-qubit gate time typically used in
characterizing computing qubits. The quality and the speed of a specific
physical platform exchanging quantum information with other physical platforms
are essential for building QMCs in the NISQ era.

The rapid advancement of quantum technologies presents abundant opportunities
for constructing QMCs across a diverse range of physical platforms. Nowadays,
the most promising quantum substrate systems for quantum computing include
superconducting qubits, microwave modes, trapped ion systems, neutral atom
systems, defects and dopped ions in solid state systems, quantum dots, and
mechanical and acoustical phonon systems. We examine their potential
applications in building QMCs, focusing on the possibility and quality of the
coupling across different physical systems.

In Table 1, we summarize the main properties of these physical systems. We
identify the bus qubits for these physical systems experimentally demonstrated
by existing works, and estimate their internal and external storage ratios.
Most of the physical systems can couple to photonic bus qubits. Depending on
their energy scales and available quantum transitions, it is possible that QMC
have optical or microwave photon interfaces.

As one of the applications of optical photonic systems is to build long-range
quantum entanglements and quantum communication links, the QMCs are integrable
with quantum communication devices, especially quantum repeaters Briegel  _et
al._ (1998); Sangouard  _et al._ (2011). In this scenario, the main role of
quantum memory is to store the quantum states to synchronize between different
quantum operations. As photonic EPR pairs are commonly utilized in quantum
communication protocols, and given their generation is usually slow compared
to the photon measurements Bennett  _et al._ (1993), photonic EPR pair
generation time can be used as a time scale to measure the photonic QMC’s
storage time. On the other hand, photonic systems can also perform quantum
computing using the measurement-based quantum computing (MBQC) scheme
Raussendorf and Briegel (2001); Raussendorf  _et al._ (2003); Benjamin  _et
al._ (2009), where adaptive single-qubit measurements drive the computation on
a pre-generated entangled resource state. In MBQC, resource state generation
is one of the most significant questions, which is usually the most time-
consuming operation. The resource state can also be constructed using photonic
EPR pairs Bartolucci  _et al._ (2021). In order to give an estimation of the
external storage ratio ($\alpha_{\text{ex}}$) of the QMCs with optical-photon-
based bus qubits, we consider using photonic EPR pair generation time as an
estimate of $T_{\text{op}}$. Specifically, in Ref. Zhang  _et al._ (2021), the
photon-pair generation rate can reach $52.36$ kHz ($T_{\text{op}}\approx
19~{}\mu$s).

Due to the fast gate operations between superconducting qubits, we envision
that transmons and fluxonium qubits will be utilized in quantum processing
units, rather than quantum memory modules (see Sec. II.3 for details). In
Table 1, we show the internal storage ratio $\alpha_{\text{in}}$ of
superconducting qubits for reference. Superconducting qubits can strongly
couple to microwave fields (see Sec. II.4). Therefore, the QMCs with
microwave-photon-based QMCs are potentially integratable with superconducting-
based QPUs. Entangling gate operations between superconducting qubits are used
as the external operations when evaluating the QMC’s external storage ratio.
Specifically, we take the CZ gate between transmon qubits $T_{\text{op}}=40$
ns with fidelity $0.998$ reported in Ref. Marxer  _et al._ (2023). In Table 1,
we report possible usage of atomic clouds, spin ensembles in solid state
systems, and phononic systems for QMCs interacting with microwave and
superconducting qubits. However, the performance of these systems still needs
to be improved to take advantage of quantum memory.

Figure 3: The internal ($\alpha_{\text{in}}$) and the external storage ratios
($\alpha_{\text{ex}}$) of QMCs built on different physical platforms. We
include superconducting qubits (blue circles), microwave modes (orange
squares), trapped ions (labeled as ‘TI’, shown as green diamonds), Rubidium
and Ytterbium trapped neutral atoms (reddish-orange triangles), neutral atomic
clouds (labeled as ‘AC’, purple inverted triangles), Rare-earth-ion-doped
crystals (REIDC) (hollow brown circles), NV centers (hollow pink squares),
quantum dots (hollow yellow diamonds), and phononic modes (hollow lavender
triangles). ‘O’ stands for connecting to optical systems, while ‘MW’ is for
connecting to microwave systems. The data points labeled as ‘expect’ are
estimated by the best performance parameters in the specific system. The
detailed numbers are discussed in the corresponding subsections and summarized
in Table 1. For external storage ratios $\alpha_{\text{ex}}<0$ and the
external storage time of NV nuclear spin-based QMCs, we set them to be $0.5$
to be able to present them in the plot.

In Fig. 3, we plot the internal and external storage time of the QMCs built on
physical systems that are discussed in the rest of the section. We plot
$\alpha_{\text{in}}=\alpha_{\text{ex}}$ as the black dashed line for
reference. We notice that there are two regions in Fig. 3, (1) above the
dashed line, and (2) below the dashed line. When a QMC point falls on the
dashed line, the external operation and the RW operations take similar times,
while if the point is above the line, the external operations take less time
than the RW operations, and vice versa.

Improving the QMCs can be reflected by shifting the corresponding point in the
storage ratio plot (Fig. 3). For example, extending the QMC coherence time can
improve both internal and external storage ratios, which shifts the data point
along the diagonal direction to the upper right corner. Reducing the RW time
of the QMC can improve the internal storage ratio, which will push the
corresponding point to the right. On the other hand, there are two methods to
improve the QMCs’ external storage ratio. One concentrates on the external
system by accelerating external operations. The other is to increase the
coupling strength and efficiency between the QMC with the external quantum
system. For example, the expected trapped ion QMCs listed in Table 1 (Yb ions)
are mainly from the storage time improvement, while the atomic cloud and rare-
earth-ion-doped crystal QMCs are mainly from the RW operations.

Contrary to the NISQ-era quantum memory devices, in the FTQC era, although the
quantum memory and quantum computing units are made of the same species of
physical qubits, the QEC codes can be different to take advantage of the QPU-
memory separation. As the quantum memory does not need to support a fault-
tolerant universal gate set, the QEC code on QMCs can have high thresholds and
yield, e.g., using the quantum LDPC codes Bravyi  _et al._ (2023). Therefore,
designing FTQC-era QMCs may focus more on QEC, e.g., designing QEC codes of
quantum memory and its interfaces to QPUs. We stress that the internal and
external storage ratios defined in Eqs. (2) and (4) can still quantify the
performance of the FTQC QMC design. The storage time $T_{\text{storage}}$ can
be estimated by the logical error rates, while the RW time $T_{\text{RW}}$
should take the gate operations between different QEC codes into
consideration.

With the focus on building QMCs, to enable fast QEC cycles on memory
registers, the physical qubits should have fast and accurate measurement and
gate operations between them. In addition, the physical qubits should support
the topology required by the QEC codes. These requirements are exactly similar
to the NISQ quantum computing qubits, and hence the discussion of physical
qubits used in FTQC-era quantum memory is beyond the scope of this paper.

###  II.3 Superconducting qubits

Superconducting circuit systems are one of the most promising systems for
quantum computing Blais  _et al._ (2021); Kjaergaard  _et al._ (2020).
Superconducting circuit systems feature strong nonlinearity provided by
Josephson junctions. This nonlinearity allows for constructing quasi-atom
structures capable of exhibiting quantum state manipulation, rapid
initialization, quantum gate operations, and readout of the quasi-atoms’
quantum states. However, the coherence time of superconducting qubits is
relatively short. For example, the coherence time of transmon qubits Koch  _et
al._ (2007); Schreier  _et al._ (2008); Houck  _et al._ (2008) can reach
$T_{2}^{*}\approx 0.3$ ms Place  _et al._ (2021); Wang  _et al._ (2022a), and
be further improved to $0.557$ ms with dynamical decoupling. A fluxonium qubit
Manucharyan  _et al._ (2009) with coherence time $T_{2}^{*}$ reaching $1.48$
ms has been reported Somoroff  _et al._ (2023). On the contrary, taking the
spin states of atoms and ions as an example, the coherence time can reach
several seconds or even tens of minutes Sheng  _et al._ (2018); Bluvstein  _et
al._ (2022); Ma  _et al._ (2022); Jenkins  _et al._ (2022); Wang  _et al._
(2017, 2021).

On the other hand, the superconducting qubits can perform fast and high-
fidelity single- and two-qubit gate operations. For example, transmon qubits
can perform CZ gates in $40$ ns with a fidelity $99.8\%$ Stehlik  _et al._
(2021); Sung  _et al._ (2021); Marxer  _et al._ (2023), while a microwave-
activated CZ gate between fluxonium qubits only takes $\sim 100$ ns with a
fidelity $99.9\%$ Nesterov  _et al._ (2018); Nguyen  _et al._ (2022). Due to
these features, superconducting qubits can be leveraged as computing registers
in quantum computing systems. In fact, utilizing the fast gate operations
provided by superconducting qubits has been discussed in the context of hybrid
quantum computing Xiang  _et al._ (2013); Kurizki  _et al._ (2015); Clerk  _et
al._ (2020). Therefore, in the NISQ-era quantum computing system design, we
skip the discussion of using superconducting qubits as quantum memory cells.
While in the FTQC era, where QEC is needed on quantum memory cells, the fast
gate operations enable fast syndrome checking and error correction cycles,
which can also be utilized as a good candidate for physical qubits to build
logical quantum memory cells.

In order to compare the performance of QMCs made by other systems with a
homogeneous superconducting-qubit-based quantum computing system, we based on
transmon and fluxonium coherence time and gate times to estimate their storage
ratio as a reference. Note that in this case, the internal and external
storage ratios are essentially similar. We only focus on the internal storage
ratio instead. The internal storage ratio of transmon qubits can reach
$\alpha_{\text{in}}\approx 1.39\times 10^{4}$, where we take
$T_{\text{RW}}=40$ ns and $F=0.998$. The internal storage ratio of fluxonium
qubits can reach $\alpha_{\text{in}}\approx 1.48\times 10^{4}$, where we take
$T_{\text{RW}}=100$ ns and $F=0.999$.

###  II.4 Microwave cavities and resonators

With the development of superconducting qubits, quantum manipulation of
microwave photonic states has become available, which has attracted a lot of
attention recently Gao  _et al._ (2021). Due to the improvement of microwave
cavity fabrication techniques, microwave photon lifetimes inside a cavity keep
improving, enabling the potential usage of QMCs for quantum information
storage. There are two approaches to utilizing microwave resonators as QMCs:
(1) using the Fock states of physical microwave photons or (2) using bosonic
QEC code encoded microwave modes as qubits to store quantum information.

In the first approach, a QMC is encoded into the presence of a single photon
in a cavity mode. The storage time of the QMC is largely determined by the
lifetime of a photon inside the cavity Scully and Zubairy (1997). The lifetime
of 3D microwave cavities can reach $10.4$ ms Reagor  _et al._ (2013) to 2 s
Romanenko  _et al._ (2020). In this case, one choice of the bus qubit of the
microwave QMCs can be a propagating microwave photon. The QMC read process is
the photon emission from the microwave cavity, while the write process is the
microwave photon absorption. The QMC, i.e., the microwave cavity or resonator,
couples to a microwave waveguide or coaxial cable that holds the itinerant
microwave photon qubit. The coupling needs to be well controlled for a high
storage fidelity and RW operation efficiency Yin  _et al._ (2013); Wenner  _et
al._ (2014); Campagne-Ibarcq  _et al._ (2018). The absorption efficiency can
reach $99.4\%$ Wenner  _et al._ (2014).

A more promising approach is to couple the microwave systems with
superconducting qubits for fast computing operations. However, compared to the
cavity microwave system, the superconducting qubit has a shorter coherence
time, which can degrade the microwave-cavity-based QMCs. With the
superconducting control qubit built in, the lifetime of the cavity photon can
still reach 2 ms Chakram  _et al._ (2021) to $25.6$ ms Milul  _et al._ (2023),
while the photon coherence time can reach $34$ ms Milul  _et al._ (2023),
which is still significantly longer than superconducting qubits. Moreover, a
superconducting bus qubit can maintain fast bus-QMC RW operations ($1~{}\mu$s
as pointed out in Ref Chakram  _et al._ (2021)), which gives microwave QMCs
internal storage ratio $\alpha_{\text{in}}\approx 3.4\times 10^{4}$, where we
estimate the RW fidelity as $0.994$ (estimated by the efficiency reported in
Ref. Wenner  _et al._ (2014)) since it is not explicitly reported in Refs.
Chakram  _et al._ (2021); Naik  _et al._ (2017). In addition, if the
microwave-based QMC is connected with superconducting quantum computing
devices, the computing operation time can be estimated by the two-qubit gate
time between two transmon qubits $T_{\text{op}}=40$ ns ($F=99.8\%$), the
external storage ratio can reach $\alpha_{\text{ex}}\approx 8.4\times 10^{5}$.

The other approach uses the quantum error correction code encoded microwave
state as the QMC qubits. Recently, promising results have been shown in the
microwave qubits encoded in GKP, cat, and other bosonic codes Grimm  _et al._
(2020); Darmawan  _et al._ (2021); Chamberland  _et al._ (2022); Gertler  _et
al._ (2021); Grimsmo and Puri (2021); Campagne-Ibarcq  _et al._ (2020); Hu
_et al._ (2019). In this case, the bus qubit needs to be a superconducting
qubit, where the QMC read and write processes are equivalent to decoding and
encoding the quantum information of the QMC qubit. Evaluating the performance
of the logically encoded QMCs requires a detailed design of the error
correction code used in the QMC and the bus qubits, which is beyond the scope
of this paper.

With their multimode feature, microwave cavities are well-suited for large
integration of QMCs. However, accessing different QMCs inside a single cavity
is limited by the number of transmon qubits that couple to the cavity mode,
typically kept low for high cavity coherence. Therefore, integrating multiple
multi-mode cavities can be a promising approach Stein  _et al._ (2023).
However, finding the best strategy for microwave-cavity-based QMCs requires a
comprehensive consideration of the memory device requirements, the cavity
design, and the connectivity of the cavities, etc.

###  II.5 Trapped ions

The trapped ion system is one of the popular systems not only for quantum
memory but also for universal quantum computing. For a thorough review of
trapped ion systems, we suggest referring to Refs. Häffner  _et al._ (2008);
Monroe and Kim (2013); Bruzewicz  _et al._ (2019); Brown  _et al._ (2021). In
the trapped ion systems, the quantum information is stored in the electronic
spin states of the ions. The ions are trapped using radio-frequency Paul traps
Neuhauser  _et al._ (1980) and other types of electromagnetic traps Dehmelt
(1990); Chiaverini  _et al._ (2005); Seidelin  _et al._ (2006); Labaziewicz
_et al._ (2008). The quantum information can be stored in the spin states of
electrons or the nuclear, which can have a long coherence time, making them
suitable for quantum memory. Specifically, quantum information can either be
encoded into the hyperfine levels Harty  _et al._ (2014); Gaebler  _et al._
(2016); Ballance  _et al._ (2016); Wang  _et al._ (2017, 2021) or Zeeman
sublevels of the same orbital Keselman  _et al._ (2011); Ruster  _et al._
(2016); Hilder  _et al._ (2022), or other quantum states in the specific ion
level structures Bermudez  _et al._ (2017); Toyoda  _et al._ (2010); Pogorelov
_et al._ (2021). Depending on the species of the ions and the type of
encoding, the coherence time of the qubits can vary significantly. For
instance, in the Zeeman qubits, the coherence time can reach $300$ ms Ruster
_et al._ (2016), while the hyperfine states are more isolated, and the
coherence time can reach several minutes to an hour Harty  _et al._ (2014);
Wang  _et al._ (2017, 2021) ($5500$ s reported in Ref. Wang  _et al._ (2021)).

Other than fast gate operations between trapped ions Gaebler  _et al._ (2016);
Blümel  _et al._ (2021); Moses  _et al._ (2023); Jeon  _et al._ (2023); Saner
_et al._ (2023); Gaebler  _et al._ (2016); Ballance  _et al._ (2016); Saner
_et al._ (2023); IonQ Staff (2023), trapped ions can have strong coupling with
optical cavity modes Stute  _et al._ (2012, 2013); Begley  _et al._ (2016);
Takahashi  _et al._ (2020); Christoforou  _et al._ (2020). In addition, they
can also be used as single-photon emitters, which can be pumped to generate
entangled ion-photon pairs Blinov  _et al._ (2004); Bock  _et al._ (2018);
Kobel  _et al._ (2021). It enables trapped ions as QMCs for quantum computing
systems with optical interfaces, photonic quantum computing systems, and
quantum communications. In terms of using stationary photonic qubits living in
the optical cavity mode as the bus qubit, the coupling strength $g/2\pi=16.7$
MHz ($T_{\text{RW}}\approx 30$ ns) has been demonstrated Christoforou  _et
al._ (2020). With the $300$ ms long coherence time achieved in the Zeeman
qubit of $\text{Ca}^{+}$ ions Ruster  _et al._ (2016), the internal storage
ratio can reach $\alpha_{\text{in}}\approx 5.1\times 10^{6}$, where the RW
efficiency is approximated by the ratio of the photon linewidth and the ion-
photon coupling $\eta\approx 1-g/\Delta\omega\approx 50.9\%$.

On the other hand, the generated entangled ion-photon pairs can be used in
heralded entanglement generation schemes to create entanglement between ions
with other photon emitters Cabrillo  _et al._ (1999); Kok  _et al._ (2007);
Duan  _et al._ (2001); Casabone  _et al._ (2013). In this scenario, for a
trapped-ion-based QMC, the bus qubit is another trapped ion, which is used as
a single-photon emitter. Using the heralded entanglement generation scheme,
the bus ion is entangled with another computing qubit and forms a Bell state
Niffenegger  _et al._ (2020); Saha  _et al._ (2023); Krutyanskiy  _et al._
(2023). The bus ion can then be entangled with the QMC ion and transfer
quantum information to the computing qubit. In this scheme, the RW time is
determined by the bus-computing entanglement generation time,
$T_{\text{e-g}}$, and a two-qubit gate time between ions $T_{\text{Gate}}$.
The entanglement generation is probabilistic, whose probability is determined
by the photon loss and photon detection efficiency. However, the generation
process can be performed in parallel to speed up the generation time Dhara
_et al._ (2022). Therefore, the internal storage ratio, in this case, depends
heavily on the specific setup.

Here we aim to furnish an approximate estimation, solely to give a qualitative
understanding of the performance of ion-based QMCs in this case. In Ref. Kobel
_et al._ (2021), entangled Yb ion-photon pairs can be generated with fidelity
$90.1\%$ and rate $62$ Hz ($T_{\text{e-g}}\approx 16.1$ ms). As the two-qubit
gates between ions can be implemented in $10$ to $600~{}\mu$s with fidelity
$>99\%$ Gaebler  _et al._ (2016); Ballance  _et al._ (2016); Saner  _et al._
(2023); IonQ Staff (2023), the entanglement generation time is dominating. If
the Yb ions can maintain long coherence time ($5500$ s reported in Ref. Wang
_et al._ (2021)), the internal storage ratio can reach
$\alpha_{\text{in}}\approx 3.1\times 10^{5}$, where we only account the
contribution of $T_{\text{e-g}}$ to the RW time.

Using trapped-ion-based QMCs for optical quantum computing and quantum
communication, with the $300$ ms coherence time of Zeeman qubits of Ca+ Ruster
_et al._ (2016), the external storage ratio can reach
$\alpha_{\text{ex}}\approx 8.0\times 10^{3}$. We estimate the RW operations
based on Ref. Christoforou  _et al._ (2020) as above, and use photonic EPR
pair generation time as the external operation time ($19~{}\mu$s, see Sec.
II.2). For a Yb ion-based QMCs with RW scheme as mentioned above, the external
storage ratio can reach $\alpha_{\text{ex}}\approx 2.6\times 10^{8}$ with
$5500$ s storage time.

In addition, the spin degree of freedom of the ions can couple to
electromagnetic fields in MHz to GHz range, which enables superconducting
qubits as bus qubits to couple to superconducting quantum computing devices.
Direct coupling between single microwave photons with single trapped ions is
possible, but the coupling strength is estimated to be in the order of tens of
Hz Verdú  _et al._ (2009). The slow coupling hinges using single microwave
photons as bus qubits to couple to superconducting qubits. Instead, another
approach using an oscillating electric field to drive sideband transitions of
ions can provide $\sim 60$ kHz coupling between an ion to superconducting
qubits. Even though this coupling strength gives RW times much smaller than
the coherence time of trapped ions, the RW time can be challenging as it is
slower compared to superconducting qubit coherence time (see more detailed
discussion in Sec. II.3).

Furthermore, the trapped-ion-based QMCs are suitable for large-scale
integration. Since ions are naturally identical, there are no fabrication
imperfections that limit the performance of individual QMCs. Specifically,
commercial companies have demonstrated and made public access to 20 to
32-qubit trapped ion quantum computing units already IonQ Staff (2023); Moses
_et al._ (2023). In addition, hundreds of ions can be trapped into a single 1D
or 2D ion trap, which shows the capability to construct quantum devices with
large sizes of trapped ions Bohnet  _et al._ (2016); Zhang  _et al._ (2017);
Kiesenhofer  _et al._ (2023). Unlike the trapped-ion quantum computing
devices, which discourage large numbers of trapped ions in a single trap due
to the hardness of driving two-qubit gates by selectively driving a single
phonon mode of the trapped ion array, trapped-ion-based quantum memory devices
do not require two-qubit gates between the QMCs, which releases the
requirement of integrating trapped-ion QMCs. However, to reduce the RW
latency, designing the structure of the quantum memories consisting of many
QMCs to minimize the transporting time is an important question.

###  II.6 Neutral atoms

Neutral atoms share several advantages with ion systems, including their
intrinsic long coherence time brought by the spin degrees of freedom for
information storage, the capability of precise control, and the ease of
integration. However, neutral atoms have their own features, which distinguish
themselves from ion-based QMCs. There are several strategies to encode quantum
information into states of single atoms. Other than the hyperfine ground
states of the Rydberg atoms Sheng  _et al._ (2018); Graham  _et al._ (2019);
Levine  _et al._ (2019); Bluvstein  _et al._ (2022) (named as GG qubits in
Ref. Morgado and Whitlock (2021)), the ground state of an atom and its Rydberg
excited state, i.e., a highly excited electronic state, can also be used to
encode the qubit $\ket{0}$ and $\ket{1}$ states Levine  _et al._ (2018);
Madjarov  _et al._ (2020) (GR qubits mentioned in Ref. Picken  _et al._
(2018); Morgado and Whitlock (2021)). The coherence time of the qubits varies
according to the species of qubits and the trapped atoms, ranging from a few
microseconds to several seconds Levine  _et al._ (2018, 2019); Norcia  _et
al._ (2019); Ebadi  _et al._ (2021); Jenkins  _et al._ (2022); Barnes  _et
al._ (2022); Ma  _et al._ (2022).

Despite coupling to another neutral atom leveraging the “Rydberg blockade”
effect Lukin  _et al._ (2001); Jaksch  _et al._ (2000); Urban  _et al._
(2009), neutral atoms also have strong coupling to optical light, which makes
optical interfaces (photonic bus qubits) possible. In Ref. Langenfeld  _et
al._ (2020), two trapped Rb atoms interacting with photonic qubits with RW
efficiency $\eta^{2}\approx 26\%$ has been demonstrated. With the coherence
time of the Rb atoms reported in the same experiment ($800~{}\mu$s) and the
address pulse durations ($8~{}\mu$s) for the RW time, the internal storage
ratio is $\alpha_{\text{in}}\approx 51.0$. Using the QMC for optical quantum
computing, where the operation time is estimated by $19~{}\mu$s (see Sec. II.2
for detailed discussion), the external storage ratio reaches
$\alpha_{\text{ex}}\approx 20.5$. Note that the coherence time of other
species of atoms can have a much longer coherence time. If the Yb atoms can
achieve the same RW operations, the corresponding internal and external
storage ratio can achieve $\alpha_{\text{in}}\approx 5.0\times 10^{5}$ and
$\alpha_{\text{ex}}\approx 2.1\times 10^{5}$, respectively
($T_{\text{coh}}=7.9$ s demonstrated in Ref. Jenkins  _et al._ (2022)). The
strong coupling between the single atom and optical modes has also been
demonstrated in experiments, where $g/2\pi=3.2$ MHz is shown in Ref. Liu  _et
al._ (2023b). Although in Ref. Liu  _et al._ (2023b), it is the Cs atoms that
couple strongly to the optical modes, the RW operations of general atom-based
QMCs are expected to be further improved in the future. With the coupling
strength $g/2\pi=2.74$ MHz, the RW operations take $T_{\text{RW}}=\pi/g\approx
182.5$ ns with efficiency $\eta^{2}\approx 26\%$. The internal and external
storage ratios can reach $\alpha_{\text{in}}\approx 2.2\times 10^{7}$, and
$\alpha_{\text{ex}}\approx 2.1\times 10^{5}$, respectively, if the coherence
time of the QMC is $7.9$ s.

In addition, a cloud of neutral atoms can also be optically controlled to
serve as QMCs for optical photons. When a cloud of atoms coherently couple to
the same field, the quantum interference can boost the coupling strength
between the field and the collective mode of the atoms Scully and Zubairy
(1997). To control the photon absorption and emission, electromagnetically
induced transparency (EIT) is one of the most commonly adopted ways to
controllably absorb and emit bus optical photons, i.e., achieve RW operations.
The EIT-based atomic cloud photonic quantum memories have been demonstrated in
both cold and warm atomic ensembles Hosseini  _et al._ (2011); Dudin  _et al._
(2013); Ding  _et al._ (2013); Nicolas  _et al._ (2014); Ding  _et al._
(2015a, b); Parigi  _et al._ (2015); Saunders  _et al._ (2016); Katz and
Firstenberg (2018); Hsiao  _et al._ (2018); Jiang  _et al._ (2019); Wang  _et
al._ (2019); Li  _et al._ (2020); Dideriksen  _et al._ (2021); Wang  _et al._
(2022b); Meßner  _et al._ (2023). The EIT-based room-temperature atomic
ensemble can have $\sim 0.9$ ms storage $1/e$ lifetime Dideriksen  _et al._
(2021); Wang  _et al._ (2022b) and in total $1$ s storage time is possible
Katz and Firstenberg (2018), while the cold atom clouds with dynamical
decoupling can extend the lifetime to $16$ s Dudin  _et al._ (2013). For
classical light pulse storage, the retrieval efficiency (equivalent to
$\eta^{2}$ used in Eq. (4)) of the atomic quantum memory can achieve $92\%$
Hsiao  _et al._ (2018), while the light storage down to single-photon level
has also been demonstrated Ding  _et al._ (2015a, b); Wang  _et al._ (2019);
Buser  _et al._ (2022).

In the EIT-based QMCs made of atomic clouds, the RW operation is achieved by
absorbing and emitting light pulses carrying the quantum information. Whenever
the quantum information in the QMC is read, i.e., the light pulses are re-
emitted from the optical media, the QMC gets reset. In the writing process,
the writing time is determined by the speed of turning the control light pulse
off. This time is compatible with the signal light pulse duration. In the
cold-atom cloud system, the storage time can be estimated by the $1/e$
lifetime, where we adopt $16$ s from Ref. Dudin  _et al._ (2013). We estimate
the internal storage ratio using the read and write full-process efficiency
$\eta^{2}=0.26$ and the control light FWHM duration $1040$ ns reported in Ref.
Dudin  _et al._ (2013) as the RW time, which results in
$\alpha_{\text{in}}\approx 7.8\times 10^{6}$. Leveraging the QMCs for optical
quantum applications ($T_{\text{op}}\approx 19~{}\mu$s), the external storage
ratio is $\alpha_{\text{ex}}\approx 4.3\times 10^{5}$. If the full-process
efficiency can be improved to $0.906$ as reported in Ref. Wang  _et al._
(2019), the internal and external storage ratios can be improved to
$\alpha_{\text{in}}\approx 1.5\times 10^{7}$ and $\alpha_{\text{ex}}\approx
8.0\times 10^{5}$, respectively.

Furthermore, similar to the ions, the spin levels of atoms can also couple to
microwave photons. However, the coupling between a single atom and a single
microwave photon is weak Verdú  _et al._ (2009); Hattermann  _et al._ (2017).
Therefore, a cloud of atoms is leveraged to enhance the coupling strength Rabl
_et al._ (2006); Petrosyan  _et al._ (2009); Hattermann  _et al._ (2017); Tu
_et al._ (2022). Specifically, in Ref. Hattermann  _et al._ (2017), an
ensemble of Rb atoms coherently coupled with microwave field, enabling atomic
Rabi frequency $20$ kHz. Based on the Rabi oscillation, we estimate the RW
time as $25~{}\mu$s with efficiency $0.6$. Assuming the storage time can still
reach $800~{}\mu$s as demonstrated in Ref. Langenfeld  _et al._ (2020), the
internal storage ratio is $\alpha_{\text{in}}\approx 19.2$ 111We acknowledge
that the hyperfine states of Rb atom used in these two works are different.
Here we aim to give an estimate of the possible implementation of the QMCs..
Suppose the microwave field can couple to transmon qubits for computing, which
takes another $1~{}\mu$s for microwave-transmon coupling with efficiency
$\eta\approx 0.994$ (see Sec. II.4), the external storage ratio can be
$\alpha_{\text{ex}}\approx 1.1\times 10^{4}$. Other attempts to construct
coherent coupling between microwave fields in superconducting coplanar
waveguides and a beam of Rydberg helium atoms have been demonstrated in
experiments Thiele  _et al._ (2015); Garcia  _et al._ (2019); Morgan and Hogan
(2020). However, limited by the coherence time and the coupling strength,
high-fidelity single microwave photon level operations still need to be
demonstrated, which is needed to connect the QMCs with superconducting quantum
computing devices.

Similar to the trapped-ion systems, neutral-atom-based QMCs can be largely
integrated, and share similar benefits with trapped-ion systems. In addition,
as neutral atoms are trapped into optical lattices, which enables higher
dimensional neutral atom lattices easily Wang  _et al._ (2015, 2016); Xia  _et
al._ (2015); Maller  _et al._ (2015); Graham  _et al._ (2019), higher
dimensional integration of neutral-atom-based QMCs into quantum memory devices
is viable. Moreover, the controlled removal of the missing sites in the
optical lattices Endres  _et al._ (2016); Bernien  _et al._ (2017); Ebadi  _et
al._ (2021); Barnes  _et al._ (2022) and coherent moving of the trapped atoms
have been demonstrated Bluvstein  _et al._ (2022), which can construct a more
compact quantum memory device.

###  II.7 Rare-earth-ion-doped Solid state systems

Similar to the trapped ion systems, the quantum states of ions doped into
solid-state systems can also be precisely addressed and quantum manipulated.
Among different species of ions, the rare-earth ion doped (REID) solid-state
system is one of the other attractive systems to build optical quantum memory
McAuslan  _et al._ (2012); Saglamyurek  _et al._ (2011); Clausen  _et al._
(2011); Ledingham  _et al._ (2012); Zhou  _et al._ (2012); Ferguson  _et al._
(2016); Jin  _et al._ (2022); Ma  _et al._ (2021a), where an ensemble of doped
ions are collectively manipulated. Recently, the atomic-frequency-combs-based
(AFC) methods have been widely adopted in building a long-storage-time on-
demand REID-based optical quantum memory Seri  _et al._ (2017); Kutluer  _et
al._ (2017); Laplane  _et al._ (2017); Holzäpfel  _et al._ (2020); Businger
_et al._ (2020); Askarani  _et al._ (2021); Ma  _et al._ (2021b). In the AFC-
based photon absorption, a sequence of narrow control pulses is sent to a
broadband optical media to carve out an equal-spacing absorption spectrum,
named ‘frequency comb’ Afzelius  _et al._ (2009). The incident light can then
be absorbed into the medium, exciting the medium atoms, and then be emitted
after a period of time. The storage time is determined by the spectral spacing
between the teeth of the frequency comb. In order to make the quantum memory
on-demand, the optical excitation stored in the optical media is then
converted into other excitation, e.g., a spin-wave excitation of the media Ma
_et al._ (2021b); Askarani  _et al._ (2021); Seri  _et al._ (2017); Kutluer
_et al._ (2017); Laplane  _et al._ (2017). This scheme also takes advantage of
the long coherence time of the spin states compared to the optical excited
states. Long storage time up to $52.9$ min with dynamical decoupling has been
demonstrated Ma  _et al._ (2021b). The efficiency of $26.9\%$ has been reached
for the AFC storage and retrieval. Converting the excitations to spin waves
reduces the overall efficiency, causing the full-process efficiency to reduce
to $\approx 7\%$ in experiments Zhu  _et al._ (2022). The conditional storage
fidelity can reach $99\%$ Zhou  _et al._ (2012); Zhu  _et al._ (2022). Further
improving the retrieval efficiency is still a challenging question of the
rare-earth ion-doped solid-state optical memory.

To estimate the REID QMCs’ internal and external storage ratios, we notice
that the AFC technique requires a preparation step before the RW operations Ma
_et al._ (2021b); Zhu  _et al._ (2022), i.e., a control light pulse is needed
to prepare the medium’s absorption spectrum into a frequency comb. This
preparation time differs from the RW time in the definition of the internal
storage ratio $\alpha_{\text{in}}$ (see Eq. (2)). Nevertheless, we can still
treat it as a time overhead to estimate the bare RW time $\tau$. Based on the
experiment reported in Ref. Ma  _et al._ (2021b), the internal storage ratio
can be estimated as $\alpha_{\text{in}}\approx 4.8\times 10^{2}$, where we
adopt $52.9$ min coherence time as the storage time, and the storage
efficiency with dynamical decoupling as the RW efficiency $\eta^{2}\approx
0.37\%$. As the exact time for the preparation pulses is not explicitly
reported in Ref Ma  _et al._ (2021b), we estimate it by $400$ ms reported in
Ref. Zhu  _et al._ (2022). The corresponding external storage time is
estimated as $\alpha_{\text{ex}}\approx 1.0\times 10^{7}$, with photon EPR
pair generation time $T_{\text{op}}=19~{}\mu$s. This shows that the QMC has a
long storage time compared to a fast EPR generation process, but a relatively
short storage time compared to its own RW operations (storage preparation time
overhead). One limitation is the low efficiency. Imagining the storage
efficiency can be improved to $26.9\%$, which is the AFC efficiency as
reported in Ref. Zhu  _et al._ (2022), the internal storage time can be
improved to $\alpha_{\text{in}}\approx 4.1\times 10^{3}$. Accordingly, the
external storage time can be $\alpha_{\text{ex}}\approx 8.7\times 10^{7}$.

Similar to the trapped ions, the spin levels of the ions can couple to
microwave fields, which makes a microwave-based bus qubit possible for quantum
memory. There are several experimental attempts to use the spin states and
hyperfine spin states of the ions to store microwave fields Probst  _et al._
(2013, 2015); Wolfowicz  _et al._ (2015). However, the coherent storing and
reading out of a quantum microwave state is still lacking to fully demonstrate
the feasibility of using REID crystals as a robust and reliable microwave
memory.

###  II.8 Solid-state defect centers

Solid-state defect centers have emerged as promising candidates for quantum
memory due to their long coherence times and controllable electronic and
nuclear spin states. Among all solid-state defect centers, the nitrogen-
vacancy (NV) centers in diamond are one of the most promising ones due to
their long spin coherence time even at room temperature Doherty  _et al._
(2011, 2013). The negatively charged NV centers are spin-1 systems, where the
electronic spin states can be used to encode quantum information. The spin
states can have $1.8$ ms lifetime in isotopically pure diamond samples without
dynamical decoupling Balasubramanian  _et al._ (2009). Although the nearby
nucleus with nonzero spin creates a spin bath and decohere the spin states,
the coherence time can be greatly extended with dynamical decoupling Bar-Gill
_et al._ (2013); Abobeih  _et al._ (2018, 2022), to $1.58$ s Abobeih  _et al._
(2018) for electronic spin states.

One natural choice of bus qubits for QMCs built on NV electronic spin states
can be optical photons, as NV centers can be used as single-photon emitters.
The entanglement between NV center spin states and the emitted photons has
been demonstrated Togan  _et al._ (2010). The heralded entanglement generation
between remote NV centers has been realized in experiments Bernien  _et al._
(2013); Pfaff  _et al._ (2014); Hensen  _et al._ (2015); Pompili  _et al._
(2021); Hermans  _et al._ (2022). One disadvantage of this scheme is that the
NV centers have a broad phonon side band Doherty  _et al._ (2011, 2013), which
largely reduces the success probability. Another factor that decreases the
success probability is the photon collection efficiency. In our analysis of
using heralded entanglement generation schemes, the low success probability
results in slow RW operations. To solve this problem, nano-photonic crystal
structures have been utilized to Purcell enhance the photon emission to the
zero-photon line and increase photon collection efficiency Hausmann  _et al._
(2013); Riedel  _et al._ (2017).

The nearby carbon and nitrogen nuclear spin levels (hyperfine levels) have
extra long coherence time compared to electronic spin states Maurer  _et al._
(2012). With dynamical decoupling, the coherence time can reach $63$ s Bradley
_et al._ (2019); Abobeih  _et al._ (2022). The manipulation of these nuclear
levels can be achieved using NV electronic states, which enable using the
nuclear spin states as QMCs Maurer  _et al._ (2012); Bradley  _et al._ (2019);
Pompili  _et al._ (2021); Bartling  _et al._ (2022); Hermans  _et al._ (2022);
Xie  _et al._ (2023), while using the NV electronic state as the bus qubit.
The gate time between nuclear and electronic states ranges from $389~{}\mu$s
to $1556~{}\mu$s Bradley  _et al._ (2019); Abobeih  _et al._ (2022). The
nearby nuclear spin ensemble also has a long coherence time and is possible to
store quantum information. The coherence time can reach $3.5$ ms with
dynamical decoupling Wang  _et al._ (2023).

With the experimental realizations of NV-center-based quantum systems shown in
Ref. Abobeih  _et al._ (2022), we can estimate the QMC performance. If carbon
nuclear spins are used as QMCs, the storage time can be estimated by the
coherence time $T=12.9$ s with dynamical decoupling. The quantum gate between
carbon nuclear spin states and the NV electronic states takes $419~{}\mu$s
with fidelity $F_{\text{gate}}=0.99$, which is used to estimate the properties
of RW operations. The internal storage ratio can reach
$\alpha_{\text{in}}\approx 3.05\times 10^{4}$. Note that in this work, there
are five carbon nuclear states used. We choose to report the largest internal
storage ratio. Although the nitrogen nuclear spin states are not used as
quantum memory in Ref. Abobeih  _et al._ (2022), making it a QMC that can
benefit from the fast gate speed ($389~{}\mu$s) and the long coherence time
with dynamical decoupling ($63$ s). With the estimated gate fidelity $0.94$,
the internal storage ratio can be $\alpha_{\text{in}}\approx 1.5\times
10^{6}$. However, one caveat of this approach is to connect the bus qubit,
i.e., the electronic state of NV centers, to other computing registers.
Although universal computing can be performed by controlling the bus qubit (NV
center electronic state) and a nearby nuclear spin (nitrogen in Ref. Abobeih
_et al._ (2022)), how to scale up the systems is still an interesting question
to explore.

Except for using the quantum state of a single defect center as a QMC, an
ensemble of color centers can be treated as a spin ensemble, which can
coherently couple to microwave fields. It enables microwave photons as bus
qubits Diniz  _et al._ (2011); Zhu  _et al._ (2011); Kubo  _et al._ (2011,
2012); Heshami  _et al._ (2014); Kalachev  _et al._ (2019). Similar to REID
crystals and atomic clouds, optical photon storage techniques, e.g., AFC and
EIT methods, can also be applied in principle. Using microwave photons as bus
qubits makes the coherent coupling to microwave-connected systems possible,
e.g., to superconducting qubits Kubo  _et al._ (2011, 2012). Direct coupling
NV center ensembles with a flux qubit has also been reported in Ref. Zhu  _et
al._ (2011). Specifically, in the experimental demonstration in Ref. Kubo  _et
al._ (2011), the Ramsey measurement gives an estimate on the storage time of
the NV ensembles $T_{\text{storage}}\approx 200$ ns. The RW of the stored
state by superconducting qubits takes $58$ ns with fidelity
$\eta=\sqrt{0.14}$. The internal storage ratio is $\alpha_{\text{in}}\approx
1.3$. Limited by the coherence of the NV ensembles, the net storage time is
smaller than twice of rescaled RW time $T_{\text{RW}}/\eta$, so the external
storage ratio $\alpha_{\text{ex}}<0$. If the electronic states can be
transferred to nuclear spin ensembles, where the coherence time can reach
$1.8$ ms can be achieved, the internal and external storage ratio can be
improved to $\alpha_{\text{in}}\approx 1.2\times 10^{4}$ and
$\alpha_{\text{ex}}\approx 1.7\times 10^{4}$, which is compatible to
homogeneous superconducting devices. To further take benefits from the NV-
ensemble-based QMCs, extending its storage time and improving the RW
operations is needed.

In general, solid-state defect centers can be compactly integrated into a
single crystal. The defect color centers inside the solid state systems can be
nicely fabricated and implanted inside the solid crystal, which makes large-
scale integration possible. In addition, other types of defect centers, e.g.,
SiV Bhaskar  _et al._ (2020); Starling  _et al._ (2023); Stas  _et al._
(2022), GeV Siyushev  _et al._ (2017), SnV Debroux  _et al._ (2021) color
centers, are also under investigation to improve their coherence properties
and develop new quantum manipulation techniques.

###  II.9 Quantum dots

Semiconductor-based quantum dot (QD) system has been attracting much attention
in quantum computing and quantum information processing in recent years.
Compared with other quantum systems, quantum dots can be fabricated by the
well-developed deposition and lithography techniques used in the semiconductor
industry. The small size of the QDs ($\sim 100$ nm) makes them easy to be
integrated largely Maurand  _et al._ (2016); Vandersypen  _et al._ (2017);
Fedele  _et al._ (2021); Zajac  _et al._ (2018); Mills  _et al._ (2022);
Burkard  _et al._ (2023). With the available high-fidelity quantum gates,
semiconductor-based quantum dots can be potentially used as one of the
candidates for quantum memory cells.

Quantum dot-based spin qubits have multiple ways to encode quantum information
into the physical systems. As each quantum dot can confine an electron, which
is a spin-$1/2$ particle, one natural way to encode quantum information is to
use the spin state of the confined electron. The corresponding spin qubit is
called ‘Loss-DiVincezo’ (LD) qubit Loss and DiVincenzo (1998); Mills  _et al._
(2022); Xue  _et al._ (2022); Zajac  _et al._ (2018); Yoneda  _et al._ (2018);
Tanttu  _et al._ (2023); Noiri  _et al._ (2022). Long coherence time up to
$20~{}\mu$s has been demonstrated in experiments Yoneda  _et al._ (2018). With
Hahn echo techniques, the coherence time can be extended to $100~{}\mu$s Mills
_et al._ (2022); Yoneda  _et al._ (2018); Tanttu  _et al._ (2023). When there
are multiple quantum dots available, especially when the tuning barriers
between the quantum dots are relatively low, the electrons confined in the
nearby quantum dots can couple with each other and form entangled states. The
quantum information can also be encoded into the state of multiple electrons.
For example, the ‘singlet-triplet’ (ST) qubit utilizes two entangled electrons
confined in two nearby quantum dots Cerfontaine  _et al._ (2020); Fedele  _et
al._ (2021); Takeda  _et al._ (2020); Nichol  _et al._ (2017). ST qubits also
show promising long spin coherence time ($\sim 2~{}\mu$s) Takeda  _et al._
(2020). The quantum information is encoded into the singlet state and one of
the three triplet states. The total spin $1/2$ states of three electrons can
also be leveraged as a manifold to define a spin qubit Weinstein  _et al._
(2023). As the quantum dot spin qubits in this type can realize universal
quantum computing only by controlling the exchange couplings between different
dots, this type of qubit is named an ‘exchange-only’ (EO) qubit DiVincenzo
_et al._ (2000); Bacon  _et al._ (2000); Burkard  _et al._ (2023); Weinstein
_et al._ (2023). For a comprehensive review of the recent development of
semiconductor quantum dot qubits, we suggest Ref. Burkard  _et al._ (2023).

QD qubits can strongly couple to microwave fields in a superconducting
resonator. The microwave field can have stronger coupling to the charge
degrees of freedom Stockklauser  _et al._ (2017); Mi  _et al._ (2017);
Scarlino  _et al._ (2019), while the spin degrees of freedom of QDs can have
longer coherence time Mi  _et al._ (2018); Landig  _et al._ (2018, 2019);
Samkharadze  _et al._ (2018). From the spectral measurements, QD charge qubits
can have a strong coupling up to $\sim 119$ MHz Stockklauser  _et al._ (2017),
while the spin qubits can a have coupling to microwave field $52$ MHz Landig
_et al._ (2019). Therefore, using microwave photons as bus qubits for a QD-
based QMC is available. Moreover, as superconducting qubits can couple to
resonators strongly, using the microwave field to couple superconducting
qubits with QDs has also been demonstrated in experiments Landig  _et al._
(2019); Scarlino  _et al._ (2019). Therefore, a transmon qubit can also be
used as a bus qubit for QD-based QMCs. Specifically, the Rabi oscillation
between a transmon qubit and a QD charge qubit is experimentally demonstrated
Scarlino  _et al._ (2019).

Based on Ref. Scarlino  _et al._ (2019), the coherence time of QD is estimated
as $59$ ns (FWHM linewidth is $2.7$ MHz). The RW operation quality can be
estimated from the Rabi oscillation, where the RW time is estimated as
$T_{\text{RW}}\approx 23.8$ ns, and the efficiency is estimated as $0.8$.
Therefore, the internal storage ratio reaches $\alpha_{\text{in}}\approx
1.98$. This means further improving the coherence time of QD qubits while
maintaining the strong coupling to microwave resonators and superconducting
qubits is needed. Note that the rescaled single RW operation time is
comparable to the storage time, the external storage ratio is negative, which
means the current QD-based QMCs still need improvement to gain advantages.
Suppose the coupling can be tuned such that the QMCs can still maintain good
coherence time ($T_{2}\approx 102~{}\mu$s in Ref. Mills  _et al._ (2022)),
while the RW operations are still as good as demonstrated in Ref. Scarlino
_et al._ (2019), the internal storage ratio can reach
$\alpha_{\text{in}}\approx 3.4\times 10^{3}$. Considering using this QD-based
QMC for superconducting quantum computing devices, where the operation time is
$T_{\text{op}}=40$ ns ($F\approx 99.8\%$), the external storage ratio can be
improved to $\alpha_{\text{ex}}\approx 2.0\times 10^{3}$.

###  II.10 Phononic systems

Phononic systems are also widely considered within the context of hybrid
quantum systems Xiang  _et al._ (2013); Kurizki  _et al._ (2015); Clerk  _et
al._ (2020) because they can interact with circuit-QED systems through the
piezoelectric effect, as well as with optical systems through the
optomechanical effect. This makes photonic systems an intermediary system for
microwave-to-optical transduction, which has been a key focus in recent
efforts to achieve long-range quantum communication between circuit-QED
devices Andrews  _et al._ (2014); Bagci  _et al._ (2014); Shao  _et al._
(2019); Forsch  _et al._ (2020); Zhong  _et al._ (2020); Xu  _et al._ (2021a);
Mirhosseini  _et al._ (2020). For a review of recent progress on nano-phononic
systems, we refer to Refs. Vasileiadis  _et al._ (2021); Bachtold  _et al._
(2022); Heinrich  _et al._ (2021).

Unlike electromagnetic waves, acoustic waves require media to propagate,
making phononic modes well-isolated and beneficial for maintaining a long
lifetime. For example, in nano-mechanical resonators which hold phonon modes
with frequency $\sim 1.4$ MHz, the single-phonon lifetime can reach $100$ s to
$1000$ s Seis  _et al._ (2022); Beccari  _et al._ (2022). The coherence of the
phonon modes can reach $100$ ms Seis  _et al._ (2022). The lifetime of phonon
modes with GHz frequencies in nano-acoustic resonators can reach $1.43$ s,
while the coherence time can reach $130~{}\mu$s MacCabe  _et al._ (2020).
Therefore, the photonic modes can build QMCs where the quantum information is
stored in the oscillations of these phonon modes. Fast coherent couplings
between microwave modes (superconducting qubits) and the phononic modes
provide necessary tools to manipulate the phononic modes in the quantum regime
and show its quantum features Teufel  _et al._ (2011); Mirhosseini  _et al._
(2020); Wollack  _et al._ (2022). An iSWAP gate between the microwave modes
and phononic mode can only take $25$ ns with fidelity $0.95$ Wollack  _et al._
(2022). Strong dispersive couplings between the microwave and phononic modes
have also been realized in experiments Wollack  _et al._ (2022); von Lüpke
_et al._ (2022), which can be used to couple phononic modes with microwave and
optical photons as well. This makes using microwave and optical photons as the
bus qubits possible. In addition, phononic QMCs can be integrated with
superconducting qubits for fast quantum gate operations with the help of
microwave bus qubits.

Using the phonon modes as QMCs and microwave photons as bus qubits, the
internal storage time of phononic QMCs can be estimated as
$\alpha_{\text{in}}\approx 4.9\times 10^{3}$, where we consider the GHz-
frequency phonon modes as the QMCs, as they naturally couple to the microwave
bus modes and can be integrated with superconducting qubits. As coupling the
microwave bus qubit with the superconducting qubit extends the RW time, to
consider the external storage time, we take the coupling between the
superconducting qubits and the microwave photon bus qubits into the
consideration of phonon-based QMC RW operations ($\approx 1.04~{}\mu$s in
total Chakram  _et al._ (2021), with efficiency $\eta\approx 0.95\times
0.994$). We then take the time for a two-qubit gate between superconducting
qubits as a quantum computing operation time ($40$ ns). The external storage
time can reach $\alpha_{\text{ex}}\approx 3.02\times 10^{3}$.

Furthermore, the phononic modes can also couple to photonic modes via
optomechanical effect, where the coherent coupling strength $g/(2\pi)\approx
700$ kHz has been demonstrated Stockill  _et al._ (2022). Therefore, using
optical photons as the bus qubits of a phononic-mode-based QMC is possible. In
this case, the RW time of the QMC can be estimated as $0.71~{}\mu$s, where we
consider the RW operation with unit fidelity for the estimation. The internal
storage ratio can be estimated as $\alpha_{\text{in}}\approx 1.8\times 10^{2}$
with storage time $130~{}\mu$s MacCabe  _et al._ (2020). Using GHz phonon mode
QMCs to store photonic qubits in optical quantum computing and quantum
communication is also possible. With EPR pair photon generation rate at
$52.36$ kHz, the external storage ratio $\alpha_{\text{ex}}\approx 6.7$. If
the MHz phonon QMCs can have a similar RW speed with optical bus qubits, the
internal and external storage ratios can reach $\alpha_{\text{in}}\approx
1.4\times 10^{5}$ and $\alpha_{\text{ex}}\approx 5.2\times 10^{7}$, which
means the phonon-based QMC needs to improve its coherence time and QMC-bus
coupling speed to further enhance its performance.

Similar to microwave-cavity-based QMCs, as a mechanical membrane or acoustic
resonator can support multiple phonon modes, these modes can all be used as
QMCs. Therefore, the phononic QMCs can be easily integrated to form a quantum
memory device. In addition, the small physical scale of the phononic systems
makes them easily fit into a single dilution refrigerator, which can be
integrated with superconducting quantum computing chips.

###  II.11 Others platforms

In addition to the physical systems we discussed above, there has been
significant interest in using topologically protected states for quantum
computing. One effort includes using the topological error correction codes to
encode physical qubits to logical qubits, whose quantum information is
topologically protected. One example is the surface code Bravyi and Kitaev
(1998); Dennis  _et al._ (2002); Fowler  _et al._ (2012). Using the
topological error correction codes for quantum memory has been discussed in
the seminal reviews Refs. Terhal (2015); Brown  _et al._ (2016). This approach
is not limited to any specific physical platforms. Another approach is to use
the physical topological states as the basic physical qubits. In this
scenario, as the physical qubit is robust to local imperfections, these
physical qubits can be more robust compared to other physical qubits and
reduce the QEC overhead. For example, the Majorana zero modes (MZM) localized
on superconducting nanowires can be used as physical systems to encode quantum
information. By braiding the MZMs, gate operations between qubits can be
applied Alicea  _et al._ (2011). A complimentary review of the theory and
experimental realization of the MZM in the solid-state systems can be found in
Ref. Sarma  _et al._ (2015), while achieving couplings between Majorana qubit
and superconducting qubit has also been proposed Chirolli  _et al._ (2022).
Reviews of topological quantum computing can be found Roy and DiVincenzo
(2017); Lahtinen and Pachos (2017). Despite that the experimental realization
of the MZM modes is still under some debate, it has the potential to become a
promising technology to realize topologically protected quantum memory.

##  III Building Quantum Memory Devices

With the development of single QMCs, how to integrate individual QMCs into a
quantum memory device (QMD) is the next question to explore. Similar to the
classical memory device, in order to address QMCs efficiently, it is necessary
to assign addresses to QMCs such that each QMC can be accessed by its address.
In Fig. 4, we show an abstraction of a quantum memory device. A quantum memory
device should have at least three interfaces: input, output, and address
ports. In the memory loading phase, the address is given, and the quantum
information carried by the QMC with the given address is exported to the
output port. In the writing phase, the quantum information is fetched into the
QMD through the input port and saved to the QMC with the given address. In
contrast to a classical memory, all the quantum memory ports can either carry
classical or quantum information. The unitary nature of quantum operations
requires to have an additional address port for address information.

Figure 4: The abstraction of a quantum memory device. A general quantum memory
device should have four ports, input, output, and two address ports. All these
ports can be either classical information or quantum information.

In order to consider different quantum memory designs and physical
implementations, we define metrics to quantitatively discuss the device
performance. A good quantum memory device should have fast RW speed, long
storage time, and, ideally, a large scale of integration of QMCs. First of
all, the internal storage time $\alpha_{\text{in}}$ discussed in Eq (2) can be
extended to

$\text{Storage ratio:
}\alpha_{\text{QMD}}=\frac{T_{\text{storage}}}{T_{\text{RW}}},$ (5)

where $T_{\text{RW}}$ is the read and write time of the quantum memory device.
Compared to the metric of QMCs, addressing the proper QMC also takes time and
may dominate the RW process. We define the QMD RW time as
$T_{\text{RW}}=T_{\text{addr}}+T_{\text{RW,QMC}}$, where $T_{\text{addr}}$ is
the addressing time and $T_{\text{RW,QMC}}$ is the RW time for the QMCs. The
numerator $T_{\text{storage}}$ is the storage time of the quantum device. For
near-term implementation, where the quantum memory is not error corrected, the
coherence time of the QMC qubits inside the memory device can be a good
measure, and hence $T_{\text{storage}}=T_{\text{coh}}-T_{\text{RW}}$. While in
the FTQC regime, the storage time can be estimated by the inverse of the
logical error rate.

On the other hand, the external storage ratio $\alpha_{\text{ex}}$ can also be
similarly extended to describe the performance of a QMD by using QMD RW time
$T_{\text{RW}}$ in Eq. (4). However, to better quantify QMD’s performance,
especially to quantify its operation time relative to the computing operation,
we consider a new metric,

$\text{Memory latency: }\beta=\frac{T_{\text{RW}}/\eta}{T_{\text{op}}},$ (6)

where $T_{\text{op}}$ is the time for a quantum operation on the quantum
computing module. This parameter $\beta$ effectively describes the latency of
the QMD measured by the quantum computing speed, and hence is called the
memory latency. An ideal quantum memory device should have a small latency.

In addition to these two metrics, we define another quantity named
addressability,

$\text{Addressability:
}\gamma=\frac{1}{\alpha_{\text{QMD}}}\cdot\frac{N}{n}=\frac{T_{\text{RW}}N}{T_{\text{storage}}n},$
(7)

where $N$ is the memory capacity, i.e., the total number of QMCs integrated
inside the quantum memory device, and $n$ is the number of QMCs that can be RW
in parallel. The meaning of the addressability $\gamma$ is the fraction of the
QMCs that can be addressed in the memory cycle allowed by the storage time of
the quantum device. Ideally, we want a quantum memory device to have
$\gamma<1$. If $\gamma\gg 1$, the quantum memory device essentially integrates
too many QMCs to be fully utilized, and the RW of the QMC is the bottleneck.

###  III.1 Comparison between RAQM and QRAM

Table 2:  Comparison between the RAQM and QRAM. We highlight their difference and the key features of each device. |  RAQM |  QRAM
---|---|---
Address Info |  Classical |  Quantum (encoded in the states of address qubits)
Addressing |  Classical |  Coherently routing bus qubits
Stored Info |  Quantum |  Classical or Quantum

We focus on the two major types of QMDs:: (1) Random access quantum memory
(RAQM), and (2) Quantum random access memory (QRAM). In this subsection, we
briefly compare RAQM and QRAM in terms of their differences and applications.
More detailed discussion and reviews on previous efforts of building these two
devices can be found in the following subsections.

A Random Access Quantum Memory (RAQM) is a quantum analog of classical random
access memory, more specifically, a dynamical RAM in classical computer
architecture. In a RAQM, many QMCs are integrated into a QMC array to store
quantum information. The QMCs can be addressed individually according to their
addresses. A RAQM only allows classical address information, which means the
QMCs can only be addressed separately. Addressing QMCs can be realized by
classical controls on the QMC array. Mapping it to the model of quantum memory
shown in Fig. 4, the input address information is purely classical and is kept
classical during the memory query. The structure of RAQM and its functionality
will be discussed in detail in Sec. III.2.

On the other hand, a Quantum Random Access Memory (QRAM) distinguishes itself
from classical RAM and RAQM by enabling coherent addressing of multiple QMCs.
Coherent addressing requires a significant modification of the classical
addressing techniques. Specifically, the quantum address information must be
represented as quantum states of address qubits. In the abstract QMD models
(Fig. 4), a QRAM can take both quantum input and quantum address information.
The structure of a QRAM, especially its quantum addressing components, and its
functionalities are discussed in Sec. III.3.

In Table. 2, we highlight the differences between RAQMs and QRAMs. We notice
that both RAQM and QRAM are analogous to the classical random access memory,
however, in two distinct directions. As demonstrated in Sec. III.2, the RAQM
stresses the quantum nature of the memory cells, where the quantum information
can be stored and retrieved, while the random access feature is purely
classical. Therefore, quantum error correction and mitigation techniques need
to be implemented on the quantum memory cells to improve the information
storage fidelity. On the other hand, demonstrated in Sec. III.3, the QRAM
focuses more on quantum routing to coherently address the information stored
in the memory array. To improve the noise resilience, quantum error correction
needs to be implemented on the quantum routing structure.

Although a QRAM, in principle, has all the functionalities of a RAQM, we still
believe RAQMs are an indispensable part of quantum computing architectures in
the future. As we discussed in Sec. III.3, if the address qubit is in a
classical state, which corresponds to a single classical address, the quantum
routing module in the QRAM can guide the bus qubit to the QMC
deterministically. Therefore, using SWAP gates as the RW operations can read
from and write to the QMC as a RAQM. However, the classical addressing in
RAQMs is unnecessary to be protected by quantum error correction. Therefore,
if classical addressing is sufficient for a quantum computing task, using
RAQMs can greatly reduce the overhead of QEC on routing.

Table 3:  Quantum memory devices with different requirements on the reading and writing process. In the memory reading process, the output and address information can be classical or quantum, while in the memory writing process, the input data and address data can be classical or quantum, too. When one bit of classical data needs to be stored in a QMC, the bus qubit needs to be prepared into $\ket{0}$ or $\ket{1}$ state and then perform the QMC writing process. When quantum data needs to be converted into a classical output, projective measurements on the state of the QMC qubit are required, which is labeled as ‘M’ in the table. N.A. specifies the situations where the application is not clear. The blue-shaded case is purely classical, whereas the red-shaded cases attract lots of attention in the current quantum computing research (see main text for more detailed discussion). Reading requirement |  Writing requirement |  Physical Realization
---|---|---
Output/Address |  Input/Address |
Classical/Classical |  Classical/Classical |  Classical Memory
Classical/Quantum |  Classical/Classical |  QRAM + M
Quantum/Classical |  Classical/Classical |  RAQM
Quantum/Quantum |  Classical/Classical |  QRAM
Classical/Classical |  Quantum/Classical |  RAQM + M
Classical/Quantum |  Quantum/Classical |  QRAM + M
Quantum/Classical |  Quantum/Classical |  RAQM
Quantum/Quantum |  Quantum/Classical |  QRAM
Any |  Classical/Quantum |  N.A.
Any |  Quantum/Quantum |  N.A.

In Table. 3, according to the demand of the QMD ports in the loading and
writing processes, we briefly summarize the possible realizations of the QMD.
Given a memory device only stores classical information in memory cells with
classical address, while it is expected to read the memory cells according to
a given classical address and output classical data, the memory device can be
a classical memory (the first row of Table 3). If the QMD needs to store
quantum information according to classical address information in the writing
process, while it loads the quantum information according to classical
addresses, the QMD can be made by a RAQM (the row of ‘Quantum/Classical,
Quantum/Classical’ in Table 3). Supposing a QMD is required to process quantum
address information in the reading process, the QMD has to be a QRAM (see
‘Quantum output, quantum address’ and ‘Classical output, quantum address’ rows
in Table 3). If the output port needs to be connected with classical
information processing modules after the memory reading process, the output
information needs to be classical. As both RAQM and QRAM will output quantum
states in general, the QMD is required to take measurements of the quantum
states and extract classical information from the output state. Therefore, it
can be constructed by a RAQM or QRAM followed by measurements. On the
contrary, in the data writing process, coherent addressing of multiple QMCs
inside the memory device is possible through the QRAM. However, the physical
application is still unclear to our best knowledge Liu  _et al._ (2022).

In the rest of this section, we provide a more detailed discussion on RAQMs in
Sec. III.2 and QRAMs in Sec. III.3.

###  III.2 Random Access Quantum Memory (RAQM)

Figure 5: The structure of a RAQM. The classical addressing is achieved using
the classical control and classical address decoding scheme, similar to the
classical RAM construction. The memory cells are QMCs, which can store quantum
information. The quantum information in the bus qubits can be addressed to the
QMC with the correct address and SWAP quantum information between them. The
quantum computing registers can couple with the bus qubits to perform further
information processing.

The architecture of the RAQM is illustrated in Fig. 5. The classical
addressing is accomplished through the classical control unit and the
classical address decoding schemes. The control unit guides the bus qubit to
interact with different QMCs to perform RW operations. The accessing mechanism
shares similarities to a classical RAM. Other quantum registers can interact
with the bus qubit to communicate with the RAQM.

During the writing process, the bus qubit is loaded with the quantum state
that needs to be stored. With the classical address given, the QMC with this
address interacts with the bus qubit and performs a SWAP gate to store the
quantum state into the corresponding QMC. The writing process can be formally
expressed as

$\displaystyle W(addr,\ket{\phi})\ket{0}_{ind=addr}\otimes\ket{\psi}_{ind\neq
addr}$
$\displaystyle\rightarrow\ket{\phi}_{ind=addr}\otimes\ket{\psi}_{ind\neq
addr}$ (8)

where $addr$ is the classical address information, $ind$ is the classical
index of the QMCs in the QMC array. We assume the state of the QMC before the
writing process is in state $\ket{0}$.

During the reading process, a classical address is given. The QMC with the
address qubit interacts with the bus qubit to perform a SWAP gate to swap the
quantum state to the bus qubit. The reading process can be formally expressed
as

$\displaystyle R(addr)\ket{\phi}_{ind=addr}\otimes\ket{\psi}_{ind\neq addr}$
$\displaystyle\rightarrow\ket{\phi}_{(b)}\otimes(\ket{0}_{ind=addr}\otimes\ket{\psi}_{ind\neq
addr})$ (9)

where we assume that the QMC with the required address $addr$ is initially in
the state $\ket{\phi}$, and it is disentangled with the other qubits for
simplicity. After the reading process, the bus qubit is in the state
$\ket{\phi}$.

Combining both reading and writing processes, operations on RAQM can be
expressed as

$\displaystyle
F_{\text{RAQM}}(addr,\ket{\phi}^{(\text{b})},\ket{\Psi}^{(\text{QM})})$
$\displaystyle=\sum_{j}\alpha_{j}f_{\text{QMC}}(\ket{\phi}^{(\text{b})},\ket{\lambda_{j}}^{(\text{QM})}_{ind=addr})\otimes\ket{\psi_{j}}^{\text{(QM)}},$
$\displaystyle=\sum_{j}\alpha_{j}\ket{\lambda_{j}}^{(\text{b})}\ket{\phi}^{(\text{QM})}_{ind=addr}\otimes\ket{\psi_{j}}^{(\text{QM})},$
(10)

where the operation on a single QMC $f_{\text{QMC}}$ is shown in Eq. (1).
Here, we express the quantum state of the QMC arrays in a Schmidt
decomposition form

$\ket{\Psi}^{(\text{QM})}=\sum_{j}\alpha_{j}\ket{\lambda_{j}}^{(\text{QM})}_{ind=addr}\ket{\psi_{j}}^{(\text{QM})},$
(11)

where the states $\ket{\lambda_{j}}$ are basis states of the QMC qubit with
index $ind=addr$ in the decomposition process. However, as we mentioned in
Sec. II.1, the RW process involves the exchange of entanglement between the
bus qubit and the memory qubits. Generalizing to a more complicated scenario
where the qubits are entangled with additional qubits is obvious.

According to the current implementation of RAQMs in photonic and microwave
systems, high-quality QMCs for the memory array are critical. In addition, the
following requirements also have to be fulfilled:

  1. 1.

Independent classical addressing of individual QMCs: The capability for
independent addressing enables parallel addressing of different QMCs.

  2. 2.

Independent quantum information storage: It is necessary that the quantum
state within one QMC remains decoupled from the states of other QMCs when
operating separately. Ideally, the cross-talk between different QMCs should be
avoided.

The primary application of the RAQM resides in its utilization as an
integrated memory device for quantum computing, a topic that will be explored
further in the subsequent sections. The integration of QMCs into an array
enables the storage of quantum states of a large number of qubits.
Additionally, the classical random access functionality enables the storage
and retrieval of quantum states in various QMCs at different times. More
applications of RAQM in various quantum memory function units will be
discussed in Sec. IV.

####  III.2.1 Experimental demonstration of RAQMs

There have been experimental demonstrations of constructing a RAQM, ranging
from storing quantum information carried by a matter qubit to a photonic
pulse. A comparison between different implementations of RAQM is summarized in
Table 4. In the rest of this subsection, we briefly survey a few experimental
demonstrations of RAQMs and discuss their performance.

Table 4:  Comparison of different experimental demonstrations of RAQMs in
various physical platforms.

QMC array |  Stored QI |  Memory Capability ($N$) |  Coherence time ($T_{2}$) |  RW fidelity ($F$) |  Efficiency ($\eta$) |  $\alpha$ |  $\beta$ |  $\gamma$ ($n=1$)
---|---|---|---|---|---|---|---|---
Atomic clouds Jiang  _et al._ (2019); Li  _et al._ (2020) |  photonic pulse ($\langle n\rangle\sim 0.5)$ |  210 QMCs, 105 qubits |  $T_{2}=27.8~{}\mu$s Jiang  _et al._ (2019) |  $F>0.9$ for $2~{}\mu$s storage |  $\eta\sim 2\%$ to $18\%$ |  $39$ to $118$ Jiang  _et al._ (2019) |  $0.012$ to $0.037$ Jiang  _et al._ (2019) |  $1.78$ to $5.3$ Jiang  _et al._ (2019), $0.31$ Chang  _et al._ (2019)a
Single atoms Langenfeld  _et al._ (2020) |  photon pulse ($\langle n\rangle\sim 1)$ |  2 qubits |  $T_{2}=800~{}\mu$s Langenfeld  _et al._ (2020) |  |  $\eta=26\pm 3$%b |  $8.2$ ($2.0\times 10^{2}$)c |  $4.1$ ($0.21$)c |  $0.20$ ($0.01$)c
Ensemble of Two-Level systems O’Sullivan  _et al._ (2022) |  photon pulse ($\langle n\rangle\sim 100$)d |  4 modes demonstrated, 16 qubits in total |  $T_{2}=2.0\pm 0.2$ mse |  |  $\eta=0.03\pm 0.02$ |  6.2 |  61 f |  2.56
Microwave modes |  Transmon states |  9 qubits |  $T_{2}\sim 2$ to $3$ msg $T_{2}^{*}\sim 1$ to $10~{}\mu$sh |  $89.0\pm 2.9$% to $96.3\pm 0.7$%${}^{\text{i}}$Naik  _et al._ (2017) |  |  $7.5$ to $415$ h, $2.0\times 10^{3}$ to $5.9\times 10^{3}$ g |  $2.63$ to $0.508$ h, $12.6$ to $25.3$ g |  $1.20$ to $2.16\times 10^{-2}$ h, $0.17$ to $0.5$ g

  * a

This is estimated using QMC coherence and RW time parameters given in Ref.
Jiang  _et al._ (2019) bur with only 49 QMCs integrated into the device as
demonstrated in Ref. Chang  _et al._ (2019),

  * b

This is for the setup to reduce the cross illustration.

  * c

This is estimated using possible improved RW time $2~{}\mu$s as pointed out in
Ref. Langenfeld  _et al._ (2020).

  * d

The photon pulses are microwave pulses.

  * e

This is measured without dynamical decoupling sequences.

  * f

Connecting this RAQM with superconducting-qubit-based quantum computing
device.

  * g

3D microwave cavity, see Ref. Chakram  _et al._ (2021).

  * h

2D resonator modes, see Ref. Naik  _et al._ (2017).

  * i

iSWAP gate fidelity from randomized benchmarking, which contains the error
from the resonator modes and the transmon.

In 2017, Naik et al. experimentally demonstrated a circuit-QED system, which
can be used as a small RAQM Naik  _et al._ (2017). The QMCs are made by 11
strongly coupled resonators. The modes in individual resonators are coupled to
form collective modes, where 9 of them are used as the QMCs in the RAQM. The
bus qubit is a transmon qubit, which can be classically controlled through
microwave parametric driving to perform iSWAP gates between the transmon mode
and the selective resonator mode. The iSWAP gate fidelity ranges from $95\%$
to $98.6\%$. The address is encoded in the collective mode frequencies. When a
specific mode with frequency $\omega_{j}$ needs to be addressed, a flux
modulation with frequency $|\omega_{j}-\omega_{t}|$ is applied, where
$\omega_{t}$ is the transmon frequency. The flux modulation activates a
sideband transition to implement the iSWAP gate.

The coherent time of the cavity modes ranges from 1 to 10 $\mu$s, while the RW
via the transmon-resonators mode iSWAP gate lasts $20$ to $100$ ns. Based on
the device parameters reported in Ref. Naik  _et al._ (2017), limited by the
relatively short coherence time, the internal storage ratio $\alpha$ can vary
from $7.5$ (estimated from $T_{\text{RW}}=100$ ns with fidelity $F\approx
0.95$, $T_{\text{storage}}\approx 1~{}\mu$s) to $\approx 415$
($T_{\text{RW}}=20$ ns with fidelity $F\approx 0.986$,
$T_{\text{storage}}\approx 8.46~{}\mu$s). The memory latency $\beta\approx
2.63$ to $0.508$, where we assume the quantum operation is a two-qubit gate
time on transmon qubits, which takes $40$ ns Marxer  _et al._ (2023); Stehlik
_et al._ (2021); Sung  _et al._ (2021). The large memory latency is due to the
fast gate operations on the quantum processor relative to the RW operations.
The addressability of the QM is $\gamma\approx 2.16\times 10^{-2}$ to $1.20$,
which means more QMCs can be integrated into the RAQM before the RW process
becomes the bottleneck. Here, we consider that the device demonstrated cannot
address different QMCs in parallel, so we take $n=1$. Note that in the worst-
case scenario, the addressability is greater than unity, which means the RAQM
needs to reduce the RW time further to fully appreciate the QMCs. On the other
hand, introducing more RW ports while maintaining similar RW fidelity and
time, which increases the parallel RW number $n$, can also reduce the
addressability, e.g., to $\approx 0.6$ with $n=2$.

Following this work, Chakram et al. used the flute method to fabricate 3D
microwave cavities, which greatly increased the coherence time of the cavity
modes to $2$ ms Chakram  _et al._ (2021). Similarly, the address information
is also encoded into the mode frequencies. However, the transmon-cavity mode
iSWAP gate is activated using an applied microwave tone with the right
difference frequencies. Although the transmon-cavity mode SWAP gate time
extends to $0.5$ \- $1~{}\mu$s, the number of RW operations increases
significantly Chakram  _et al._ (2021), which can be seen from a significant
increase of the internal storage time $\alpha$ to $2.0\times 10^{3}$ to
$5.9\times 10^{3}$ ($T_{\text{RW}}=0.5$ to $1.0~{}\mu$s with fidelity
$F\approx 0.99$, $T_{\text{storage}}\approx 2$ ms and $3$ ms). However,
because the RW operation becomes slower, the memory latency $\beta\approx
12.6$ to $25.3$. Due to the increase of internal storage time $\alpha$,
integrating $9$ cavity modes as QMCs and addressing QMCs sequentially is still
acceptable, with $\gamma\approx 1.5$ to $4.5\times 10^{-3}$. Even with 1000
modes integrated, the addressability $\gamma\approx 0.17$ to $0.5$, which
means the RAQM design is still in a good regime ($\gamma<1$).

In addition to the circuit-QED system, RAQM is also experimentally realized in
atomic cloud systems to store the quantum information carried by photonic
qubits. Jiang et al. demonstrated using Rb atom clouds as QMCs to store
optical photons Jiang  _et al._ (2019). They demonstrated the capability of
storing $105$ dual-rail encoded photonic qubits in $210$ memory cells. The
storage is achieved through electromagnetically induced transparency, while
the random access feature is achieved by deflecting the control pulses to the
cloud ensemble with the right address. The beam deflecting is obtained by
acoustic-optical deflectors (AODs) using microwave tones.

In Ref. Jiang  _et al._ (2019), the QMC coherent time is about $27.8~{}\mu$s.
The read and write efficiency is lower than $20$% for all memory cells (2% to
18% reported). Although the RW control pulse extends to $500$ ns, the memory
retrieval photon pulse is emitted almost when the control pulse is applied. We
take the stored photon pulse duration to estimate the RW speed of a single QMC
$T_{\text{RW}}\approx 100$ ns. Note that the RW time of a quantum memory
device should include the time cost of setting the classical address and
sending the control pulse to address the QMC. Since the AOD setting time is
not reported in Refs. Jiang  _et al._ (2019); Chang  _et al._ (2019), we
ignore its contribution to the RW time. However, the AOD switching time is
reported as $40~{}\mu$s in Ref. Langenfeld  _et al._ (2020). If the addressing
time $T_{\text{addr}}\approx 40~{}\mu$s, it will obviously dominate the RW
time of QMCs, and even dominate the storage time of QMCs.

If the addressing time is negligible, the RW time of the device is
$T_{\text{RW}}\approx 100$ ns, the device internal storage time can reach
$\alpha\approx 39$ (RW efficiency $\eta\approx\sqrt{0.02}$) to $118$
($\eta\approx\sqrt{0.18}$). Using the RAQM for quantum communication, as we
discussed in Sec. II.2, the key operation is the EPR pair generation, which is
estimated to $T_{\text{op}}\approx 19~{}\mu$s. The memory latency of the RAQM
is relatively small $\beta\approx 0.012$ to $0.037$. If all QMCs inside the
RAQM are addressed individually, the addressability $\gamma\approx 1.78$ to
$5.3$, where we consider using 210 cells as individual QMCs. In order to
efficiently use all the QMCs, addressing 2 to 6 QMCs in parallel via
multiplexing is needed. This experimental setup is improved in Ref. Chang  _et
al._ (2019), where the control pulse is further reduced to improve RW time,
and a smaller number of QMCs are integrated (49 QMCs), which makes the
addressability to be $0.31$ when addressing QMCs sequentially. In addition, in
Ref Li  _et al._ (2020), the optical communication between two memories has
been demonstrated.

On the other hand, Langenfeld et al. demonstrates using single Rb atoms as
QMCs in the RAQM Langenfeld  _et al._ (2020). Although only two atoms (QMCs)
are shown in the RAQM device, the combined read and write operation reaches
$26$%. Similar to the atomic cloud-based RAQMs, the random access feature is
realized by guiding the control pulses to the correct atom using AODs, where
the addressing time is $T_{\text{addr}}=40~{}\mu$s. The coherence of the QMCs
can reach $800~{}\mu$s. Although the addressing time is long, thanks to the
relatively long coherence time, the internal storage time is still decent,
$\alpha\approx 8.2$. However, using the RAQM to interact with a fast EPR
generator makes the addressing latency not negligible, where the memory
latency $\beta\approx 4.1$. The addressability of this RAQM $\gamma\approx
0.20$, which is reasonable with only two QMCs. However, if more QMCs need to
be integrated into this RAQM, the slow addressing time will soon become a
bottleneck. This scenario requires either suppressing the total RW time or
introducing parallel addressing techniques into the RAQM RW processes. As
pointed out by the authors, the addressing time is possible to be reduced to
$2~{}\mu$s by using electro-optical deflectors. The suppression of the
addressing time to $2~{}\mu$s can improve the RAQM performance greatly by
$\alpha\approx 2.0\times 10^{2}$, memory latency $\beta\approx 0.21$, and
addressability $\gamma\approx 0.010$.

In addition, O’Sullivan et al. demonstrates an echo-based scheme to store
quantum information carried by photons into an ensemble of two-level atoms
O’Sullivan  _et al._ (2022). The quantum information can be encoded using
chirped pulses to imprint a phase pattern to write to the RAQM. The same
chirped pulse can be used to unwind the phase to read out the information.
Multiple chirped pulses are used to realize the random access feature. The
classical address of the memory is ‘labeled’ by the chirped pulse. To RW of
the correct QMC inside the RAQM, the corresponding chirped pulse needs to be
generated and sent into the quantum memory media. The RW time of each QMC is
mainly determined by the chirped pulse duration ($100~{}\mu$s), where the
addressing time is determined by the speed of setting the chirped pulse
parameters. The read or write process efficiency is $17\%$. As the addressing
time is not explicitly reported in Ref. O’Sullivan  _et al._ (2022), and it is
negligible in the time sequence, we ignore the addressing time in evaluating
the RAQM performance. Unlike the other RAQM experiments reported in this
section, where the capacity of the RAQM is not determined by the number of
physical systems that make individual QMCs, the quantum information is stored
in the collective excitations of the single optical media in this experiment.
Therefore, the capacity of the RAQM is determined by the number of distinct
chirped pulses to access these distinct collective excitations. In the
experiments, 16 modes are accessed, which give $16$ QMCs inside the RAQM. The
coherent time of the QMCs is extended to $2$ ms using dynamical decoupling
O’Sullivan  _et al._ (2022).

In terms of the performance of this RAQM, the RW time is relatively short
compared to the coherence time of the quantum memory, which is shown by its
internal storage time $\alpha\approx 6.2$. With the $16$ QMCs, the
addressability is $\gamma\approx 2.56$, which means to address all the QMCs,
multiplexing to address $n\approx 2$ QMCs in parallel is needed. However, as
the bus qubit of the RAQM is microwave pulses, integrating this RAQM with
either quantum communication protocols or superconducting quantum computing
processors is possible. In terms of connecting this RAQM with superconducting
quantum computing processors, the superconducting qubits need to interact with
the microwave bus qubit, which takes another $1~{}\mu$s for this operation and
it is part of the RW time. However, the fast gate operations between
superconducting qubits make the RAQM latency a disadvantage, with
$\beta\approx 61$. On the other hand, using the RAQM for quantum communication
protocols requires a detailed discussion of microwave quantum communication
protocols to evaluate the performance of the RAQM, which is beyond the scope
of this paper. To give a rough estimate of its performance, we point out that
microwave photon generation processes from superconducting qubits commonly
take less than $1~{}\mu$s Besse  _et al._ (2020); Reuer  _et al._ (2022).
Comparing it with the re-scaled RW time of the RAQM $T_{\text{RW}}\approx
0.24$ ms, further improving the memory latency seems necessary. On the other
hand, if microwave-to-optical transduction is involved in order to convert the
microwave photon to the optical domain for long-range quantum communication,
due to the limited transduction efficiency, the effective microwave EPR pair
generation speed is in the order of $1$ Hz to $1$ kHz levels Delaney  _et al._
(2022); Sahu  _et al._ (2022); Xu  _et al._ (2021b); Ang  _et al._ (2022),
which enables the latency $\beta<1$. However, the overall performance of the
RAQM and the transduction device need to be further improved to meet other
requirements of efficient quantum computing and quantum information processing
Ang  _et al._ (2022).

###  III.3 Quantum Random Access Memory (QRAM)

(a)  (b)

Figure 6: The architecture of a QRAM is shown in (a). The key element of a
QRAM is its quantum routing structure. A sketch of the quantum routing
structure (up to three levels) is shown in (b). The address qubits and the bus
qubits are sent through the routing systems from the top. The address qubits
set the states of quantum switches. When the quantum switch is set to state
$\ket{L}$ ($\ket{R}$), the next incoming qubit is routed to the left (right)
child switch.

Quantum random access memory (QRAM) distinguishes itself from classical RAM
and RAQM by achieving coherent addressing of the QMCs. In Fig. 6a, we sketch
the architecture of a QRAM. The key ingredient of the QRAM is the quantum
routing module (see Fig. 6b as an example). Based on the state of the address
qubits, the routes of the bus qubits are coherent superposes after interacting
with the quantum routing module, making the bus qubits coherently visit the
corresponding QMCs and be returned as the output.

QRAMs were first proposed and designed by Giovannetti, Lloyd, and Maccone
Giovannetti  _et al._ (2008a, b). Their design uses quantum routers in the
quantum routing module, whose state can be set by the address qubits. After
the router state is set, it coherently routes the next incoming qubit to the
two different paths (see Fig. 6b). Sending all the address qubits into the
routing module carves paths that guide the bus qubits to the corresponding
QMCs, which will read out the information coherently. The bus qubit is then
sent out from the QRAM, and the routers are unset to return to their starting
state for the next memory call. The authors named this seminal design ‘bucket-
brigade’ (BB) architecture. Unlike the direct analogy from the classical
addressing structure, ‘fan-out’ architecture, they pointed out that the BB
architecture is more efficient and noise-resilient. Following this seminal
work, Hong et al. proposed an alternation of the bucket-brigade architecture
by modifying the quantum switch qubits Hong  _et al._ (2012).

As demonstrated in Ref. Harrow  _et al._ (2009), where Harrow et al. proposed
the famous quantum linear algebra algorithms (HHL algorithm, named by the
authors) to efficiently solve the inverse of a large matrix, the construction
of QRAM and coherently addressing the memory content efficiently becomes
indispensable for the speedup. Therefore, there is growing interest in
building QRAM on different physical platforms. Hann et al. performed a
realistic analysis on how to implement QRAM based on a superconducting system
and acoustic quantum memory Hann  _et al._ (2019), while Chen et al. consider
using solid-state systems and photons instead Chen  _et al._ (2021b). In
addition, based on QRAM development, the concept and the architecture of a
quantum data center have been proposed in Ref. Liu  _et al._ (2022).
Furthermore, QRAMs based on quantum random walk have also been demonstrated
Asaka  _et al._ (2021, 2023a, 2023b). In addition to the bucket-brigade
architecture, there are proposals to construct QRAM with other architectures,
e.g., the flip-flop QRAM Park  _et al._ (2019), hybrid QRAM Matteo  _et al._
(2020); Paler  _et al._ (2020), etc. However, constructing a QRAM and
demonstrating its performance have not been achieved in experiments yet, to
the best of our knowledge.

On the other hand, the efficiency of QRAMs becomes another interesting
question. In Ref. Arunachalam  _et al._ (2015), Arunachalam et al. consider
the noise resilient of the coherent addressing in a bucket-brigade QRAM. They
claimed that the bucket-brigade architecture is not as noise-resilient as
claimed in Refs. Giovannetti  _et al._ (2008a, b), and the error scales
exponentially as the number of address qubits. Contrary to this work, Hann et
al. give further analysis to the noise resilience of coherently addressing
different QRAMs. They pointed out that the errors occurring on quantum
switches controlled by an inactive quantum switch do not degrade the final
returned states from the QRAM. Therefore, the QRAM can still be noise
resilient Hann  _et al._ (2021). In addition, how to improve the efficiency of
the QRAM operations in various scenarios is also discussed in Refs. Chen  _et
al._ (2023); Matteo  _et al._ (2020); Paler  _et al._ (2020). The architecture
for large integration of QRAM routing qubits and the memory qubits, and the
possible realization using H-tree architecture are also discussed in Ref. Xu
_et al._ (2023). For recent reviews on the topic of QRAM, we refer to Refs.
Hann (2021); Phalak  _et al._ (2023).

Nowadays, one of the main motivations for developing a QRAM is to realize a
quantum oracle for coherently accessing the memory data,

$\displaystyle\hat{O}_{\mathbf{x}}\sum_{j}c_{j}\ket{j}^{(\text{addr})}\ket{0}^{(\text{b})}=\sum_{j}c_{j}\ket{j}^{(\text{addr})}\ket{x_{j}}^{(\text{b})},$
(12)

where $\mathbf{x}$ represents some data that needs to be accessed, $\hat{O}$
is the oracle operation. After the oracle call, the bus qubit state contains
the information of $\mathbf{x}$, and it is entangled with the address qubits.
Compared to a classical oracle that only allows accessing each data
$\mathbf{x}$ according to the classical address, with this quantum oracle,
several algorithms can be efficiently implemented with fewer oracle calls and
give quantum speedup. For example, the Grover search algorithm Grover (1996),
quantum Fourier transform algorithm Nielsen and Chuang (2010), HHL algorithm
for linear algebra Häffner  _et al._ (2008), etc.

This quantum oracle can be achieved by QRAM. Classical data $\mathbf{x}$ are
preloaded into the QMC array according to its classical address, where the
QMCs can be described by the state
$\ket{\Psi^{(\text{QM})}}=\otimes_{k}\ket{x_{k}}$. We then prepare the address
state, $\ket{\psi^{(\text{addr})}}=\sum_{j}c_{j}\ket{j}$, and initialize the
bus qubit in the state $\ket{0^{(\text{b})}}$. The bus qubit and the address
qubits are sent to the quantum routing module in the QRAM, which allows the
bus qubit to be coherently coupled with the QMCs with address $addr=j$. To
generate the output state of the quantum oracle in Eq. (12), a sequence of
control-NOT gates are applied to the QMC qubits and the bus qubit, which
leaves the state of QMCs unchanged and not entangled with the bus qubit or
address qubits. Lastly, the bus qubit and address qubits are returned by the
quantum routing module.

We should stress that the above process is only one way to operate QRAM, where
the information stored in each QMC is purely classical. The process
disentangles the QMC qubits with the bus qubits after the CNOT gates.
Furthermore, to implement the quantum oracle in Eq. (12), only the reading
process of the QRAM is necessary. In addition, the data reading process does
not rely on SWAP gates between the bus qubit and the QMC qubit. Next, we aim
to survey how QRAM can be operated and what the outcome would be.

When operating a QRAM, a series of address qubits with the bus qubits are
input into the QRAM, while after the QRAM operation, these qubits are
returned. When the input address qubits are in a classical state, i.e., the
state is in the computational basis, the quantum routing module will guide the
bus qubit to a single QMC with the corresponding address. So, when we need to
perform RW operation to the QMCs, regardless of whether the QMC state is
classical or quantum, the RW operation can be achieved by a SWAP gate
operation. With classical address information, RAQM can achieve the same
functionality with less overhead on the quantum routing module design and
operations. Therefore, if the address information is purely classical, using
QRAM does not seem to be necessary.

When the address information is quantum, we have briefly discussed how to read
classical data out using classical ‘copy’ operation, which can be implemented
using CNOT gates between the bus qubit and QMC qubits (or classical-controlled
Pauli-X gates on the bus qubit Hann  _et al._ (2019); Hann (2021)). However, a
few questions remain unclear, e.g., what will happen when the QRAM is in the
writing mode, what are the QRAM outputs when the data is quantum, etc. In
Refs. Hann  _et al._ (2019); Hann (2021) and Ref. Liu  _et al._ (2022), the
reading and writing process of QRAMs are briefly discussed. For the
completeness of our discussion and to help answer these questions, we briefly
go over the reading and writing process of QRAMs, and discuss the state of the
address qubits, the bus qubits, and the QMC qubits. We further assume that a
single bus qubit is enough (word length is one qubit in each QMC), which can
be easily generalized to cases with more bus qubits.

####  III.3.1 QRAM reading classical data

When the QMCs store classical information, i.e., the state of each QMC is
either $\ket{0}$ or $\ket{1}$, the data stored in the QMCs can be viewed as a
binary vector $\mathbf{x}$, where the $j$-th element is $x_{j}$, which is
stored in the state of the QMC qubit with address $j$, labeled by
$\ket{x_{j}^{(j)}}$. The address qubits are in the state
$\ket{\phi^{(\text{addr}}}=\sum_{j}c_{j}\ket{j}$, where $c_{j}$ is the complex
coefficient when the state is written in the computational basis. The bus
qubit is initialized to $\ket{0^{(\text{b})}}$ state. The initial state of the
bus qubit, address qubits, and the QMCs is

$\displaystyle\ket{\phi^{(\text{addr})}}\ket{0^{(\text{b})}}\left(\bigotimes_{k}\ket{x_{k}^{(k)}}\right)=\sum_{j}c_{j}\ket{j}\ket{0^{(\text{b})}}\left(\bigotimes_{k}\ket{x_{k}^{(k)}}\right)$
(13)

After sending the address qubits and the bus qubit into the QRAM, according to
the BB architecture, coherent paths that guide the bus qubits to the
corresponding QMCs with address $j$ are activated. Mathematically, in each
term of Eq. (13), the bus qubit can interact with the QMC qubits with $j$
address. Because $\text{CNOT}\ket{x}\ket{0}=\ket{x}\ket{0\oplus
x}=\ket{x}\ket{x}$, where $x=0,1$, to copy the classical data out to the bus
qubit, a CNOT gate with the QMC qubit as the control can be applied. After the
CNOT gate, the state is transformed to

$\displaystyle\sum_{j}c_{j}\ket{j}\ket{0^{(\text{b})}}\left(\bigotimes_{k}\ket{x_{k}^{(k)}}\right)\rightarrow\sum_{j}c_{j}\ket{j}\ket{x_{j}^{(\text{b})}}\left(\bigotimes_{k}\ket{x_{k}^{(k)}}\right),$
(14)

where QMCs are still disentangled from the bus qubit and the address qubits,
while the bus and the address qubits are entangled. And the quantum oracle in
Eq. (12) has been realized.

To be more consistent with the quantum memory we have discussed so far, we
consider using a SWAP gate between the connected QMCs and the bus qubit. In
this case, the QMC qubit with address $j$ is swapped with the bus qubit state,
which gives

$\displaystyle\sum_{j}c_{j}\ket{j}\ket{x_{j}^{(\text{b})}}\left(\ket{0^{(j)}}\bigotimes_{k\neq
j}\ket{x_{k}^{(k)}}\right)=\left[\sum_{j}c_{j}\ket{j}\ket{x_{j}^{(\text{b})}}\left(\ket{0^{(j)}}\bigotimes_{\mathclap{\begin{subarray}{c}k\in\\{addr\\}\\\
k\neq
j\end{subarray}}}\ket{x_{k}^{(k)}}\right)\right]\otimes\left(\bigotimes_{k\notin\\{addr\\}}\ket{x_{k}^{(k)}}\right),$
(15)

where $\ket{0^{(j)}}$ shows the QMC with the address $j$ is in the state
$\ket{0}$, $\\{addr\\}$ is the set of addresses that are contained in the
state of address qubits $\ket{\phi^{(\text{addr})}}$. From Eq. (15), the
output state of the address qubits and the bus qubit is entangled with the QMC
qubits that have been addressed.

####  III.3.2 QRAM reading quantum data

When the stored information is quantum, the state of the QMC is no longer
along the computational basis. Without losing generality, we consider that the
state of the QMCs can be described by
$\ket{\Psi^{(\text{QM})}}=\bigotimes_{j}\ket{\psi_{j}^{(j)}}$, where
$\ket{\psi_{j}^{(j)}}=m_{j,0}\ket{0^{(j)}}+m_{j,1}\ket{0^{(j)}}$, which means
the QMCs do not have entanglement before the reading process. If a CNOT gate
between the QMC and the bus qubit, which is in state $\ket{0^{(\text{b})}}$,
is applied following the classical data readout, the resulting state is

$\displaystyle\text{CNOT}\ket{\psi_{j}^{(j)}}\ket{0^{(\text{b})}}=m_{j,0}\ket{0^{(j)}0^{(\text{b})}}+m_{j,1}\ket{1^{(j)}1^{(\text{b})}},$

where we can no longer get the state
$\ket{\psi_{j}^{(j)},\psi_{j}^{(\text{b})}}$. Instead, the QMC qubit is
entangled with the bus qubit. In fact, if the state of each individual QMCs is
unknown, due to the no-cloning theorem, it is impossible to construct an
operation to ‘copy’ the QMC state to the bus qubit.

If the QRAM is set to use the CNOT gates in its reading process, the resulting
state of memory, address, and bus qubits are

$\displaystyle\sum_{j}c_{j}\ket{j}\left(m_{j,0}\ket{0^{(j)}0^{(\text{b})}}+m_{j,1}\ket{1^{(j)}1^{(\text{b})}}\right)\left(\bigotimes_{k\neq
j}\ket{\psi_{k}^{(k)}}\right)$
$\displaystyle=\left[\sum_{j}c_{j}\ket{j}\left(m_{j,0}\ket{0^{(j)}0^{(\text{b})}}+m_{j,1}\ket{1^{(j)}1^{(\text{b})}}\right)\left(\
\ \bigotimes_{\mathclap{\begin{subarray}{c}k\in\\{addr\\}\\\ k\neq
j\end{subarray}}}\ket{\psi_{k}^{(k)}}\right)\right]\otimes\left(\bigotimes_{k\notin\\{addr\\}}\ket{\psi_{k}^{(k)}}\right).$
(16)

Unlike the classical data readout, the address qubits, the bus qubit, and the
addressed QMC qubits are entangled.

If a series of SWAP gates are applied to the QMCs and the bus qubit, rather
than using CNOT gates in the reading process, the state is

$\displaystyle\sum_{j}c_{j}\ket{j}\ket{\psi_{j}^{(\text{b})}}\left(\ket{0^{(j)}}\bigotimes_{k\neq
j}\ket{\psi_{k}^{(k)}}\right)=\left[\sum_{j}c_{j}\ket{j}\ket{\psi_{j}^{(\text{b})}}\left(\ket{0^{(j)}}\bigotimes_{\mathclap{\begin{subarray}{c}k\in\\{addr\\}\\\
k\neq
j\end{subarray}}}\ket{\psi_{k}^{(k)}}\right)\right]\otimes\left(\bigotimes_{k\notin\\{addr\\}}\ket{\psi_{k}^{(k)}}\right),$
(17)

where again, the reading process leaves the bus and the address qubits
entangled with the QMC qubits. If the state stored in the QMCs is entangled,
according to the entanglement pre-exists in the QMCs, more qubits in QMCs can
be entangled with the bus and address qubits regardless of quantum gates used
in the reading process.

####  III.3.3 Writing classical data into QRAMs

In the memory writing process, the bus qubit is prepared in an unknown quantum
state and then sent into the memory module with the address information. The
memory module will save the information inside the memory media according to
the address information. However, QRAMs can take coherent address information,
and the bus qubit can entangle with the address qubits. Therefore, we assume
the bus and the address qubits are initialized into the state
$\sum_{j}c_{j}\ket{j}\ket{x_{j}^{(\text{b})}}$, where $x_{j}\in\\{0,1\\}$ and
then sent into the QRAM for the writing process.

Providing the QRAM memory is initialized to state
$\bigotimes_{k}\ket{0^{(k)}}$, because the information contained in the bus
qubit is classical, we can use a CNOT gate controlled by the bus qubit to copy
to the QMC qubit. However, with coherent address information, the resulting
state becomes,

$\displaystyle\sum_{j}c_{j}\ket{j}\ket{x_{j}^{(\text{b})}}\ket{x_{j}^{(j)}}\left(\bigotimes_{k\neq
j}\ket{0^{(k)}}\right)=\left[\sum_{j}c_{j}\ket{j}\ket{x_{j}^{(\text{b})}}\left(\ket{x_{j}^{(j)}}\bigotimes_{\mathclap{\begin{subarray}{c}k\in\\{addr\\}\\\
k\neq
j\end{subarray}}}\ket{0^{(k)}}\right)\right]\otimes\left(\bigotimes_{k\notin\\{addr\\}}\ket{0^{(k)}}\right).$
(18)

To understand this process, let us consider the bus qubit is disentangled with
the address qubits at the beginning, i.e.,
$\ket{x_{j}^{(\text{b})}}=\ket{x^{(\text{b})}}$ is independent of address $j$.
The state in Eq. (18) becomes

$\displaystyle\ket{x^{(\text{b})}}\otimes\sum_{j}c_{j}\ket{j}\otimes\ket{x^{(j)}}\bigotimes_{k\neq
j}\ket{0^{(k)}},$ (19)

which means the bus qubit is still disentangled from the rest of the system,
and the bus qubit state is coherently saved to the QMCs with the addresses
$j\in\\{addr\\}$. However, this is different from keeping multiple copies of
$\ket{x}$ in QMCs with addresses $j\in\\{addr\\}$, which results in

$\displaystyle\ket{x^{(\text{b})}}\sum_{j}c_{j}\ket{j}\left(\bigotimes_{k\in\\{addr\\}}\ket{x^{(k)}}\right)\left(\bigotimes_{k\notin\\{addr\\}}\ket{0^{(k)}}\right),$

where the QMC qubits are disentangled from the rest of the system. This state
is different from Eq. (19). Similarly, in the general case shown in Eq. (18),
the classical data is saved to the corresponding QMC coherently, which leaves
all the qubits involved in this process entangled. This process is different
from writing classical data one by one into the corresponding QMCs
deterministically.

If the write operation is a SWAP gate, similar to using SWAP gates to read
classical data out of a QRAM (see Sec. III.3.1), the writing process leaves
the involved QMC qubits entangled with the address qubits. The outcome state
is

$\displaystyle\ket{0^{(\text{b})}}\sum_{j}c_{j}\ket{j}\left(\ket{x_{j}^{(j)}}\bigotimes_{k\neq
j}\ket{0^{(k)}}\right)=\ket{0^{(\text{b})}}\left[\sum_{j}c_{j}\ket{j}\left(\ket{x_{j}^{(j)}}\bigotimes_{\mathclap{\begin{subarray}{c}k\in\\{addr\\}\\\
k\neq
j\end{subarray}}}\ket{0^{(k)}}\right)\right]\otimes\left(\bigotimes_{k\notin\\{addr\\}}\ket{0^{(k)}}\right).$
(20)

####  III.3.4 Writing quantum data into QRAMs

When the bus qubit is prepared in a quantum state and entangled with the
address qubits, i.e., the state of the bus and the address qubits are

$\displaystyle\sum_{j}c_{j}\ket{j}\ket{x_{j}^{(\text{b})}}=\sum_{j}c_{j}\ket{j}\left(b_{j,0}\ket{0^{(\text{b})}}+b_{j,1}\ket{1^{(\text{b})}}\right),$

where the coefficients $b_{j,0}$ and $b_{j,1}$ are nonzero. In this case, the
writing result is similar to the reading process, shown in Sec. III.3.2. If
the writing operation is a CNOT gate controlled by the bus qubit, the outcome
state is

$\displaystyle\sum_{j}c_{j}\ket{j}\left(b_{j,0}\ket{0^{(\text{b})}0^{(j)}}+b_{j,1}\ket{1^{(\text{b})}1^{(j)}}\right)\left(\bigotimes_{k\neq
j}\ket{0^{(k)}}\right)$
$\displaystyle=\left[\sum_{j}c_{j}\ket{j}\left(b_{j,0}\ket{0^{(\text{b})}0^{(j)}}+b_{j,1}\ket{1^{(\text{b})}1^{(j)}}\right)\left(\
\ \bigotimes_{\mathclap{\begin{subarray}{c}k\in\\{addr\\}\\\ k\neq
j\end{subarray}}}\ket{0^{(k)}}\right)\right]\otimes\left(\bigotimes_{k\notin\\{addr\\}}\ket{0^{(k)}}\right),$
(21)

where all the qubits involved in the process are entangled. While the writing
process is performed using SWAP gates, the state is

$\displaystyle\ket{0^{(\text{b})}}\sum_{j}c_{j}\ket{j}\left(\ket{\psi_{j}^{(j)}}\bigotimes_{k\neq
j}\ket{0^{(k)}}\right)=\ket{0^{(\text{b})}}\left[\sum_{j}c_{j}\ket{j}\left(\ket{0^{(j)}}\bigotimes_{\mathclap{\begin{subarray}{c}k\in\\{addr\\}\\\
k\neq
j\end{subarray}}}\ket{0^{(k)}}\right)\right]\otimes\left(\bigotimes_{k\notin\\{addr\\}}\ket{0^{(k)}}\right),$
(22)

where the bus qubit is disentangled while the other qubits involved are
entangled together.

####  III.3.5 Comparison between different QRAM operation modes

Table 5:  Comparison of different operation modes of QRAM. We consider the entanglement inside the output state. Specifically, we layout the entangled qubits, ‘addr’ is for address qubits, ‘b’ is for the bus qubit, ‘QMC’ is for the QMC qubits in the memory, and ‘all’ means all the qubits involved are entangled. |  | RW operation
---|---|---
|  |  CNOT |  SWAP
Read |  Classical |  addr, b |  all
Quantum |  all |  all
Write |  Classical |  all |  addr, QMC