# Resource overheads and attainable rates for trapped-ion lattice surgery

Hudson Leone  Center for Quantum Software and Information – University of
Technology Sydney  Thinh Le  Center for Quantum Software and Information –
University of Technology Sydney  S. Srikara  Center for Quantum Software and
Information – University of Technology Sydney  Simon Devitt
<EMAIL_ADDRESS>Center for Quantum Software and Information –
University of Technology Sydney  InstituteQ, Aalto University, 02150 Espoo,
Finland.

###### Abstract

We present estimates for the number of ions needed to implement fault-tolerant
lattice surgery between spatially separated trapped-ion surface codes.
Additionally, we determine attainable lattice surgery rates given a number of
dedicated “communication ions” per logical qubit. Because our analysis depends
heavily on the rate that syndrome extraction cycles take place, we survey the
state-of the art and propose three possible cycle times between $10$ and
$1000\mu s$ that we could reasonably see realised provided certain
technological milestones are met. Consequently, our numerical results indicate
that hundreds of resource ions will be needed for lattice surgery in the
slowest case, while close to a hundred thousand will be needed in the fastest
case. The main factor contributing to these prohibitive estimates is the
limited rate that ions can be coupled across traps. Our results therefore
indicate an urgent need for improved optical coupling in order for trapped-ion
quantum computers to scale.

##  I Introduction

Trapped ions are among the best studied and most technologically mature type
of qubits to date; Their long coherence times and high-fidelity gates alone
justify them as a candidate qubit for scalable quantum computing [1]. How a
quantum computer is scaled will depend on its underlying architecture. Broadly
speaking, an architecture may be monolithic [2] or modular [3]. A monolithic
architecture is scaled by increasing the size of the chip, while a modular
architecture is scaled by increasing the number of chips. Physical constraints
and routing overheads generally cap the number of qubits that a monolithic
architecture can reasonably support, which makes modularity something of an
informal requirement when scaling quantum computers. Another requirement for
scalability is error correction [4]. Industrial applications for quantum
computing require programs to run for hours or even days. This is considerably
longer than the coherence times of trapped ions, which means that
computational qubits must be encoded and periodically corrected.

Based on these considerations, we expect that scalable quantum computers will
be both modular and error corrected. One obvious disadvantage of the modular
architecture is that two-qubit operations are not intrinsically possible
between qubits that live in separate modules. Instead, some amount of
entanglement has to be shared between modules as a resource for state or gate
teleportation [5]. This process is complicated by the fact that entanglement
distribution is probabilistic and noisy. To say that distribution is
probabilistic means there is a significant chance of failure when attempting
to entangle two physical qubits. For inter-modular two qubit operations to be
reliable, this means that a large number of communication qubits will be
required as an overhead to ensure that enough entanglement is collected. On
the other hand, to say that distribution is noisy means that errors are
inadvertently introduced into the entangled states which must be corrected
before any teleportation can take place. This correction is done through
entanglement purification [6] which non-deterministically reduces a large
ensemble of weakly entangled pairs into a smaller ensemble of strongly
entangled pairs.

In this paper, we conduct resource analysis on the number of ions needed to
implement reliable two qubit operations between logically encoded qubits in
different modules at different speeds. Specifically, we limit our attention to
the lattice-surgery operation between surface-code encoded qubits (See Fig. 1
for a simplified schematic). This analysis is significantly influenced by the
speed at which lattice surgery can be performed. Faster operations are
desirable of course, but myriad factors limit the attainable rate. To ground
our analysis, we survey the state-of-the-art in trapped-ion technologies and
synthesise this information to propose three possible surgery times together
with a rubric of technological milestones that are necessary to achieve each
one. Additionally, we determine the attainable rates for lattice surgery
operations given a fixed number of ions.

Figure 1:  A collection of trapped ions in two separate Elementary Logical
Units (ELUs). Some of the ions in each trap are used to encode a logical
surface code qubit while other communication ions collect and refine
entanglement to be used for a two-qubit lattice surgery operation.

##  II Background

###  II.1 Surface code and lattice surgery

An $[[n,k,d]]$ stabilizer code is a quantum error correcting code that uses
$n$ physical qubits called data qubits to encode $k$ logical qubits with a
code distance $d$. The code is specified (non-uniquely) by $n-k$ independent
stabilizer generators that define the set of valid code-words. Each stabilizer
generator is an observable that is implemented by measuring an ancilla qubit
(also called a measure or syndrome qubit) that has been coupled to a number of
data qubits. Assuming each stabilizer generator has its own measure qubit, the
total number of physical qubits needed for an $[[n,k,d]]$ stabilizer code is
$n_{\text{phys}}=n+(n-k)=2n-k$. A stabilizer code cycle or syndrome extraction
cycle is a measurement of all $n-k$ stabilizers (typically implemented in
parallel) which results in a collection of measurement outcomes called
syndromes $(s\in\\{+1,-1\\}^{n-k})$. When syndrome extraction cycles are
repeated multiple times, changes in syndromes can be used to infer the most
likely physical errors that have occurred in the code.

The surface code [7] is a popular choice of stabilizer code because of its
high error tolerance (between 0.1% and 1% for unbiased noise [8] and up to
43.7% for biased noise [9]) and because it can be implemented using only
nearest-neighbor qubit interactions. Crucially, (and unlike the majority of
codes) it is also known how to perform universal quantum computation on
surface code encoded qubits [10]. In its original implementation, the surface
code is a $[[d^{2}+(d-1)^{2},1,d]]$ stabilizer code. In this paper however,
every mention of the surface code will refer to a similar (but slightly more
efficient) variant called the rotated surface code which has the parameters
$[[d^{2},1,d]]$.

One of the necessary conditions for universality is the existence of an
entangling gate. Several options exist for implementing two-qubit entangling
gates between surface code qubits, though we limit our consideration to just
two. A transversal gate is performed by coupling every physical qubit in one
code to a counterpart in an adjacent code. These transversal operations are
challenging to implement in two-dimensional architectures due to the numerous
non-local interactions required [11]. An easier alternative is lattice surgery
which, unlike transversal gates, can be implemented with only nearest neighbor
interactions [12]. In brief, lattice surgery is executed by performing a
syndrome extraction over two code patches as if they were one elongated patch.
The disadvantage of lattice surgery is that, unlike a transversal gate, it
requires measurements on a subset of the physical qubits that can introduce
new, undetected errors into the ensemble. To correct for this, it is necessary
to perform at least $d$ rounds of lattice surgery to build confidence that the
operation was done correctly. This makes lattice surgery slow compared to the
transversal gate but is still the favored option on account of its
feasibility.

An important, though unrelated, fact is that transversal gates and lattice
surgery can both be performed on surface codes that are not directly adjacent
in space by using shared entanglement. Specifically, maximally entangled qubit
pairs can be used to teleport the required two-qubit gates in either case. For
surface codes of distance $d$, transversal gates require a total of $d^{2}$
pairs since each qubit in a $d\times d$ lattice must be matched up with its
counterpart in the other lattice. Coincidentally, lattice surgery also
requires $d^{2}$ pairs since $d$ pairs are needed for each of the $d$ rounds
that are necessary to account for measurement errors. Although these two
operations require the same total amount of entanglement, the rate of required
entanglement is much smaller for lattice surgery since only $d$ pairs are
required at each time-step.

It was previously thought that the infidelities of the entangled pairs used in
lattice surgery must at least match the error threshold of the code, however
recent work by Ramette et. al. indicates that pairs can tolerate an order of
magnitude more error than expected [13]. The reason for this robustness stems
from the fact that entangled pairs contribute errors along a single spatial
dimension of the code during lattice surgery which limits the number of ways
in which errors can form paths in the code.

Figure 2:  An illustration of the lattice surgery operation between two
surface code encoded qubits. The white circles represent data qubits which
work together to encode the logical qubits in either box. The floral tiles
represent syndrome extraction circuits which are executed in parallel to
obtain information about errors that may have occurred on the data qubits.
During a lattice surgery operation, two code patches undergo a syndrome
extraction cycle together as if they were one elongated patch. For codes of
distance $D$, lattice surgery requires $D$ entangled pairs along the seam to
implement the $D$ CNOTs depicted. The effect of this operation is an $XX$
parity check between the two encoded qubits which, with single qubit gates, is
sufficient for universal quantum computing.

###  II.2 Trapped-ion architectures

Monroe et. al. [14] were among the first to perform a systematic study of a
modular trapped-ion architecture, and some of our our terminology follows from
their work. The modular trapped-ion computer is a collection of Elementary
Logic Units (ELUs) which serve as local processors and or memory banks. In the
Monroe framework, each ELU is a linear Coulomb crystal containing an identical
quantity of ions. Some of these are communication ions which are coupled to
photonic interconnects and can be used to create entangled pairs between ELUs.
Still another fraction of the ions are may be used for sympathetic cooling,
which is when one ion is brought in proximity to another to absorb some of its
vibrational energy.

An attractive advantage of the linear crystal is that it is all-to-all
connected: No rearrangement is needed to implement a two-qubit gate between
any pair of ions, though there’s an effective limit to the crystal’s length.
Monroe et. al. believed this limit to be around 100 ions which, ten years
later, seems to be a well justified estimate since the longest linear crystal
today is around 30 computational qubits [15]. Further corroborating evidence
for this limit is discussed in greater detail by Murali et. al. [16]. On the
other hand, Ratcliffe et. al. [17] propose a micro-trap based architecture
with all-to-all connectivity which they claim can be scaled beyond a linear
trap. This is accomplished with a non-adiabatic gate which, at the cost of
higher power, circumvents the need to use conventional side-band resolving
gates which are slow and more susceptible to vibrational noise. A two
dimensional extention to the microtrap architecture has also been studied in
some detail [18].

In practice, we do not need to restrict ourselves by limiting the ELU to a
single linear crystal. One possible workaround for further scaling is to have
multiple crystals “chained together” in the same ELU to form a segmented
linear trap [19]. The crystals in this chain can be separated, combined, and
rotated to move a qubit in one crystal to any other crystal in the trap.
Though the segmented linear trap has a larger qubit capacity, it lacks the
all-to-all connectivity of a single crystal – meaning that some amount of
physical routing is required for general computation. On average, the number
of swap operations needed to move quantum information from one end of the
chain to the other scales linearly with the number of modules and the number
of qubits per segment. Monroe et. al. believe more optimistically that a
maximum of 1000 ions should be possible in an segmented linear trap [14].

A still more general option for an ELU architecture is a Quantum Charged
Coupling Device (QCCD) [19] [20]. This is a two-dimensional configuration of
ion chains which may be routed along a fixed network of corridors and
junctions. Theoretically, QCCD architectures are monolithic, well connected,
and faster than segmented linear traps, though they are difficult to fabricate
and currently limited to around ten qubits. For a survey on the technical
challenges of scaling QCCDs, see Murali et. al. [16]. True two and three
dimensional ion crystals (also called Wigner crystals) may also be possible to
engineer in the future on the scale of hundreds or perhaps even thousands of
ions [21] [22].

###  II.3 Trapped-ion surface code implementations

Specialised architectures for quantum error correction will likely be easier
to realise in the near term since error correction is predictable, repetitive,
and often nearest neighbor (as is the case for the surface code). Though an
experimental demonstration of a trapped-ion surface code has yet to be
realised, there is nevertheless a growing body of theoretical work around this
objective. LeBlond et. al. presented software for compiling surface code
operations to trapped-ion hardware [23]. Trout et. al. conducted extensive
simulations of a distance 3 surface code implemented in a trapped-ion linear
array [24], and reported a pseudothreshold of $3\times 10^{-3}$ with syndrome
cycle times ranging from around 3 to 8 milliseconds. Similarly, Li et. al.
studied a surface code modeled on a segmented linear trap [25]. For segment
lengths of around 15 qubits, they report an error tolerance of $0.12\%$ but
say nothing about syndrome extraction times. Lekitsch et. al. [26] present a
proof-of-concept for a monolithic surface code architecture that closely
resembles a QCCD. A crucial difference however is that the Lekitsch
architecture relies on global fields for a majority of the operations instead
of individual lasers, which they argue is more feasible for monolithic scaling
since it circumvents the need to align many optical elements with high
precision. Their proposed cycle times are around $300\mu s$.

##  III Estimating surface code cycle times

The rate we are able to do lattice surgery is upper bounded by the rate at
which syndrome extraction cycles can be performed. Some care is therefore
required to establish reasonable estimates for the attainable cycle times in
trapped-ion systems. The required time will depend not only on the specific
architecture, but also various factors such as the speeds of single and two-
qubit gates, measurements, ion-shuttling and cooling. We consider each of
these factors in the following subsections and conclude our review by
establishing three cycle time paradigms we expect are feasible provided that
specific technological milestones are met.

###  III.1 Trapped-ion gates

The review of Bruzewicz et. al. presents a thorough comparison of single and
two qubit trapped-ion gate times [27]. Typical single qubit gates with
fidelities greater than surface code threshold are reported between $2\mu s$
and $12\mu s$, though lower fidelity operations have been demonstrated on the
order of nanoseconds. Two qubit gates are generally slower and lower fidelity.
Typical two-qubit gates with fidelities close to a desired operational rate of
$0.1\%$ error threshold are clocked between $1.6\mu s$ and $30\mu s$. It is
not unreasonable to assume therefore that the time it takes to implement the
gates in a surface code cycle is around $10\mu s$.

###  III.2 Trapped-ion measurements

Single-qubit trapped-ion measurements are commonly implemented via state-
dependent fluorescence. In this method, laser light is directed at an ion
which exclusively couples the $|1\rangle$ state to a ‘cycling transition’ that
scatters numerous easily detectable photons. Likewise, the absence of photons
indicates a measurement of the $|0\rangle$ state [27]. Although fluorescence
measurements are relatively fast (on the order of $10\mu s$ [28] [29]) and
high fidelity, the scattered photons (both from the laser and from the
irradiated ion) are likely to decohere nearby qubits that aren’t also being
measured. This is a significant problem for error correcting circuits which
all rely on mid-circuit measurements. Broadly speaking, there are two
complementary strategies for mitigating measurement induced decoherence. The
first is to incorporate techniques that suppress the decoherence, and the
second is to move the ions some distance away to be measured safely. Both of
these strategies will be discussed in the following subsections.

####  III.2.1 Techniques for suppressing decoherence

One way to limit measurement induced decoherence is to shorten the amount of
time the qubit(s) are illuminated. This comes at the cost of measurement
fidelity since there are fewer scattered photons to be detected. Naturally,
faster and higher fidelity measurements will be possible with improvements in
the photon collection rate and photo-detector efficiency. See the introduction
of Wolk et. al. for a brief summary of techniques used to improve sparse
detection fidelities [30].

Another approach for protecting against decoherence is to use quantum logic
spectroscopy [31]. This is when the information of one qubit is transferred
onto an ion of a different species that when measured emits off-resonant
photons which are unlikely to disturb the states of neighboring qubits. An
accidental benefit of this approach is that preexisting cooling ions may be
used for this purpose. The disadvantages of quantum logic spectroscopy are
that it is more difficult to maintain coherent control of multiple ion-species
simultaneously, and that it requires additional ions (at most double for a
one-to-one pairing). A promising alternative might be to use ions of the same
species but have the data and measurement qubits encoded in different energy
levels of the ion [32] [33]. An alternative strategy would be to suppress the
decoherence effects altogether so that additional measurement ions are not
required. Gaebler et. al. [34] demonstrate a technique for reducing
measurement cross-talk errors by an order of magnitude using tailored
micromotion which may reduce and potentially eliminate the need for logic
spectroscopy or shuttling altogether. Micromotion is a time-dependent, driven
motion that naturally occurs as a result of ion confinement. Too much
micromotion however is known to push ions outside the Lamb-Dicke regime,
making high fidelity gates infeasible. Using tailored micromotion to hide ions
from fluorescence induced measurements may therefore require more cooling than
usual.

####  III.2.2 Ion-shuttling speeds

Perhaps the most intuitive strategy for mitigating measurement induced
decoherence is to move the ions a safe distance away before measuring them.
Ideally we’d like to complete this operation as fast as possible, but faster
shuttling introduces more thermal noise which can have a detrimental effect on
two-qubit gates in particular. Broadly speaking, the infidelity of a Mølmer-
Sørensen gate (See section III.3) applied between two qubits in an ion-chain
is known to depend on both the temperature of the chain and its displacement
in phase space. These effects have been fully characterised for two different
error metrics [35]. In the ion-shuttling literature, the amount of heat
imparted in transport is commonly characterised in terms of how much the
expected energy quanta of a particular motional mode increases. Sterk et. al.
[36] use the results of Ruzic et. al. [35] to develop a helpful rule-of-thumb:
Trapped-ions in a linear chain can each tolerate around 1 quanta of energy
before there is an appreciable drop in the Mølmer-Sørensen gate fidelity. The
fastest and quietest reported shuttling operation at the time of writing is
also from Sterk et. al. who demonstrate a $210\mu m$ one way ion transport in
$6\mu s$ with a maximum gain of $0.36\pm 0.08$ quanta for an average speed of
$35$ $\mu m$ $\mu s^{-1}$ [36]. Slower, but more conservative routing was also
demonstrated in $55\mu s$ with a gain in 0.1 quanta [37].

####  III.2.3 Estimates for shuttling times

How far do ions need to be separated for the effects of measurement induced
decoherence to be considered negligible? At the shorter end, Pino et. al.
report a QCCD architecture where a shuttling distance of $110\mu m$ resulted
in cross-talk errors between $3.5\times 10^{-3}$ and $1.5\times 10^{-2}$ [20].
Similarly, Crain et. al. show that a separation of $370\mu m$ results in
cross-talk errors of $2\times 10^{-5}$ [28]. If we assume a distance of
$300\mu m$ is tolerable, then with the shuttling speed reported by Sterk et.
al. we can assume that a two-way shuttling time of around $10\mu s$ is
sufficient for eliminating decoherence effects.

####  III.2.4 Multi qubit measurements

Strategic multi-qubit fluorescence measurements may be an effective way to
reduce shuttling time further since high fidelity measurements are possible on
groups of proximate ions. Zhukhas et. al. for example present a four ion
readout with an overall error lower than twenty parts per million [38].
Similarly, IonQ’s Harmony device is able to perform an 11 qubit readout with a
cross-talk error lower than $10^{-4}$ [39]. Assuming their linear trap is
around 100 micrometers long, this would suggest that ion separations below
$10\mu m$ or so are sufficient for high fidelity simultaneous measurements.

###  III.3 Cooling trapped ions

All gates and operations of trapped ion quantum computers require low
temperatures, but this is especially true of the two qubit gates since they
depend on vibrational coupling which is highly sensitive to noise. In the
early days of trapped ion-quantum computing, two qubit gates required
temperatures close to the ground state energy. The breakthrough discovery of
Mølmer and Sørrensen [40] shifted this paradigm by introducing a gate that
could operate at the Doppler temperature – the temperature regime attainable
with Doppler cooling. In the following subsections, we present a brief review
of the cooling techniques used to bring collections of ions to Doppler and
sub-Doppler temperatures – endeavoring to report approximate cooling times
wherever possible. Although cooling single ions is considerably easier than
cooling ion crystals (since there are fewer motional modes to be addressed
[41]), it is unlikely that single-ion cooling will be a leading technology in
the context of quantum computation. This is because virtually all quantum
architectures (with the possible exception of QCCDs) keep their computational
ions organised in crystals.

At a high level, Doppler cooling works by shining a laser on an ion with a
frequency just below what the ion will absorb. When the ion moves towards the
laser, the incoming light is blue-shifted with respect to the ion which causes
it to absorb a photon and slow down. Aside from Doppler cooling, other
established laser based cooling techniques that operate under similar
principles include resolved sideband cooling, Raman sideband cooling, and
Electromagnetically Induced Transparency cooling (EIT) with the fastest of
these being EIT. Feng et. al. report cooling a 40 ion chain to a near ground
state energy in under $300\mu s$ [42] while Jordan et. al. reach similar
temperatures for a 100 ion Penning trap within $200\mu s$. Some disadvantages
of EIT are that it has a limited range of motional frequencies it can cool,
and it is slow at cooling low frequency excitations [43].

Sympathetic cooling, where cold ions are brought into physical contact with
computational ions, has been discussed in some detail in the previous
sections. The major disadvantage of this approach is that it is relatively
slow compared to other cooling methods and requires additional resource
overheads [44]. A recent experimental demonstration showed that ion chains up
to length 28 could be cooled to the global Doppler cooling limit using only
two dedicated cooling ions of the same species [45]. This paper reported
relaxation times (defined as the time required for the noise to settle within
$5\%$ of noise of the initial state) between 10 and 100 $ms$. Though these
numbers are somewhat discouraging, one promising direction for further study
is persistent cooling where a number of sympathetic cooling ions are brought
in perpetual contact with computational ions. As the computation proceeds, the
cooling ions are continuously chilled with Doppler cooling. This technique
could lift the requirement for cooling processes that halt the computation.
Lin et. al. present an analysis of the dynamics of a linear array where a
small subset of the ions are continuously cooled [46]. Additionally, a
theoretic proposal for sympathetic cooling between one ion and a pre-cooled
resource ion can be accomplished on the order of tens of microseconds, which
may find some applicability in this context [47].

###  III.4 Cycle time paradigms

At the beginning of this section (III), we mentioned that estimating
attainable cycle times is crucial to our resource estimation task. This is
because the cycle time has a direct bearing on the number of communication
ions we require per ELU; Faster cycles mean that more ions are required to
collect the necessary entanglement in a shorter period. In this section we
synthesise our findings from the previous review by proposing three cycle time
paradigms $(1000\mu s,100\mu s,10\mu s)$ that we could reasonably expect to
see achieved for trapped-ion surface codes given various technical
assumptions. For a short-hand summary of these paradigms see Table 1. The
first and slowest cycle time we propose is around $1000\mu s$. This is several
times faster than what was simulated by Trout et. al. [24] and around three
times slower than the architecture proposed by Lekitsch et. al. [26]. This
time scale permits some flexibility in routing and cooling options making it
especially suitable for segmented-linear trap and QCCD architectures which
require extensive use of both. Here, we expect one or more stages of cooling
per cycle and shuttling to avoid measurement induced decoherence. The second
time proposed is $100\mu s$. This is a more optimistic regime, being several
times faster than the EIT cooling times reported in Section III.3. Because of
this, we require that fewer than one dedicated round of cooling is made per
clock cycle. There is considerably less flexibility permitted for routing or
shuttling at this scale. Dedicated zones for multi-qubit measurement (Section
III.2.4) will likely become significant time and heat savers as will sub-
quanta shuttling. Architectures that are likely to be viable in this paradigm
include linear-traps, Wigner crystals, and QCCDs. It is likely as well that at
least one strategy for mitigating measurement induced decoherence will be
employed (Section III.2.1). The final, and most optimistic regime is $10\mu
s$. At this timescale, our clock cycle matches the two qubit gate times
reported in Sec. III.1 meaning that no processes are allowed which interrupt
syndrome extraction. Persistent cooling is an absolute necessity here, as is
an architecture that doesn’t require any routing or shuttling. Linear traps,
Wigner crystals or micro-trap based architectures are the most likely
candidates for this regime.

Cycle time |  System assumptions
---|---
$1000\mu s$ |  No assumptions made. Cycle time is comparable to theoretic proposals in literature.
$100\mu s$ |  Less than one dedicated round of cooling per cycle. EIT cooling with sub-quanta shuttling required. Multi-qubit measurement stages recommended. Will likely incorporate at least one suppression technique discussed in Sec. III.2.1.
$10\mu s$ |  Virtually no shuttling allowed. Persistent cooling that doesn’t pause syndrome extraction cycle is essential. Multiple suppression techniques from Sec. III.2.1 will likely be used together. Purification circuits are low-depth with one round of measurement.
Table 1: A summary of three cycle time paradigms for trapped-ion surface codes
and the various technological milestones required for each speed.

###  III.5 Entangling ion pairs

Any modular architecture requires some means of communicating quantum
information between the constituent ELUs. A common approach is to establish
maximally entangled pairs of qubits between dedicated communication qubits to
be used for quantum state teleportation. First, an ion is pulsed to create an
entangled pair between an internal state of the ion and an emitted photon.
Then, photons emitted from two different ELUs are routed together and fused
with an polarization resolving Bell measurement that establishes entanglement
between the separated ions. The rate at which ion-ion entanglement is
established this way depends on the photon scattering rate (the maximum rate
that photons can interact with ions), the photon capture rate, and the
probability of the fusion operation succeeding. The photon scattering rate
(which can be interpreted as an attempt rate) is physically constrained to
around 100 MHz, though experimental instances of this today are practically
limited to around 1 MHz [48]. The fastest and highest quality ion-ion
distribution rate at the time of writing comes from the same paper cited and
reports 94% fidelity Bell pairs with a success probability of $2.18\times
10^{-4}$ for an average pair rate of $182s^{-1}$.

##  IV Methodology

Figure 3:  Three concurrent stages for a single lattice surgery operation.
(Bottom) Entanglement is established between pairs of communication ions in
separate ELUs. (Middle) Distributed pairs in storage ions are refined via
entanglement purification. (Top) Refined pairs are used to teleport the
mediating gates needed for a lattice surgery between two surface code patches.

###  IV.1 A heuristic for fault-tolerant lattice surgery

Our primary objective for this work is to estimate the number of trapped-ions
needed to perform fault-tolerant lattice surgery between surface codes at the
rates specified in Table 1. So far however, we have not addressed the question
of what it means for lattice surgery to be fault-tolerant. Here, we formalise
a definition by introducing a heuristic consisting of three criteria that must
all be met for lattice surgery to be considered fault-tolerant. These
conditions correspond to three subroutines of lattice surgery, which are
depicted in Fig. 4. Essentially, the point of this heuristic is to ensure that
each of of these necessary subroutines succeeds with high probability.

The first criteria is the promise of a purification protocol that takes $n$
Bell pairs of some initial fidelity $F_{in}$ and, with some probability $p$,
returns one pair at or above the required fidelity threshold $F_{ideal}$. The
second condition is that each purification circuit is multiplexed (run in
parallel copies) until the probability of getting at least one pair from the
lot exceeds $P_{\textrm{pair}}$. The final condition is that we are able to
collect enough entanglement within the cycle time $T$ to implement $d$
instances of the multiplexed purification protocol (one for each “stitch” of
the lattice surgery). We stress that this collection must take place within
the time $T$ so that enough entanglement is acquired to be used for the next
round of lattice surgery. The probability that this collection succeeds must
equal or exceed a threshold $P_{\textrm{LS}}$.

Figure 4:  Illustrations of the three conditions we require for our lattice
surgery to be considered fault-tolerant: (A): We are given an $n\rightarrow 1$
purification protocol where the output pair meets or exceeds fidelity
$F_{\textrm{ideal}}$. (B): We duplicate the circuit until the probability of
getting at least one purified pair exceeds $P_{\textrm{pair}}$. (C): We have
enough communication ions such that after after a collection time $T$, we are
sure up to a confidence of $P_{\textrm{LS}}$ that we have enough entangled
implement $D$ instances of the protocol described in (B).

####  IV.1.1 Minimum number of communication ions required given cycle time

Let $p$ be the success probability of a purification circuit. The probability
of obtaining at least one success out of $n$ trials is $1-(1-p)^{n}$.
Naturally the minimum number of purification circuits needed to produce at
least one pair with a confidence of $P_{\textrm{pair}}$ is then

$K\equiv\min_{n}\bigg{[}1-(1-p)^{n}\geq P_{\textrm{pair}}\bigg{]}$ (1)

If the purification circuit takes $N_{p}$ raw pairs as input and returns one
pair as output, the total number of raw pairs needed for the lattice surgery
according to our heuristic is

$N_{\textrm{LS}}=DN_{p}K$ (2)

If $T$ is the surface code clock cycle (the time it takes to perform a round
of syndrome extraction) and if $R$ is the rate at which entanglement can be
attempted between pairs of ions, then we have $A=TR$ attempts to collect
$N_{\textrm{LS}}$ pairs. Suppose each ELU has
$N_{\textrm{ions}}>N_{\textrm{LS}}$ communication ions. During a collection
attempt, each of the $v\leq N_{\textrm{ions}}$ vacant ions are pulsed and may
become entangled with probability $p_{e}$. Entangled ions are not pulsed in
subsequent rounds, and we assume the entanglement does not degrade as it
waits. Our first objective is to determine the probability that
$N_{\textrm{LS}}$ pairs can be collected in $A$ attempts. The probability that
a single ion pair is entangled after $A$ attempts is given by:

$P_{\textrm{onepair}}=1-(1-p_{e})^{A}$ (3)

Let $X\sim\mathcal{B}(N_{\textrm{ions}},P_{\textrm{onepair}})$ be the binomial
random variable representing the number of ion pairs out of the initial
$N_{\textrm{ions}}$ that are populated after $A$ rounds. The minimum number of
communication ions needed to collect at least $N_{\textrm{LS}}$ pairs in a
code cycle with confidence $P_{\textrm{LS}}$ is then

$\min_{N_{\textrm{ions}}}\bigg{[}P(X\geq N_{\textrm{LS}})\geq
P_{\textrm{LS}}\bigg{]}$ (4)

####  IV.1.2 Maximum attainable rate given given number of communication ions

Suppose now that $N_{\textrm{ions}}$ is fixed. Let $A_{\textrm{min}}$ be the
minimum number of attempts needed to populate the $N_{\textrm{LS}}$ ions
needed for lattice surgery with an overall confidence of $P_{\textrm{LS}}$.

$A_{\textrm{min}}=\min_{A}\bigg{[}P(X\geq DN_{p}K)\geq P_{LS}\bigg{]}$ (5)

The maximum attainable rate for our fault-tolerant lattice surgery given
$N_{\textrm{ions}}$ is then just $A_{min}/R$

###  IV.2 Device parameters and assumptions

From Stephenson et. al. [48], we assume that we can pulse ions at a rate of
$1\textrm{MHz}$ where each pulse has a $2.18\times 10^{-4}$ chance of
producing an entangled ion-ion pair of fidelity $0.94$. We assume that our
surface codes have an operational error rate of $0.1\%$ which, from the
results of Ramette et. al. [13], means we can tolerate Bell pairs with an
infidelity of $0.01$. We assume that the routing and circuits within the
purification stage take a negligible amount of time compared with the
entanglement collection. Single and two qubit gate error are approximated as
single and two-qubit depolarizing channels that occur with probabilities
$1\times 10^{-5}$ and $5\times 10^{-5}$ respectively. Measurement errors are
taken as bitflip channels that occur with probability $1\times 10^{-5}$.
Although ion-trapping lifetimes are extremely good (hours, and even months in
extreme cases), they are not indefinite. We do not consider ion loss or
replacement in our resource estimation. Neither do we consider leakage errors
that are known to accumulate with consecutive surface code cycles [49]. Though
a linear crystal architecture has all-to-all connectivity in theory, it may
not be possible in practice to perform arbitrary simultaneous two qubit gates
as we have assumed. Nevertheless, we note promising results from the current
state-of-the-art [50].

###  IV.3 Optimizing entanglement purification with device level noise

Figure 5: A high yield purification circuit discovered by the genetic
algorithm from Addala et. al. [51]. This circuit takes three partially
entangled pairs as input $\\{(q_{0},q_{3}),(q_{1},q_{3}),(q_{2},q_{5})\\}$ and
non-deterministically returns a higher fidelity pair at $(q_{0},q_{3})$. The
protocol succeeds if $c_{1}=c_{4}$ and $c_{2}\neq c_{5}$ (in other words, the
measurement outcome of qubit $q_{1}$ is coincident with the measurement of
$q_{4}$ and the measurement of $q_{2}$ is anti-coincident with $q_{5}$). When
this circuit is run with three copies of the Stephenson pair (see Appendix) as
input together with the noise parameters described in sec. IV.2, the
purification produces a fidelity $F=0.9904$ pair with probability $p=0.819$

Our need for fault-tolerant lattice surgery highlights the importance of a
high yield pair purification protocol. Though all such protocols theoretically
asymptote to unit fidelity, the practical reality is that device level-noise
imposes a cap on the pair fidelities that are attainable with purification. It
is essential therefore to find a purification protocol that is able to reach
our target fidelity of $F_{\textrm{ideal}}=0.99$ despite circuit-level noise.
To this end, we decided to search for high-performing purification protocols
using recently developed numerical methods. Goodenough et. al. proposed an
exhaustive search over purification protocols by mapping the problem to an
enumeration over so called graph codes [52], while Addala et. al. [51], built
on earlier work from Krastanov et. al. [53] to refine a genetic algorithm for
finding purification protocols. We opted to use the genetic optimization over
the enumeration because of its ease of use and because the attainable
fidelities reported by Addala et. al. were comparable to those reported by
Goodenough. We used this genetic algorithm to identify several hundred
potentially suitable purification circuits. From this initial pool of
candidates, we simulated each circuit using the noise parameters detailed in
IV.2. For added realism, we modeled our initial $F=0.94$ entangled pairs after
the density matrix of an experimentally realised ion-ion pair reported in the
supplementary material of Stephenson et. al. [48] (See appendix). The highest
yield purification circuit we discovered with this genetic algorithm is
presented in fig. 5. This protocol takes three Stephenson pairs as input and
produces one output pair with a fidelity of $F=0.9904$ with an overall success
probability of $0.819$. A full discussion of our methodology and findings is
presented in the appendix of this paper.

##  V Results

Figure 6:  Minimum numbers of communication ions required to ensure that
sufficient entanglement can be collected Minimum number of communication ions
required to ensure that sufficient entanglement can be enough entanglement can
be supplied within a given cycle time.

Our numerical results are presented as tables in Fig. 6 and Fig. 7
respectively. In Fig. 6 we used Eq. 4 to determine the minimum number of
communication ions needed to collect sufficiently many entangled pairs for
fault-tolerant lattice surgery for a given cycle time $T$. We considered three
cycle times of $10\mu s,100\mu s,$ and $1000\mu s$ according to the
technological paradigms we discussed in section III over a small range of code
distances. Our calculations indicate that the number of communication ions
required is approximately linear with respect to both the code distance and
the cycle time within our selected ranges. As the cycle time decreases in
orders of magnitude, we find straightforwardly that the number of
communication ions increases in orders of magnitude. If we assume that a given
ELU may contain around 1000 ions at most, we find that a $D=9$ code is
theoretically supported at a clock cycle $1000\mu s$, while cycle times
considerably faster than this appear out of reach.

In fig 7, we used Eq. 5 to calculate the maximum lattice surgery rates that
are theoretically possible according to our fault-tolerant heuristic given
various numbers of communication ions and various code distances. The whited
out squares in the 100 ion column from $D=7$ onward indicate that fault-
tolerant lattice surgery is not possible at these distances, since the number
of required pairs exceeds the number of communication ions available. Similar
to what we observed in the previous table, we find that there’s a tenfold
difference between the 1,000 and 10,000 ion columns, though we note a slight
deviation from this trend at the 100 ion column. This behavior occurs because
the number of communication ions is close to the number of required pairs. As
the required number of pairs approaches the number of available ions, we
expect an exponential increase in the number of attempts needed to collect the
entanglement since this collection is done without replacement. Our results
indicate that with 100 communication ions, we could expect to support a
distance 5 or 6 code at a maximum rate of around $100$Hz. For 1000 and 10000
communication ions we find that larger code distances are possible with rates
at around $1$KHz and $10$KHz respectively.

Figure 7:  Average lattice surgery rates for different code distances and
numbers of communication ions

##  VI Discussion

Our results, although promising for short term demonstrations of surface code
quantum computing, indicate long term concerns for scalability due to the
large number of physical resources required. If $10\mu s$ is about the fastest
clock cycle we can hope for, our findings in figure 6 indicate that we would
need upwards of 40,000 communication ions per ELU even for modestly sized
surface codes. The prohibitive cost of this indicates an urgent need for
improved optical coupling; As it stands, the low probability of entangling
ions in separate ELUs ($2.18\times 10^{-4}$ [48]) is a leading cause for this
inflated resource overhead. Though ion-photon interaction rates appear to be
limited by physical constraints, we anticipate that improvements can be made
in photon collection rates. Literature today reports photon collection
efficiencies as high as $10\%$ – roughly an order of magnitude above what was
previously possible [54]. Entanglement distribution using neutral atoms to
mediate interactions has been discussed in the context of quantum networking
[55]. We note as well that our purification protocol is another target for
improvement. Our $3\rightarrow 1$ protocol has a $81.9\%$ success rate, which
for a confidence threshold of $P_{\textrm{Pair}}=0.999$ means that we require
$K=5$ purification circuits (Eq. 1) per stitch in the lattice surgery. This is
effectively a $15\rightarrow 1$ purification circuit, which appears rather
wasteful. It is possible that further developments in the study of
entanglement purification will result in high-confidence protocols with higher
overall yield.

In this work we estimated the number of communication ions needed to perform
lattice surgery between two trapped-ion surface code qubits. To this end, we
developed three paradigms for syndrome extraction cycle times that were
predicated on various technological milestones and presented a heuristic for
determining whether a lattice surgery operation is fault tolerant.

##  VII Acknowledgement and funding

We thank Ilia Khait, Stefan Krastanov, Vaishnavi Addala, and Kenneth
Goodenough for helpful discussions. The views, opinions, and/or findings
expressed are those of the author(s) and should not be interpreted as
representing the official views or policies of the Department of Defense or
the U.S. Government. This research was developed with funding from the Defense
Advanced Research Projects Agency [under the Quantum Benchmarking (QB) program
under Awards No. HR00112230007 and No. HR001121S0026 contracts].

A.M.D.G

## References

  * Bruzewicz et al. [2019a] Colin D. Bruzewicz, John Chiaverini, Robert McConnell, and Jeremy M. Sage.  Trapped-ion quantum computing: Progress and challenges.  _Applied Physics Reviews_ , 6(2):021314, Jun 2019a.  ISSN 1931-9401.  doi: 10.1063/1.5088164.  URL http://dx.doi.org/10.1063/1.5088164.
  * Lekitsch et al. [2017a] Bjoern Lekitsch, Sebastian Weidt, Austin G. Fowler, Klaus Mølmer, Simon J. Devitt, Christof Wunderlich, and Winfried K. Hensinger.  Blueprint for a microwave trapped ion quantum computer.  _Science Advances_ , 3(2):e1601540, 2017a.  doi: 10.1126/sciadv.1601540.  URL https://www.science.org/doi/abs/10.1126/sciadv.1601540.
  * Nemoto et al. [2014] Kae Nemoto, Michael Trupke, Simon J. Devitt, Ashley M. Stephens, Burkhard Scharfenberger, Kathrin Buczak, Tobias Nöbauer, Mark S. Everitt, Jörg Schmiedmayer, and William J. Munro.  Photonic architecture for scalable quantum information processing in diamond.  _Phys. Rev. X_ , 4:031022, Aug 2014.  doi: 10.1103/PhysRevX.4.031022.  URL https://link.aps.org/doi/10.1103/PhysRevX.4.031022.
  * Roffe [2019] Joschka Roffe.  Quantum error correction: an introductory guide.  _Contemporary Physics_ , 60(3):226–245, 2019.
  * Chou et al. [2018] Kevin S. Chou, Jacob Z. Blumoff, Christopher S. Wang, Philip C. Reinhold, Christopher J. Axline, Yvonne Y. Gao, L. Frunzio, M. H. Devoret, Liang Jiang, and R. J. Schoelkopf.  Deterministic teleportation of a quantum gate between two logical qubits.  _Nature_ , 561(7723):368–373, September 2018.  ISSN 1476-4687.  doi: 10.1038/s41586-018-0470-y.  URL http://dx.doi.org/10.1038/s41586-018-0470-y.
  * Bennett et al. [1996] Charles H. Bennett, Gilles Brassard, Sandu Popescu, Benjamin Schumacher, John A. Smolin, and William K. Wootters.  Purification of noisy entanglement and faithful teleportation via noisy channels.  _Physical Review Letters_ , 76(5):722–725, jan 1996.  doi: 10.1103/physrevlett.76.722.
  * Fowler et al. [2012] Austin G. Fowler, Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland.  Surface codes: Towards practical large-scale quantum computation.  _Physical Review A_ , 86(3), Sep 2012.  ISSN 1094-1622.  doi: 10.1103/physreva.86.032324.  URL http://dx.doi.org/10.1103/PhysRevA.86.032324.
  * Stephens [2014] Ashley M. Stephens.  Fault-tolerant thresholds for quantum error correction with the surface code.  _Phys. Rev. A_ , 89:022321, Feb 2014.  doi: 10.1103/PhysRevA.89.022321.  URL https://link.aps.org/doi/10.1103/PhysRevA.89.022321.
  * Tuckett et al. [2018] David K. Tuckett, Stephen D. Bartlett, and Steven T. Flammia.  Ultrahigh error threshold for surface codes with biased noise.  _Phys. Rev. Lett._ , 120:050505, Jan 2018.  doi: 10.1103/PhysRevLett.120.050505.  URL https://link.aps.org/doi/10.1103/PhysRevLett.120.050505.
  * Litinski [2019] Daniel Litinski.  A game of surface codes: Large-scale quantum computing with lattice surgery.  _Quantum_ , 3:128, March 2019.  ISSN 2521-327X.  doi: 10.22331/q-2019-03-05-128.  URL http://dx.doi.org/10.22331/q-2019-03-05-128.
  * Vasmer and Browne [2019] Michael Vasmer and Dan E. Browne.  Three-dimensional surface codes: Transversal gates and fault-tolerant architectures.  _Phys. Rev. A_ , 100:012312, Jul 2019.  doi: 10.1103/PhysRevA.100.012312.  URL https://link.aps.org/doi/10.1103/PhysRevA.100.012312.
  * Horsman et al. [2012] Clare Horsman, Austin G Fowler, Simon Devitt, and Rodney Van Meter.  Surface code quantum computing by lattice surgery.  _New Journal of Physics_ , 14(12):123011, dec 2012.  doi: 10.1088/1367-2630/14/12/123011.  URL https://doi.org/10.1088%2F1367-2630%2F14%2F12%2F123011.
  * Ramette et al. [2023] Joshua Ramette, Josiah Sinclair, Nikolas P. Breuckmann, and Vladan Vuletić.  Fault-tolerant connection of error-corrected qubits with noisy links, 2023.
  * Monroe et al. [2014] C. Monroe, R. Raussendorf, A. Ruthven, K. R. Brown, P. Maunz, L.-M. Duan, and J. Kim.  Large-scale modular quantum-computer architecture with atomic memory and photonic interconnects.  _Phys. Rev. A_ , 89:022317, Feb 2014.  doi: 10.1103/PhysRevA.89.022317.  URL https://link.aps.org/doi/10.1103/PhysRevA.89.022317.
  * Chen et al. [2023] Jwo-Sy Chen, Erik Nielsen, Matthew Ebert, Volkan Inlek, Kenneth Wright, Vandiver Chaplin, Andrii Maksymov, Eduardo Páez, Amrit Poudel, Peter Maunz, and John Gamble.  Benchmarking a trapped-ion quantum computer with 29 algorithmic qubits, 2023.
  * Murali et al. [2020] Prakash Murali, Dripto M. Debroy, Kenneth R. Brown, and Margaret Martonosi.  Architecting noisy intermediate-scale trapped ion quantum computers.  In _Proceedings of the ACM/IEEE 47th Annual International Symposium on Computer Architecture_ , ISCA ’20, page 529–542. IEEE Press, 2020.  ISBN 9781728146614.  doi: 10.1109/ISCA45697.2020.00051.  URL https://doi-org.ezproxy.lib.uts.edu.au/10.1109/ISCA45697.2020.00051.
  * Ratcliffe et al. [2018] Alexander K. Ratcliffe, Richard L. Taylor, Joseph J. Hope, and André R. R. Carvalho.  Scaling trapped ion quantum computers using fast gates and microtraps.  _Phys. Rev. Lett._ , 120:220501, May 2018.  doi: 10.1103/PhysRevLett.120.220501.  URL https://link.aps.org/doi/10.1103/PhysRevLett.120.220501.
  * Mehdi et al. [2020] Zain Mehdi, Alexander K. Ratcliffe, and Joseph J. Hope.  Scalable quantum computation with fast gates in two-dimensional microtrap arrays of trapped ions.  _Phys. Rev. A_ , 102:012618, Jul 2020.  doi: 10.1103/PhysRevA.102.012618.  URL https://link.aps.org/doi/10.1103/PhysRevA.102.012618.
  * Kaushal et al. [2020] V. Kaushal, B. Lekitsch, A. Stahl, J. Hilder, D. Pijn, C. Schmiegelow, A. Bermudez, M. Müller, F. Schmidt-Kaler, and U. Poschinger.  Shuttling-based trapped-ion quantum information processing.  _AVS Quantum Science_ , 2(1):014101, 03 2020.  ISSN 2639-0213.  doi: 10.1116/1.5126186.  URL https://doi.org/10.1116/1.5126186.
  * Pino et al. [2021] J. M. Pino, J. M. Dreiling, C. Figgatt, J. P. Gaebler, S. A. Moses, M. S. Allman, C. H. Baldwin, M. Foss-Feig, D. Hayes, K. Mayer, C. Ryan-Anderson, and B. Neyenhuis.  Demonstration of the trapped-ion quantum ccd computer architecture.  _Nature_ , 592(7853):209–213, April 2021.  ISSN 1476-4687.  doi: 10.1038/s41586-021-03318-4.  URL http://dx.doi.org/10.1038/s41586-021-03318-4.
  * Wu et al. [2021] Y.-K. Wu, Z.-D. Liu, W.-D. Zhao, and L.-M. Duan.  High-fidelity entangling gates in a three-dimensional ion crystal under micromotion.  _Phys. Rev. A_ , 103:022419, Feb 2021.  doi: 10.1103/PhysRevA.103.022419.  URL https://link.aps.org/doi/10.1103/PhysRevA.103.022419.
  * Wang et al. [2015] S.-T. Wang, C. Shen, and L.-M. Duan.  Quantum computation under micromotion in a planar ion crystal.  _Scientific Reports_ , 5(1), February 2015.  ISSN 2045-2322.  doi: 10.1038/srep08555.  URL http://dx.doi.org/10.1038/srep08555.
  * Leblond et al. [2023] Tyler Leblond, Ryan S. Bennink, Justin G. Lietz, and Christopher M. Seck.  Tiscc: A surface code compiler and resource estimator for trapped-ion processors.  SC-W ’23, page 1426–1435, New York, NY, USA, 2023. Association for Computing Machinery.  ISBN 9798400707858.  doi: 10.1145/3624062.3624214.  URL https://doi.org/10.1145/3624062.3624214.
  * Trout et al. [2018] Colin J Trout, Muyuan Li, Mauricio Gutiérrez, Yukai Wu, Sheng-Tao Wang, Luming Duan, and Kenneth R Brown.  Simulating the performance of a distance-3 surface code in a linear ion trap.  _New Journal of Physics_ , 20(4):043038, April 2018.  ISSN 1367-2630.  doi: 10.1088/1367-2630/aab341.  URL http://dx.doi.org/10.1088/1367-2630/aab341.
  * Li and Benjamin [2018] Ying Li and Simon C. Benjamin.  One-dimensional quantum computing with a ‘segmented chain’ is feasible with today’s gate fidelities.  _npj Quantum Information_ , 4(1), May 2018.  ISSN 2056-6387.  doi: 10.1038/s41534-018-0074-2.  URL http://dx.doi.org/10.1038/s41534-018-0074-2.
  * Lekitsch et al. [2017b] Bjoern Lekitsch, Sebastian Weidt, Austin G. Fowler, Klaus Mølmer, Simon J. Devitt, Christof Wunderlich, and Winfried K. Hensinger.  Blueprint for a microwave trapped ion quantum computer.  _Science Advances_ , 3(2):e1601540, 2017b.  doi: 10.1126/sciadv.1601540.  URL https://www.science.org/doi/abs/10.1126/sciadv.1601540.
  * Bruzewicz et al. [2019b] Colin D. Bruzewicz, John Chiaverini, Robert McConnell, and Jeremy M. Sage.  Trapped-ion quantum computing: Progress and challenges.  _Applied Physics Reviews_ , 6(2):021314, 05 2019b.  ISSN 1931-9401.  doi: 10.1063/1.5088164.  URL https://doi.org/10.1063/1.5088164.
  * Crain et al. [2019] Stephen Crain, Clinton Cahall, Geert Vrijsen, Emma E. Wollman, Matthew D. Shaw, Varun B. Verma, Sae Woo Nam, and Jungsang Kim.  High-speed low-crosstalk detection of a 171yb+ qubit using superconducting nanowire single photon detectors.  _Communications Physics_ , 2(1), August 2019.  ISSN 2399-3650.  doi: 10.1038/s42005-019-0195-8.  URL http://dx.doi.org/10.1038/s42005-019-0195-8.
  * Myerson et al. [2008] A. H. Myerson, D. J. Szwer, S. C. Webster, D. T. C. Allcock, M. J. Curtis, G. Imreh, J. A. Sherman, D. N. Stacey, A. M. Steane, and D. M. Lucas.  High-fidelity readout of trapped-ion qubits.  _Phys. Rev. Lett._ , 100:200502, May 2008.  doi: 10.1103/PhysRevLett.100.200502.  URL https://link.aps.org/doi/10.1103/PhysRevLett.100.200502.
  * Wolk et al. [2015] Sabine Wolk, Ch Piltz, Theeraphot Sriarunothai, and Christof Wunderlich.  State selective detection of hyperfine qubits.  _Journal of Physics B: Atomic_ , 48, 04 2015.  doi: 10.1088/0953-4075/48/7/075101.
  * Schmidt et al. [2005] P. O. Schmidt, T. Rosenband, C. Langer, W. M. Itano, and et al.  Spectroscopy using quantum logic.  _Science_ , 309(5735):749–52, Jul 29 2005.  URL http://ezproxy.lib.uts.edu.au/login?url=https://www.proquest.com/scholarly-journals/spectroscopy-using-quantum-logic/docview/213616639/se-2.  Copyright - Copyright American Association for the Advancement of Science Jul 29, 2005; Document feature - Equations; Diagrams; Graphs; ; Last updated - 2023-12-04; CODEN - SCIEAS.
  * Feng et al. [2023] L. Feng, Y. Y Huang, Y. K. Wu, W. X. Guo, J. Y. Ma, H. X. Yang, L. Zhang, Y. Wang, C. X. Huang, C. Zhang, L. Yao, B. X. Qi, Y. F. Pu, Z. C. Zhou, and L. M. Duan.  Realization of a crosstalk-avoided quantum network node with dual-type qubits by the same ion species, 2023.
  * Yang et al. [2022] H.-X. Yang, J.-Y. Ma, Y.-K. Wu, Y. Wang, M.-M. Cao, W.-X. Guo, Y.-Y. Huang, L. Feng, Z.-C. Zhou, and L.-M. Duan.  Realizing coherently convertible dual-type qubits with the same ion species.  _Nature Physics_ , 18(9):1058–1061, August 2022.  ISSN 1745-2481.  doi: 10.1038/s41567-022-01661-5.  URL http://dx.doi.org/10.1038/s41567-022-01661-5.
  * Gaebler et al. [2021] J. P. Gaebler, C. H. Baldwin, S. A. Moses, J. M. Dreiling, C. Figgatt, M. Foss-Feig, D. Hayes, and J. M. Pino.  Suppression of midcircuit measurement crosstalk errors with micromotion.  _Phys. Rev. A_ , 104:062440, Dec 2021.  doi: 10.1103/PhysRevA.104.062440.  URL https://link.aps.org/doi/10.1103/PhysRevA.104.062440.
  * Ruzic et al. [2022] B. P. Ruzic, T. A. Barrick, J. D. Hunker, R. J. Law, B. K. McFarland, H. J. McGuinness, L. P. Parazzoli, J. D. Sterk, J. W. Van Der Wall, and D. Stick.  Entangling-gate error from coherently displaced motional modes of trapped ions.  _Phys. Rev. A_ , 105:052409, May 2022.  doi: 10.1103/PhysRevA.105.052409.  URL https://link.aps.org/doi/10.1103/PhysRevA.105.052409.
  * Sterk et al. [2022] Jonathan D. Sterk, Henry Coakley, Joshua Goldberg, Vincent Hietala, Jason Lechtenberg, Hayden McGuinness, Daniel McMurtrey, L. Paul Parazzoli, Jay Van Der Wall, and Daniel Stick.  Closed-loop optimization of fast trapped-ion shuttling with sub-quanta excitation.  _npj Quantum Information_ , 8(1):68, Jun 2022.  ISSN 2056-6387.  doi: 10.1038/s41534-022-00579-3.  URL https://doi.org/10.1038/s41534-022-00579-3.
  * Bowler et al. [2012] R. Bowler, J. Gaebler, Y. Lin, T. R. Tan, D. Hanneke, J. D. Jost, J. P. Home, D. Leibfried, and D. J. Wineland.  Coherent diabatic ion transport and separation in a multizone trap array.  _Phys. Rev. Lett._ , 109:080502, Aug 2012.  doi: 10.1103/PhysRevLett.109.080502.  URL https://link.aps.org/doi/10.1103/PhysRevLett.109.080502.
  * Zhukas et al. [2021] Liudmila A. Zhukas, Peter Svihra, Andrei Nomerotski, and Boris B. Blinov.  High-fidelity simultaneous detection of a trapped-ion qubit register.  _Phys. Rev. A_ , 103:062614, Jun 2021.  doi: 10.1103/PhysRevA.103.062614.  URL https://link.aps.org/doi/10.1103/PhysRevA.103.062614.
  * Wright et al. [2019] K. Wright, K. M. Beck, S. Debnath, J. M. Amini, Y. Nam, N. Grzesiak, Chen J-S, N. C. Pisenti, M. Chmielewski, C. Collins, K. M. Hudek, J. Mizrahi, J. Wong-Campos, S. Allen, J. Apisdorf, P. Solomon, M. Williams, A. M. Ducore, A. Blinov, S. M. Kreikemeier, V. Chaplin, M. Keesan, C. Monroe, and J. Kim.  Benchmarking an 11-qubit quantum computer.  _Nature Communications_ , 10:1–6, 11 2019.  URL http://ezproxy.lib.uts.edu.au/login?url=https://www.proquest.com/scholarly-journals/benchmarking-11-qubit-quantum-computer/docview/2319732029/se-2.
  * Sørensen and Mølmer [1999] Anders Sørensen and Klaus Mølmer.  Quantum computation with ions in thermal motion.  _Phys. Rev. Lett._ , 82:1971–1974, Mar 1999.  doi: 10.1103/PhysRevLett.82.1971.  URL https://link.aps.org/doi/10.1103/PhysRevLett.82.1971.
  * Kang et al. [2023] Mingyu Kang, Qiyao Liang, Ming Li, and Yunseong Nam.  Efficient motional-mode characterization for high-fidelity trapped-ion quantum computing.  _Quantum Science and Technology_ , 8(2):024002, jan 2023.  doi: 10.1088/2058-9565/acb3f1.  URL https://dx.doi.org/10.1088/2058-9565/acb3f1.
  * Feng et al. [2020] L. Feng, W. L. Tan, A. De, A. Menon, A. Chu, G. Pagano, and C. Monroe.  Efficient ground-state cooling of large trapped-ion chains with an electromagnetically-induced-transparency tripod scheme.  _Phys. Rev. Lett._ , 125:053001, Jul 2020.  doi: 10.1103/PhysRevLett.125.053001.  URL https://link.aps.org/doi/10.1103/PhysRevLett.125.053001.
  * Joshi et al. [2020] M K Joshi, A Fabre, C Maier, T Brydges, D Kiesenhofer, H Hainzer, R Blatt, and C F Roos.  Polarization-gradient cooling of 1d and 2d ion coulomb crystals.  _New Journal of Physics_ , 22(10):103013, October 2020.  ISSN 1367-2630.  doi: 10.1088/1367-2630/abb912.  URL http://dx.doi.org/10.1088/1367-2630/abb912.
  * Lin et al. [2013] Y. Lin, J. P. Gaebler, T. R. Tan, R. Bowler, J. D. Jost, D. Leibfried, and D. J. Wineland.  Sympathetic electromagnetically-induced-transparency laser cooling of motional modes in an ion chain.  _Phys. Rev. Lett._ , 110:153002, Apr 2013.  doi: 10.1103/PhysRevLett.110.153002.  URL https://link.aps.org/doi/10.1103/PhysRevLett.110.153002.
  * Mao et al. [2021] Z.-C. Mao, Y.-Z. Xu, Q.-X. Mei, W.-D. Zhao, Y. Jiang, Y. Wang, X.-Y. Chang, L. He, L. Yao, Z.-C. Zhou, Y.-K. Wu, and L.-M. Duan.  Experimental realization of multi-ion sympathetic cooling on a trapped ion crystal.  _Phys. Rev. Lett._ , 127:143201, Sep 2021.  doi: 10.1103/PhysRevLett.127.143201.  URL https://link.aps.org/doi/10.1103/PhysRevLett.127.143201.
  * Lin and Duan [2015] Guin-Dar Lin and L.-M. Duan.  Sympathetic cooling in a large ion crystal.  _Quantum Information Processing_ , 15(12):5299–5313, November 2015.  ISSN 1573-1332.  doi: 10.1007/s11128-015-1161-3.  URL http://dx.doi.org/10.1007/s11128-015-1161-3.
  * Sägesser et al. [2020] T Sägesser, R Matt, R Oswald, and J P Home.  Robust dynamical exchange cooling with trapped ions.  _New Journal of Physics_ , 22(7):073069, July 2020.  ISSN 1367-2630.  doi: 10.1088/1367-2630/ab9e32.  URL http://dx.doi.org/10.1088/1367-2630/ab9e32.
  * Stephenson et al. [2020] L. J. Stephenson, D. P. Nadlinger, B. C. Nichol, S. An, P. Drmota, T. G. Ballance, K. Thirumalai, J. F. Goodwin, D. M. Lucas, and C. J. Ballance.  High-rate, high-fidelity entanglement of qubits across an elementary quantum network.  _Phys. Rev. Lett._ , 124:110501, Mar 2020.  doi: 10.1103/PhysRevLett.124.110501.  URL https://link.aps.org/doi/10.1103/PhysRevLett.124.110501.
  * Brown and Brown [2019] Natalie C. Brown and Kenneth R. Brown.  Leakage mitigation for quantum error correction using a mixed qubit scheme.  _Phys. Rev. A_ , 100:032325, Sep 2019.  doi: 10.1103/PhysRevA.100.032325.  URL https://link.aps.org/doi/10.1103/PhysRevA.100.032325.
  * Grzesiak et al. [2020] Nikodem Grzesiak, Reinhold Blümel, Kenneth Wright, Kristin M. Beck, Neal C. Pisenti, Ming Li, Vandiver Chaplin, Jason M. Amini, Shantanu Debnath, Jwo-Sy Chen, and Yunseong Nam.  Efficient arbitrary simultaneously entangling gates on a trapped-ion quantum computer.  _Nature Communications_ , 11(1), June 2020.  ISSN 2041-1723.  doi: 10.1038/s41467-020-16790-9.  URL http://dx.doi.org/10.1038/s41467-020-16790-9.
  * Addala et al. [2023] Vaishnavi L. Addala, Shu Ge, and Stefan Krastanov.  Faster-than-clifford simulations of entanglement purification circuits and their full-stack optimization, 2023.
  * Goodenough et al. [2023] Kenneth Goodenough, Sébastian de Bone, Vaishnavi L. Addala, Stefan Krastanov, Sarah Jansen, Dion Gijswijt, and David Elkouss.  Near-term $n$ to $k$ distillation protocols using graph codes, 2023.
  * Krastanov et al. [2019] Stefan Krastanov, Victor V. Albert, and Liang Jiang.  Optimized Entanglement Purification.  _Quantum_ , 3:123, February 2019.  ISSN 2521-327X.  doi: 10.22331/q-2019-02-18-123.  URL https://doi.org/10.22331/q-2019-02-18-123.
  * Carter et al. [2023] Allison L. Carter, Jameson O’Reilly, George Toh, Sagnik Saha, Mikhail Shalaev, Isabella Goetting, and Christopher Monroe.  Ion Trap with In-Vacuum High Numerical Aperture Imaging for a Dual-Species Modular Quantum Computer.  _arXiv e-prints_ , art. arXiv:2310.07058, October 2023.  doi: 10.48550/arXiv.2310.07058.
  * Hannegan et al. [2021] John Hannegan, James D. Siverns, Jake Cassell, and Qudsia Quraishi.  Improving entanglement generation rates in trapped-ion quantum networks using nondestructive photon measurement and storage.  _Phys. Rev. A_ , 103:052433, May 2021.  doi: 10.1103/PhysRevA.103.052433.  URL https://link.aps.org/doi/10.1103/PhysRevA.103.052433.

*

##  Appendix A Noisy entanglement distillation

Implementations $\tilde{\mathcal{D}}$ of any entanglement distillation
protocol $\mathcal{D}$ are generally subjected to noise in the sense that
$0\neq\lVert\tilde{\mathcal{D}}-\mathcal{D}\rVert\leq\epsilon$ for small
$\epsilon$. Here we benchmark the performance of entanglement distillation
protocols obtained with genetic algorithm [51] subjected to noise in ion trap
systems. The genetic algorithm takes a Bell-diagonal state

$\displaystyle F\phi_{+}+(1-F)(p_{x}\psi_{+}+p_{z}\phi_{-}+p_{y}\psi_{-})$

as input and searches for optimal $n\rightarrow k$ purification protocols for
that state by iterating an initial randomly generated population of circuits
(describing entanglement distillation protocols) over a number of generations.
The fitness of the individuals in the population is evaluated with respect to
one of several possible objective functions. We optimized with respect to the
“average marginal fidelity,” which is the average fidelity of each output pair
traced out from the final ensemble. This is determined analytically and may
optionally account for single and two qubit depolarizing gate noise along with
measurement errors. Each output circuit is returned with its average marginal
fidelity and overall success probability.

Although the Bell-diagonal states may at first appear to be a somewhat
contrived category of entangled pairs, it turns out that all two-qubit mixed
states can be deterministically twirled into Bell-diagonal pairs of the same
fidelity using local operations and classical communications. This may however
cost a small amount of the distillable entanglement depending on the input
state, though quantifying the amount of entanglement lost and developing
recovery techniques appear to be open research directions. For this reason,
and because twirling introduces a small amount of noise, we developed our
search methodology around the objective of finding purification protocols that
could work without twirling.

Our strategy therefore was to perform an initial search for promising looking
protocols using $F=0.94$ Bell-diagonal pairs with $p_{x}=p_{y}=p_{z}=1/3$
under the parameter values $n=(3,4,5)$ and $k=1$. Our decision to limit our
search to $k=1$ was motivated by our analysis indicating that the $k>1$
protocols produced output pairs with some amount of mutual entanglement
between them. This is a significant issue for lattice surgery, since it is
assumed that each input pair is independent and required us to restrict
ourselves to the $k=1$ case. Simulating beyond $n=5$ proved to be unnecessary
since the average success rate of the protocols can be seen to decrease with
increasing $n$ in Fig. 8. For an $(n>4)\rightarrow 1$ protocol to have a
higher yield than the $3\rightarrow 1$ we identified, it would be necessary
for the larger purification circuit to have a significantly higher success
probability.

Each simulation was performed with a population of 100 circuits evolved for
150 generations. We selected the top performing circuits from each simulation
and benchmarked their performance under the same circuit level noise when
simulated with $F=0.94$ Stephenson pairs (See sec. IV.3) as input. Our
numerical results are presented in Fig. 8. The broad trend indicates that as
the number of pairs increases, the success probability of the protocol
decreases while the average success probability increases. None of the
protocols we identified were able to exceed the required fidelity threshold of
$F_{\text{req}}=0.999$.

Figure 8:  A scatter plot of the success probabilities and output pair
fidelities of a high performing subset of $n\rightarrow 1$ purification
protocols that were first identified with the genetic algorithm [51] then
simulated under circuit level noise with $F=0.94$ Stephenson pairs (See eq. 7)
as inputs. The highest yield purification protocol that exceeds the required
fidelity threshold $F_{\textrm{ideal}}=0.99$ is circled in orange. This is a
$3\rightarrow 1$ purification protocol whose circuit is presented in fig. 5.

##  Appendix B The Stephenson pair

In section IV.3, we alluded to an experimentally realised inter-trap ion pair
reported by Stephenson et. al. in the supplementary material of their main
paper [48]. Strictly speaking, there are four pairs reported which correspond
to four possible interferometer detection events. Since these state are all
effectively equivalent under local operations and classical communications, we
arbitrarily chose to consider the state presented in equation 6. When
expressed in the Bell basis, the predominant term of this state is seen to be
$|\phi^{-}\rangle\langle\psi^{-}|$ up to some phase. As a matter of
convenience, it is preferable for this state to be predominantly entangled
with respect to $|\phi^{+}\rangle\langle\phi^{+}|$. We therefore apply the
rotation $(I\otimes XZ)\rho(I\otimes XZ)$ to obtain $\rho^{\prime}$ in
equation 7. This is the Stephenson pair that we refer to in the main body of
our paper.

$\rho=\left(\begin{array}[]{cccc}0.01&-0.00487616+0.00349614i&0.0135924\,+0.00634402i&0.00374015\,-0.00331833i\\\
-0.00487616-0.00349614i&0.569&0.0542638\,+0.440672i&-0.012985-0.0292471i\\\
0.0135924\,-0.00634402i&0.0542638\,-0.440672i&0.416&-0.0225074-0.00473484i\\\
0.00374015\,+0.00331833i&-0.012985+0.0292471i&-0.0225074+0.00473484i&0.005\\\
\end{array}\right)$ (6)
Figure 9: The “unrotated” Stephenson state, taken from Fig. S4(i) of the
supplementary material of [48].
$\rho^{\prime}=\left(\begin{array}[]{cccc}0.569\,+0.i&-0.00487616-0.00349614i&-0.0292471+0.012985i&0.440672\,-0.0542638i\\\
-0.00487616+0.00349614i&0.01\,+0.i&-0.00331833-0.00374015i&0.00634402\,-0.0135924i\\\
-0.0292471-0.012985i&-0.00331833+0.00374015i&0.005\,+0.i&-0.0225074+0.00473484i\\\
0.440672\,+0.0542638i&0.00634402\,+0.0135924i&-0.0225074-0.00473484i&0.416\,+0.i\\\
\end{array}\right)$ (7) Figure 10: A rotated version of Eq. 6 obtained with
the transformation $\rho^{\prime}=(I\otimes XZ)\;\rho\;(I\otimes XZ)$

##  Appendix C Tables of constants

In this section we present two tables that detail the most important free
parameters and physical constants used throughout the paper. Table C is a
summary of the free parameters used and table 3 is a summary of the constants.

Parameter | Definition
---|---
$N_{\textrm{ions}}$ | The number of communication ions in an ELU
$d$ | Code distance
$T$ | Syndrome extraction cycle time
Table 2: A summary of the free parameters considered in our analysis. Parameter |  Definition | Value |  Justification
---|---|---|---
$p$ |  Purification protocol success probability | 0.819 |  Simulated numerically under circuit level noise
$R$ |  Pulse rate |  $1$ MHz |  Within the magnitude of what is physically possible [48]
$p_{c}$ |  The probability of entangling two ions with one pulse-attempt | $2.18\times 10^{-4}$ |  State of the art: [48]
$F_{\textrm{ideal}}$ |  The fidelity required for pairs used in lattice surgery | 0.99 |  Originally $0.999$, but improved thanks to [13]
$N_{p}$ |  The number of pairs required for the purification circuit | 3 |  Fig. 5
$P_{\textrm{pair}}$ |  The required confidence for multiplexed purification circuits to produce at least one pair | 0.999 |  Arbitrarily high
$K$ |  The required number of purification circuits needed to meet multiplexing confidence | 5 |  Substituting appropriate values into eq. 1
$P_{\textrm{LS}}$ |  The required confidence for collecting sufficient entanglement within a given clock cycle | 0.999 |  Arbitrarily high
Table 3: A catalogue of important numerical constants used throughout this
paper with justifications.