Quantum computing using two coherent states as a qubit basis is a proposed alternative architecture with lower overheads but has been questioned as a practical way of performing quantum computing due to the fragility of diagonal states with large coherent amplitudes. We show that using error correction only small amplitudes (alpha>1.2) are required for fault-tolerant quantum computing. We study fault tolerance under the effects of small amplitudes and loss using a Monte Carlo simulation. The first encoding level resources are orders of magnitude lower than the best single photon scheme.
Quantum computing using two coherent states as a qubit basis is a proposed alternative architecture with lower overheads but has been questioned as a practical way of performing quantum computing due to the fragility of diagonal states with large coherent amplitudes. We show that using error correction only small amplitudes (alpha>1.2) are required for fault-tolerant quantum computing. We study fault tolerance under the effects of small amplitudes and loss using a Monte Carlo simulation. The first encoding level resources are orders of magnitude lower than the best single photon scheme.
Quantum computing promises a new paradigm of computation where information is processed in a way that has no classical analogue. There are a number of physical platforms conducive to quantum computation, each with a number of advantages and challenges. Single photons, manipulated using integrated linear optics, constitute a promising platform for universal quantum computation. Their low decoherence rates make them particularly favourable, however the inability to perform deterministic two-qubit gates and the issue of photon loss are challenges that need to be overcome. In this thesis we explore the construction of a linear optical quantum computer based on the cluster state model. We identify the different necessary stages: state preparation, cluster state construction and implementation of quantum error correcting codes, and address the challenges that arise in each of these stages. For the state preparation, we propose a series of linear optical circuits for the generation of small entangled states, assessing their performance under different scenarios. For the cluster state construction, we introduce a ballistic scheme which not only consumes an order of magnitude fewer resources than previously proposed schemes, but also benefits from a natural loss tolerance. Based on this scheme, we propose a full architectural blueprint with fixed physical depth. We make investigations into the resource efficiency of this architecture and propose a new multiplexing scheme which optimises the use of resources. Finally, we study the integration of quantum error-correcting codes in the linear optical scheme proposed and suggest three ways in which the linear optical scheme can be made fault-tolerant.
Quantum computing is an exciting field that promises great improvements to our ability to solve certain intractable classes of problem. Implementing a quantum computer will require a physical system in which quantum effects are strongly evident. Many different physical systems have been proposed for this task, including ion traps, quantum dots, neutral atoms and photons. This thesis focuses on optical implementations of a quantum computer, and specifically on single-photon designs, as opposed to those utilising coherent states. Photonic systems have shown a great deal of promise for quantum computing tasks since it was shown by Knill, Laflamme and Milburn (KLM) that scalable efficient quantum computing could be performed using only linear optical elements and measurement. This was made viable through the use of error-correcting codes. The work in this thesis covers the use of error-correcting codes in single-photon linear optics quantum computing (LOQC). The central feature of these schemes is the parity code introduced by KLM and used to overcome the gate errors that are inherent in this type of LOQC. First is a discussion of an improved scheme that incorporates the fusion gates used in Browne and Rudolph's cluster state proposal in order to simplify the encoding and gate procedures. This results in high-probability gates with a resource usage comparable to the cluster state schemes. The remainder of the thesis examines the application of further error correcting codes to handle other errors that may arise in any practical implementation of an optical quantum computer. The most significant type of error in any optical system is photon loss, and hence an extension of the parity code is presented that allows loss errors to be detected and corrected. Procedures for performing universal quantum computation whilst employing this encoding are also described. These enable the establishment of loss thresholds for parity-state based LOQC, revealing this code is capable of handling up to 10\% loss in all elements during general computation, or 17\% if it is used solely as an active memory. Although loss is the most common type of optical error, other types of error will also become an issue when attempting to produce large quantum computing systems. An analysis of the error thresholds and resource usage which can be expected when applying a general error correcting code such as the Steane code to this type of LOQC system is also presented. The error thresholds and resource requirements established are greater than those found for cat state optical quantum computing, but fall below those calculated for cluster states. However, the resource requirements of the scheme are significantly smaller than the cluster state requirements for an equivalent circuit. Finally, a new experiment is proposed, achievable with today's technology, for testing the loss-tolerant encoding described earlier. Expansions of the experiment that would demonstrate tolerance of actual experimental error are also discussed.
We use a combination of analytical and numerical techniques to calculate the noise threshold and resource requirements for a linear optical quantum computing scheme based on parity-state encoding. Parity-state encoding is used at the lowest level of code concatenation in order to efficiently correct errors arising from the inherent nondeterminism of two-qubit linear-optical gates. When combined with teleported error-correction (using either a Steane or Golay code) at higher levels of concatenation, the parity-state scheme is found to achieve a saving of approximately three orders of magnitude in resources when compared to the cluster state scheme, at a cost of a somewhat reduced noise threshold.
We propose a novel architecture for fault-tolerant quantum computing that incorporates strong single-photon nonlinearities into a photonic GHZ-measurement-based architecture. The nonlinearities substantially reduce resource overheads compared to conventional linear-optics-based architectures, which require significant redundancy to accommodate probabilistic photon generation and probabilistic entangling operations. By removing linear-optical failure modes, our nonlinear architecture can also tolerate much higher optical losses than linear approaches, with a baseline loss tolerance of $\sim$12\% using a 32-photon resource state and a foliated surface code. Nonlinear photonic architectures provide a route to dramatically improving practical implementations of fault-tolerant quantum computing.
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.
A heavy focus for optical quantum computing is the introduction of error correction, and the minimization of resource requirements. We detail a complete encoding and manipulation scheme designed for circuit-model linear optics quantum computing, incorporating scalable operations and loss-tolerant architecture. We also calculate loss thresholds for the gate systems described, with an efficiency of 83 required for the single-qubit operations, and 90 for the two-qubit controlled-NOT gate.