# Modular architectures to deterministically generate graph states

Hassan Shapourian  Cisco Research, San Jose, CA 95134, USA  Alireza Shabani
Cisco Research, Los Angeles, CA 90049, USA

###### Abstract

Graph states are a family of stabilizer states which can be tailored towards
various applications in photonic quantum computing and quantum communication.
In this paper, we present a modular design based on quantum dot emitters
coupled to a waveguide and optical fiber delay lines to deterministically
generate N-dimensional cluster states and other useful graph states such as
tree states and repeater states. Unlike previous proposals, our design
requires no two-qubit gates on quantum dots and at most one optical switch,
thereby, minimizing challenges usually posed by these requirements.
Furthermore, we discuss the error model for our design and demonstrate a
fault-tolerant quantum memory with an error threshold of $0.53\%$ in the case
of a 3d graph state on a Raussendorf-Harrington-Goyal (RHG) lattice. We also
provide a fundamental upper bound on the correctable loss in the fault-
tolerant RHG state based on the percolation theory, which is $1.24$ dB or
$0.24$ dB depending on whether the state is directly generated or obtained
from a simple cubic cluster state, respectively.

##  I Introduction

Photonic systems offer a promising route for scalable quantum computing and
networking (collectively called quantum information processing). Integrated
photonic chips have a small footprint and are network compatible in the sense
that they can be connected together via an optical quantum network to realize
distributed quantum computing O’Brien  _et al._ (2009); Bogdanov  _et al._
(2017). Another feature of photon-based qubits compared to matter-based qubits
is that photonic qubits are protected from decoherence since they barely
interact with environment. However, developing quantum photonic technologies
poses two new challenges: First, photons do not easily interact with each
other and require nonlinear devices to mediate interactions 111There is a
separate line of research on quantum computing Knill  _et al._ (2001) and
realizing gates based on linear optics which led to development of
probabilistic postselected and fusion gates Ralph  _et al._ (2002); Hofmann
and Takeuchi (2002); Browne and Rudolph (2005). We do not address these
approaches in this work.. Even though integrating several devices in the form
of a quantum circuit (where photons interact by flowing through) can be done
for a specific task, it is not a general purpose solution. Second, photonic
systems suffer from loss error where photons either are absorbed or leak out.

Fortunately, both issues can be addressed in a measurement-based scheme
Briegel  _et al._ (2009); Zwerger  _et al._ (2016) where various tasks
including applying quantum gates, error (loss) correction, teleportation, etc.
can be realized in terms of a sequence of (easily reconfigurable) single-qubit
measurements on a multi-photon entangled state, a.k.a. resource state.
Resource states are usually realized in the form of a graph state. Among
others, two important advantages of using graph states are that they are
stabilizer states which means the stabilizer formalism toolbox is available
and they are equipped with a graph representation which provides room for
further innovations by applying graph theory ideas. In the context of
computing, cluster states in two and three dimensions are archetypal examples
of graph states which can be used to perform universal Raussendorf  _et al._
(2003); Raussendorf and Briegel (2001); Nielsen (2004) and fault-tolerant
Raussendorf  _et al._ (2006) quantum computation, respectively. In the context
of networking, quantum repeater states and loss-tolerant quantum error
correcting codes, based on all-to-all connected Zwerger  _et al._ (2012,
2013); Azuma  _et al._ (2015a), self-similar Wallnöfer  _et al._ (2016), and
tree graphs Borregaard  _et al._ (2020); Morley-Short  _et al._ (2019),
respectively, have been developed as new generations of quantum communication
protocols. Consequently, design and implementation of photonic devices to
efficiently generate resource graph states play a crucial role in realizing
measurement-based photonic quantum information processing. Our focus in this
work is on optimal designs for a deterministic resource state generator.

Different protocols to generate entangled resource states generally fall into
two categories Orieux  _et al._ (2017); Moody  _et al._ (2022): One involves
probabilistic sources of entangled photon pairs, based on three-wave or four-
wave mixing, whose output is fed into a linear optical circuit for further
probabilistic gating and postselection of the desired graph state Adcock  _et
al._ (2019). Despite the technological breakthroughs in this field, the
probabilistic nature of this approach causes a large overhead and has limited
its scalability. The other approach is based on light-matter interfaces or
quantum emitters which are deterministic sources of single photons Aharonovich
_et al._ (2016). A semiconductor quantum dot (QD) Senellart  _et al._ (2017);
Javadi  _et al._ (2018) in a nanophotonic cavity or waveguide is a
prototypical example of a quantum emitter which can further be used as a
source of nonlinearity Jeannic  _et al._ (2021); Schrinski  _et al._ (2021)
and integrated with photonic chips. Quantum emitters have also been realized
in other systems such as atoms, ions, vacancy centers, and molecules. The main
advantage of the latter approach is that the photon source and nonlinear gates
are deterministic, which leads to high resource-state generation rates without
a large overhead. Additionally, recent advances in QD technologies Uppu  _et
al._ (2020); Tomm  _et al._ (2021); Uppu  _et al._ (2021) offer a great deal
of quantum controllability and makes it possible to achieve large Purcell
enhancement and produce indistinguishable photons over extended timescales.

Designing optical circuits and protocols for deterministic generation of
entangled states of photons such as Greenberger–Horne–Zeilinger (GHZ) and
linear cluster states via a single quantum emitter was pioneered in Ref.
Lindner and Rudolph (2009), which was subsequently demonstrated experimentally
using a QD Schwartz  _et al._ (2016) and more recently using a single atom in
a cavity Thomas  _et al._ (2022). The core idea is that by applying a temporal
sequence of resonant pulses to a quantum emitter whose logical state is
controlled by a separate optical transition, we obtain a sequence of entangled
photons at the output. This scheme was extended to coupled QDs for generating
2d cluster states Economou  _et al._ (2010); Gimeno-Segovia  _et al._ (2019),
and repeater states Buterakos  _et al._ (2017), which was followed up and
further analyzed in several recent studies Russo  _et al._ (2019); Hilaire
_et al._ (2021); Li  _et al._ (2022). Despite being theoretically interesting,
experimentally realizing such circuit designs are often extremely challenging
since they require multiple actively monitored emitters and two-qubit gates on
them. Even if the two-qubit gates were feasible, it would limit the overall
generation rate of resource states as these gates are typically slow.
Furthermore, unlike the original proposal, these designs typically lack a
regular repeated pattern of resonant pulses and emitter gates, which leads to
an irregular temporal output. In other words, there is no obvious way to
define a reference clock cycle for outgoing photons. This is particularly an
important issue for quantum communication purposes where clock synchronization
is vital.

In a parallel direction, Ref. Pichler and Zoller (2016) opened another route
by designing a novel resource state generator in terms of a quantum emitter
coupled to a quantum feedback loop (or a time-delay line), which was further
pursued to design protocols for generating cluster states in 2d Pichler  _et
al._ (2017) and 3d Wan  _et al._ (2021) as well as tree graph states Zhan and
Sun (2020). Such designs involve only a single emitter and relax the multi-
emitter requirement. In addition, the photon emission rate is manifestly
regular. However, the feedback loop idea by itself relies on a particular
photonic qubit encoding (i.e., presence/absence), where single-qubit gates are
not readily available. Moreover, this type of qubit encoding is very sensitive
to dephasing error and may not be a good choice, especially because in these
schemes qubits travel through optical fiber delay line. Hence, resource states
obtained from this approach cannot be easily manipulated for different tasks
without introducing extra overhead. In addition, introducing more than one
delay-line Wan  _et al._ (2021) in this scheme requires multiple ultrafast
optical switches for routing which puts an upper bound on the device overall
performance in terms of generation rate. Needless to say that optical switches
lead to larger loss rate in the system.

In this paper, we attempt to resolve the issues with existing prototypes
mentioned above and propose a new optical circuit design for deterministic
resource state generators. Our design consists of two components: An active
component, a quantum emitter which sends photons to a passive component,
comprising an optical circulator attached to a scattering block Schrinski  _et
al._ (2021) with a delay-line feedback loop (see Fig. 1). Different graph
states can be obtained by changing the resonant pulse sequence applied to QD
and possibly additional single-qubit gates. Furthermore, our design is
modular, i.e., the passive component can be stacked to realize graphs on
higher dimensional lattices. We should note that our proposal is not
restricted to the QD platform and may be applicable to other quantum emitter
technologies. Regarding the aforementioned issues, our design contains only
one emitter; as a result, it does not require any two-qubit gates for emitters
and manifestly has a reference clock cycle which is governed by the resonant
pulse sequence applied to the emitter. We use time-bin qubit encoding where
single-qubit gates are readily available for performing customized tasks on
the output resource state. Additionally, time-bin encoding is generally not
sensitive to dephasing error and suitable for long-distance quantum
communication Brendel  _et al._ (1999). Last but not least, our setup does not
generally require ultra-fast optical switches running at photon generation
rate. In certain cases, we may have to use an optical switch; however, it only
needs to run at a much slower speed than the photon generation rate and hence
does not impose a constraint on the overall resource state generation rate.

Figure 1: Schematic setup to generate (a) two-dimensional and (b)
$N$-dimensional cluster state. $\mathcal{Q}$ and cz denote quantum emitter and
controlled-phase gate (based on a quantum dot array), respectively. Optical
fiber delay lines are terminated by a reflective plane; however, we show
round-trip trajectories of photons for clarity.

We provide explicit design protocols for generating cluster states in any
dimension, repeater states, and tree graph states. We further discuss an error
model for our design where for simplicity we accompany every (effective) gate
with a depolarizing channel and calculate the circuit error threshold in the
case of fault-tolerant cluster state in three dimensions. We find the circuit
error threshold to be $0.53\%$ which shows an improvement compared to the
error threshold of $0.39\%$ found in Ref. Wan  _et al._ (2021). This roughly
means that fault-tolerant error correction can be achieved as along as the
gate infidelities are below $0.53\%$.

We also study tolerance against the loss error and find that loss rates for
directly generating graph states on RHG lattice can be tolerated up to
$24.9\%$ (or equivalently $1.24$ dB) corresponding to the bond percolation
transition on simple cubice lattice. Alternatively, one can imagine generating
a 3d cluster state on cubic lattice and then carving out an RHG lattice by
measuring a subset of qubits in Z basis. We show the loss threshold in this
case to be quite lower around $5.4\%$ (or $0.24$ dB) which is described by the
bond percolation transition on cubic lattice with second and fourth nearest
neighbor links. As we explain, the fault-tolerant regime can be reached
despite the loss error in optical fiber delay lines as long as the photon
emission rates are greater than $7.5$ or $130$ MHz with or without conversion
to the telecomm frequency band. There are two other places where loss error is
dominant, namely, the emitter-waveguide and chip-to-fiber interfaces. Chip-to-
fiber connection in principle can be improved by engineering a better
interface. At the same time, recent developments in QD technologies have
resulted in the emitter radiation efficiency near unity (e.g., $98.4\%$
reported in Ref. Arcari  _et al._ (2014)) and the path forward looks promising
Tiurev  _et al._ (2020).

The rest of this paper is organized as follows: In Sec. II, we provide some
background materials on graph states and the physics of quantum emitters and
explain the two entangling gates available in our setup. Next, in Sec. III we
present details of our optical circuit design to deterministically generate
various graph states. In Sec. IV, we focus on fault-tolerant properties of 3d
cluster states and show that our optical circuit can generate a robust state
in the presence of photon loss and gate errors. Finally, we close in Sec. V
with concluding remarks and future directions. Some of the details and
derivations are presented in three appendices.

##  II Preliminary remarks

In this section, we review some basics of the graph states and also discuss
the building blocks of our optical circuits, namely, quantum dots coupled to a
waveguide which we use to generate entangled photons and implement
deterministic gates.

###  II.1 Graph state representation

Figure 2: (a) 2-dim cluster state. Qubits are numbered and color coded
according to the circuit in Fig. 6. (b) RHG lattice for fault-tolerant quantum
computing. In panel (b), black edges are to used to show the 3D structure,
while blue edges represent edges in the graph state representation.

In this part, we review some definitions and introduce our notations. Consider
an undirected graph $G$ with $N$ vertices representing $N$ qubits. A graph
state (see Ref. Hein  _et al._ (2006) for a detailed review) associated with
$G$ is then defined as a quantum state of $N$ qubits and given by

$\displaystyle\ket{\Psi_{G}}=\prod_{(i,j)\in
G}\textsc{cz}_{i,j}\ket{+}^{\otimes N},$ (2.1)

where subscripts are qubit labels $i,j=1,\cdots,N$, and $\textsc{cz}_{i,j}$ is
a controlled-phase gate between qubits $i$ and $j$ for every edge $(i,j)$ on
graph $G$. We should note that the ordering of cz gates in the above
expression does not matter as they commute with each other. Throughout this
paper, we use $\\{X_{i},Y_{i},Z_{i}\\}$ to denote the Pauli operators acting
on qubit $i$. Also, $\ket{+}$ refers to the eigenstate of $X$ Pauli operator,
i.e., $X\ket{\pm}=\pm\ket{\pm}$, which can be obtained by a Hadamard gate
$\ket{+}=H\ket{0}$.

An important property of graph states is that they can be characterized as
stabilizer states, i.e., a common eigenvector of a stabilizer group generated
by $N$ commuting set of Pauli operators (aka stabilizer generators)
$\mathcal{S}=\\{P_{1},\cdots,P_{N}\\}$. The $i$-th stabilizer generator
associated with the $i$-th vertex on $G$ is defined by

$\displaystyle P_{i}=X_{i}\bigotimes_{(i,j)\in G}Z_{j}.$ (2.2)

In other words, the $i$-th stabilizer is a product of an $X$ Pauli operator on
$i$-th vertex and $Z$ Pauli operators of adjacent (in the sense of graph)
vertices. We should note that graph state is a stabilizer state (as opposed to
a stabilizer code) since there are $N$ stabilizers which determine a unique
state for $N$ qubits.

There are several advantages to use graph states; to name two, let us mention
that they are equipped with a graphical representation which gives some
intuition to the multipartite entanglement nature of the system, and second
the stabilizer formalism provides an efficient classical description of the
graph state (despite being a non-trivial many-body state) which makes the
simulation of error processes (and possible error correction schemes)
tractable on a classical computer. Figures 2-4 show some commonly used graph
states with various applications from quantum computing to quantum networking
and communications. Graph states on a hypercubic lattice in $N$-dimensions are
generally referred to as $N$-dim cluster states (see Fig. 2). A 1d (linear)
cluster state is a simplest state which can be used as a teleportation channel
or for entanglement distribution in a quantum network. A 2d cluster state
shown in Fig. 2(a) is a resource state for universal quantum computation in a
measurement-based computation scheme Raussendorf  _et al._ (2003); Raussendorf
and Briegel (2001). Most importantly, a 3d cluster state or its variant in the
form of a Raussendorf-Harrington-Goyal (RHG) lattice Raussendorf  _et al._
(2006, 2005) (Fig. 2(b)) can be used as a platform for universal fault-
tolerant quantum computation.

Figure 3: Graph representation of photonic repeater states of (a) twelve and
(b) sixteen qubits. Numbers indicate the temporal position of the photon in
the sequence.

Other useful graph states with applications in quantum communication include
all-to-all graph (repeater) states such as the ones shown in Fig. 3 222Note
that we use a slightly modified version of repeater states which has the same
functionality while it is simpler to implement on our hardware. for all
photonic quantum repeaters Azuma  _et al._ (2015a) and tree graph states as a
quantum error-correcting code to realize a one-way quantum communication
protocol Borregaard  _et al._ (2020).

Before, we delve into the details of our optical circuit designs, let us
briefly go over the circuit building blocks, i.e., quantum emitters and
controlled-phase gates in the next part.

Figure 4: Tree graph state of fifteen qubits. Numbers indicate the temporal
position of the photon in the sequence.

###  II.2 Quantum emitters for deterministic gates

As mentioned, quantum emitters such as a quantum dot coupled to a waveguide
can be used both as a deterministic source of entangled photons and a
nonlinear medium for two-photon gates. In this section, we review these facts
in some detail which then will be used in the following sections as principles
for the circuit design. As we see, the photon emission process is effectively
a controlled-not gate where the control qubit is the emitter and the target
qubit is a photonic qubit.

Throughout this paper, we use an emitter with a $\Lambda$-type energy level
structure as shown in Fig. 5(a), where we use the transition
$\ket{g}\leftrightarrow\ket{f}$ to send and absorb photons denoted by $a$ and
$a^{\dagger}$. The other state is denoted by $\ket{e}$ and the transition is
$\ket{e}\leftrightarrow\ket{f}$ is not active and undesired. The logical
states of the emitter are

$\displaystyle\ket{1}_{q}\coloneqq\ket{g},\qquad\ket{0}_{q}\coloneqq\ket{e}.$
(2.3)

Such energy levels can be realized in a QD subject to a few Tesla magnetic
field (see e.g. Appel  _et al._ (2021)), where $\ket{g}$ and $\ket{e}$
correspond to electron or hole spin degree of freedom, and $\ket{f}$ describes
a state with an additional exciton.

We apply two types of resonant pulses: One that controls the logical state of
the emitter $\ket{g}\leftrightarrow\ket{f}$ with Rabi frequency $\Omega_{O}$,
and another one that drives the transition $\ket{g}\leftrightarrow\ket{e}$
with Rabi frequency $\Omega_{R}$. We should note that in the case of QDs the
latter transition (between electron or hole spin up and down) is driven by a
detuned Raman laser and is not an optical dipole transition Appel  _et al._
(2021); nevertheless, this process results in a transition with an effective
ground state coupling $\Omega_{R}$.

For the photonic qubits, we use a time-bin encoding of quantum information
based on the photon arrival (generation) time. The logical states of a
photonic qubit are defined by

$\displaystyle\ket{1}_{p}\coloneqq
a_{e}^{\dagger}\ket{\text{vac}},\qquad\ket{0}_{p}\coloneqq
a^{\dagger}_{l}\ket{\text{vac}},$ (2.4)

where the subscript of the photon creation operator $e\ (l)$ denotes the early
(late) generation time, respectively. Here, $\ket{\text{vac}}$ denotes the
vacuum state of the photonic mode in the waveguide. Two advantages of using
this encoding scheme is that single-qubit gates can be implemented and
dephasing error is nearly supressed. A potential challenge with this encoding
would be implementing a controlled-phase gate between the emitter and photonic
qubits, where a simple scattering off the emitter Lodahl  _et al._ (2017);
Pichler  _et al._ (2017) is not effective since we get a $\pi$-phase shift
regardless of the logical state of the photonic qubit. However, as we explain
shortly, we can implement a controlled-phase gate between two time-bin encoded
photonic qubits by using an array of QDs following a recent proposal by
Schrinski _et al._ Schrinski  _et al._ (2021). In what follows, we explain the
two basic gates we use to generate entangled states: A controlled-not gate
during the emission process and a controlled-phase gate through a scattering
process.

Figure 5: (a) Energy levels of the quantum dot (emitter) where we use
$\\{\ket{e},\ket{g}\\}$ as the computational basis for the emitter. (b)
Quantum dot coupled to photonic waveguide as a photon source. We use time-bin
encoding characterized by intra-qubit time-delay $\tau_{1}$ and inter-qubit
time difference of $\tau_{2}$. (c) Array of quantum dots to mediate a
controlled-phase gate between two time-bin photonic qubits incident from left
and right.

_Emission process:_ We initialize the emitter state in a Hadamard state
$\ket{+}_{q}=(\ket{0}_{q}+\ket{1}_{q})/\sqrt{2}$ by sending a resonant
$\pi/2$-pulse between $\ket{0}\leftrightarrow\ket{1}$ at $\Omega_{R}$. This
corresponds to a Hadamard gate on the emitter, which we denote by $H_{q}$.
Then, we send a resonant $\pi$-pulse of $\Omega_{O}$ which after possible
spontaneous emission gives the following state

$\displaystyle\frac{1}{\sqrt{2}}(\ket{1}_{q}\otimes
a_{e}^{\dagger}\ket{\text{vac}}+\ket{0}_{q}\otimes\ket{\text{vac}}).$

Note that the photon emitted at this instance is the early one. Next, we apply
a $\pi$-pulse of $\Omega_{R}$ followed by another $\pi$-pulse of $\Omega_{O}$
where the state after the emission is found to be

$\displaystyle\frac{1}{\sqrt{2}}(\ket{0}_{q}\otimes
a_{e}^{\dagger}\ket{\text{vac}}+\ket{1}_{q}\otimes
a_{l}^{\dagger}\ket{\text{vac}})$
$\displaystyle=\frac{1}{\sqrt{2}}(\ket{0}_{q}\otimes\ket{1}_{p}+\ket{1}_{q}\otimes\ket{0}_{p}),$
(2.5)

After another $\pi$-pulse of $\Omega_{R}$ we obtain the desired state

$\displaystyle\frac{1}{\sqrt{2}}(\ket{1}_{q}\otimes\ket{1}_{p}+\ket{0}_{q}\otimes\ket{0}_{p}),$
(2.6)

which is a Bell pair between the emitter and the photonic qubit. Therefore,
the emission process effectively acts as a $\textsc{cnot}_{q,k}$ gate where
the control qubit is the emitter. Combined with the emitter initialization,
this process corresponds to the following quantum circuit

(2.7)

As we discuss in the next section, by applying resonant pulses regularly we
generate an array of time-ordered photonic qubits in a desired graph state. In
particular, we use the emitter (possibly equipped with single-qubit gates) to
generate linear cluster states, star graph states, and single qubits in
$\ket{\pm}$ states. The basic timing requirement is $\gamma\tau_{i}\gg 1$
where $\tau_{i}^{-1}$ is the photon generation rate (or $\tau_{i}$ with
$i=1,2$ is the time difference between two consecutive photons, see Fig.
5(b)), and $\gamma$ is the emitter decay rate. Hence, a QD with $\gamma\sim
1$-$100$ GHz Appel  _et al._ (2021); Tiurev  _et al._ (2020) can accommodate
photon emission rates of $\tau\sim 0.1$-$10$ nsec.

_Scattering process:_ To build arbitrary graph states, we need another two-
qubit gate besides the nonlinearity during the emission process. This could be
achieved by using the fact that a photon scattered by a (resonant) QD
accumulates a $\pi$-phase shift Shen and Fan (2005); *PhysRevA.76.062709;
Ralph  _et al._ (2015), which effectively acts as a cz gate between the QD and
the photonic qubit (in a presence/absence encoding) Pichler  _et al._ (2017).
A possible circuit design for arbitrary graph states would then have delay-
line feedback loops into a single quantum emitter Pichler  _et al._ (2017);
Wan  _et al._ (2021). Despite the simplicity and minimal requirement for
number of components, these designs need high speed optical switches as fast
as $\tau^{-1}$ (photon generation rate) for photon routing. Furthermore, it is
not clear how to implement an arbitrary single-qubit gate for universal
quantum computation in a presence/absence encoding. As mentioned, we would
like to use the time-bin encoding, as a result of which the above emitter-
photonic-qubit cz gate is not available (simply because in either logical
state of photonic qubit there will be a $\pi$-phase shift). Hence, to induce a
$\pi$-phase shift, we use the nonlinearity induced by an array of QDs as shown
in Fig. 5(c) following Ref. Schrinski  _et al._ (2021). The basic idea is
based on the absence of scattering $\pi$-phase shift when two photons
simultaneously pass through a QD. If the time-bin photonic qubits are
scheduled to arrive such that the late component of the incoming photon from
left overlaps with the early component of the incoming photon from right, then
we will get the following (relative) phase-shifts

$\displaystyle\ket{e_{L},e_{R}}$ $\displaystyle\to\ket{e_{L},e_{R}},$
$\displaystyle\ket{l_{L},e_{R}}$ $\displaystyle\to-\ket{l_{L},e_{R}},$
$\displaystyle\ket{e_{L},l_{R}}$ $\displaystyle\to\ket{e_{L},l_{R}},$
$\displaystyle\ket{l_{L},l_{R}}$ $\displaystyle\to\ket{l_{L},l_{R}}.$ (2.8)

Here, $\ket{t_{s}}\coloneqq a^{\dagger}_{ts}\ket{\text{vac}}$ in which $t=e\
(l)$ refers to early (late) time-bin in photonic qubits and $s=L\ (R)$ denotes
the incoming qubit from left (right) (c.f. Fig. 5(c)). From the computational
basis defined in Eq. (2.4), it is easy to see that the above transformation
corresponds to a combined gate $X_{L}\textsc{cz}_{L,R}X_{L}$.

In the next section, we introduce our designs by combining a quantum emitter
and cz gates along with delay lines to generate various graph states.

##  III Optical Circuit Designs for Graph States

Our typical optical circuit design to generate time-ordered graph states is
shown in Fig. 1(a). It consists of an active component and a passive component
which may be composed of a few passive modules. The active component is a
quantum emitter, denoted by $\mathcal{Q}$, coupled to a waveguide as a source
of either linear clusters or individual photonic qubits. Each passive module
consists of an optical circulator, a cz (scattering) gate, and an optical
fiber delay-line that is in turn terminated by a reflector (or mirror). The
entanglement is built within both passive and active regions of the circuit.
As we explain later in this section, passive modules can be stacked to
generate more complex graph states (see Fig. 1(b)). Depending on the type of
graph state we wish to generate, we apply a series of $\Omega_{O}$ and
$\Omega_{R}$ pulses to the $\mathcal{Q}$ emitter and may need to have
additional single-qubit gates as shown in Fig. 7.

In what follows we shall use two basic subgraphs, namely, the star graph and
linear cluster, generated by a quantum emitter to form more complex graphs. As
we recall in Sec. II.2, a five-step sequence of $\Omega_{O}$ and $\Omega_{R}$
resonant pulses lead to a Bell-pair between the emitter and a photonic qubit:
(i) $\frac{\pi}{2}$-pulse of $\Omega_{R}$, (ii)-(v) four alternating
$\pi$-pulses of $\Omega_{O}$ and $\Omega_{R}$. Repeating the last four steps
$N$-times lead to a GHZ state of $N$ photonic qubits and the emitter. Upon
applying hadamard to photonic qubits, we obtain a star graph,

(3.1)

where the central vertex on the graph is the emitter. The effective circuit is
depicted by:

(3.2)

Repeating all five steps lead to a linear cluster state such that in the graph
representation the emitter is adjacent to the last emitted photonic qubit as
in

(3.3)

It is worth noting that we can combine the last $\pi$-pulse of $\Omega_{R}$ in
a given step with the first $\frac{\pi}{2}$-pulse of $\Omega_{R}$ in the next
step to make it a four-step pulse sequence: Three $\pi$-pluses of
$\Omega_{O}$, $\Omega_{R}$, and $\Omega_{O}$, respectively, along with a
$\frac{\pi}{2}$ $\Omega_{R}$ pulse. The corresponding quantum circuit can be
shown as

(3.4)

The above two protocols are modified versions of the original Lindner-Rudolph
Lindner and Rudolph (2009) machine-gun proposal to account for qubit time-bin
encoding. We denote the time difference between early and late bins within a
photonic qubit by $\tau_{1}$ and the time difference between the late and
early bins of two consecutive qubits by $\tau_{2}$ (see Fig. 5(b)). This
simply implies that the time difference between the early bins of two
consecutive qubits is $\tau=\tau_{1}+\tau_{2}$. As we see, we can obtain graph
states on different lattices by tuning the $\tau_{1}/\tau_{2}$ ratio.

The other subgraph we may need is an array of unentangled qubits prepared in
hadamard basis $\ket{\pm}$. We propose three ways to do that. One way to
achieve this is to interrupt the linear cluster generation by measuring the
emitter in the Hadamard basis (which puts the photonic qubit in $\ket{\pm}$
depending on the measurement outcome). This corresponds to the following
circuit:

(3.5)

Another way is to prepare a star graph (3.1) and measure the emitter
afterwards. As a third method, we can put the emitter in the logical state
$\ket{1}$ and run it as a two-level system. Then, applying a sequence of
$\pi$-pulses of $\Omega_{O}$ yields a series of single photons. By placing a
Mach-Zehnder interferometer (MZI) with a phase-shifter and a delay line (of
$\tau_{1}$)

(3.6)

we can then generate a sequence of time-bin qubits in $\ket{+}$ as follows: An
early photon passes through MZI while we set $\varphi=\frac{\pi}{2}$ so that
half of the incoming signal goes to the delay line and the other half leaves.
Upon approaching $t=\tau_{1}$ we set $\varphi=\pi$ so that the output of the
delay line comes out of the MZI. We should note that these three methods have
their own pros and cons. For example, the emitter measurement and
reinitialization could be slow ($\sim 0.1$-$1\ \mu$sec) Appel  _et al._
(2021), which is used for every qubit in method one. In contrast, the latter
two methods only require emitter resetting once. However, they come at the
cost of single qubit gates such as Hadamard in the second method (3.2) and MZI
with a delay line in the third method (3.6) which would introduce further loss
into the system.

###  III.1 N-dimensional cluster states

Our algorithm to make higher dimensional cluster states is incremental in the
sense that we start with linear cluster states and stitch them together via cz
scattering gate to get a 2d cluster state (Fig. 2(a)) at the output. This step
involves keeping $n$-th linear cluster in the delay line while $(n+1)$-th line
is being prepared by the emitter as shown in Fig. 1(a). As a result, if we
want to produce a $L_{x}\times L_{y}$ 2d cluster state (qubit time-orderings
and their coordinates are illustrated in Fig. 2(a)), we need a delay line of
$L_{x}(\tau_{1}+\tau_{2})+\tau_{1}$ (such that $\tau_{1}<\tau_{2}$) and
continue the process $L_{y}$ times. The effective quantum circuit is shown in
Fig. 6. We should note that here we measure the emitter after the completion
of each line so that we get a 2d cluster state with open boundaries. Setting
$\tau_{1}=\tau_{2}$, we obtain a 2d graph state on triangular lattice. To
generate a 3d cluster state, we add another passive module at the output of
this circuit which is used to stitch together layers of 2d cluster states. To
make a $L_{x}\times L_{y}\times L_{z}$ lattice, we need to have a
$L_{x}L_{y}(\tau_{1}+\tau_{2})+\tau_{1}$ delay line in the second module.
Repeating this process over $N$-modules lead to an $N$-dimensional graph state
on a hypercubic lattice.

An important example is the RHG state Raussendorf  _et al._ (2006, 2007) shown
in Fig. 2(b) which can be obtained by measuring (in $Z$-basis) a subset of
photons on 3d cubic lattice, which form a body-centered lattice in a doubled
unit cell. Alternatively, we can make an RHG state by modifying the resonant
pulse sequence in every other line and use one of the three methods discussed
near the end of the previous part (see the discussion around Eq. (3.5)) so
that we get a sequence of qubits in $\ket{+}$. This gives the downward output
of the first optical circulator to be the desired state on $xy$ plane of RHG
state, which is a cluster state version of surface code with half of
stabilizers. As we will see in the next section, preparing a cubic lattice and
measuring qubits has a lower loss threshold compared to the direct
construction (i.e., the three aforementioned methods); however, the former
method does not involve any switches or resetting the emitter, and hence,
might have a better performance in terms of state generation rate since
resetting emitters (in particular QDs) is potentially a slow process.

Let us now compare our protocol with the previous studies Pichler  _et al._
(2017); Wan  _et al._ (2021). First, both single-rail encodings in previous
work are based on absence/presence encoding where applying a direct arbitrary
single-qubit gates is not possible. This is particularly important because the
most basic requirement is measurement in $X$ basis (e.g., for error
correction) which is not immediately available in such encoding. In contrast,
our protocol is based on time-bin encoding which can be easily converted to
dual-rail encoding where linear optics can be used for single-qubit gates. The
dual-rail encoding in Ref. Wan  _et al._ (2021) involves distinguishable
photons and may be used for applying arbitrary single-qubit gates, but at the
cost of extra overhead such as frequency converters. Second, adding two delay-
lines Wan  _et al._ (2021) requires ultrafast switching at the photon emission
rate, while there is no need for ultrafast switches or only one switch in our
scheme. Third, the RHG generation protocol in Ref. Wan  _et al._ (2021)
requires emitter resetting quite frequently. As mentioned above, this is
potentially a very slow process for QDs and not experimentally desirable. In
our case, we have two alternative ways of doing that by using a star graph or
running the QD as a two-level system (albeit at the cost of introducing
actively reconfigured MZI switches), whereas there is no such flexibility in
Ref. Wan  _et al._ (2021).

Figure 6: Effective quantum circuit to generate 2D cluster state (Fig. 2(a))
using the setup shown in Fig. 1, where qubit numbers indicate the temporal
position of the photonic qubit in the sequence.

###  III.2 Repeater graph states

One of the challenges to form an entanglement distribution across a quantum
network is amplifying a quantum signal which is prohibited by the no-cloning
theorem. A possible solution is to realize long-range Bell-pairs by preparing
local Bell-pairs and sequentially send one (photonic) qubit of each repeater
station to the next station where a fusion measurement gate is performed. The
issue with this approach is that fusion gates are probabilistic and over a
long distance (and many repeater stations) the success probability of
generating a long-range Bell-pair decays (exponentially) rather quickly. To
increase the success probability of each fusion gate, all-photonic repeater
states were developed Azuma  _et al._ (2015a), which effectively act as a
multiplexed fusion gate: Instead of sending one qubit of Bell-pair, multiple
qubits (left/right half of repeater states in Fig. 3) are sent and multiple
fusion gates are performed on the outer qubits (labeled 1 to 6 in Fig. 3(a)).
Depending on the fusion outcomes, inner qubits are measured to complete a Bell
link between two consecutive repeater station. Since the pioneering work Azuma
_et al._ (2015a), there have been several studies on trade-off and resource
requirements to realize these states deterministically Buterakos  _et al._
(2017); Russo  _et al._ (2019); Hilaire  _et al._ (2021); Li  _et al._ (2022);
Zhan and Sun (2020) and perform various quantum communication tasks based on
the repeater states Pant  _et al._ (2017); Azuma  _et al._ (2015b); Zwerger
_et al._ (2016).

Here, as a byproduct of our design, we show how to determinstically generate
repeater states in our setup. We should note that compared to previous works
Buterakos  _et al._ (2017); Russo  _et al._ (2019); Hilaire  _et al._ (2021);
Li  _et al._ (2022) which use actively controlled multiple QDs (or solid-state
emitters) and require two-qubit gates on them, our setup has only one active
component. Figure 7 shows a schematic optical circuit which only differs from
the 2d-cluster state generator of Fig. 1(a) by a logic gate block.

We now explain how to generate repeater state of $2N$ qubits (see Fig. 3(a)
and (b) for $N=6$ and $8$, respectively). As mentioned, the multi-qubit output
state in our system is time-ordered. A natural ordering for repeater states is
to enumerate outer qubits and then inner qubits (e.g., Fig. 3(a)). Given this
ordering, we need to define a sequence of resonant pulses on the quantum
emitter and a proper delay line so that the outer qubits in $\ket{\pm}$ states
and collide them with an all-to-all connected graph of inner qubits. The
equivalent quantum circuit is shown in Fig. 8. To obtain the $N$ outer qubits,
we have three options as we discussed earlier in this section. In the quantum
circuit depicted in Fig. 8, we use the star graph (3.1) and then measure the
emitter. The generated sequence of $N$ outer qubits goes through the identity
path in the logic block of Fig. 7(b) and is held in the delay line while the
inner part is prepared. Hence, the duration of the delay line needs to be
$N(\tau_{1}+\tau_{2})+\tau_{1}$ (provided that $\tau_{1}<\tau_{2}$), and the
optical switch rate is $N(\tau_{1}+\tau_{2})$ since we only need to have an
additional single qubit gate for the inner qubits. For the inner layer, we
prepare another star graph and apply a local complementation Van den Nest  _et
al._ (2004); Hein  _et al._ (2004) with respect to the emitter vertex and
measure the emitter in $Z$ basis subsequently. The local complementation is
achieved by $\sqrt{iZ}$ and $\sqrt{iX}$ gates on qubits and the emitter,
respectively. It is worth noting that the single-qubit gates commute with each
other and only need to be performed before the cz gate. Next, the all-to-all
graph is stitched to the outer qubits in the delay line by the cz scattering
gate. We also note that since our design is modular we can stack another
passive layer at the output of this circuit (similar to 1(b)) and effectively
add multiple levels of tree branches to the outer qubits (see next part below
for further details).

Figure 7: Schematic setup to generate a repeater graph state (Fig. 3).
$\mathcal{Q}$ and cz denote quantum emitter and controlled-phase gate (based
on a quantum dot array), respectively. Panel (b) shows the contents of logic
gate block in (a). We note that to generate a repeater state of $2N$ qubits,
the switch remains at each position for $N\tau$. Figure 8: Effective quantum
circuit to generate 12-qubit repeater state in Fig. 3(a) using the setup in
Fig. 7. Here, numbers indicate the temporal position of the photon in the
sequence.

###  III.3 Tree graph states

One of the main challenges in one-way quantum communication with discrete
variable (DV) encoding is photon loss. A possible resolution within the DV
formalism is to use quantum error correcting codes Varnava  _et al._ (2006).
This way, quantum information is encoded in several qubits in the form of a
stabilizer state and sent to a repeater station where the state is
reconstructed (even though a portion of qubits are lost) based on the
remaining qubits received at that point. As it was shown in Ref. Varnava  _et
al._ (2006), tree graphs could be a good candidate stabilizer state for this
purpose. Another application of tree states is a tree-type channel between two
nodes on a graph as a loss tolerant teleportation channel Morley-Short  _et
al._ (2019).

Let us now explain how to generate a binary tree graph of $N$ layers
consisting of $2^{N}-1$ qubits. We consider a natural ordering of vertices
from bottom to top as shown in Fig. 4 for $N=4$. The resonant pulse sequence
we develop is applied to an optical circuit similar to Fig. 1 and realizes the
quantum circuit shown in Fig. 9. All the qubits here are generated by using
the single-qubit protocol in Eq. (3.5). Similar to the repeater states, the
lowest layer can alternatively be prepared by generating a star graph state
and measuring the emitter. The delay line and pulse sequence is designed such
that upper level qubits collide with two consecutive lower level qubits while
passing through cz and realize a binary branch structure. For instance, late
component of qubit $1$ and early component of qubit $9$ and early component of
qubit $2$ and late component of qubit $9$ meet at cz scattering center.
Therefore, we must set $\tau_{1}^{(0)}=\tau_{2}^{(0)}$ and the delay line
duration is $\Delta=(2^{N}+1)\tau_{1}^{(0)}$; here, we need to use a varying
time-bin encoding in each layer (according to a pattern which we discuss
below) and include a superscript $(n)$ to denote the layer number in the tree
structure from $n=0$ (lowest) to $n=N$ (highest). By a direct time-analysis we
find that

$\displaystyle\tau_{1}^{(n+1)}$ $\displaystyle=\tau_{2}^{(n)},$
$\displaystyle\tau_{2}^{(n+1)}$
$\displaystyle=2\tau_{1}^{(n)}+\tau_{2}^{(n)},$ (3.7)

which leads to the following temporal bins for the $n$-th layer

$\displaystyle\tau_{1}^{(n)}$
$\displaystyle=\frac{\tau_{1}^{(0)}}{3}\left(2^{n+1}+(-1)^{n}\right),$
$\displaystyle\tau_{2}^{(n)}$
$\displaystyle=\frac{\tau_{1}^{(0)}}{3}\left(2^{n+2}-(-1)^{n}\right).$ (3.8)

The emission time of the first qubit in the $n$-th layer satisfies the
following relation

$\displaystyle
t_{\text{init}}^{(n+1)}=\Delta+t_{\text{init}}^{(n)}+\tau_{1}^{(n)},$ (3.9)

and the solution is given by

$\displaystyle t_{\text{init}}^{(n)}$
$\displaystyle=n\Delta+\sum_{j=0}^{n-1}\tau_{1}^{(j)}$ (3.10)
$\displaystyle=n\Delta+\frac{\tau_{1}^{(0)}}{6}\left(4(2^{n}-1)+1-(-1)^{n}\right),$
(3.11)

where we set the time origin at the moment when the early component of the
qubit $1$ is emitted, i.e., $t_{\text{init}}^{(0)}=0$.

Figure 9: Effective quantum circuit to generate 15-qubit binary tree state in
Fig. 4 using the setup in Fig. 1(a).

In closing, let us note that all three types of graph states discussed in this
section can be obtained fully by a sequence of qubits in $\ket{+}$ and a cz-
delay line block. Hence, we may use a regular QD (two-level system) as a
single-photon emitter and a linear optical circuit of Eq. (3.6) to generate
qubits in $\ket{+}$ states using time-bin encoding.

##  IV Error analysis of fault-tolerant state

In this section, we focus on a graph state on an RHG lattice which is a
candidate state for fault-tolerant quantum computing and show that our
protocol can realize a fault-tolerant regime. Before we delve into details of
error models, let us briefly review how error correction works in an RHG
cluster state. Here, we only consider the cluster state as a quantum memory.

As shown in Fig. 2(b), the graph representation defines face stabilizers as

$\displaystyle S_{f}=X_{f}\bigotimes_{e\in\partial f}Z_{e},$ (4.1)

where $f$ denotes a (primal) cubic face (black squares in Fig. 2(b)) and
$\partial f$ denotes the boundary edges of face $f$. A subgroup of the
stabilizers can be constructed in terms of product of the face stabilizers
$S_{f}$ corresponding to the faces of a given cell $c$ which takes the form of

$\displaystyle S_{c}=\bigotimes_{f\in\partial c}S_{f}=\bigotimes_{f\in\partial
c}X_{f},$ (4.2)

where the edge Pauli operators cancel out. Here, $\partial c$ denotes the
boundary faces of cell $c$. Another subgroup of stabilizers can be similarly
defined in terms product of the stabilizers associated with edges connected to
a vertex on the primal (or cells on the dual) lattice. The two set of
stabilizers can be used towards a topological quantum error correction as
explained below.

In the absence of loss, error correction process on primal lattice (which in
this case is simple cubic) is realized by measuring qubits on faces in $X$
basis and calculating the parity checks associated with cell stabilizers (4.2)
Raussendorf  _et al._ (2006). It is more convenient to consider the dual
lattice, where cell stabilizers are defined on vertices and qubits are placed
on the edges. Such a lattice is called a syndrome graph (Fig. 10(a)). The
erroneous qubits on the syndrome graph form an error chain connecting failed
parity checks (a.k.a. syndrome defects), see Fig. 10(b). The goal of error
correction is to find recovery (or correction) chains which match the syndrome
defects as their endpoints. By definition, the error and recovery chains form
closed loops. Logical errors occur when these loop operators do not commute
with logical operators, otherwise, the error correction succeeds.

In practice, finding a suitable correction chain is computationally difficult.
Following the literature Wang  _et al._ (2003); Raussendorf  _et al._ (2006),
we use Edmonds’ minimum-weight perfect matching (MWPM) algorithm Edmonds
(1965) which is known as a heuristic but efficient method for this purpose.
The MWPM algorithm, in short, pairs up syndrome defects which are closest to
each other and minimize the sum of weights of the correction chains, i.e.,
minimum number of qubits connecting failed checks (which, on a regular lattice
with equal error rate on each link, simply equals the taxicab distance, c.f.
Fig. 10(b)). As we explain below, the effective error rate of physical qubits
in our setup is not uniform since the state generation process is anisotropic.
Because of that, we use Dijkstra’s algorithm for finding shortest paths on a
weighted graph. In our numerical simulations, we wish to probe the bulk
properties; hence, we consider periodic boundary conditions in all three
directions to avoid boundary effects in a finite-size system. Therefore,
logical errors occur when the loops formed by combining error and correction
chains span nontrivial $\mathbb{Z}_{2}$ cycles of the syndrome graph (that is
a 3d torus in this case).

Figure 10: (a) Syndrome graph shown in violet, where vertices and edges are
associated with parity checks (cells of RHG cubic lattice) and qubits (faces),
respectively, superimposed on RHG lattice shown in gray. Bit flip errors are
shown in (b) and a loss error in (c) and (d). (b) An error chain (pink) with
two failed parity checks at its endpoints (black vertices). As explained in
the text, stabilizer generators need to be modified to account for a qubit
loss. (c) A lost qubit is shown by the dashed green edge where the two
adjacent parity checks are impacted. (d) By combining the two impacted
stabilizers, a supercheck operator (green ellipse) is constructed and the
syndrome graph is no longer a regular (simple cubic) lattice.

For our simulations, we consider a general error model for single-qubit and
two-qubit gates. We also account for the photon loss and explain the decoding
procedure later in this section. Each single-qubit gate is accompanied by a
single-qubit depolarizing channel

$\displaystyle{\cal
D}_{a}(\rho)=(1-p)\rho+\frac{p}{3}\sum_{P\in\\{X,Y,Z\\}}P_{a}\rho P_{a},$
(4.3)

with probability $p$. There are several stages where this error may happen:
single-qubit gate on the emitter ($p_{q}$), and on photonic qubits ($p_{S}$),
where we label various processes with the corresponding error rate.
Furthermore, we consider single-qubit errors on the emitter preceding a
measurement ($p_{T}$) and single-qubit errors on photonic qubits preceding the
final $X$-measurement ($p_{F}$) in the cluster state.

Similarly, a two-qubit gate is accompanied by a two-qubit depolarizing channel

$\displaystyle{\cal
D}_{a,b}(\rho)=(1-p^{\prime})\rho+\frac{p^{\prime}}{15}\sum_{\begin{subarray}{c}P,P^{\prime}\in\\{I,X,Y,Z\\}\\\
(P,P^{\prime})\neq(I,I)\end{subarray}}P_{a}P_{b}^{\prime}\rho
P_{a}P_{b}^{\prime},$ (4.4)

and we have two types of two-qubit gates: The emission process (c.f. the
$\textsc{cnot}_{q,n}$ gate in (2.7)) with error probability $p_{2,q}$ and the
$\textsc{cz}_{n,m}$ scattering gate with $p_{2}$.

As discussed in Sec. III.1, we generate linear clusters along $x$ axis and
stitch them to form a 2d clusters in $xy$ plane which are then stitched to
obtain a 3d structure. This way of generating a 3d resource state is clearly
anisotropic and hence we have different effective error rates for the three
kinds of qubits associated with the three faces ($xy$, $yz$, $xz$) of the
primal (or dual) lattice. We further make use of the fact that at each
instance of time the quantum state is a stabilizer state and we can transform
errors to local errors up to stabilizer generators. This trick was also
elucidated in Ref. Wan  _et al._ (2021). The overall single-qubit error rate
for the qubits on $yz$ faces is given by

$\displaystyle
q_{x}=\frac{4}{3}p_{q}+\frac{2}{3}(p_{T}+p_{F})+\frac{8}{15}p_{2,q}+\frac{32}{15}p_{2},$
(4.5)

while for the qubits on $xz$ and $xy$ faces, we have

$\displaystyle
q_{y}=q_{z}=\frac{4}{3}p_{q}+\frac{2}{3}p_{F}+\frac{16}{15}(p_{2,q}+p_{2}),$
(4.6)

where the subscript indicates the normal vector to the face on which the qubit
lies. Here, the error rates are calculated by noting that since qubits are
measured in $X$ basis (as discussed earlier) then either $Z$ or $Y$ Pauli
operators are considered a bit flip error (see Appendix A for details).

Figure 11: Correlated errors on the syndrome graph.

Furthermore, two-qubit gates cause simultaneous errors on some qubits located
on opposite edges of faces in syndrome graph,

$\displaystyle q_{yz}$ $\displaystyle=q_{zy}=\frac{4}{15}p_{2},$
$\displaystyle q_{xy}$
$\displaystyle=q_{xz}=\frac{4}{15}p_{2}+\frac{8}{15}p_{2,q},$ (4.7)

where the subscript is read in the following way: The first and second letters
denote the edge direction and the direction connecting two edges,
respectively, as shown in Fig. 11. We note that our state generation protocol
implies that not all opposite edges experience a simultaneous error (see
Appendix A for details).

Using the above error model, we run Monte-Carlo simulations on finite-size
lattices, and the results are plotted in Fig. 12. For simplicity, the error
rates are set to be equal,

$\displaystyle p_{q}=p_{S}=p_{T}=p_{F}=p_{2}=p_{2,q}=p.$ (4.8)

Since the error model is anisotropic, the weights in the MWPM decoder are
given in terms of their respective error probability $q_{l}$ as follows

$\displaystyle w_{l}=\log\left((1-q_{l})/q_{l}\right),$ (4.9)

and Dijkstra’s algorithm is exploited for finding shortest paths between every
pair of vertices. We cross-checked our code with PyMatching package Higgott
(2021). As shown in Fig. 12, we obtain the circuit error threshold of
$p_{\text{th}}=(0.53\pm 0.02)\%$ which is close to the original theoretical
model of Ref. Raussendorf  _et al._ (2006), that reported $0.58\%$. Our
circuit threshold can be further improved by better decoders which exploit
sublattice correlations Raussendorf  _et al._ (2007); Raussendorf and
Harrington (2007) and take into account degeneracies of possible matchings
Barrett and Stace (2010). We postpone using decoders with either features to a
future work.

Figure 12: Error thresholds for the RHG state without loss. Ensemble size for
averaging is $100$k. Inset shows the scaling collapse with $\nu=1$.

In the remainder of this section, we discuss the effect of unheralded loss on
the logical error rate. Loss in our case is detected during the measurement
process and can be viewed as a quantum erasure channel where the error
location is known but the error type is not known. The reason that here we are
dealing with erasure (not deletion) is because every qubit is measured during
the decoding process. Hence, the missing photons can be located through the
detection process. In terms of the construction process, if a qubit is lost at
any point in our architecture, cz will not be active; however, the gate error
rates on the present qubits remain the same.

Figure 13: Error thresholds of the RHG state for various loss error rates and
a quadratic fit (black solid line). Horizontal lines corresponds to curves
(colors represent different sizes) in Fig. 14 where logical error rate is
calculated. All lines are at $p=10^{-3}$ and displaced slightly vertically for
clarity.

Mathematically, loss error corresponds to partial tracing over the missing
qubits. For instance, a loss (or erasure) channel for qubit $a$ is described
by the following quantum channel,

$\displaystyle{\cal
L}_{a}(\rho)=(1-p_{\text{loss}})\rho+p_{\text{loss}}\text{tr}_{a}(\rho)\otimes\ket{e}\\!\bra{e},$
(4.10)

where $\ket{e}$ denotes an unknown state outside the computational basis for
qubit $a$, which in our case correspond to an empty (vacuum) state with no
photon in either time bins. We should contrast this with presence/absence
encoding Wan  _et al._ (2021) where the photon loss corresponds to a forced
measurement (state collapse) to $\ket{0}$ rather than an erasure. To
circumvent this issue, Ref. Wan  _et al._ (2021) proposed a dual-rail encoding
(with two distinguishable photonic modes) by considering two additional energy
levels in emitters. This idea however requires extra hardware overhead if one
wants to measure the photonic qubits in bases other than the computational
basis.

One way to model the qubit loss is to reduce the stabilizer group to only
stabilizer operators which commute with the Pauli operators acting on the
missing qubit. This effect leads to a syndrome graph on an irregular lattice
Stace and Barrett (2010); *Stace-2d; Barrett and Stace (2010); Whiteside and
Fowler (2014). Suppose that a qubit connecting two nodes $c$ and $c^{\prime}$
is lost (green edge in Fig. 10(c)). Since the two check operators associated
with $c$ and $c^{\prime}$, denoted by $S_{c}$ and $S_{c}^{\prime}$, do not
commute the lost qubit operators, we are only left with $S_{c}S_{c}^{\prime}$
as a new stabilizer or supercheck operator. This effectively leads to a
syndrome graph shown in Fig. 10(d)) which is no longer simple cubic. Now, in
general multiple loss events occur and we end up with an irregular lattice
with several supercheck vertices which may be connected to each other via more
than one edge. For our decoder, we need to define a graph with only one edge
connecting a pair of vertices. Suppose there are $n_{i}$ edges oriented along
$i=x,y,z$ direction connecting two supercheck operators. We replace those
edges with a single edge with an effective error rate

$\displaystyle
p_{l}=\frac{1}{2}\left(1-(1-2q_{x})^{n_{x}}(1-2q_{y})^{n_{y}}(1-2q_{z})^{n_{z}}\right),$
(4.11)

which is simply derived by noting that syndrome defect occurs when odd number
of those qubits are flipped. For the Monte-Carlo simulations we generate an
error syndrome according to these modified error rates. The MWPM algorithm can
be run on this graph, but finding whether the recovery chain causes a logical
error or not is non-trivial since the graph is irregular, and it is not clear
how to define $\mathbb{Z}_{2}$ cycles. Following Ref. Stace and Barrett
(2010), we run the MWPM decoder on the original (cubic) lattice, where it is
easy to determine the homology group of error recovery chains, provided that
we put zero weights on missing edges (associated with loss error) and assign
weights (4.9) to the remaining edges according to Eq. (4.11). For a given loss
error rate, we calculate the logical error rate for several system sizes
$L=8,10,12,14,16$ (see Appendix A for simulation data), and find the error
threshold. Figure 13 shows the circuit error threshold as a function of loss
error probability $(p_{\text{loss}},p_{\text{th}})$, where we fit the data
with a quadratic function and include the two limiting cases: No loss
$(0,0.053)$ and when lost edges percolate $(0.249,0)$ and error correction
always fails. The latter case corresponds to the bond percolation transition
on a simple cubic lattice Barrett and Stace (2010); Delfosse and Zémor (2020)
(see Appendix B). For reference, as we recall from Sec. III.1 the RHG lattice
can be constructed by measuring qubits on a body-centered lattice in a 3d
cluster state. This method has several advantages such as simplicity and low
hardware overhead; however, the overall performance in terms of error
thresholds is worse. In Appendix B, we identify the loss threshold in this
case to be a bond percolation transition on simple cubic lattice with first,
second, and fourth nearest neighbors which occurs at $5.4\%$, which is
significantly lower than directly generated RHG state.

Figure 13 may be interpreted as a 2d phase diagram in the sense that if the
system characteristics $(p_{\text{loss}},p)$ fall within the shaded area
(correctable) then we are in the fault-tolerant regime, i.e. the logical error
rate can be reduced exponentially as we increase the cluster dimension $L$.
However, in practice as we increase the cluster size, the dominant factor to
the photon loss will be the optical fiber where the cumulative loss
probability grows with system size as in

$\displaystyle p_{\text{loss}}=1-10^{-\frac{\lambda}{10}v\tau L^{2}},$ (4.12)

since we are using an optical fiber delay line to store $L^{2}$ qubits. Here,
$\lambda$ denotes the loss per unit length (in units of dB/km), $v=2.13\times
10^{8}$ m/s is the speed of light in the fiber and $\tau$ is the time
difference between two consecutive photonic qubits as discussed in Sec. III
(c.f. Fig. 5(b)), which varies over the range of $\tau\approx 0.1$-$50$nsec
Uppu  _et al._ (2021). Therefore, enlarging the cluster state size eventually
overwhelms the error correction and takes us outside the correctable region of
the phase diagram.

Figure 14: Logical error rate for different system sizes as a function of
optical fiber loss rate per qubit, i.e. $\lambda v\tau$ defined in Eq. (4.12).
Here, we assume physical qubit error rates are $p=0.1\%$. The ensemble average
for each point is performed on $N_{s}=5\times 10^{5}$ samples and error bars
$\sqrt{p_{\text{fail}}(1-p_{\text{fail}})/N_{s}}$ are shown when applicable.
Solid lines are guide for eyes.

Given that the loss rate increases with the system size, one may ask whether
this setup can be exploited to reduce the logical error rate and eventually be
used as a fault-tolerant quantum memory. To address this question, let us run
a numerical experiment: We start with a physical error rate $p=p_{0}$ and ask
whether a typical loss rate in optical fiber can allow for smaller logical
error rates upon going to larger cluster states. That is to ask, does error
correction in our scheme work given the typical values in real systems? We set
$p_{0}=10^{-3}$ and compute the logical error rate as a function of loss per
length in number of qubits [dB/qubit] for various system sizes as plotted in
Fig. 14. As we see, if the loss rate obeys $\lambda v\tau<5.7\times 10^{-3}$
dB/qubit, the logical error rate is smaller than the circuit error rate.
Typical fiber losses are $\lambda=3.5$ dB/km at the native QD operation
wavelength ($950$ nm) Uppu  _et al._ (2021), and improve to $\lambda=0.2$
dB/km at the telecom C-band. Hence, for the protocol to work without a
frequency converter, the emission rate needs to be $\tau\lesssim 7.6$ nsec so
that the break-even point for the error rate occurs at $3.5$ dB/km.

As mentioned, for a fixed circuit error rate as we increase the cluster size,
the loss error rate also increases. For instance, points in Fig. 14 for
various loss rates per qubit and system sizes correspond to spanning
horizontal lines in the phase diagram as shown in. Fig. 13. In other words, as
we increase the system size, the new system corresponds to a point further
right in the phase diagram. We should note that at each loss rate per qubit
the logical error rate is bounded from below, and there is an optimum system
size $L_{\text{opt}}$ which gives the lowest possible logical error rate. Ref.
Wan  _et al._ (2021) showed that the optimal logical error rate associated
with $L_{\text{opt}}$ follows an empirical formula
$p_{\text{opt}}\sim\exp(-c^{\prime}\lambda^{-1/2})$. In Appendix C, we use the
saddle point approximation and derive this relation by assuming an
exponentially decaying (in cluster dimension) logical error rate within the
correctable region of the phase diagram. However, our numerical data is not
conclusive in the sense that a wide range of exponents $0<x<1$ in
$p_{\text{opt}}\sim\exp(-c^{\prime}\lambda^{-x})$ can fit our data well. We
suspect the data in Ref. Wan  _et al._ (2021) may suffer from the same issue.
We attribute this observation to the finite-size effects and possible
invalidity of the assumption that the logical error rate decays exponentially
with the system size.

Last but not least, in all finite-size scaling analyses (with or without
loss), we estimate the circuit error threshold and the critical exponent by
collapsing the data on a single-parameter scaling ansatz

$\displaystyle
p_{\text{logic}}(p,L)-p_{\text{logic}}(p_{\text{th}},L)=f((p-p_{\text{th}})L^{1/\nu}),$
(4.13)

without a polynomial fit to the data following the method developed in Ref.
Skinner  _et al._ (2019) (see details in Appendix A), where
$p_{\text{logic},c}=p_{\text{logic}}(p_{\text{th}},L)$ denotes the logical
error rate at the scale-invariant (critical) point. We find that $\nu=1.00\pm
0.05$ (e.g., see inset of Fig. 12) which matches the critical exponent of the
transition in the random plaquette $\mathbb{Z}_{2}$ gauge theory in 3D Wang
_et al._ (2003). We also observe that $p_{\text{logic},c}$ in our case is
close to those of Refs. Wang  _et al._ (2003); Raussendorf  _et al._ (2006);
Barrett and Stace (2010). This further indicates that our numerics (despite
detailed differences with previous works) probe the same phase transition
since the value $p_{\text{logic},c}$ must be related to some universal
physical observable such as the conductivity which only depends on the
universality class.

Let us conclude this section by reiterating a general remark about fault-
tolerant photonic quantum memories based on discrete-variable cluster states
on RHG lattice. As we discussed earlier in this section, there is a hard upper
bound on loss tolerance in such systems (regardless of the protocol)
corresponding to a bond percolation transition in a simple cubic lattice which
occurs at $p_{\text{loss}}=24.9\%$. The critical value in turn translates into
$1.24$ dB transmission loss, which imposes an upper bound on the allowed
overall loss. In other words, quantum error correction in such schemes would
not work if the total transmission loss is greater than $1.24$ dB, regardless
of how low the qubit (bit flip) error rate can be made. Assuming that the loss
is dominated by the optical fiber, it is easy to show that the largest fault-
tolerant cluster is given by,

$\displaystyle L_{\text{max}}=\left|\frac{10}{\lambda
v\tau}\log_{10}(1-p_{\text{perc.}})\right|^{1/2}.$ (4.14)

Plugging in $\lambda=0.2$ dB/km, we find that $L_{\text{max}}$ ranges between
$24$ to $540$ corresponding to $\tau=50$ nsec and $\tau=0.1$ nsec,
respectively. An interesting observation here is that if the emission rate is
fast enough $\tau^{-1}>1/3$ GHz the photon loss in the delay line does not
fundamentally preclude the realization of a quantum memory with million
qubits.

##  V Discussion

In conclusion, we propose a new optical circuit design based on quantum
emitters and optical fiber delay lines to deterministically generate resource
graph states. Our design consists of an active component and a stack of
passive ones which are responsible for single photon generation and gating,
respectively. As we show, different graph states can be obtained by varying
the resonant pulse sequence applied to the quantum emitter and possibly
additional single-qubit gates. Our optical circuit admits a modular structure,
where passive components can be stacked to produce graphs on higher
dimensional lattices. We provide explicit design protocols for generating
cluster states in any dimension, repeater states, and tree graph states. We
further discuss an error model for our design and calculate the circuit error
threshold in the case of fault-tolerant cluster state. We map out an error-
correction phase diagram in terms of circuit error and loss rates in our setup
and identify the correctable region. In the absence of loss, we find the
circuit error threshold to be $0.53\%$, while in the absence of circuit error,
the loss threshold is $24.9\%$ corresponding to bond percolation on a cubic
lattice. Finally, we show through an example that the break-even point for
error reduction in the fault-tolerant construction can be reached with the
existing technology.

There have been several recent studies on using quantum emitters to
deterministically generate graph states for quantum communication Buterakos
_et al._ (2017); Russo  _et al._ (2019); Hilaire  _et al._ (2021); Li  _et
al._ (2022); Pichler and Zoller (2016) as well as quantum computing Pichler
_et al._ (2017); Wan  _et al._ (2021). A central theme in all these works
(including ours) is to reduce the number of components by optimizing the
generation protocol. This is particularly beneficial in terms of reducing the
engineering challenges to achieve the desired outcome, as in such systems
improving a small number of components leads to a great performance
enhancement. Nonetheless, these minimal architectures pose new challenges. In
this work, we address some of these issues in a more realistic design. Our
circuit contains only one actively monitored emitter and does not require any
two-qubit gates for emitters. Having one emitter implies a reference clock
cycle which is governed by the resonant pulse sequence applied to the emitter.
Our protocol is based on time-bin qubit encoding which is not sensitive to
dephasing error and equipped with arbitrary single-qubit gate set for
performing computation or other manipulations on the output resource state.
Furthermore, there is no need for ultrafast optical switches in our design.

At the hardware level, our proposed device architectures are inspired by the
platforms based on semiconductor QDs coupled to a waveguide, although they are
not restricted to such platforms and may be applicable to other quantum
emitter technologies such as atomic systems where atom-photon entanglement and
quantum memory were demonstrated Togan  _et al._ (2010); Duan  _et al._
(2001). As mentioned above, there is a hard upper bound for loss error
threshold depending on the generation protocol of the RHG lattice: We report
$24.9\%$ for direct generation and $5.4\%$ for indirect generation by
measuring 3d cluster state, which translate into $1.24$ and $0.24$ dB
transmission loss, respectively. Reaching the levels below the loss threshold
requires minimizing the signal loss at several locations in a photonic system
most notably at the interfaces between different components and inside the
optical fiber delay line. As we discussed in Sec. IV, one should be able to
deal with the loss in the optical fiber as long as the photon emission rate is
fast enough, which is currently achievable Uppu  _et al._ (2021). Another
place for improvement is the QD coupling to a single mode waveguide or
nanocavity which needs to be strong enough while coupling to unwanted leaky
modes must be suppressed; this is quantified by the single-photon coupling
efficiency or $\beta$ factor (i.e., the ratio of the number of emitted photons
in the guided mode to that of all modes), which routinely reaches near unity
in nanophotonic devices. See for example Refs. Arcari  _et al._ (2014); Uppu
_et al._ (2021) which reports $\beta>98.4\%$ implying a quantum cooperativity
(i.e., the ratio between the number of emitted photons in the guided mode and
that of undesired modes) of $C=\beta/(1-\beta)\geq 62$. Photon
indistinguishability is also an essential requirement for discrete-variable
quantum information processing which has been achieved for single QD Somaschi
_et al._ (2016); however, having multiple QDs emitting nearly
indistinguishable photons is quite challenging. Here, we tried to minimize
that by having only one active device as a photon source and use passive
devices containing multiple QDs which reduce the chance of incompatibility.

We close the discussion with a survey of new avenues for future research. In
this paper, we base our design on quantum emitters with a $\Lambda$-type
energy level-structure and use them to generate linear cluster states as part
the desired graph states. However, the three energy levels are not so
essential in our design, and a two-level emitter can work as well. As
mentioned in Sec. III, one way to generate a linear cluster state with a two-
level emitter is by using the circuit in Fig. 7 and putting an MZI with a
delay line as in Eq. (3.6) which effectively generates a sequence of time-bin
qubits in $\ket{+}$. The drawback is that we have one additional cz layer in
our passive component stack. It would be interesting to fully examine the
error model in this case. Upon first glance, it looks like the error model is
identical to that of the original work of Raussendorf _et al._ Raussendorf
_et al._ (2006) where the error threshold is $0.58\%$. Here, we explained how
to generate some prototypical graph states; an interesting direction would be
to develop a general algorithm to produce arbitrary graphs using emitter with
delay lines, perhaps along the lines of Ref. Li  _et al._ (2022).

Throughout this work, we use a standard MWPM decoder to calculate the circuit
error thresholds for the fault-tolerant cluster state on the RHG lattice. In
principle, the thresholds can be further improved by using a better decoder.
As mentioned earlier, cluster states on the RHG lattice can tolerate a maximum
loss error rate of $24.9\%$. As shown in Refs. Nickerson and Bombín (2018);
Newman  _et al._ (2020), this threshold can be improved significantly to
larger values (near $50\%$) by realizing graph states on more complex (beyond
foliated) 3d crystal structures. Designing protocols to generate such states
could be worth pursuing. Here, we focus on the state generation and discuss
the fault-tolerant properties of the 3d cluster state as a quantum memory. A
natural next step is to define protocols for performing logical gates on these
states and envision a multi-qubit setup with a fault-tolerant logical gate
set. One of the building blocks of our design was the cz scattering block
Jeannic  _et al._ (2021); Schrinski  _et al._ (2021) based on array of QDs.
The nonlinearity induced by this device could enable a new capability for non-
Gaussian operations in continuous-variable quantum information processing
schemes possibly via a hybrid discrete-continuous variable protocol.

###### Acknowledgements.

The authors acknowledge insightful discussions with Bing Qi, Peter Lodahl,
Ramana Kompella, and Stephen DiAadamo. We especially thank Galan Moody,
Stefano Paesani, and Isaac Kim for valuable discussions and helpful comments
on the manuscript.

##  Appendix A Details of error threshold simulations

In this appendix, we show how to derive the error rates used in the main text,
Eqs. (4.5), (4.6) and (4.7). We also provide some raw data for the phase
diagram and briefly discuss how the error threshold and critical exponent are
computed.

###  A.1 Effective circuit error rates

In this part, we derive the effective circuit error rates for the cluster
state on RHG lattice given the error processes in our setup. We only consider
lowest order contribution in probability amplitudes as we are only exploring
small error regimes $\lesssim 10^{-2}$.

Let us begin with qubits on the $yz$ faces (normal to the $x$ axis). They can
be generated via the process in Eq. (3.5) where the initial state of the
emitter is $\ket{0}$. After the first hadamard gate or before the final qubit
measurement, $Z_{q}$ or $Y_{q}$ error gives $Z_{n}$ error with probabilities
$\frac{2}{3}p_{q}$ and $\frac{2}{3}p_{F}$, respectively. Also, after the
second hadamard gate or before the emitter measurement, $X_{q}$ or $Y_{q}$
error leads to a $Z_{n}$ error on the qubit with probabilities
$\frac{2}{3}p_{q}$ and $\frac{2}{3}p_{T}$, respectively. Note that we
considered errors up to instantaneous stabilizers. Regarding two-qubit gates:
first, $\textsc{cnot}_{q,n}$ gives $Z_{n}$ via the errors
$(Z_{q},Y_{q})\otimes(I_{n},X_{n})$ and $(I_{q},X_{q})\otimes(Z_{n},Y_{n})$
give $Z_{n}$ with overall probability $2\times\frac{4}{15}p_{2,q}$. Second,
$x$-type qubit undergoes four cz gates where $(Y_{n},Z_{n})\otimes
P_{n^{\prime}}$ Kraus operators give a circuit error with probability
$4\times\frac{8}{15}p_{2}$. Hence, we obtain

$\displaystyle
q_{x}=\frac{4}{3}p_{q}+\frac{2}{3}(p_{T}+p_{F})+\frac{8}{15}p_{2,q}+\frac{32}{15}p_{2}.$
(A1)

The qubits on the $xz$ and $xy$ faces (or $y$ and $z$ type qubits,
respectively) are part of the linear cluster generated by the emitter $Q$,
where the emitter error can be transformed into a qubit error by using an
instantaneous stabilizer at each moment, i.e., $X_{q}\otimes Z_{n}$ after
emission of $n$-th qubit. At every qubit emission process, we effectively
apply the operator

$\displaystyle A_{n}=H_{q}\textsc{cnot}_{q,n}.$ (A2)

As far as $H_{q}$ gate is concerned, a $Z_{q}$ error before $A_{n}$ and an
$X_{q}$ after $A_{n}$ lead to a $Z_{n}$ error with probability of
$\frac{2}{3}p_{q}$. $Y_{q}$ error before $A_{n}$ causes a two-qubit
$Z_{n}Z_{n-1}$ error with prob $p_{q}/3$. Since qubits $n$ and $n-1$ belong to
primal and dual lattices, then this error is simplified into single-qubit
errors. Plus, qubits experience $Z$ or $Y$ error right before measurement with
probability $\frac{2}{3}p_{F}$. As for two qubit gates: Similar to $x$-type
qubits $\textsc{cnot}_{q,n}$ leads to $Z_{n}$ with probability
$2\times\frac{4}{15}p_{2,q}$. Second, $\textsc{cnot}_{q,n-1}$ gives $Z_{n}$
through 8 Kraus terms $(X_{q},Y_{q})\otimes P_{n-1}$ with probability
$\frac{8}{15}p_{2,q}$. Third, these types of qubits experience two cz gates
where $(Y_{n},Z_{n})\otimes P_{n^{\prime}}$ Kraus operators are circuit errors
with probability $2\times\frac{8}{15}p_{2}$. We note that there is no error
propagation from neighboring qubits since they are prepared in the hadamard
basis (i.e., eigenstates of $X$ operator). Hence, the overall single-qubit
error rates for $y$ and $z$ type qubits is given by

$\displaystyle
q_{y}=q_{z}=\frac{4}{3}p_{q}+\frac{2}{3}p_{F}+\frac{16}{15}(p_{2,q}+p_{2}).$
(A3)

Next, we consider correlated errors. Let us reemphasize that nearest neighbor
qubits on the RHG lattice belong to primal and dual lattice and next nearest
neighbor qubits belong to the same parity check. Hence, they are not
considered correlated errors. In our setup, we only generate correlated errors
between opposite edges of each face on the primal lattice or neighboring faces
on the same plane (which correspond to opposite edges of faces on the syndrome
graph (c.f. Fig. 11)). For all types of qubits, we may consider two cz gates
connecting two next nearest neighbor qubits, where
$(X_{k},Y_{k})\otimes(Y_{n},Z_{n})$ error after the first gate ($k$ denotes
the shared qubit for the two cz gates) leads to a correlated error with
probability $\frac{4}{15}p_{2}$. For $x$-type qubits, we have an additional
error due to $P_{q}\otimes(X_{n},Y_{n})$ error with probability
$\frac{8}{15}p_{2,q}$ from cnot gate during the linear cluster generation
process. Therefore, we may write

$\displaystyle q_{yz}$ $\displaystyle=q_{zy}=\frac{4}{15}p_{2},$ (A4)
$\displaystyle q_{xy}$
$\displaystyle=q_{xz}=\frac{4}{15}p_{2}+\frac{8}{15}p_{2,q}.$ (A5)

###  A.2 Simulation data for the phase diagram

As discussed in Sec. IV, we run Monte-Carlo simulations to find the circuit
error threshold for various loss rates and map out a phase diagram for our
design. The simulation results are summarized in Fig. 15. We use the algorithm
of Ref. Skinner  _et al._ (2019) for estimating the circuit error threshold
$p_{\text{th}}$ and the correlation length exponent $\nu$ which is based on
searching for scaling collapse among curves
$p_{\text{logic}}(p,L)-p_{\text{logic}}(p_{\text{th}},L)$ as a function of the
single variable $(p-p_{\text{th}})L^{1/\nu}$. Below, we briefly discuss this
method.

Figure 15: Error thresholds of the RHG state for various loss rates. Ensemble
size for averaging is $60$k.

The objective is to minimize a cost function $R(p_{\text{th}},\nu)$ which
essentially measures deviation from a data collapse on a universal (unknown)
function. The corresponding optimal values are our estimates for
$p_{\text{th}}$ and $\nu$. For a given value of $p_{\text{th}}$ and $\nu$, we
estimate $p_{\text{logic}}(p_{\text{th}},L)$ for each system size $L$ by a
piece-wise linear interpolation. We then calculate the function
$y_{L}(x)=p_{\text{logic}}(p,L)-p_{\text{logic}}(p_{\text{th}},L)$ and
$x=(p-p_{\text{th}})L^{1/\nu}$ for given values of $p$ and $L$ from the
dataset. This gives a family of curves $y_{L}(x)$ vs. $x$, which we wish to
collapse on a single curve. Next, we sample from these curves at a set of
discrete points $x_{i}$ and define the cost function

$\displaystyle R=\sum_{i,L}\left[y_{L}(x_{i})-\bar{y}(x_{i})\right]^{2},$ (A6)

in terms sum of the variance of $y_{L}(x_{i})$ for different system sizes,
where

$\displaystyle\bar{y}(x_{i})=\frac{1}{N_{L}}\sum_{L}y_{L}(x_{i}),$ (A7)

is the mean value at point $x_{i}$, and $N_{L}$ is the number of different
system sizes in the dataset. We should note that again we use piece-wise
linear interpolation to estimate $y_{L}(x_{i})$ and omit a point for a given
$L$ if it is outside the range of the dataset for that particular $L$.
Finally, we search numerically for the values of $p_{\text{th}}$ and $\nu$
that minimize the objective function.

In order to estimate the uncertainty in our results for $p_{\text{th}}$ and
$\nu$, we examine how the optimum point change when we run the minimization
algorithm on a subset of data. In particular, we choose every pair of system
sizes and calculate the optimum values of $p_{\text{th}}$ and $\nu$ and use
their variation as a proxy for the uncertainty.

##  Appendix B Loss error threshold and percolation transition

As mentioned in the main text, there is a loss threshold for a fault-tolerant
graph state similar to the circuit error threshold above which the quantum
error correction is not effective. Their difference is that the location of
loss errors are known. In this appendix, we discuss the connection between
loss error and bond percolation transition where the critical probability in
the percolation problem correspond to the loss threshold.

Consider a syndrome graph where the edges and parity checks are associated
with edges and vertices of the graph. For instance, syndrome graph for the RHG
cluster state forms a simple cubic lattice (Fig. 10). Loss error is modeled as
independent random processes on every edge with probability $p$. When a qubit
is lost (erased), the parity checks on the adjacent vertices are not well-
defined. Instead, one can define supercheck operators which are product of
even number of the adjacent parity checks, so that the new stabilizers do not
have a Pauli operator acting on the lost qubit. For a given set of lost
qubits, we check for a logical error event by determining whether the error
chain form a non-contractible loop or not. This is exactly the bond
percolation problem on the syndrome graph. This means that below the critical
probability $p_{\text{perc.}}$ in percolation problem increasing the system
size decreases the percolation probability. In the quantum error correction
language, this is equivalent to saying that below the loss threshold
$p_{\text{th}}$ the logical error probability can be arbitrarily reduced by
increasing the system size. In other words, $p_{\text{th}}=p_{\text{perc.}}$.
So, the loss threshold for the RHG lattice is described by the bond
percolation on the simple cubic lattice and is equal to
$p_{\text{perc.}}\simeq 24.9\%$.

Now, let us consider another example when we start with a 3d cluster state
(i.e., simple cubic lattice) and remove a subset of qubits on the body-
centered lattice in a doubled unit cell, i.e., the center of cell and its six
corners (c.f. 2(b)), by measuring them in $Z$ basis. Before the measurement,
the product of stabilizers on faces of a cell $c$ is given by

$\displaystyle S_{c}=\bigotimes_{f\in\partial c}S_{f}=\bigotimes_{i}Z_{c\pm
2\textbf{e}_{i}}\bigotimes_{f\in\partial c}X_{f}.$ (A1)

Notice the extra operators in front of the actual stabilizer in Eq. (4.2).
Here, $\textbf{e}_{i}$ with $i=x,y,z$ denotes the basis vectors in the cluster
state cubic lattice. So, $c\pm 2\textbf{e}_{i}$ correspond to six fourth
nearest neighbor qubits (distance $2a$ with lattice constant $a$) of the
center of the cell. If there is no loss, measuring these qubits simply replace
them with $\pm$ depending on the measurement outcome. However, if these qubits
are lost, we need to combine those stabilizers sharing them. Same applies
independently to the stabilizers associated with the dual lattice. We note
that each of the qubits to be removed is shared between six parity checks
located at $\pm 2\text{e}_{i}$ with respect to that qubit. Hence, given a
missing qubit with probability $p$, we must connect the parity check on cell
$c$ with its second (distance $2\sqrt{2}a$) and fourth (distance $4a$) nearest
neighbors on the syndrome graph. Therefore, threshold in this case corresponds
to the bond percolation transition on cubic lattice with not only nearest
neighbor links but also links connecting to the second and fourth nearest
neighbors. To estimate the loss error threshold, we use the formula
$p_{\text{perc.}}\sim\frac{1}{z-1}$ where $z$ is total coordination number of
a lattice point Galam and Mauger (1996) and find that $p_{\text{perc.}}\simeq
5.4\%$ since $z=6+12+6$.

##  Appendix C Optimum logical error rate with fiber delay lines

In the main text, we learn that increasing the cluster size does not
necessarily lead to decreasing logical error rate since the cumulative loss
rate grows due to the signal propagation through the delay lines. For a given
loss error rate per qubit in the fiber, $\eta$, we have the overall loss as
$p_{\text{loss}}=1-e^{-\eta L^{2}}$, where $\eta$ is related to $\lambda$ in
Eq. (4.12) via $\eta=\lambda v\tau\ln(10)/10$ [because of using a different
base]. In this appendix, we use the saddle point approximation and show that
there is an optimum value for $L$ where the logical error rate is minimum and
obeys the form $p_{\text{opt}}\sim\exp(-c^{\prime}\eta^{-1/2})$.

Figure 16: Logical error rate for different system sizes using exponentially
decaying logical error rate in the correctable region of the phase diagram,
e.g. Eq. (B1). The system size is varied from $L=4$ to $20$ as shown by the
arrow.

We start by assuming an exponential form for the logical error rate,

$\displaystyle p_{\text{logic}}$
$\displaystyle\sim\left(\frac{p}{p_{\text{th}}(p_{\text{loss}})}\right)^{\frac{L}{2}}$
(B1) $\displaystyle=\left(\frac{p}{\alpha\eta
L^{2}+\beta}\right)^{\frac{L}{2}}$ (B2) $\displaystyle=e^{f(L)}$ (B3)

where we use a linear approximation to the error threshold as a function of
loss rate (phase boundary in Fig. 13),

$\displaystyle p_{\text{th}}(p_{\text{loss}})$ $\displaystyle=\alpha
p_{\text{loss}}+\beta$ $\displaystyle=\alpha(1-e^{-\eta L^{2}})+\beta$
$\displaystyle\approx\alpha\eta L^{2}+\beta,$ (B4)

and define

$\displaystyle f(L)=\frac{L}{2}(\ln(p)-\ln(\alpha\eta L^{2}+\beta)).$ (B5)

The ansatz (B1) is plotted in Fig. 16 for various system sizes where we use
the fit to the phase boundary in Fig. 13 for $p_{\text{th}}(p_{\text{loss}})$.
We observe that the analytical curves are qualitatively similar to the
numerical results in Fig. 14. However, we could not find a good quantitative
fit to our data using this ansatz. To find the minimum logical error, we use
the saddle point approximation by setting $f^{\prime}(L_{\text{opt}})=0$, and
we get

$\displaystyle(\ln(p)-\ln(\alpha\eta
L_{\text{opt}}^{2}+\beta))-\frac{2\alpha\eta L_{\text{opt}}^{2}}{(\alpha\eta
L_{\text{opt}}^{2}+\beta)}=0.$ (B6)

The above equation can be turned into an algebraic equation independent of
$\eta$ for an axiliary variable $x_{0}=\alpha\eta L_{\text{opt}}^{2}$. Hence,
we can plug in the solution $L_{\text{opt}}=\sqrt{x_{0}/\eta\alpha}$ to Eq.
(B1) and obtain

$\displaystyle p_{\text{logic}}$
$\displaystyle\approx\left(\frac{p}{x_{0}+\beta}\right)^{\frac{1}{2}\left(\frac{x_{0}}{\eta\alpha}\right)^{1/2}}$
(B7)

which is exponentially decaying in $\eta^{-1/2}$.

## References

  * O’Brien  _et al._ (2009) J. L. O’Brien, A. Furusawa, and J. Vučković, Nature Photonics 3, 687 (2009).
  * Bogdanov  _et al._ (2017) S. Bogdanov, M. Y. Shalaginov, A. Boltasseva, and V. M. Shalaev, Opt. Mater. Express 7, 111 (2017).
  * Note (1) There is a separate line of research on quantum computing Knill  _et al._ (2001) and realizing gates based on linear optics which led to development of probabilistic postselected and fusion gates Ralph  _et al._ (2002); Hofmann and Takeuchi (2002); Browne and Rudolph (2005). We do not address these approaches in this work.
  * Briegel  _et al._ (2009) H. J. Briegel, D. E. Browne, W. Dür, R. Raussendorf, and M. Van den Nest, Nature Physics 5, 19 (2009).
  * Zwerger  _et al._ (2016) M. Zwerger, H. J. Briegel, and W. Dür, Appl. Phys. B 122, 50 (2016).
  * Raussendorf  _et al._ (2003) R. Raussendorf, D. E. Browne, and H. J. Briegel, Phys. Rev. A 68, 022312 (2003).
  * Raussendorf and Briegel (2001) R. Raussendorf and H. J. Briegel, Phys. Rev. Lett. 86, 5188 (2001).
  * Nielsen (2004) M. A. Nielsen, Phys. Rev. Lett. 93, 040503 (2004).
  * Raussendorf  _et al._ (2006) R. Raussendorf, J. Harrington, and K. Goyal, Annals of Physics 321, 2242 (2006).
  * Zwerger  _et al._ (2012) M. Zwerger, W. Dür, and H. J. Briegel, Phys. Rev. A 85, 062326 (2012).
  * Zwerger  _et al._ (2013) M. Zwerger, H. J. Briegel, and W. Dür, Phys. Rev. Lett. 110, 260503 (2013).
  * Azuma  _et al._ (2015a) K. Azuma, K. Tamaki, and H.-K. Lo, Nat. Commun. 6, 6787 (2015a).
  * Wallnöfer  _et al._ (2016) J. Wallnöfer, M. Zwerger, C. Muschik, N. Sangouard, and W. Dür, Phys. Rev. A 94, 052307 (2016).
  * Borregaard  _et al._ (2020) J. Borregaard, H. Pichler, T. Schröder, M. D. Lukin, P. Lodahl, and A. S. Sørensen, Phys. Rev. X 10, 021071 (2020).
  * Morley-Short  _et al._ (2019) S. Morley-Short, M. Gimeno-Segovia, T. Rudolph, and H. Cable, Quantum Science and Technology 4, 025014 (2019).
  * Orieux  _et al._ (2017) A. Orieux, M. A. M. Versteegh, K. D. Jöns, and S. Ducci, Reports on Progress in Physics 80, 076001 (2017).
  * Moody  _et al._ (2022) G. Moody, V. J. Sorger, D. J. Blumenthal, P. W. Juodawlkis, W. Loh, C. Sorace-Agaskar, A. E. Jones, K. C. Balram, J. C. F. Matthews, A. Laing, M. Davanco, L. Chang, J. E. Bowers, N. Quack, C. Galland, I. Aharonovich, M. A. Wolff, C. Schuck, N. Sinclair, M. Lončar, T. Komljenovic, D. Weld, S. Mookherjea, S. Buckley, M. Radulaski, S. Reitzenstein, B. Pingault, B. Machielse, D. Mukhopadhyay, A. Akimov, A. Zheltikov, G. S. Agarwal, K. Srinivasan, J. Lu, H. X. Tang, W. Jiang, T. P. McKenna, A. H. Safavi-Naeini, S. Steinhauer, A. W. Elshaari, V. Zwiller, P. S. Davids, N. Martinez, M. Gehl, J. Chiaverini, K. K. Mehta, J. Romero, N. B. Lingaraju, A. M. Weiner, D. Peace, R. Cernansky, M. Lobino, E. Diamanti, L. T. Vidarte, and R. M. Camacho, Journal of Physics: Photonics 4, 012501 (2022).
  * Adcock  _et al._ (2019) J. C. Adcock, C. Vigliar, R. Santagati, J. W. Silverstone, and M. G. Thompson, Nat. Commun. 10, 3528 (2019).
  * Aharonovich  _et al._ (2016) I. Aharonovich, D. Englund, and M. Toth, Nature Photonics 10, 631 (2016).
  * Senellart  _et al._ (2017) P. Senellart, G. Solomon, and A. White, Nature Nanotechnology 12, 1026 (2017).
  * Javadi  _et al._ (2018) A. Javadi, D. Ding, M. H. Appel, S. Mahmoodian, M. C. Löbl, I. Söllner, R. Schott, C. Papon, T. Pregnolato, S. Stobbe, L. Midolo, T. Schröder, A. D. Wieck, A. Ludwig, R. J. Warburton, and P. Lodahl, Nature Nanotechnology 13, 398 (2018).
  * Jeannic  _et al._ (2021) H. L. Jeannic, A. Tiranov, J. Carolan, T. Ramos, Y. Wang, M. H. Appel, S. Scholz, A. D. Wieck, A. Ludwig, N. Rotenberg, L. Midolo, J. J. García-Ripoll, A. S. Sørensen, and P. Lodahl, arXiv:2112.06820 (2021).
  * Schrinski  _et al._ (2021) B. Schrinski, M. Lamaison, and A. S. Sørensen, arXiv:2112.11328 (2021).
  * Uppu  _et al._ (2020) R. Uppu, F. T. Pedersen, Y. Wang, C. T. Olesen, C. Papon, X. Zhou, L. Midolo, S. Scholz, A. D. Wieck, A. Ludwig, and P. Lodahl, Science Advances 6, eabc8268 (2020).
  * Tomm  _et al._ (2021) N. Tomm, A. Javadi, N. O. Antoniadis, D. Najer, M. C. Löbl, A. R. Korsch, R. Schott, S. R. Valentin, A. D. Wieck, A. Ludwig, and R. J. Warburton, Nature Nanotechnology 16, 399 (2021).
  * Uppu  _et al._ (2021) R. Uppu, L. Midolo, X. Zhou, J. Carolan, and P. Lodahl, Nature Nanotechnology 16, 1308 (2021).
  * Lindner and Rudolph (2009) N. H. Lindner and T. Rudolph, Phys. Rev. Lett. 103, 113602 (2009).
  * Schwartz  _et al._ (2016) I. Schwartz, D. Cogan, E. R. Schmidgall, Y. Don, L. Gantz, O. Kenneth, N. H. Lindner, and D. Gershoni, Science 354, 434 (2016).
  * Thomas  _et al._ (2022) P. Thomas, L. Ruscio, O. Morin, and G. Rempe, arXiv:2205.12736 (2022).
  * Economou  _et al._ (2010) S. E. Economou, N. Lindner, and T. Rudolph, Phys. Rev. Lett. 105, 093601 (2010).
  * Gimeno-Segovia  _et al._ (2019) M. Gimeno-Segovia, T. Rudolph, and S. E. Economou, Phys. Rev. Lett. 123, 070501 (2019).
  * Buterakos  _et al._ (2017) D. Buterakos, E. Barnes, and S. E. Economou, Phys. Rev. X 7, 041023 (2017).
  * Russo  _et al._ (2019) A. Russo, E. Barnes, and S. E. Economou, New Journal of Physics 21, 055002 (2019).
  * Hilaire  _et al._ (2021) P. Hilaire, E. Barnes, and S. E. Economou, Quantum 5, 397 (2021).
  * Li  _et al._ (2022) B. Li, S. E. Economou, and E. Barnes, npj Quantum Information 8, 11 (2022).
  * Pichler and Zoller (2016) H. Pichler and P. Zoller, Phys. Rev. Lett. 116, 093601 (2016).
  * Pichler  _et al._ (2017) H. Pichler, S. Choi, P. Zoller, and M. D. Lukin, Proceedings of the National Academy of Sciences 114, 11362 (2017).
  * Wan  _et al._ (2021) K. Wan, S. Choi, I. H. Kim, N. Shutty, and P. Hayden, PRX Quantum 2, 040345 (2021).
  * Zhan and Sun (2020) Y. Zhan and S. Sun, Phys. Rev. Lett. 125, 223601 (2020).
  * Brendel  _et al._ (1999) J. Brendel, N. Gisin, W. Tittel, and H. Zbinden, Phys. Rev. Lett. 82, 2594 (1999).
  * Arcari  _et al._ (2014) M. Arcari, I. Söllner, A. Javadi, S. Lindskov Hansen, S. Mahmoodian, J. Liu, H. Thyrrestrup, E. H. Lee, J. D. Song, S. Stobbe, and P. Lodahl, Phys. Rev. Lett. 113, 093603 (2014).
  * Tiurev  _et al._ (2020) K. Tiurev, M. H. Appel, P. L. Mirambell, M. B. Lauritzen, A. Tiranov, P. Lodahl, and A. S. Sørensen, arXiv:2007.09295 (2020).
  * Hein  _et al._ (2006) M. Hein, W. Dür, J. Eisert, R. Raussendorf, M. V. den Nest, and H.-J. Briegel, arXiv:quant-ph/0602096 (2006).
  * Raussendorf  _et al._ (2005) R. Raussendorf, S. Bravyi, and J. Harrington, Phys. Rev. A 71, 062313 (2005).
  * Note (2) Note that we use a slightly modified version of repeater states which has the same functionality while it is simpler to implement on our hardware.
  * Appel  _et al._ (2021) M. H. Appel, A. Tiranov, A. Javadi, M. C. Löbl, Y. Wang, S. Scholz, A. D. Wieck, A. Ludwig, R. J. Warburton, and P. Lodahl, Phys. Rev. Lett. 126, 013602 (2021).
  * Lodahl  _et al._ (2017) P. Lodahl, S. Mahmoodian, S. Stobbe, A. Rauschenbeutel, P. Schneeweiss, J. Volz, H. Pichler, and P. Zoller, Nature 541, 473 (2017).
  * Shen and Fan (2005) J. T. Shen and S. Fan, Opt. Lett. 30, 2001 (2005).
  * Shen and Fan (2007) J.-T. Shen and S. Fan, Phys. Rev. A 76, 062709 (2007).
  * Ralph  _et al._ (2015) T. C. Ralph, I. Söllner, S. Mahmoodian, A. G. White, and P. Lodahl, Phys. Rev. Lett. 114, 173603 (2015).
  * Raussendorf  _et al._ (2007) R. Raussendorf, J. Harrington, and K. Goyal, New J. Phys. 9, 199 (2007).
  * Pant  _et al._ (2017) M. Pant, H. Krovi, D. Englund, and S. Guha, Phys. Rev. A 95, 012304 (2017).
  * Azuma  _et al._ (2015b) K. Azuma, K. Tamaki, and W. Munro, Nat. Commun. 6, 10171 (2015b).
  * Van den Nest  _et al._ (2004) M. Van den Nest, J. Dehaene, and B. De Moor, Phys. Rev. A 69, 022316 (2004).
  * Hein  _et al._ (2004) M. Hein, J. Eisert, and H. J. Briegel, Phys. Rev. A 69, 062311 (2004).
  * Varnava  _et al._ (2006) M. Varnava, D. E. Browne, and T. Rudolph, Phys. Rev. Lett. 97, 120501 (2006).
  * Wang  _et al._ (2003) C. Wang, J. Harrington, and J. Preskill, Annals of Physics 303, 31 (2003).
  * Edmonds (1965) J. Edmonds, Can. J. Math. 17, 449–467 (1965).
  * Higgott (2021) O. Higgott, arXiv:2105.13082 (2021).
  * Raussendorf and Harrington (2007) R. Raussendorf and J. Harrington, Phys. Rev. Lett. 98, 190504 (2007).
  * Barrett and Stace (2010) S. D. Barrett and T. M. Stace, Phys. Rev. Lett. 105, 200502 (2010).
  * Stace and Barrett (2010) T. M. Stace and S. D. Barrett, Phys. Rev. A 81, 022317 (2010).
  * Stace  _et al._ (2009) T. M. Stace, S. D. Barrett, and A. C. Doherty, Phys. Rev. Lett. 102, 200501 (2009).
  * Whiteside and Fowler (2014) A. C. Whiteside and A. G. Fowler, Phys. Rev. A 90, 052316 (2014).
  * Delfosse and Zémor (2020) N. Delfosse and G. Zémor, Phys. Rev. Research 2, 033042 (2020).
  * Skinner  _et al._ (2019) B. Skinner, J. Ruhman, and A. Nahum, Phys. Rev. X 9, 031009 (2019).
  * Togan  _et al._ (2010) E. Togan, Y. Chu, A. S. Trifonov, L. Jiang, J. Maze, L. Childress, M. Dutt, A. Sørensen, P. Hemmer, A. Zibrov, and M. Lukin, Nature 466, 730 (2010).
  * Duan  _et al._ (2001) L.-M. Duan, M. D. Lukin, J. I. Cirac, and P. Zoller, Nature 414, 413 (2001).
  * Somaschi  _et al._ (2016) N. Somaschi, V. Giesz, L. De Santis, J. C. Loredo, M. P. Almeida, G. Hornecker, S. L. Portalupi, T. Grange, C. Antón, J. Demory, C. Gómez, I. Sagnes, N. D. Lanzillotti-Kimura, A. Lemaítre, A. Auffeves, A. G. White, L. Lanco, and P. Senellart, Nature Photonics 10, 340 (2016).
  * Nickerson and Bombín (2018) N. Nickerson and H. Bombín, arXiv:1810.09621 (2018).
  * Newman  _et al._ (2020) M. Newman, L. A. de Castro, and K. R. Brown, Quantum 4, 295 (2020).
  * Galam and Mauger (1996) S. Galam and A. Mauger, Phys. Rev. E 53, 2177 (1996).
  * Knill  _et al._ (2001) E. Knill, R. Laflamme, and G. J. Milburn, Nature 409, 46 (2001).
  * Ralph  _et al._ (2002) T. C. Ralph, N. K. Langford, T. B. Bell, and A. G. White, Phys. Rev. A 65, 062324 (2002).
  * Hofmann and Takeuchi (2002) H. F. Hofmann and S. Takeuchi, Phys. Rev. A 66, 024308 (2002).
  * Browne and Rudolph (2005) D. E. Browne and T. Rudolph, Phys. Rev. Lett. 95, 010501 (2005).