Computer architectures which exploit quantum mechanical effects can solve computing tasks that are otherwise impossible to perform. A quantum computer operates on a number of small quantum mechanical systems, known as quantum bits, or qubits. Since these systems are realized on the scale of atoms, they are very prone to errors. Errors occur when the environment interacts with the qubits, a process called decoherence. It is widely accepted that it will not be possible to shield qubits completely from the outside world. If one were to perform a quantum computation on the qubits directly, then after a short period of time the information present in the qubits would be lost. To counter decoherence the state of a qubit can be encoded into multiple physical ones. This is called a quantum error correcting code. Performing quantum error correction allows one to extend the life time of the encoded qubit arbitrarily, assuming that the rate of errors remains below a certain threshold value. The use of quantum codes creates an overhead in resources, as for every logical qubit many more physical qubits are needed. The resource overhead for fault-tolerance is problematic, since realizing qubits will be costly, and in the early stages of building quantum computers the number of physical qubits will be limited. The currently favored coding architecture is the toric code and its variant the surface code in which the physical qubits are put on a square grid in which interactions are only between nearest neighbors. In this thesis we will explore quantum codes in which qubits interact as if they were nearest neighbors in more exotic spaces. In the first part we will consider closed surfaces with constant negative curvature. We show how such surfaces can be constructed and enumerate all quantum codes derived from them which have less than 10.000 physical qubits. For codes that are extremal in a certain sense we perform numerical simulations to determine the value of their threshold. Furthermore, we give evidence that these codes can be used for more overhead efficient storage as compared to the surface code by orders of magnitude. We also show how to read and write the encoded qubits while keeping their connectivity low. In the second part we consider codes in which qubits are layed-out according to a four- dimensional geometry. Such codes allow for much simpler decoding schemes compared to codes which are two-dimensional. In particular, measurements do not necessarily have to be repeated to obtain reliable information about the error and the classical hardware performing the error correction is greatly simplified. We perform numerical simulations to analyze the performance of these codes using decoders based on local updates. We also introduce a novel decoder based on techniques from machine learning and image recognition to decode four-dimensional codes.
Computer architectures which exploit quantum mechanical effects can solve computing tasks that are otherwise impossible to perform. A quantum computer operates on a number of small quantum mechanical systems, known as quantum bits, or qubits. Since these systems are realized on the scale of atoms, they are very prone to errors. Errors occur when the environment interacts with the qubits, a process called decoherence. It is widely accepted that it will not be possible to shield qubits completely from the outside world. If one were to perform a quantum computation on the qubits directly, then after a short period of time the information present in the qubits would be lost. To counter decoherence the state of a qubit can be encoded into multiple physical ones. This is called a quantum error correcting code. Performing quantum error correction allows one to extend the life time of the encoded qubit arbitrarily, assuming that the rate of errors remains below a certain threshold value. The use of quantum codes creates an overhead in resources, as for every logical qubit many more physical qubits are needed. The resource overhead for fault-tolerance is problematic, since realizing qubits will be costly, and in the early stages of building quantum computers the number of physical qubits will be limited. The currently favored coding architecture is the toric code and its variant the surface code in which the physical qubits are put on a square grid in which interactions are only between nearest neighbors. In this thesis we will explore quantum codes in which qubits interact as if they were nearest neighbors in more exotic spaces. In the first part we will consider closed surfaces with constant negative curvature. We show how such surfaces can be constructed and enumerate all quantum codes derived from them which have less than 10.000 physical qubits. For codes that are extremal in a certain sense we perform numerical simulations to determine the value of their threshold. Furthermore, we give evidence that these codes can be used for more overhead efficient storage as compared to the surface code by orders of magnitude. We also show how to read and write the encoded qubits while keeping their connectivity low. In the second part we consider codes in which qubits are layed-out according to a four- dimensional geometry. Such codes allow for much simpler decoding schemes compared to codes which are two-dimensional. In particular, measurements do not necessarily have to be repeated to obtain reliable information about the error and the classical hardware performing the error correction is greatly simplified. We perform numerical simulations to analyze the performance of these codes using decoders based on local updates. We also introduce a novel decoder based on techniques from machine learning and image recognition to decode four-dimensional codes.
PhD thesis investigating homological quantum codes derived from curved and higher dimensional geometries. In the first part we will consider closed surfaces with constant negative curvature. We show how such surfaces can be constructed and enumerate all quantum codes derived from them which have less than 10.000 physical qubits. For codes that are extremal in a certain sense we perform numerical simulations to determine the value of their threshold. Furthermore, we give evidence that these codes can be used for more overhead efficient storage as compared to the surface code by orders of magnitude. We also show how to read and write the encoded qubits while keeping their connectivity low. In the second part we consider codes in which qubits are layed-out according to a four- dimensional geometry. Such codes allow for much simpler decoding schemes compared to codes which are two-dimensional. In particular, measurements do not necessarily have to be repeated to obtain reliable information about the error and the classical hardware performing the error correction is greatly simplified. We perform numerical simulations to analyze the performance of these codes using decoders based on local updates. We also introduce a novel decoder based on techniques from machine learning and image recognition to decode four-dimensional codes.
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.
Quantum computing has enormous potential, but this can only be realised if quantum errors can be controlled sufficiently to allow quantum algorithms to be completed reliably. However, quantum-error-corrected logical quantum bits (qubits) which can be said to have achieved meaningful error suppression have not yet been demonstrated. This thesis reports research on several topics related to the challenge of designing fault-tolerant quantum computers. The first topic is a proposal for achieving large-scale error correction with the surface code in a silicon donor based quantum computing architecture. This proposal relaxes some of the stringent requirements in donor placement precision set by previous ideas from the single atom level to the order of 10 nm in some regimes. This is shown by means of numerical simulation of the surface code threshold. The second topic then follows, it is the development of a method for benchmarking and assessing the performance of small error correcting codes in few-qubit systems, introducing a metric called 'integrity' - closely linked to the trace distance -- and a proposal for experiments to demonstrate various stepping stones on the way to 'strictly superior' quantum error correction. Most quantum error correcting codes, including the surface code, do not allow for fault-tolerant universal computation without the addition of extra gadgets. One method of achieving universality is through a process of distilling and then consuming high quality 'magic states'. This process adds additional overhead to quantum computation over and above that incurred by the use of the base level quantum error correction. The latter parts of this thesis report an investigation into how many physical qubits are needed in a `magic state factory' within a surface code quantum computer and introduce a number of techniques to reduce the overhead of leading magic state techniques. It is found that universal quantum computing is achievable with ∼ 16 million qubits if error rates across a device are kept below 10-4. In addition, the thesis introduces improved methods of achieving magic state distillation for unconventional magic states that allow for logical small angle rotations, and show that this can be more efficient than synthesising these operations from the gates provided by traditional magic states.
Quantum computers are far more error-prone than their classical counterparts. Therefore, to build a quantum computer capable of running large-scale quantum algorithms, we must use the techniques of quantum error correction to ensure that the computer produces the correct output even when its components are unreliable. However, the resource requirements of building such a fault-tolerant quantum computer are currently prohibitive. Here, we examine the utility of using three-dimensional (3D) surface codes in a fault-tolerant quantum computer. This family of topological error-correcting codes is a generalization of the well-known 2D surface code to three spatial dimensions. We show that certain 3D surface codes have a transversal logical non-Clifford gate. In a quantum computing architecture, a non-Clifford gate is required to achieve computational universality. Transversal gates do not entangle qubits in different codes, so they are naturally fault tolerant because they do not spread errors. Next, we consider the problem of decoding 3D surface codes. In a quantum error-correcting code, we cannot observe the qubits directly, so we measure parity-check operators to gain information about the state of the code. Decoding is the problem of estimating what error has occurred given a list of unsatisfied parity checks. We observe that 3D surface codes offer asymmetric protection against bit-flip and phase-flip errors, but in both cases, we find that a threshold error rate exists below which we can suppress logical errors by increasing the size of the code. We use our results about logical gates and decoding to propose two fault-tolerant quantum computing architectures that utilize 3D surface codes. Finally, we compare the resource requirements of our architectures with the requirements of leading quantum computing architectures based on topological codes. We find that one of our architectures may be competitive with the leading architectures, depending on the properties of the physical systems used to build the qubits.
Building a quantum computer is a formidable challenge. In this thesis, we focus on two projects, which tackle very different aspects of quantum computation, and yet still share a common goal in hopefully getting us closer to implementing a quantum computer on a large scale. The first project involves a numerical error threshold calculation of a quantum error correcting code called a surface code. These are local check codes, which means that only nearest neighbour interaction is required to determine where errors occurred. This is an important advantage over other approaches, as in many physical systems, doing operations on arbitrarily spaced qubits is often very difficult. An error threshold is a measure of how well a given error correcting scheme performs. It gives the experimentalists an idea of which approaches to error correction hold greater promise. We simulate both toric and planar variations of a surface code, and numerically calculate a threshold value of approximately 6.0times10−3, which is comparable to similar calculations done by others \\cite{Raussendorf2006,Raussendorf2007,Wang2009}. The second project deals with coupling superconducting flux qubits together. It expands the scheme presented in \\cite{Plourde2004} to a three qubit, two coupler scenario. We study L-shaped and line-shaped coupler geometries, and show how the coupling strength changes in terms of the dimensions of the couplers. We explore two cases, the first where the interaction energy between two nearest neighbour qubits is high, while the coupling to the third qubit is as negligible as possible, as well as a case where all the coupling energies are as small as possible. Although only an initial step, a similar scheme can in principle be extended further to implement a lattice required for computation on a surface code.
Quantum computation holds the promise of solving certain complex problems exponentially faster than classical computers. However, the high prevalent noise in current quantum devices impedes the accurate execution of even basic algorithms. This can be remedied by protecting quantum information with a quantum error-correcting code, where the logical information of an algorithmic qubit is spread across multiple physical qubits. Individual quantum errors are then located and corrected by the fault-tolerant measurement of multi-qubit stabilizer operators (parity checks). Unfortunately, error correction and fault tolerance both impose large demands on the qubit overhead: hundreds to thousands of physical qubits per logical qubit.
We reduce the spacetime cost of fault tolerance by redesigning key building blocks of an error-corrected quantum computer. First, we develop a combinatorial proof with flag fault tolerance that exponentially reduces the extra qubits needed to measure a stabilizer of any size, while tolerating one fault. We leverage these proofs to then design state preparation circuits for the Steane and Golay codes with 100% yield. Next, we improve error correction on a planar layout by showing that a distance-four code encoding six logical qubits protects information as well as the distance-five surface code, using one-tenth as many physical qubits. Finally, we optimize the time overhead of logical gates in surface code quantum computers by protecting measurement results with a classical code, cutting computation time by a factor of two to six. Our hardware-agnostic optimizations of fault tolerance overheads thus suggest new routes to advance the timeline of error-free quantum computing.