Hybrid architecture for encoded measurement-based quantum computation.

We present a hybrid scheme for quantum computation that combines the modular structure of elementary building blocks used in the circuit model with the advantages of a measurement-based approach to quantum computation. We show how to construct optimal resource states of minimal size to implement elementary building blocks for encoded quantum computation in a measurement-based way, including states for error correction and encoded gates. The performance of the scheme is determined by the quality of the resource states, where within the considered error model a threshold of the order of 10% local noise per particle for fault-tolerant quantum computation and quantum communication.

Quantum computation holds the promise of solving certain problems much faster than any classical computer could. Several models for quantum computation have been put forward1234 that do not only offer conceptual insights into the scope and power of quantum computation, but also put different requirements and emphasis for an experimental realization. While the standard quantum gate-based approach makes use of a modular structure where coherent operations are chosen from a finite set of elementary gates and applied sequentially, measurement-based quantum computation is centered on the usage of a universal, highly entangled resource state that is processed by single qubit measurements only35. For certain set-ups, the preparation of specific entangled states will be easier than the coherent manipulation of arbitrary states, in particular if two-qubit gates requiring interactions between different systems are involved. However, large resource states need to be prepared and stored for universal measurement-based quantum computation. It is hence natural to consider hybrid schemes, in which elements of different computational schemes are combined into a computational architecture that unifies the advantage of the different approaches. Here we report on such a hybrid architecture, where both elementary blocks and larger parts/entire subroutines of a quantum algorithm are performed in a highly compressed and measurement-based way, i.e. by preparing algorithm-specific resource states, which are then combined and measured in a sequential fashion as in the circuit model. This hybrid architecture combines, thus, the one-way quantum computer3 with the gate-teleportation model4. We construct resource states of minimal size and find that the error threshold for universal fault-tolerant quantum computation is given by 13.6% local depolarizing noise per qubit.

Among the applications are e.g. a quantum memory and a quantum communication scheme6 based on sending encoded states, which does not require the creation of entanglement across the channel like the (entanglement-based) quantum repeater7.

The emphasis of our approach lies on (fault-tolerant) measurement-based realization of quantum error correction and the manipulation of encoded quantum information. In any realistic scenario, quantum information needs to be protected against noise and decoherence, which can be done by non local encoding and making use of quantum error correction18910111213. Here we demonstrate how the elementary building blocks of such encoded quantum computation - including encoding, syndrome-read out, decoding, but also realization of encoded quantum gates- can be done optimally in a measurement-based fashion. To this aim, we construct optimal resource states of minimal size for all these tasks, for arbitrary Calderbank-Shor-Steane (CSS)1213 and stabilizer codes8. All these resource states are stabilizer states, which can in principle be prepared probabilistically or pre-purified using known entanglement purification schemes25262728 to achieve a higher fidelity of the resource state and consequently of the performed operations. Such a probabilistic state preparation does not jeopardize the deterministic character of the overall computational scheme. What is more, we show how these basic elements can be combined in a straightforward way to obtain optimal resource states for a combination of the different tasks, including, e.g., code switchers or encoded gates combined with error syndrome readout, that is built-in error correction. These measurement-based elements are then applied sequentially as in a gate-based approach, providing a modular and flexible structure. The coupling between the building blocks corresponds to simple Bell-measurements. Conceptually, our scheme is similar to14 where teleportation-based implementation of sub-block error correction was used to achieve high error thresholds within the circuit model. Here we implement larger blocks together with logical gates directly in a measurement-based way, and concentrate on a different error model, which is better suited for a measurement-based implementation.

The performance of the scheme is determined by the quality of the resource states. We first show that for all computations that only consist of Clifford operations, more than 13.6% of local depolarizing noise per particle is tolerable. In this sense our architecture provides a fault-tolerant Clifford quantum computer with a very high error threshold. In particular, we obtain a fault-tolerant quantum memory and code switcher, and a scheme for long-distance quantum communication. Using magic state distillation15 at the logical level, we find that the threshold of 13.6% local noise per particle also applies to universal fault-tolerant quantum computation. Notice, however, that these numbers can not be directly compared to other fault-tolerance thresholds (e.g.91416), as they are based on a different error model. We are considering a consistent error model within the measurement-based framework, where the main source of noise is due to imperfect preparation of resource states and imperfect measurements, which we model by single-qubit depolarizing noise.

Methods

Background

Quantum error correction

We start by reviewing quantum error correction and measurement-based quantum computation. In quantum error correction, quantum information is encoded in a non local way into several physical systems such that arbitrary errors acting on one or several of the physical qubits can be corrected. In the standard (gate-based) approach, a quantum circuit transforms an (unknown) single qubit state α|0〉 + β|1〉 to an encoded M-qubit state α|0〉 + β|1〉. The code is designed in such a way that each possible error operator –which is typically described by (tensor products) of Pauli operators corresponding to bit-flip, phase flip or both errors on one or several qubits respectively– maps the logical subspace spanned by {|0〉, |1〉 to a different orthogonal two-dimensional subspace. Clearly, the number of correctable errors is limited by the available dimension of the Hilbert space. Error syndrome read-out takes place by projecting the system onto one of these two-dimensional error-subspaces. This is typically done with help of m additional ancilla systems and a circuit acting on the total M + m qubits. The state of the ancillas is subsequently measured, thereby reading out the error syndrome and projecting the remaining system onto one of the two-dimensional error-subspaces. The measurement outcome also determines the correction operation needed to undo the error and return the system to the initial logical subspace. Notice that by this measurement, a discretization of errors is enforced, i.e. a superposition of different error-states is projected (probabilistically) onto one of the possibilities, and can then be subsequently corrected. This is also the reason why it is sufficient to consider only elementary Pauli errors, as these operators form a basis for all Hermitian operators and hence any error can be written as a superposition of elementary Pauli errors. Decoding works in a similar way as encoding, where the inverse unitary is applied.

A special class of error correction codes of particular importance are so-called CSS codes12. They are stabilizer codes, that is, the codewords are stabilizer states, and their error-correction properties can be understood using the stabilizer formalism8. For CSS error correction codes, encoding, decoding- and syndrome readout circuits are Clifford circuits, i.e., they can be implemented using only Clifford gates and Pauli measurements8. This property will be important for us later, when we show how to realize the corresponding circuits in a measurement-based way.

Measurement-based quantum computation

In measurement-based quantum computation one starts with an entangled resource state. A quantum circuit is translated to a single-qubit measurement pattern on the resource state. There are several resource states which allow for universal quantum computation, e.g. the 2D cluster states17. It is important to note that Clifford gates are implemented by Pauli measurements and can be done in the very first step of the measurement-based computation. Alternatively they can be taken into account even beforehand, entering into the design of smaller, task dependent resource state. A circuit which contains only Clifford gates and Pauli measurements, and has n input and m output qubits can be implemented on a n + m qubit graph state18. Clifford circuits are crucial in entanglement purification and quantum error correction.

Elementary building blocks

Construction of resource states. We will now show how to efficiently construct resource states of minimal size to perform certain gates or circuits in a measurement-based fashion. There are two different ways to construct the required resource states. The first one starts with a sufficiently large 2D cluster state17 and the measurement pattern for the desired map. One can then apply the rules for Pauli measurements on graph states19 and obtains the resource state of minimal size.

Alternatively one can construct the resource state via the Jamiolkowski isomorphism, which relates a completely positive map and a state20. It is simply the state which results from applying the map to (the second qubits of) N maximally entangled Bell pairs , where N is the number of qubits on which the map acts. Notice that the implementation is deterministic as long as the map involves only Clifford gates and Pauli measurements, but becomes probabilistic otherwise.

In both cases the calculations can be done efficiently using the stabilizer formalism8. There exist programs to do so2122.

Resource states for elementary gates and encoding & decoding

A deterministic single qubit rotation around the X-axis can be implemented with the three qubit graph state shown in figure 1a), yellow (middle) box. Here the qubit at the left hand side serves as input and the one on the right hand side as output. Also a two-qubit gate can be implemented deterministically using a 4-qubit resource state (see Supplementary material). The CZ gate and the arbitrary single qubit gates form an universal set of gates, allowing to perform any quantum computation.

Figure 1

(a) Illustration of fusion of resource states for a single qubit gate on a logical qubit. The resource states for decoding/encoding (left/right) are combined with the resource state for the rotation (middle) via Bell measurements. (b) Illustration of fusion of resource states for code switching. The resource states for decoding (left) and encoding (right) for two different codes are combined via a Bell measurement. (c) Resource states for encoding, repetitive error correction and decoding. (d) Two steps of the computation. Noise on input particles (blue) is moved to input particles (red). Noise on output particles is considered in the next step.

For all CSS codes, encoding and decoding require only Clifford gates and Pauli measurements. Particles that are measured in the Pauli basis can be removed from the resource state in a measurement-based implementation23. Consequently, such a circuit (independent of its length) can be done with a M + 1 qubit resource state, where M is the size of the code. Resource states corresponding to a 3-qubit repetition code (capable of correcting a single-qubit bit-flip error) and a 5-qubit graph code (capable of correcting an arbitrary single qubit error) for encoding/decoding are shown in figure 1b) (see Supplementary material).

The Bell measurements at the read-in of a logical qubit to a decoding resource state reveal the error syndrome, since the measurement results are correlated14. Alternatively the syndrome could be obtained by constructing the resource state which implements the syndrome read-out (or syndrome read-out and decoding). In the construction of this resource state it is assumed that the measurements of the ancilla qubits, which determine the syndrome, have a particular outcome. The byproducts from the Bell measurements, which occur whenever one does not project on |ϕ+〉 have to be commuted through the circuit and will then lead to effective projections of the ancilla qubits and reveal the error syndrome. This is similar to what has been used in measurement-based entanglement purification in order to determine whether a purification step was successful in23, where one can find an explicit example.

Fusion of resource states

The resource states described above can be combined to accomplish gates on the logical qubits. This is done in the following way: the output qubit of one resource state and the input qubit of the other resource state are measured in the Bell basis. This is illustrated for a single qubit rotation on a logical qubit and for code switching in figure 1a, 1b. In addition, the Bell measurements at the read-in reveal the error syndrome, so that error correction is combined with logical gates in a single step. The same technique can be used to design resource states for concatenated error correction or for combining logical gates, error correction and code switching. In all cases, one obtains resource states of minimal size. We would like to stress that these resource states are significantly smaller than a 2D cluster which could accomplish the same task. This can be illustrated as follows. Consider a single error correction step on a logical qubit encoded into N physical qubits. The optimized resource state will contain 2N qubits. The circuit for the error correction requires N stabilizer measurements, each of which itself requires an ancilla qubit and a number of phase gates (upper bounded by some constant). A 2D cluster state capable of performing the procedure in a measurement-based way will contain order of N2 qubits. A similar scaling can be found for resource states which implement error correction and logical gates.

Hybrid Computational Model

Using the techniques explained in the methods section, we describe the hybrid architecture for encoded quantum computation. Processing of (encoded) quantum information takes place in a sequential way, where elementary building blocks are realized in a measurement-based fashion as described above. These elementary building blocks can correspond to rather complicated and lengthy quantum circuits, and error correction can always be included. The measurement-based realization allows one to implement them in a compact way using resource states of minimal size that only consist of input and output particles, independent of the length of the circuit. In addition, no ancilla particles are required, thereby reducing the number of involved particles. The complexity of the circuit is encoded in the specific structure of the resource state. The reduced size and complexity of this measurement-based implementation makes it less susceptible to noise, similar as encountered in measurement-based entanglement purification24.

Elementary building blocks are combined sequentially by performing Bell measurements between output particles of the previous block and input particles of the next block (see Fig. 1c). The results of these measurements determine the error syndrome and the necessary correction operations. This modular structure limits the number of particles to be stored and operated on as compared to a purely measurement-based approach, as resource states can be prepared on the fly re-using the involved particles. In addition, no coherent manipulation by means of (entangling) gates is required, in contrast to the gate-based approach. Processing of (encoded) information is solely realized by preparation of small-scale resource states, together with Bell measurements. Notice that resource states may be prepared probabilistically and pre-purified using (multipartite) entanglement purification. As all resource states are graph states (up to local unitary operations), entanglement purification protocols are available25262728. Such an approach may have significant advantages in certain set-ups such as for photons, especially since (probabilistic) creation of states is often a much easier task than coherent manipulation by means of gates.

Influence of Noise and Thresholds

Error model

Imperfections in the resource state preparation, together with possibly imperfect Bell state measurements are the main sources of noise in this set-up. As we are dealing with processing encoded information, we have to make sure that despite these effects and external decoherence, the noise at the logical level can be fully suppressed.

As a noise model, we consider local depolarizing noise (LDN) acting on each of the qubits individually, . Noisy resource states are thus given by , where n is the size of the resource state and p specifies the amount of noise per particle. The effect of imperfect Bell measurements can be incorporated into local depolarizing noise for each particle, i.e. into the parameter p. In addition, we describe the effect of decoherence and other imperfections by depolarizing noise with parameter q acting on each of the particles of the encoded system.

This noise model reflects the increasing difficulty of preparing larger resource states, as the fidelity drops exponentially with the system size for fixed p. In addition, it is not associated with a particular preparation scheme. In16 it is also argued that this noise model is appropriate if one uses entanglement purification to increase the fidelity of the resource states, since the purification process acts locally on the states.

Thresholds

As shown in24, LDN can be effectively moved to other qubits when performing Bell measurements (see also the supplementary material). Resource states for (encoded) Clifford gates and circuits (even with built-in error correction) only contain input and output particles. The key observation is that noise coming from imperfect preparation of resource states can be moved in part to the input state, and to the output state (after processing, i.e. it is considered in the next step of the computation). The total effect is that each particle of an encoded system is influenced by LDN twice coming from imperfect state preparation, plus noise coming from depolarization, i.e. , before it is processed perfectly in the desired way, i.e. by an encoded Clifford gate with built-in error correction (see Fig. 1d). Since each of the encoded gates includes an error correction step, the noise at the logical level is reduced –corresponding to a larger value q- as long as p2q is above the threshold pCode of the chosen error correcting code (w.r.t. depolarizing noise)29303233. Using the code in a concatenated fashion in fact ensures that q → 1 in this regime, i.e. noise at the logical level can be fully suppressed2930. A sequential application of several of such logical operations is hence also possible. Given that the distance of such a noisy logical operation to the perfect unitary is sufficiently small, say , it follows that the sequential application of M such operations has a distance smaller than 31. Notice that can be made exponentially small with only a polynomial overhead, e.g. by using a concatenated error correction code. As error correction can in principle be done very frequently, one can assume that q ≈ 1. This is also justified by the fact that no active feed forward is required as long as only Clifford operations are involved. In fact, all correction operations can be postponed until the end of the logical circuit that may involve multiple blocks. It follows that the threshold p = pcrit for depolarizing noise per particle is simply given by . In a situation where q = p, one finds . Thresholds for a concatenated 5-qubit code2930 and Shor-type codes3132 are given by pCode = 0.8250 [pCode = 0.7449] respectively. This leads to pcrit = 0.8631 and for the Shor-type codes.

Applications

Clifford circuits

As imperfections in resource states and Bell measurement are taken into account, we have that all Clifford circuits, including error correction circuits, codes switchers (see also Supplementary material) and logical Clifford gates for CSS codes can be implemented fault tolerantly in this way. The tolerable noise per particle for imperfect resource states is more than 13.6%, which follows from . An important application of Clifford circuits is e.g. a quantum memory.

Quantum communication

The standard approach to scalable quantum communication is the (entanglement-based) quantum repeater7. A different scheme for long distance quantum communication was proposed in6. There, quantum information is encoded into quantum error correction codewords and send through noisy quantum channels and errors are corrected repetitively. The drawback of this scheme compared to (entanglement-based) quantum repeaters was that it has much tighter constraints on the tolerable noise, which are essentially given by the thresholds for fault-tolerant Clifford circuits. We can apply the results from above to determine the error thresholds of a measurement-based implementation of this scheme. As channel segments should not be too short, i.e. the noise 1 − q coming from the channel is not negligible, one has q < 1. For p = q this leads to , i.e. more than 9% noise per particle for imperfect resource states and for channel noise is acceptable in this case. This could provide a viable alternative for long distance quantum communication, with thresholds comparable to those of measurement-based quantum repeaters23.

Universal quantum computation

Universal quantum computation also requires the implementation of non-Clifford gates. For single-qubit encoded non-Clifford gates, the yellow (upper) qubit in figure 1a) has however to be treated differently, since it is not coupled to a logical qubit. Noise acting on it translates directly to an error on the logical qubit, and hence above arguments do not apply. In the following we describe two ways how to avoid that: the first is based on a code switch and transversal single qubit gates, and the second uses magic states15.

Fault-tolerance threshold using a code switch and transversal single-qubit gates

Here we describe how error thresholds for universal fault-tolerant computation can be obtained using code switchers and transversal single-qubit gates. A single qubit non-Clifford gate is realized by switching to an error correction code such as the 15-qubit CSS code related to classical Reed-Muller codes15. In this code, an encoded logical π/8-gate can be implemented transversally, i.e. by single qubit rotations on physical qubits. However, the code suffers from a relatively low error threshold of pCode = 0.98116. Together with logical Clifford gates, this constitutes a universal gate set. The code switch can be done fault-tolerantly as described above. The procedure is then the following: whenever a non-Clifford gate is required one switches to the 15 qubit CSS code and applies the single qubit rotations to the physical qubits. Afterwards one switches back to a code with a higher threshold. The single qubit rotation is assumed to be noisy, , where noise can however be moved to the next error correction step, simply further decreasing the quality of the input particles, i.e. (the implementation of such single qubit unitary operations could also be done in a measurement-based way, however this is overly complicated).

The fault tolerance threshold of the computation is again given by the condition p2q × q > pCode, i.e. the threshold of the code against depolarizing noise. In many physical systems, such as e.g. trapped ions or superconducting qubits, single qubit rotations can be done with extraordinary accuracy3435, i.e. q ≈ 1. Even when assuming p = q, we have . For the 15 qubit CSS code, we have pCode = 0.98116, i.e. universal fault tolerant quantum computation is possible with errors up to 0.64% error probability per particle and single-qubit gate, and almost 1% per particle when assuming high-fidelity single-qubit rotations.

Fault-tolerance threshold using magic state distillation and state injection

An alternative to the method described above, however with significant overheads, is given by using magic states and state injection15 for implementing a single qubit, non-Clifford rotation (see also14). It is based on the observation that Clifford gates and an ancilla qubit prepared in a magic state suffice to implement a π/8 gate. The motivation is that fault-tolerant Clifford gates can be implemented with fairly high thresholds and that noisy magic states can be purified with Clifford gates and Pauli measurements only. It has been found36 that magic states can be purified probabilistically as long as their fidelity exceeds (assuming that the Clifford operations themselves are perfect), which translates to p > 0.8047 for local depolarizing noise.

Here we use a magic state distillation procedure at the logical level, i.e. we prepare several copies of encoded magic states, by using the graph state which implements the encoding circuit into the desired quantum error correction code. If we encode a noisy physical qubit using a measurement-based encoding circuit, noise at the physical qubit and the state for read in will directly translate to noise at the logical level, i.e. pcrit > 0.8047. Notice that a direct read-in via a single qubit measurement on the resource state is preferable to coupling an additional (noisy) particle via a Bell measurement. As long as noise at the logical level is below pcrit, a (asymptotically) perfect magic state can then be prepared at the logical level with help of magic state distillation.

The implementation of the magic state distillation as well as the logical single-qubit gate realized by state injection requires only Clifford circuits15. In the latter case, the Clifford operations act on the (logical) magic state and the encoded quantum information. The threshold for noisy resource states to implement (logical) Clifford circuits fault-tolerantly are given above for different codes, and can be as high as 13.6% per particle. Hence the threshold for universal fault-tolerant quantum computation is determined by the applicability of fault-tolerant Clifford computation rather than the threshold for magic state distillation, since this gives the tighter constraint on the noise. We thus find that the error threshold for universal fault-tolerant quantum computation is given by 13.6% local noise per particle.

As the resource states implement concatenated quantum error correction codes any improvements on the overheads, e.g. via better codes, or improved magic state distillation with higher yield3738, will carry over to this approach.

Conclusions and Outlook

We have proposed a hybrid architecture for quantum computation, where elementary building blocks corresponding to error correction or encoded gates are implemented in a measurement-based fashion. This can be done with resource states of minimal size, thereby reducing the number of involved systems and the operational complexity. At the same time, we obtain very high error thresholds, where local depolarizing noise of the order of 10% per particle is tolerable for the involved resource states. The crucial assumption in the derivation is that all noisy resource states can be described by local, uncorrelated noise acting on the individual qubits. Whether this can be justified for gate-based or other generation procedures remains an open issue.

Notice that these numbers can not directly be compared to other threshold results for universal fault tolerant quantum computation, as they are based on a different error model. The error model we use is consistent within a measurement-based set-up, and is not associated with a particular preparation procedure. The preparation of resource states can in principle be done in various ways, not necessarily involving (deterministic) gates. For instance, a cooling process to prepare the ground state of a (properly controlled) Hamiltonian is conceivable, or a probabilistic generation of states as e.g. done for photons, where parametric down conversion serves as a very successful tool to prepare highly entangled states without the need to apply gates. A reduction to usually considered error models, where thresholds are based on error probabilities of elementary single- and two qubit gates, may hence not be meaningful. That is, it may not lead to relevant insight for a given experimental situation. This also applies to situations where additional gates are available. For instance, in a trapped ion set-up, a many-qubit gate is available that allows for the direct preparation of large-scale GHZ states3940, a task that otherwise requires N − 1 two qubit gates.

Our scheme is perfectly suited for several set-ups, and following our proposal, elementary building blocks corresponding to measurement-based quantum error correction have already been experimentally demonstrated with photons41 and ions39.

Author Contributions

All authors (M. Z., H. J. B., and W. D.) contributed to this work.