Experimental quantum coding against qubit loss error

Abstract

The fundamental unit for quantum computing is the qubit, an isolated, controllable two-level system. However, for many proposed quantum computer architectures, especially photonic systems, the qubits can be lost or can leak out of the desired two-level systems, posing a significant obstacle for practical quantum computation. Here, we experimentally demonstrate, both in the quantum circuit model and in the one-way quantum computer model, the smallest nontrivial quantum codes to tackle this problem. In the experiment, we encode single-qubit input states into highly entangled multiparticle code words, and we test their ability to protect encoded quantum information from detected 1-qubit loss error. Our results prove in-principle the feasibility of overcoming the qubit loss error by quantum codes.

Quantum computers are expected to harness the strange properties of quantum mechanics such as superposition and entanglement for enhanced ways of information processing. However, it has proved extremely difficult to build such devices in practice. Arguably, the most formidable hurdle is the unavoidable decoherence caused by the coupling of the quantum computers to the environment, which destroys the fragile quantum information rapidly. It is thus of crucial importance to find ways to reduce the decoherence and carry out coherent quantum operations in the presence of noise.

Recent experiments have made progress toward this goal by demonstrating quantum error correction (1–5), decoherence-free subspace (6–9) and entanglement purification (10, 11). These experiments were designed to cope with one special kind of decoherence, that is, when qubits become entangled with the environment or undergo unknown rotations in the qubit space. Such errors can be represented as linear combinations of the standard errors: no error, bit-flip, phase-flip, or both.

There is, however, another significant source of error—the loss of qubits in quantum computers. The qubit, which is the basic element of standard quantum computation (QC), is supposed to be an isolated two-level system consisting of a pair of orthonormal quantum states. However, most proposed quantum hardware are in fact multilevel systems, and the states of qubits are defined in a two-level subspace, which may leak out of the desired qubit space and into a larger Hilbert space (12–14). This problem is common in practical QC with various qubits candidates, such as Josephson junctions (15), neutral atoms in optical lattices (16), and, most notoriously, single photons that can be lost during processing or owing to inefficient photon sources and detectors (17–21). The loss of physical qubits is detrimental to QC because the working of quantum gates, algorithms and error correction codes (see, e.g., refs. 22–24) all hinge on the percept that the quantum system remains in the qubit space.

Here, we demonstrate the smallest meaningful quantum codes to protect quantum information from detected 1-qubit loss. Our experiment deals with qubit loss in both the quantum circuit model and one-way quantum computer model (25). We encode single-qubit states into loss-tolerant codes that are multiparticle entangled states. The performances of the quantum codes are tested by determining the fidelities of the recovered states compared with the ideal original states. Our results verify that the qubit loss error could, in principle, be overcome by quantum codes.

Theoretical Schemes

We now briefly review the quantum codes designed to tackle the problem of qubit loss. A special class of quantum erasure–error correction (QEEC) code was proposed by Grassl et al. (26), where a 4-qubit code is sufficient to correct a detected 1-qubit loss error. The QEEC code was used by Knill et al. (18) to deal with the photon-loss problem for scalable photonic QC. In recent years, extensive efforts have been devoted to devising loss-tolerant quantum computer architectures (27–30). In particular, in the quantum circuit model Ralph et al. (29) used an incremental parity encoding method to achieve efficient linear optics QC and showed that a loss-tolerant optical memory was possible with a loss probability <0.18. In the approach known as the one-way QC, Varnava et al. (30) exploited the inherent correlations in cluster states and introduced a scheme for fault-tolerantly coping with losses in the one-way QC that can tolerate up to 50% qubit loss.

QEEC Codes

To show the principle of the QEEC codes (26), let us start with a specific example: a 4-qubit code that is able to protect a logical qubit from loss of a physical qubit. Here, a logical qubit |ψ〉_l = a₀|0〉_l+a₁|1〉_l is encoded in the subspace with four physical qubits as

This code can also be viewed as a combination of parity and redundant encoding, which is the basic module in Ralph's scheme of loss-tolerant optical QC (29).

We can consider the effect of a qubit loss as an unintended measurement from which we learn no information. The main feature of the code shown as Eq. 1 is that the detected loss of any one of the physical qubits will not destroy the information of the logical qubit but merely yields a recoverable Pauli error. Suppose, for example, qubit 1 is lost. We first measure qubit 2 in the computational (|0/1〉) basis. With its measurement result (q₂ = 0 or 1), we can obtain a pure quantum state |ψ′〉_l = a₀(|0〉₃|0〉₄ + |1〉₃|1〉₄) + (−1)^q2a₁(|0〉₃|0〉₄ − |1〉₃|1〉₄). With similar reasoning, more-qubit loss can also be corrected by increasing the size of loss-tolerant codes in the form of |ψ〉_l = a₀(|^⊗n + |1^⊗n)^⊗m + b₀(|0〉^⊗n − |1〉^⊗n)^⊗m, which can be created, e.g., by the incremental encoding scheme proposed in ref. 29.

Demonstration of the QEEC Code

A quantum circuit to implement the encoding of the 4-qubit QEEC code is shown in Fig. 1. To implement this, we design a linear optics network (see Fig. 2A). The physical qubits are encoded by the polarizations of photons, with 0 corresponding to the horizontal (H) polarization and 1 to the vertical (V). As shown in refs. 32 and 33, such an encoding method naturally incorporates a loss-detection mechanism and may enable high-fidelity linear optical QC. Our experimental setup is illustrated in Fig. 2B. We use spontaneous parametric down-conversion (34) to create the primary photonic qubits, which are then coherently manipulated by linear optical elements to implement the coding circuit and read out by using single-photon detectors (see the legend of Fig. 2B and Methods).

Fig. 1.

A quantum circuit with two Hadamard (H_d) gates and three CNOT gates for implementation of the 4-qubit QEEC code. The stabilizer generators of the QEEC code are X ⊗ X ⊗ X ⊗ X and Z ⊗ Z ⊗ Z ⊗ Z, where X(Z) is short for Pauli matrix σ_x (σ_z) (24). As proposed by Vaidman et al. (31), this 4-qubit code can also be used for error detection.

Fig. 2.

The linear optical networks and experimental setup. (A) We simulate the CNOT gate in Fig. 1 using a polarizing beam splitter (PBS) and a half-wave plate (HWP), through which a control photon (α|H〉 + β|V〉) and a target photon |H〉 evolve into (α|H〉|H〉 + β|V〉|V〉) after postselection. Thus, the circuit in Fig. 1 can be realized by this linear optical network. (B) A pulsed infrared laser (788 nm, 120 fs, 76 MHz) passes through a LiB₃O₅ (LBO) crystal where the laser is partially up-converted to UV (λ = 394 nm). Behind the LBO, five dichroic mirrors (only one shown) are used to separate the mixed UV and infrared light components. The reflected UV laser passes through two β-barium borate (BBO) crystals to produce two pairs of entangled photons. The transmitted infrared laser is further attenuated to a weak coherent photon source. To achieve good spatial and temporal overlap, the photons are spectrally filtered by narrow-band filters (Δλ_FWHW = 3.2 nm, with peak transmission rates of ≈98%) and detected by fiber-coupled single-photon detectors (D₁, …, D₅) (35). The compensator consists of a HWP sandwiched by two thin BBO crystals. By tilting the BBO, we can compensate the undesired phase shift in the PBS. (C) The five-photon cluster state can be prepared by small modifications of the scheme of A.

To demonstrate that the quantum codes work for general unknown states, we test three different input states: |V〉, |+〉, and |R〉 = (|H〉+ i|V〉)/$\sqrt{2}$, which are encoded into the 4-qubit QEEC codes, respectively, as (normalizations omitted)

where the subscript denotes the spatial mode. Interestingly they show three distinct types of entanglement: |V〉_l is a product state of two Einstein–Podolsky–Rosen (EPR) pairs (38), |+〉_l is a 4-qubit Greenberger–Horne–Zeilinger (GHZ) state (39), whereas |R〉_l is locally equivalent to a cluster state (40).

We test the performance of the encoding process by determining fidelities of the encoded 4-qubit states. The fidelities are judged by the overlap of the experimentally produced state with the ideal one: F = 〈ψ|ρ_exp|ψ〉. To do so, we first decompose ρ = |ψ〉〈ψ| into locally measurable observables that are products of Pauli operators [the detailed constructions are shown in supporting information (SI) SI Text]. For the states |V〉_l, |+〉_l and |R〉_l, we need to take 9, 5, and 9 settings of four-photon polarization correlation measurements, respectively, each composed of 2⁴ coincidence detections, to determine the probabilities of different outcome combinations. From the data shown in Figs. S1–S3, the fidelities of the QEEC codewords are: F_V = 0.620 ± 0.017, F₊ = 0.566 ± 0.020, F_R = 0.554 ± 0.017. The fidelities of the 4-qubit GHZ state and cluster state are above the threshold of 0.5, thus they are confirmed to contain genuine four-partite entanglement (41, 42). The imperfections of the fidelities are caused mainly by high-order emissions of entangled photons and remaining distinguishability of independent photons overlapping on the PBSs. Finally, it should be noted that for the purpose of “benchmarking” quantum computers, more settings of measurements will be needed to infer the average fidelity of the quantum coding (2).

“Loss-and-Recovery” Test

Now we test the codes' ability to protect the logical qubit information from one detected physical qubit loss through a “loss-and-recovery” process. Here, we simulate the loss of a photon by detecting the photon without knowing its polarization information, which only tells us that the photon is lost. Experimentally, this is done by placing no polarizer or PBS in front of the detector.

In principle, the QEEC code works when only one and any one of the four physical qubits is lost. In our experiment, we test individually all possible cases where any single one of the four photons is lost. For instance, if we assume photon 2 is lost, the experimental procedure goes as follows. We erase the photon 2, perform a measurement in H/V basis on photon 3 and in +/− basis on photon 4. Depending on different measurement results: |H〉₃|+〉₄, |V〉₃|+〉₄, |H〉₃|−〉₄, |V〉₃|−〉₄, correction operations: H_d, H_dX, H_dZ, H_dXZ should be applied on photon 5. As a proof-of-principle, here, we apply corrections for every individual outcome of photons 3 and 4, and determine the state fidelity of photon 5 compared with the original input state. For an explicit example, if we fix the polarizers in front of D₃ and D₄ in |V〉 and |+〉 polarization, we should apply H_dX to photon 5 and then measure its fidelity. Each measurement is flagged by a fivefold coincidence event where all five detectors fire simultaneously.

Fig. 3 shows the measured recovery fidelities compared with original input state for all possible combinations. For input states |V〉, |+〉, and |R〉, the recovery fidelities averaged over all possible measurement outcomes are found to be 0.832 ± 0.012, 0.764 ± 0.014, and 0.745 ± 0.015, respectively, which establish the effectiveness of the 4-qubit QEEC codes. It can be noticed that the encoding and recovery fidelities for the state |V〉 is higher than those for |+〉 and |R〉. We believe this is because in our setup, the coding process for |V〉 requires interference of photons only on PBS₂ and PBS₃, whereas for the latter cases, the interferences involve all three PBSs. Also it can be seen from Fig. 3A that for the input state |V〉, the recovery fidelities when we simulate photons 4 or 5 are lost are considerably better than those when photons 2 or 3 are lost. We note that this is because in the former case, the coding involves interference between dependent photons c and d (from the same EPR pair) on the PBS₂, whereas the latter case requires interference of independent photons b and e on the PBS₃.

Fig. 3.

Experimental results of recovering quantum information from detected qubit loss. Recovered state fidelities are listed for all possible cases of photon loss (2 or 3 or 4 or 5) and necessary feedforward correction operations (H_d or H_dX or H_dZ or H_dXZ). (A) data for input state |V〉. (B) For |+〉. (C) For |R〉.

Loss-Tolerant One-Way QC

Now we consider how to overcome the qubit loss in the one-way QC model (25). In this model, QC is achieved by single-qubit measurements on prepared highly entangled cluster states (40), where the orders and choices of measurements determine the algorithm computed. It is important to note that the loss detection is naturally incorporated in the measurement step in this QC model.

To tackle fault tolerance in this architecture, protocols have been developed by exploiting the built-in properties of the entangled cluster states that provide natural resilience to decoherence (30, 43). In particular, Varnava et al. (30) used the tree-shaped graph states and analyzed that a high error threshold of 0.5 exists for qubit loss error. The salient feature of this scheme is illustrated in Fig. 4. Briefly, the tree graph state takes advantage of the perfect correlations in the cluster states and embodies two useful features that enable reduction of the effective qubit loss rate. First, it allows multiple attempts to do the desired measurement on an encoded qubit. Second, it is designed such that any given qubit within the cluster could be removed (see the legend of Fig. 4).

Fig. 4.

Principle of the loss-tolerant one-way quantum computation scheme (30). A cluster state can be represented by a graph, where the vertices take the role of qubits, and the edges represent interaction (44). (A) Certain measurements on a cluster state have interesting effects: A Z measurement removes the qubit from the cluster and breaks all of the bonds between the qubit and the rest; two adjacent X measurements on a linear cluster remove the qubit and form direct bonds between their neighbors. (B) A cluster state is an eigenstate of a set of stabilizers that predict with certainty correlations in the measurement outcomes of certain sets of measurements. For instance, for a 2-qubit state that is stabilized by the operator X_1Z2, if observable X₁ is measured, then the outcome of Z₂ is known with certainty. This allows us to measure a qubit even if it is lost, which is called “indirect measurement” (30). (C) The tree-graph cluster state that can be used for reduction of the effective qubit loss rate. We plant a cluster tree by two adjacent X measurements, on which instead of doing the A measurement on the in-line qubit, we can perform the measurement on a qubit in the third horizontal level. When this measurement succeeds, we break the bounds with all other qubits in the tree. If it fails, we remove this damaged qubit and attempt the A measurement on other qubits in the third level. The tree structure ensures that the removal of damaged qubits can be done by direct or indirect Z measurements. (D) The 5-qubit cluster state can be used for an in-principle verification of this scheme.

Creation of a 5-Qubit Cluster State

We use a 5-qubit cluster state for demonstration of Varnava et al.'s scheme (30). As shown in Fig. 4D, it can be thought of as being reduced from a 7-qubit cluster after two adjacent X measurements. Alternatively, the cluster can be grown directly, as we do in our experiment.

Starting from an EPR pair and three single photons, we use the linear optical network shown in Fig. 2C and the experimental setup shown in Fig. 2B to create the five-photon cluster state (see Methods). When each of the five output modes registers a photon, the five photons are in the highly entangled cluster state

where the subscript labels the photon's spatial mode (see Fig. 2C). The state |φ₅〉 is local unitarily equivalent to the 5-qubit linear cluster state shown in Fig. 4D under the H_d transformations on photon 1, 3, and 5. This is, to our best knowledge, the longest one-dimensional cluster state realized so far.

To determine the fidelity of the five-photon cluster state, we decompose the projector |φ₅〉〈φ₅| into 15 local measurable observables (see SI Text), each takes 2⁵ fivefold coincidence measurements. The experimental results are shown in Fig. 5, yielding F_c = 〈φ₅|ρ_exp|φ₅〉 = 0.564 ± 0.015. Because the fidelity of the cluster state exceeds 0.5, the presence of true five-partite entanglement of our cluster state is also confirmed (42).

Fig. 5.

Experimental results of the five-photon cluster state |φ₅〉. (A) Five-photon detection events in the H/V basis. (B) Measured expectation values of the other 14 observables M₁, M₂, …, M₁₄ (detailed representations shown in SI Text) to determine the fidelity of the cluster state |φ₅〉. The error bars denote one standard deviation, deduced from propagated Poissonian counting statistics of the raw detection events.

One-Way QC in the Presence of Loss

With the cluster state prepared, now we demonstrate its loss-tolerant feature by simulation of a quantum circuit in the presence of loss. First, let us briefly review how QC is done by measurements in the one-way model. The measurement is chosen in basis B_j(α) = {|+α〉_j,|−α〉_j}, where |±α〉_j = (|0〉_j ± e^iα|1〉_j)/$\sqrt{2}$, which realizes the single-qubit rotation R_z(α) = exp(−iασ_z/2), followed by a Hadamard operation on the encoded qubit in the cluster. We define the outcome s_j = 0 if the measurement on the physical qubit j yields |+α〉_j, and s_j = 1 if it is |−α〉_j. When s_j = 0, the computation proceeds without error, whereas when s_j = 1, a known Pauli error is introduced that has to be compensated for (see refs. 25, 45, and 46 for more details).

The 2-qubit cluster shown in Fig. 6A can implement a simple circuit, rotating an encoded input qubit |+〉 to an output state: |ψ_out〉 = X^saH_dR_z(α)|+〉. With this 2-qubit cluster, however, one can only have a one-shot A measurement on the qubit a, that is, if this measurement fails, then the whole computation fails. As a comparison, the 5-qubit cluster state we prepared can be used to realize the circuit in a more robust fashion. It provides two alternative and equivalent attempts to do the A measurement as depicted in Fig. 6 B and C. And if any one of the qubits (2, 3, 4, or 5) for the A measurement is lost, we can always find a suitable indirect Z measurement to remove the damaged qubit. For example, if the A measurement on qubit 2 fails, we can try to remove it from the cluster by an X measurement on qubit 3, and then proceed to make the A measurement on qubit 4. It can be checked that as long as no more than one physical qubit is lost, the computation will be successful.

Fig. 6.

Experimental results of loss-tolerant one-way quantum computing. (A) A 2-qubit cluster state used to simulate a single-qubit rotation circuit by a measurement on qubit a. (B and C) A 5-qubit cluster state could realize the circuit in the presence of 1-qubit loss. (D and E) The experimentally measured fidelities of output states of the single-qubit rotation circuit. D (E) shows the results of the scheme B (C), respectively. Measurements on the qubit 4 (2) are performed in basis B_j(α) for different α value, {0, −π/2, −π/3}, so that the target output state will be {|+〉, |R〉, |S〉}, respectively.

Now we demonstrate this experimentally. To verify the scheme depicted in Fig. 6B, we erase photon 2, which makes the remaining cluster in a mixed state. Then we make an X measurement on photon 3—this should effectively remove the loss error from the cluster, leaving it as a smaller but pure quantum cluster state. Next the redundant photon 5 is measured in the Z basis. Note that because the actual state |φ₅〉 is unitarily equivalent to the 5-qubit linear cluster state shown in Fig. 4D under the H_d transformations on photons 1, 3, and 5, the X (Z) measurement on photon 3 (or 5) is performed on a rotated laboratory basis of H/V (+/−). Depending on the measurement outcomes of photon 3 and 5 (|H〉₃|+〉₅, |V〉₃|+〉₅, |H〉₃|−〉₅, |V〉₃|−〉₅), Pauli corrections (I, X, Z, XZ) are applied to photon 4. After that, measurements in the basis B_j(α) are applied on photon 4 to implement the rotation. We choose α to be three different values, 0, −π/2, −π/3, so that theoretically the output states will be |+〉, |R〉, and |S〉 = (|0〉 + e^iπ/3|1〉)/$\sqrt{2}$, respectively. Then we readout the polarizations of photon 1 and determine its fidelities compared with the ideal states. The scheme of Fig. 6C is also tested in a similar manner.

In Fig. 6 D and E, we show the experimental results of one-way QC in the presence of 1-qubit loss. In the case of photon 2 lost, we find a fidelity of 0.738 ± 0.029, 0.750 ± 0.030, and 0.765 ± 0.028 for target output state |+〉, |R〉, and |S〉, respectively. In the case of photon 4 lost, the fidelity is 0.865 ± 0.021, 0.792 ± 0.029, and 0.767 ± 0.030 for target output state |+〉, |R〉, and |S〉. Here, the difference of the fidelity performance is caused by similar reasons as in the QEEC codes. For instance, the case for target output state |+〉 corresponds to Fig. 3A, where the input state is in the state of |V〉. These results conclusively demonstrate the underlying principle of loss-tolerant one-way QC.

Discussion

As in all current linear optical QC experiments, the multiphoton code states here are created probabilistically and conditioned on that there is one and only one photon out of each output, a technique called postselection (35). Although this does not prevent an in-principle verification of the loss-tolerant quantum codes, we note that eventual scalable implementations will need significant improvements such as on-demand entangled photon sources and high-efficiency single-photon detectors.

In summary, we have demonstrated, in both the quantum circuit model and in the one-way model, the smallest meaningful quantum codes to protect quantum information from qubit-loss error. These quantum codes are the key modules for the loss-tolerant quantum computer architectures (29, 30) and can, in principle, be extended to larger numbers of qubits. Our results verify that it is possible to overcome the qubit-loss error, a major decoherence mechanism common in many physical systems, and thus constitute a necessary step toward scalable quantum information processing, especially for photon-based QC. The loss-tolerant quantum codes can be further concatenated with standard quantum error-correction codes (22–24) or decoherence-free space (6–9) to correct multiple errors and may become a useful part of future implementations of quantum algorithms (45–50).

Methods

Experimental Implementation.

We first prepare two entangled photon pairs in spatial modes a–b and c–d with an average coincidence count of ≈6.2 × 10⁴s⁻¹, and a pseudosingle photon source in mode e, which has a very small probability (p) of containing a single photon for each pulse. The p value is carefully chosen to be ≈0.07 experimentally to get an optimal visibility (36). Photon a serves as a trigger, indicating that the pair photon b is under way; Photon b is prepared in different input states; Photons c, d, nd e are initialized in the +45° linear polarization state |+〉 = (|H〉 + |V〉)/$\sqrt{2}$. We superpose photons b, c, d, and e on the three PBSs step by step. For alignment on the PBS₁, for instance, we first initialize the two photons b and c at state |+〉 before they enter into the PBS₁, and, by making fine adjustment of delay Δd₁, we are able to observe the two-photon Hong–Ou–Mandel type dip (37) after the PBS₁ by performing polarization measurements in both output modes in the |±〉 = (|H〉 ± |V〉)/$\sqrt{2}$ basis. Similarly, optimal superpositions of the photons on the other two PBSs are also achieved. The optimal interference occurs at the regime of zero delay, where our experimental measurements are performed. Note that some PBSs may have undesired phase shifts, that is, when two input photons that were prepared in the states of |+〉 are superposed on the PBSs, the output photons are not in the expected state of (|H〉|H〉 + |V〉|V〉)/$\sqrt{2}$ but in the state of (|H〉|H〉 + e^iθ|V〉|V〉)/$\sqrt{2}$ with a θ phase shift. This can be overcome by a compensator (see Fig. 2B) that can introduce a phase delay between |H〉 and |V〉.

Five-Photon Cluster State Preparation.

An EPR photon pair as prepared in the spatial mode a–b in the state (|H〉_a|H〉_b + |V〉_a|V〉_b)/$\sqrt{2}$ with a visibility of ≈92% in the +/− basis. We note that this nonperfect visibility may add additional noise into the five-photon cluster state compared with the four-photon states by using the scheme as shown in Fig. 2A. To get a better fidelity for the cluster state, we lower the pump power and obtain an average coincidence of ≈5.0 × 10⁴s⁻¹ in modes a–b and c–d, such that the rate of double pair emission of entangled photons is diminished. Meanwhile, the p value for the pseudosingle photon source is also reduced to ≈0.06 accordingly.