ar
X
iv
:0
70
7.
09
03
v1
[
qu
an
t-p
h]
6
Ju
l 2
00
7
Loss-tolerant operations in parity-code linear optics quantum computing
A. J. F. Hayes,∗ A. Gilchrist, and T. C. Ralph
Centre for Quantum Computer Technology, University of Queensland, QLD 4072, Brisbane, Australia.
(Dated: February 1, 2008)
A heavy focus for optical quantum computing is the introduction of error-correction, and the
minimisation of resource requirements. We detail a complete encoding and manipulation scheme
designed for linear optics quantum computing, incorporating scalable operations and loss-tolerant
architecture.
PACS numbers: 42.50Dv
I. INTRODUCTION
Linear optics is a highly promising architecture in the
drive to produce a quantum computer. It was first shown
by Knill, Laflamme and Milburn (KLM) [1] that lin-
ear optics was a viable system for implementing scal-
able quantum computing [2]. Further work by various
researchers has produced experimental demonstrations of
some of the basic components required by linear optics
quantum computing (LOQC) [3, 4, 5]. Another focus of
work in the field is on improving the efficiency with which
computation could be performed. An alternative scheme
put forward by Nielsen [6] introduced the use of the clus-
ter state model [7] in LOQC. A stream-lined version of
this scheme can be found in the paper by Browne and
Rudolph [8], which significantly decreases the size of the
overheads required for computing, when compared with
the original KLM design. More recently, there has been
research done on the task of introducing error-correction
into the cluster-state model [9, 10]. For a more extensive
overview of the field of LOQC, see [11].
We have previously presented an approach to loss-
tolerant active memory based on an incremental parity
encoding [12, 13]. Parity encoding was used in the origi-
nal KLM proposal to protect against both teleporter fail-
ures (i.e. the non-determinism of the gates) and photon
loss. By using parity encoding but re-encoding incre-
mentally (instead of by concatenation) we are able to
obtain the reduction in overheads characteristic of the
cluster state approach whilst retaining the circuit model
and parity encoding of KLM. With the addition of a layer
of redundancy encoding, this allowed for recovery from
photon loss.
In this paper we will present a universal set of gates for
use with a parity-based loss-tolerant code, to allow scal-
able quantum computing. We will show that these gates
maintain loss-tolerance during operation, and calculate
the loss-tolerant thresholds for computation within the
scheme. Though our techniques for detecting and cor-
recting loss are themselves also subject to loss, above a
particular threshold efficiency the effect of loss can be
negated to arbitrary accuracy, making the computation
∗Electronic address: ahayes@physics.uq.edu.au
loss-tolerant.
In section II we shall describe the structure of the en-
coding that allows us to recover from loss, and the gate
operations available to us in designing a system for uni-
versal quantum computation. In this case, we assume
the use of photon sources and detectors, linear optical
elements, and fast feed-forward. Section III details the
operations that will form a universal set of gates on the
logical qubits. We demonstrate that using re-encoding
to perform these gates allows recovery from losses that
occur whilst attempting them. Finally, in section IV, we
calculate the loss threshold for general computation, un-
der this set of operations. These calculations deal only
with loss errors, and do not consider other classes of er-
ror, such as depolarisation. We have focussed on qubit
loss, as it is a dominant source of error in optics, however
it should be noted that by neglecting other forms of error
we are assuming that photon loss is by far the dominant
source of error [14].
II. THE ENCODING
We will deal with qubits in three different tiers of en-
coding: (i) physical encoding, (ii) parity encoding and
(iii) redundant encoding. At the first tier are the ba-
sic physical states that we will use to construct qubits,
these will be the polarisation states of a photon so that
|0〉 ≡ |H〉 and |1〉 ≡ |V 〉. The advantage of this choice in
optics, is that we can perform any single physical-qubit
unitary deterministically with passive linear optical ele-
ments. Of course gates between different physical qubits
become difficult and in LOQC these are typically non-
deterministic. The function of the parity encoding is to
allow near deterministic operations and to convert pho-
ton loss to heralded bit-flip errors. The redundant en-
coding then allows recovery from these errors.
A. Parity Encoding
We have shown how this class of code may be imple-
mented on an arbitrary number of qubits [12]. In this
paper the notation |ψ〉(n) will be used to represent a log-
ical qubit |ψ〉 parity-encoded across n distinct physical
modes each containing one photon. We describe these

2individual photons as the physical qubits that make up
the system. The physical qubits also correspond to the
first level of encoding.
A parity encoding across n photons is given by
|0〉(n) ≡ (|+〉⊗n + |−〉⊗n)/
√
2
|1〉(n) ≡ (|+〉⊗n − |−〉⊗n)/
√
2, (1)
where |±〉 = (|0〉 ± |1〉)/
√
2. The |0〉(n) and |1〉(n) states
have only even or odd parity terms respectively. A com-
putational basis measurement of any one of the physical
qubits will merely reduce the level of the parity encoding
by one, without losing the logical qubit. A bit-flip cor-
rection may be needed dependent on the measurement
result.
B. Gates at the Parity Level
The logical gates described in KLM were based on us-
ing concatenation to build up a very large resource state,
and then teleporting the logical qubits in order to apply
the gate operation. This method also allowed for par-
tial loss protection to be built into the gates [15], but
the resource costs were extremely high. Our alternative
scheme [12], based on the same code, uses re-encoding to
perform gates and has a reduced resource cost as a result.
The operation that allows us to teleport qubits or
entangle states is the partial Bell state measurement
[16, 17]. For qubits encoded in the polarisation modes of
a photon, this operation is done by mixing two physical
qubits on a polarising beam splitter followed by measure-
ment in the diagonal-antidiagonal basis. It is successful
when one photon is detected in each arm of the beam-
spitter’s output. If both photons appear at one of the
outputs, the operation has failed. The probability of suc-
cess for the operation is 1/2. When successful it projects
onto the Bell states |00〉±|11〉, otherwise it projects onto
the separable states |01〉 and |10〉, measuring the qubits
in the computational basis. The operation can be used
to attach physical qubits to a parity encoded state. This
is referred to as type-II fusion (fII) [8].
There are two operations which are easily performed
on parity encoded states. One is a rotation by an arbi-
trary amount around the x-axis of the Bloch sphere (ie
Xθ = cos(θ/2)I − i sin(θ/2)X), which can be performed
by applying that operation to any of the physical qubits;
and the other is a Z operation, which can be performed
by applying Z to all the physical qubits (since the odd-
parity states will acquire an overall phase flip). This
means that all the Pauli operations can be performed
deterministically. The remaining gates needed in order
to achieve a universal gate set are a Z90 and a cnot gate.
These can be efficiently performed on the parity encoded
states through re-encoding.
Re-encoding is done by applying a type-II fusion be-
tween a physical qubit from the code state and a resource
FIG. 1: This is the optical layout for a type-II fusion gate. It
enacts a partial Bell measurement on two input qubits, acting
as an entangling gate with a 50% probability of success.
of |0〉(n+2). The result is
fII |ψ〉(m)|0〉(n+2) →
{
|ψ〉(m+n) (success)
|ψ〉(m−1)|0〉(n+1) (failure)
(2)
When this is successful, the length of the parity qubit
is extended by n (two qubits are consumed in the opera-
tion). A phase flip correction may be necessary depend-
ing on the measurement results. Failure causes the phys-
ical qubit from the parity encoded state to be measured,
lowering the level of encoding by one. The resource state
is left in the state |0〉(n+1) and can be re-used.
Full details of how to enact the Z90 and cnot gates
can be found in Gilchrist et al. [18].
C. Redundant encoding
The full loss-tolerant encoding begins with a parity
code of length n, and concatenates it with a redundancy
code of length q. Thus at the highest level our logical
qubits are given by:
|ψ〉L = α|0〉
(n)
1 |0〉
(n)
2 .....|0〉(n)q + β|1〉
(n)
1 |1〉
(n)
2 .....|1〉(n)q
= α
q
⊗
|0〉(n) + β
q
⊗
|1〉(n)
= α|0〉(n,q) + β|1〉(n,q) (3)
where
⊗q indicates the tensor product of q such states.
It turns out to be useful to build the following resource
state:
|0〉|0〉(n,q) + |1〉|1〉(n,q) (4)
We can create an “encoder” gate that correctly encodes
from a parity qubit to a full redundancy qubit by sim-
ply fusing the resource state above onto the parity qubit.
We attempt type-II fusion between this resource and the

3parity qubit, |ψ〉(n), repeating until successful (on aver-
age twice) giving the (phase flip corrected) result
α[|0〉(n−k)|0〉(n,q) + |1〉(n−k)|1〉(n,q)]+
β[|1〉(n−k)|0〉(n,q) + |0〉(n−k)|1〉(n,q)] (5)
where 0 < k < n − 1 is the number of unsuccessful at-
tempts made before fusion was achieved. This state is
made up of qn “new” photons introduced by the resource
and n − k of the “old” photons that made up the par-
ity qubit. By measuring the old photons in the compu-
tational basis and making a bit flip (on all-new parity
qubits if needed) we obtain the expected encoded state
(Eq 3).
D. Active Memory Circuit
The identity operation on the encoded state acts to
detect and correct loss errors that may have occurred.
Regularly performing this check can protect the quantum
information from loss [13].
In this operation, one of the constituent parity qubits
is sent into the encoder described earlier. With arbi-
trarily high probability, the encoder either successfully
re-encodes the parity qubit as a full redundancy state, or
it detects a loss. If a loss is detected, measurements in
the diagonal basis |0〉(n)±|1〉(n) can be performed on the
remaining constituents of the parity qubit to disentangle
it from the rest of the state. Once the logical state is
no longer entangled with the lost photon, the encoding
operation may be reattempted.
When the encoder succeeds, diagonal basis measure-
ments can be used to remove the rest of the original par-
ity qubits from the entanglement. In each case, after
disentangling, it may be necessary to apply a phase-flip
to return the logical qubit to the state in Eq 3. Higher
levels of loss can be tolerated by increasing the size of
the redundancy code. For a redundancy code of size q,
it is possible to tolerate loss on up to q − 1 of the par-
ity qubits, with the state being fully re-encoded from the
remaining parity qubit.
III. LOGICAL GATES IN LOSS TOLERANT
ENCODING
To achieve loss-tolerant quantum computing, the next
step is to incorporate a full set of universal gates into
the loss-tolerant memory scheme described above. We
already have a universal set of gates at the level of the
parity encoding [18], and these will be the basis for our
development of gates for the loss-tolerant code. The key
lies in finding an implementation of a universal set of
gates that can be applied efficiently to qubits in this loss-
tolerant encoding.
It is also necessary to ensure that the protection
against loss is not compromised by these operations. As
a logical operation typically consists of a series of gates
enacted on physical qubits, it is possible for losses to oc-
cur and be detected during this process. However, if the
component gates have taken the logical qubit out of the
code space, it may no longer be possible to correct an er-
ror. This why it is necessary to design logical operations
that will not compromise the integrity of the code at any
point.
In the parity encoding, we are able to perform arbi-
trary rotations about the x-axis (Xθ), 90-degree rota-
tions about the z-axis (Z90), and cnot gates between
qubits. These are the fundamental operations that make
up a universal set at that level of encoding. Moving to
the redundancy code, it can be seen that Zθ rotations on
a single parity qubit apply to the entire code, but that
performing Xθ rotations would in general be significantly
more difficult. Consequently, we will focus on implement-
ing (Zθ) and (X90) at the redundancy level. However, all
the Pauli gates may be performed deterministically at
this level, as at the parity level of encoding.
A. The Zθ rotation
Although performing an arbitrary Zθ rotation on a log-
ical qubit requires merely a Zθ rotation on a single parity
qubit within the state, such Zθ rotations on the parity
qubits are not trivial to perform. To enact a Zθ rotation
on a parity qubit using the set of gates described in [18]
would require a couple of steps, during which the logi-
cal qubit is not always in a code state, and hence not
properly protected from photon loss. To avoid this prob-
lem, it is necessary to change the procedure for doing an
arbitrary Zθ rotation.
Consider a general redundancy qubit |ψ〉(n,q):
|ψ〉(n,q) = α|0〉(n,q) + β|1〉(n,q)
= α|0〉(n,q−1)[|0〉(n−1)A |0〉B + |1〉
(n−1)
A |1〉B]
+ β|1〉(n,q−1)[|1〉(n−1)A |0〉B + |0〉
(n−1)
A |1〉B] (6)
We will require a resource state |R1〉 to perform a log-
ical Zθ of the form
|R1〉 = |0〉n+1 = |0〉C |0〉
(n) + |1〉C |1〉
(n) (7)
Step 1 is to perform a Zθ rotation on a single compo-
nent qubit of the redundancy state (qubit B):
|ψ1〉 = α|0〉(n,q−1)[|0〉(n−1)A |0〉B + eiθ|1〉
(n−1)
A |1〉B]
+ β|1〉(n,q−1)[|1〉(n−1)A |0〉B + eiθ|0〉
(n−1)
A |1〉B] (8)
Step 2, a type-II fusion gate is performed between
qubit B and a component qubit of the resource state
(qubit C). The fusion acts to re-encode the state from
the single qubit we have rotated.
|ψ2〉 = α[|0〉(n,q−1)][|0〉(n−1)A |0〉
(n) + eiθ|1〉(n−1)A |1〉
(n)]
+ β[|1〉(n,q−1)][|1〉(n−1)A |0〉
(n) + eiθ|0〉(n−1)A |1〉
(n)] (9)

4Step 3 is to measure in the computational basis the
remainder of the parity qubit (A). In the event that an
odd parity is measured, an X gate on the newly-added
parity qubit is required as a correction.
〈0|(n−1)A |ψ2〉 :
|ψ3〉 = α|0〉(n,q−1)|0〉(n) + β|1〉(n,q−1)eiθ|1〉(n)
= α|0〉(n,q) + eiθβ|1〉(n,q) (10)
〈1|(n−1)A |ψ2〉 :
|ψ4〉 = eiθα|0〉(n,q−1)|1〉(n) + β|1〉(n,q−1)|0〉(n) (11)
X|ψ4〉 :
|ψ5〉 = α|0〉(n,q) + e−iθβ|1〉(n,q) (12)
It can be seen that the result of an odd parity mea-
surement is a rotation of the form Z−θ. In this case the
logical gate must be re-attempted, using Z2θ. It is worth
noting that the logical Z180 operation can be performed
deterministically, and hence that a Z90 gate would only
need to be attempted once regardless of the outcome of
the measurement.
For a general Zθ gate, an average of two attempts
would be required. The advantage this method holds for
our purposes is that the redundancy qubit will always be
left in a code state, maintaining the protection against
loss.
B. The X90 rotation
For a universal set of gates, an X90 gate is also re-
quired. To enact theX90 gate, the operation is performed
on one of the component physical qubits. It is then pos-
sible to re-encode from this phyiscal qubit in a similar
manner to that used for the Zθ gate. Measurement of
the old qubits will once again allow us to determine an
appropriate set of corrections.
As before, we begin by considering a general redun-
dancy qubit |ψ〉(n,q) (Eq. 6). A larger resource state
|R2〉 is required for the logical X90 gate:
|R2〉 = |0〉C |0〉(n,q) + |1〉C |1〉(n,q) (13)
We then proceed as before, step 1 being an X90 rota-
tion on one component qubit (B). Step 2 is to perform
a fusion gate between that qubit and the qubit labelled
as C in the resource state. In step 3, it is necessary to
measure all the old qubits which made up the original
redundancy state. Those qubits in the parity state from
which the rotated qubit came (A) are measured in the
computational basis. All others (D) are measured in the
diagonal basis. Corrections will depend on the overall
parity of the qubits measured computationally, and on
whether an odd number of the other parity qubits are
measured in the |−〉 state.
The possible states after measurement are:
〈0|A〈+|D|ψ〉 :
|ψ6〉 = (α− iβ)|0〉(n,q) − i(α+ iβ)|1〉(n,q)
〈1|A〈+|D|ψ〉 :
|ψ7〉 = (β − iα)|0〉(n,q) − i(β + iα)|1〉(n,q)
〈0|A〈−|D|ψ〉 :
|ψ8〉 = (α− iβ)|0〉(n,q) + i(α+ iβ)|1〉(n,q) (14)
〈1|A〈−|D|ψ〉 :
|ψ9〉 = (β − iα)|0〉(n,q) + i(β + iα)|1〉(n,q)
Accordingly, we may require a logical X gate, a logical
Z gate, or both in order to correct the resulting state.
Once any necessary corrections are performed, we are
left with a redundancy state on which the X90 operation
has been successfully applied.
C. Logical CNOT
It was explained earlier in this paper that a logical
cnot gate could be enacted on a parity qubit by a pro-
cess of encoding. The cnot is performed between two
redundancy qubits, |ψ〉 and |φ〉. Here |ψ〉 is the control
and |φ〉 is the target.
|ψ〉L = α|0〉(n,q) + β|1〉(n,q) (15)
|φ〉L = γ|0〉(n,q) + δ|1〉(n,q) (16)
The logical cnot gate is performed as an iterative pro-
cess, with a parity-level cnot performed for each parity
qubit in |ψ〉. Each of these parity-level cnot gates will
use an arbitrary parity qubit from |φ〉 as its target input.
We use the following resource for each iteration.
|R3〉 = |0〉C |0〉
(n)(|0〉(m)|0〉D + |1〉
(m)|1〉D)
+|1〉C |1〉
(n)(|1〉(m)|0〉D + |0〉
(m)|1〉D) (17)
where m = ⌊n/2⌋. It consists of two parity qubits with a
cnot already performed between them. The target par-
ity qubit, m, is shorter since re-encoding is not required
on the second logical qubit.
Step 1 of the process is then to fuse a member of the se-
lected parity qubit from |ψ〉 with qubit C in the resource,
|R3〉.
If this is successful, step 2 is to measure the remaining
original physical qubits in the parity state, to complete
the re-encoding. If a loss is detected anywhere up to
this point, we disentangle the chosen parity qubit and
the resource from the rest of the |ψ〉 state using diagonal
basis measurements. This allows us to recover and re-
attempt the process.
In step 3, perform a fusion gate between qubit D in the
resource and a physical qubit taken from |φ〉. To recover
from a loss, should one occur during this fusion, we dis-
entangle the resource from |ψ〉 by making diagonal basis

5measurements on it, and do the same for the parity qubit
in |φ〉 on which we have acted. Once again, Z and/or X
gates may be required as corrections on both qubits de-
pending on the outcome of the measurements. These
Pauli gates can be applied deterministically to parity or
redundancy states. To perform the full logical cnot, this
process is iterated for each parity qubit in |ψ〉.
These encoding-based gate operations continually re-
place the photons used for the logical qubits, and the old
photons are measured, identifying any losses that arise.
In this way, loss detection and correction are continually
applied during computation.
IV. LOSS-TOLERANT THRESHOLDS
In order for the encoding to be useful in a scalable
quantum computing scheme, it is necessary to show that
a loss threshold exists. If the loss is below this threshold,
it is possible to drive the probability of failure arbitrarily
close to zero by increasing the size of the code. We will
first summarize the threshold calculation for the identity
operation, as presented in our previous paper [13]. We
then present a revised threshold for general computation,
using the logical gate operations we have described.
A. A Loss-Tolerance Threshold for the Active
Memory
The active memory scheme is used to protect an en-
coded logical qubit |Ψ〉(n,q), by regularly re-encoding it
using the resource given in Eq 4. We begin by consid-
ering the probability of loss for each photon. The effi-
ciency of the photon source will be labelled ηs, and the
efficiency of the detectors will be ηd. We will use ηm to
indicate the memory efficiency, which is the probability
a photon will not be lost during the time it is in mem-
ory, in-between re-encoding cycles. This means that the
probability of detecting a new photon, from a resource
state, is η2 = ηsηd, and the probability of detecting an
old photon, from the code state, is η1 = ηsηmηd. Note
that fusing a resource onto a logical qubit will succeed
or fail with probability η1η2/2 and detect a photon loss
with probability 1− η1η2.
In calculating the loss-tolerant threshold for the en-
coding, we consider the possible outcomes of an attempt
to re-encode the state. For a given parity qubit in the
overall state, there are three possible outcomes when at-
tempting to re-enode from it.
The first possible outcome is successful re-encoding
without loss. This occurs when the fusion is successful on
one of the first n− 1 physical qubits in the parity state,
and the remainder are measured in the computational
basis without loss. The probability for this is:
PQs =
n−1
∑
i=1
(
1
2
η1η2)iηn−i1 (18)
Note that if only one component qubit remains in the
parity state, we instead measure it in the diagonal basis
to disentangle it, and begin again with another parity
qubit from the overall state.
The second outcome that can occur is total failure.
This can result from a long series of losses and/or fusion
failures. The probability for total failure is:
Pff =
n−1
∑
j=1
(
1
2
η1η2)j−1(1− η1η2)(1− η1)n−j
+R
n−2
∑
j=0
(
1
2
η1η2)j+1
n−2−j
∑
k=0
ηk1 (1 − η1)n−1−j−k
+ (
1
2
η1η2)n−1(1 − η1) (19)
R =
q
∑
k=1
(
q
k
)
(1− η2)kn[1− (1− η2)n]q−k (20)
HereR is the probability of failing to recover via measure-
ments on the new resource qubits. This can occur when
photon loss is detected after a fusion has been performed,
and attempts to disentangle by measuring components of
the original parity qubit have proven unsuccessful.
The third possibility is that of recovery after partial
failure. The probability of this can be calculated from
the previous two equations: PQf = 1 − PQs − Pff . We
can tolerate this outcome occurring up to q−1 times when
attempting to re-encode. Therefore, the total probability
for successfully re-encoding is:
PE =
q−1
∑
j=0
P jQfPQs[1− (1 − η1)n]q−1−j (21)
where the [1 − (1 − η1)n]q−1−j factor occurs because it
is necessary to disentangle the remainder of the original
state once the chosen parity qubit has been successfully
re-encoded.
For the probability PE to approach one for large en-
codings, it is necessary to maintain a particular ratio
between n and q. The optimal ratio can be found by
solving ddqPE = 0 for q in terms of n This relationship
is shown in figure 2. In these calculations, we consid-
ered an equally high error rate in all parts of the circuit
(ηs = ηm = ηd = η). Using the optimal ratio, we found
numerically that PE can be driven arbitrarily close to
one when η ≥ 0.82. This is shown in figure 3.
B. A Loss-Tolerance Threshold for Computation
The thresholds for the single-qubit logical gates are the
same as the threshold for the identity (memory) case, due
to the strong similarity between the gate operations, and
the re-encoding used in the active memory. The Zθ op-
eration uses smaller resources, and as such has a slightly

6FIG. 2: Variation of the optimal value of q with n, for given
values of η
10
20
30
40
n
0.8
0.85
0.9
0.95
1
Η
0
0.2
0.4
0.6
0.8
1
P
FIG. 3: Probability of success for active memory using opti-
mal q as a function of η and n
higher probability of success, but this difference becomes
vanishingly small for large code sizes. This results in it
having the same threshold as the X90 operation, and the
identity. The cnot gate is the most complicated of the
universal set of gates we have developed, and we would
expect it to be the most vulnerable to loss.
The probability of successfully performing our cnot
gate without loss can be evaluated by considering three
possible outcomes for each iteration in the procedure.
These consist of a no-progress outcome, in which a cnot
between parity qubits fails due to loss or measurement
errors, a progress outcome, in which the cnot is success-
ful, and total failure, in which one or both logical qubits
are lost. There are several ways in which a no-progress
outcome can occur. These events and their probability
are listed below.
1. Fusion attempts are unsuccessful, and the chosen
parity qubit is disentangled from the rest of the state:
M1 = (
1
2
η1η2)n−1η1 (22)
2. A loss occurs during a fusion attempt, and the parity
qubit is disentangled:
M2 =
n−2
∑
i=0
(
1
2
η1η2)i(1− η1η2)[1 − (1− η1)n−i−1] (23)
3. A loss occurs while measuring off qubits after a
successful fusion, and the parity qubit is disentangled:
M3 = (24)
n−2
∑
i=1
(
1
2
η1η2)i
n−i−2
∑
j=0
ηj1(1− η1)[1 − (1− η1)n−i−j−1]
4. A loss occurs while measuring off qubits after a
successful fusion, the parity qubit is not disentangled,
and it is necessary to measure the resource in order to
disentangle it:
M4 =
n−1
∑
i=1
(
1
2
η1η2)i
n−i−1
∑
j=0
ηj1(1− η1)n−i−j (25)
[(1− (1− η2)n)(1 − (1− η2)
n
2 +1)]
5. A loss occurs during fusion with the target qubit,
which is measured in order to disentangle it:
M5 =
n−1
∑
i=1
(
1
2
η1η2)iηn−i1 (1 − η1)(
1
2
η1η2)(1− (1 − η1)
n
2 +1)
(26)
For most of these events, it is necessary to re-encode
the logical control qubit afterwards to ensure it is fully
protected. This has a probability of success of PE .
Hence the probability of a no-progress outcome (M)
is:
M = PE
4
∑
k=1
Mk +M5 (27)
Here PE is the probability of successfully re-encoding
a logical qubit, as shown earlier. The probability of a
progress outcome (K) is:
K =
n−1
∑
i=0
(
1
2
η1η2)iηn−i1 [
1
2
η1η2
+ (1− η1η2)(1 − (1− η1)n−1)(1− (1 − η2)
n
2 )] (28)
For a gate between two logical qubits, each made up
of q parity qubits, the overall probability of success is:
PTOTAL =
(
K
1−M
)q
(29)
To simplify the calculation, we again consider the case
in which the different parts of the system (sources, mem-
ory/manipulation, detectors) contribute equally to the
loss. We represent the efficiency of each of these compo-
nents as η. Using the equations shown, we can examine

710
20
30
40
n
0.8
0.85
0.9
0.95
1
Η
0
0.2
0.4
0.6
0.8
1
P
FIG. 4: Probability of success for a logical cnot gate on
redundancy qubits
the way the probability of success varies with this effi-
ciency (figure 4). It is assumed the n : q ratio of these
logical qubits will be optimised for re-encoding, using the
formula found earlier.
It can be seen that the threshold approaches a value
of 90% efficiency for the cnot gate. So far, we have as-
sumed an equal contribution to the loss from different
components. However, if we assume that one or more
parts of the system are lossless (e.g. perfect detectors),
the thresholds for the rest of the system will drop accord-
ingly.
V. RESOURCES
The procedures we have described require many entan-
gled resource states to be prepared separately for use in
computation. We assume our basic building blocks for
these resources to be maximally-entangled Bell pairs, in
the state |0〉(2). Such Bell pairs would have to be gen-
erated directly from a heralded source, or created from
single photons via a KLM-style entangling gate [1].
The first step in creating the resources required is to
generate larger parity states, of the form |0〉(n). These
states are built up iteratively by fusing smaller parity
states together, in a similar manner to that used to gen-
erate cluster states [8]. Initially, it is necessary to use
a type-I fusion gate, which acts as a single-rail partial
Bell measurement. As in the case of the type-II fusion
gate, both input qubits are mixed at a 50-50 beamsplit-
ter. However, only one arm is measured. The type-I
gate is successful when exactly one photon is found in
this arm. To achieve the desired fusion operation for
combining parity states, Hadamard gates are performed
on the inputs and output of the type-I fusion gate. This
operation has the advantage that only one qubit is mea-
sured, but a failure means that both parity states are
completely lost.
(H⊗H)fIH |0〉(n)|0〉(m) →
{
|0〉(m+n−1) (success)
− (failure)
(30)
As a result, the type-I fusion gate is used to create
short parity qubits, which are then joined in larger chains
using type-II fusion 2. The type-II fusion measures one
qubit from each state, but does not destroy the state
in the event of failure, allowing resources to be recycled.
Additionally, if one of the input qubits to the type-II gate
is missing the loss will be detected, reducing loss errors
due to gates in the entanglement construction. For effi-
FIG. 5: (a) A representation of the two-qubit parity state
used as a starting resource, |0〉(2). (b) The process by which
larger parity states are generated, using fusion gates between
qubits.
cient resource production, states of the form |0〉(5) could
be produced using type-I fusion, as shown in figure 5.
This would require an average of 16 Bell pairs. In order
to generate larger states, the type-II fusion gate should
be used to join multiple copies of the |0〉(5) state.
To create redundantly encoded resources, we begin by
performing a cnot between a pair of physical qubits
taken from the states |0〉(n+1) and |0〉(n). If successful,
this will produce the state
|0〉|0〉(n,2) + |1〉|1〉(n,2) (31)
which can be used to encode a qubit |Ψ〉 in the logical
state |Ψ〉(n,2). To build a larger redundancy resource, we
fuse multiple copies of the state given by Eq. 31.
VI. CONCLUSIONS
In this paper we have given a full description of a re-
dundancy code for performing circuit-based linear opti-
cal quantum computing in the presence of photon loss.
We have found that the code is successful as a quantum
memory if each potential area of loss (the photon source,
the memory/operational section of the circuit, and the
detectors) has an efficiency of 82% or greater. For gen-
eral computation in this system, the threshold efficiency

8FIG. 6: (a) A graphical representation of the state |0〉|0〉(n,2)+
|1〉|1〉(n,2) (equation 31). (b) A fusion between two such
states. Once the remainder of the parity qubit being encoded
has been measured in the computational basis, the resulting
state is |0〉|0〉(n,3) + |1〉|1〉(n,3).
is 90%, as this is the minimum efficiency which will al-
low all the gate operations to work successfully. For both
of these thresholds, an efficiency less than the threshold
in an area of loss can be tolerated if other areas have
correspondingly higher efficiencies. We have restricted
our consideration to photon loss which has enabled us
to describe a quite complete error correction protocol
for general quantum computation with a high loss tol-
erant threshold. However, neglecting other noise sources
is rather unrealistic. In future work we plan to address
more general error correction codes based on optical par-
ity states.
Acknowledgments
This work was supported by the Australian Re-
search Council, Queensland State Government, and
DTO-funded U.S. Army Research Office Contract No.
W911NF-05-0397.
[1] E. Knill, R. Laflamme, and G. Milburn, Nature 409, 46
(2001).
[2] M. A. Nielsen and I. L. Chuang, Quantum Computation
and Quantum Information (Cambridge University Press,
Cambridge, 2000).
[3] T. B. Pittman, M. J. Fitch, B. C. Jacobs, and J. D.
Franson, Phys. Rev. A p. 032316 (2003).
[4] J. L. O’Brien, G. J. Pryde, A. G. White, T. C. Ralph,
and D. Branning, Nature p. 264 (2003).
[5] S. Gasparoni, J. W. Pan, P. Walther, T. Rudolph, and
A. Zeilinger, Phys. Rev. Let. p. 020504 (2004).
[6] M. A. Nielsen, Optical quantum computation using clus-
ter states (2004), quant-ph/0402005.
[7] R. Raussendorf and H. J. Briegel, Phys. Rev. Lett. 86,
5188 (2001).
[8] D. E. Browne and T. Rudolph, Phys. Rev. Lett. 95,
010501 (2005).
[9] M. A. Nielsen and C. M. Dawson, Phys. Rev. A 71,
042323 (2005).
[10] C. M. Dawson, H. L. Haselgrove, and M. A. Nielsen,
Phys. Rev. A 73, 052306 (2006).
[11] P. Kok, W. J. Munro, K. Nemoto, T. C. Ralph, J. P.
Dowling, and G. J. Milburn, Rev. Mod. Phys. 73, 052306
(2006).
[12] A. J. F. Hayes, A. Gilchrist, C. R. Myers, and T. C.
Ralph, J. Opt. B 6, 533 (2004).
[13] T. C. Ralph, A. J. F. Hayes, and A. Gilchrist, Phys. Rev.
Lett. 95, 100501 (2005).
[14] P. P. Rohde, T. C. Ralph, and W. J. Munro, Phys. Rev.
A 75, 010302 (2007).
[15] E. Knill, R. Laflamme, and G. Milburn, Thresholds
for linear optics quantum computation (2000), quant-
ph/0006120.
[16] H. Weinfurter, Europhysics Lett. 25, 559 (1994).
[17] S. L. Braunstein and A. Mann, Phys. Rev. A 51, 1727
(1995).
[18] A. Gilchrist, A. J. F. Hayes, and T. C. Ralph, Phys. Rev.
A 75, 052328 (2007).