Microclusters are the basic building blocks used to construct cluster states capable of supporting fault-tolerant quantum computation. In this paper, we explore the consequences of errors on microcluster construction using two error models. To quantify the effect of the errors we calculate the fidelity of the constructed microclusters and the fidelity with which two such microclusters can be fused together. Such simulations are vital for gauging the capability of an experimental system to achieve fault tolerance.
Microclusters are the basic building blocks used to construct cluster states capable of supporting fault-tolerant quantum computation. In this paper, we explore the consequences of errors on microcluster construction using two error models. To quantify the effect of the errors we calculate the fidelity of the constructed microclusters and the fidelity with which two such microclusters can be fused together. Such simulations are vital for gauging the capability of an experimental system to achieve fault tolerance.
We explore basic necessary protocols to achieve fault tolerance for quantum computation in the cluster state and circuit models. For the cluster state model we simulate the implementation of an arbitrary rotation via only measurement on a decohered cluster state. Fidelity is used to quantify the accuracy of the initial cluster state and a gate fidelity for the arbitrary rotation is determined. In the circuit model we compare the accuracy of two methods that can be used to construct a logical zero state appropriate for the [7, 1, 3] Steane quantum error correction code in a non-equiprobable Pauli operator error environment: a fault tolerant method done by applying error correction on seven qubits all in the state zero, and a non-fault tolerant method done by implementing the encoding gate sequence. We find that the latter construction method, in spite of its lack of "fault tolerance," outputs a seven qubit state with a higher fidelity than the first (fault tolerant) method. However, the fidelity of the single qubit of stored information exhibits almost equivalent values between the two construction methods.
Quantum computing has the potential to transform information technology by offering algorithms for certain tasks, such as quantum simulation, that are vastly more efficient than what is possible with any classical device. But experimentally implementing practical quantum information processing is a very difficult task. Here we study two important, and closely related, aspects of this challenge: architectures for quantum computing, and quantum error correction Exquisite quantum control has now been achieved in small ion traps, in nitrogen-vacancy centres and in superconducting qubit clusters, but the challenge remains of how to scale these systems to build practical quantum devices. In Part I of this thesis we analyse one approach to building a scalable quantum computer by networking together many simple processor cells, thus avoiding the need to create a single complex structure. The difficulty is that realistic quantum links are very error prone. Here we describe a method by which even these error-prone cells can perform quantum error correction. Groups of cells generate and purify shared resource states, which then enable stabilization of topologically encoded data. Given a realistically noisy network (10% error rate) we find that our protocol can succeed provided that all intra-cell error rates are below 0.8%. Furthermore, we show that with some adjustments, the protocols we employ can be made robust also against high levels of loss in the network interconnects. We go on to analyse the potential running speed of such a device. Using levels of fidelity that are either already achievable in experimental systems, or will be in the near-future, we find that employing a surface code approach in a highly noisy and lossy network architecture can result in kilohertz computer clock speeds. In Part II we consider the question of quantum error correction beyond the surface code. We consider several families of topological codes, and determine the minimum requirements to demonstrate proof-of-principle error suppression in each type of code. A particularly promising code is the gauge color code, which admits a universal transversal gate set. Furthermore, a recent result of Bombin shows the gauge color code supports an error-correction protocol that achieves tolerance to noisy measurements without the need for repeated measurements, so called single-shot error correction. Here, we demonstrate the promise of single-shot error correction by designing a decoder and investigating its performance. We simulate fault-tolerant error correction with the gauge color code, and estimate a sustainable error rate, i.e. the threshold for the long time limit, of ~0.31% for a phenomenological noise model using a simple decoding algorithm.
In order to build a scalable quantum computer error correction will be required to reduce the impact of errors. Implementing error correction in the framework of measurement based computation manifests itself as the construction of fault tolerant cluster states (FTCSs). While any 2-dimensional stabilizer code can be used to construct a FTCS through the process of foliation, here we find FTCSs that cannot be constructed through foliation of a stabilizer code, and identify new examples of self-dual codes that can still be implemented in a 2-dimensional physical architecture.
This thesis is concerned with certain theoretical problems that arise naturally in the context of fault-tolerant quantum computation. Fault-tolerance can be defined as the art of building reliable devices from unreliable components, and is of particular importance for quantum computers that aim to precisely control the dynamics of extremely sensitive quantum systems. A model of quantum computation is a specification of the basic building blocks by which a quantum computation is implemented. The best known model is the quantum circuit model, where computations are implemented by means of unitary quantum gates that are applied to two-level quantum systems known as qubits. In a physical implementation of a quantum circuit, the gates and qubits will inevitably be affected by noise. Fault-tolerant quantum circuits are designed to be resilient against the effects of this noise, provided that it is not too strong. Fault-tolerance in the quantum circuit model is well developed thanks to the theory of quantum error-correcting codes. These codes allow for the correction of small numbers of errors introduced by a variety of noise processes. In a fault-tolerant quantum circuit, qubits are replaced with encoded qubits, and quantum gates with encoded gates that are immediately followed by special quantum circuits for error correction. Provided the rate at which errors occur is below a constant threshold value, the accumulation of errors can be checked so that the correct output of the computation correctly determined. The threshold acts as both a measure of how good the design of a quantum circuit is, and also as a target for experimenters aiming to implement quantum circuits. Much current research in quantum computation is aimed at designing quantum circuits that increase the noise threshold, hopefully to the point where it becomes within the reach of experimenters. A fault-tolerant encoded quantum gate must limit the propagation of errors so that the code’s corrective capabilities are not overwhelmed. It is not so easy to design encoded gates that satisfy this property, and to date only a finite handful of such gates are known. In a faulttolerant quantum circuit, all quantum gates must be decomposed or compiled in terms of those that may be implemented fault-tolerantly. In the first part of this thesis, we present two results that may be applied to this problem of gate compilation. The first is a generic method based on the Solovay-Kitaev theorem that may be applied to all quantum gates, but is most effective for those that act on single qubits. We present the Solovay-Kitaev theorem in its simples known form as an algorithm, together with novel constructions that can be used to implement it. Following this we give a two specialized methods for two-qubit gate decomposition, based on the Cartan decomposition of the Lie group SU(4). The cluster-state model of computation is an alternative to the quantum circuit model, and makes use of quantum measurements and highly entangled cluster-states to implement a quantum computation. The fault-tolerant techniques developed for quantum circuits are not immediately applicable in this model, so in order for it to be a realistic candidate for performing computations we prove that such techniques are possible. In the second part of the thesis we prove that constant fault-tolerance thresholds may be achieved in the cluster-state model, and in particular in an adaption to an optical implementation. Following this we design a complete error correction scheme for optical cluster-state computation, and numerically determine the threshold of this model in the face of the dominant noise models likely to affect such an implementation.
Introduction Cluster states were introduced in Chapter 18, along with some of the approaches to achieving fault tolerance in measurement-based quantum computing. In this chapter, we describe an extremely promising fault-tolerant cluster state quantum computing scheme [RH07, RHG07] with a threshold error rate of 7.46 × 10 −3 , low overhead arbitrarily long-range logical gates and novel adjustable strength error correction capable of correcting general errors through the correction of Z errors only. Detailed proposed implementations of this scheme exist for ion traps [SJ09] and single photons with cavity mediated interactions [DGI+07]. The discussion is organized as follows. In Section 20.2, we describe the topological cluster state, which is a specific three-dimensional (3D) cluster state, and give a brief overview of what topological cluster state quantum computing involves. Section 20.3 describes logical qubits in more detail and how to initialize them to ∣0 L 〉 and ∣+ L 〉 and measure them in the Z L and X L bases. State injection, the non-fault-tolerant construction of arbitrary logical states, is covered in Section 20.4. Logical gates, namely the logical identity gate and the logical CNOT gate, are discussed in Section 20.5 along with their byproduct operators. Section 20.6 describes the errorcorrection procedure. In Section 20.7, we calculate an estimate for the threshold of this scheme. Section 20.8 presents an analysis of the overhead as a function of both the circuit size and the error rate.
The ability to construct large photonic cluster states capable of supporting universal quantum computation relies on fusing together cluster primitives. These fusion operations are probabilistic and the efficiency of the construction process relies on recycling remains of cluster primitives that have undergone failed fusion attempts. Here I consider the effects of the inevitable decoherence that must arise while storing cluster primitives. First, I explore the case where dephased two-qubit cluster states are the basic resource for the construction of all larger cluster states, all fusion operations are successful, and no further dephasing occurs during the construction process. This allows us to explore how decoherence of the most basic, primitive clusters translates into imperfections of the larger cluster states constructed from them. I then assume that decoherence occurs before every attempted fusion operation and determine the best way to build a five-qubit cluster. This requires including the effects of the fusion operation failures. Fidelity is used as the measure of accuracy for the constructed cluster states. Finally, I include a short discussion of photon loss and how it affects the construction of simple photonic clusters.