Based on amplitude character of quantum Rabi oscillation driven by coherent field we show that there exists an upper bound to logic complexity of quantum circuit. We introduce a parameter called single-qubit logic complexity and estimate its decoherence limit in a reasonable case. The analysis show that a generally accepted constant threshold of the threshold theorem limits the logic complexity to so small a number that even a typical construction of fault-tolerant quantum Toffoli gate can hardly be implemented reliably. This result suggests that the construction of feasible fault-tolerant quantum gates is still an arduous task.
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.
This paper shows that quantum computation can be made fault-tolerant against errors and inaccuracies when
η, the probability for an error in a qubit or a gate, is smaller than a constant threshold
ηc. This result improves on Shor's result [Proceedings of the 37th Symposium on the Foundations of Computer Science, IEEE, Los Alamitos, CA, 1996, pp. 56–65], which shows how to perform fault-tolerant quantum computation when the error rate
η decays polylogarithmically with the size of the computation, an assumption which is physically unreasonable. The cost of making the quantum circuit fault-tolerant in our construction is polylogarithmic in time and space. Our result holds for a very general local noise model, which includes probabilistic errors, decoherence, amplitude damping, depolarization, and systematic inaccuracies in the gates. Moreover, we allow exponentially decaying correlations between the errors both in space and in time. Fault-tolerant computation can be performed with any universal set of gates. The result also holds for quantum particles with
p>2 states, namely, p-qudits, and is also generalized to one-dimensional quantum computers with only nearest-neighbor interactions. No measurements, or classical operations, are required during the quantum computation. We estimate the threshold of our construction to be
ηc≃10−6, in the best case. By this we show that local noise is in principle not an obstacle for scalable quantum computation. The main ingredient of our proof is the computation on states encoded by a quantum error correcting code (QECC). To this end we introduce a special class of Calderbank–Shor–Steane (CSS) codes, called polynomial codes (the quantum analogue of Reed–Solomon codes). Their nice algebraic structure allows all of the encoded gates to be transversal. We also provide another version of the proof which uses more general CSS codes, but its encoded gates are slightly less elegant. To achieve fault tolerance, we encode the quantum circuit by another circuit by using one of these QECCs. This step is repeated polyloglog many times, each step slightly improving the effective error rate, to achieve the desired reliability. The resulting circuit exhibits a hierarchical structure, and for the analysis of its robustness we borrow terminology from Khalfin and Tsirelson [Found. Phys., 22 (1992), pp. 879–948] and Gács [Advances in Computing Research: A Research Annual: Randomness and Computation, JAI Press, Greenwich, CT, 1989]. The paper is to a large extent self-contained. In particular, we provide simpler proofs for many of the known results we use, such as the fact that it suffices to correct for bit-flips and phase-flips, the correctness of CSS codes, and the fact that two-qubit gates are universal, together with their extensions to higher-dimensional particles. We also provide full proofs of the universality of the sets of gates we use (the proof of universality was missing in Shor's paper). This paper thus provides a self-contained and complete proof of universal fault-tolerant quantum computation in the presence of local noise.
Quantum computers store and manipulate information in individual quantized energy levels. These devices, not yet realized in their full potential, have the ability to perform certain computational tasks more efficiently than any classical computer. One possible way to implement a quantum computer is to use superconducting circuits controlled by single-mode electromagnetic fields. These circuits constitute the physical quantum bits, or qubits, that are used to store quantum information. A complete, fault-tolerant quantum computer potentially consists of at least millions of physical qubits which are grouped to form fault-tolerant logical qubits. Controlling each physical qubit individually requires a great amount of energy, and hence a future challenge is to reduce the energy consumption in qubit control while maintaining the high precision. In this thesis, we derive a fundamental upper bound for the gate fidelity of a single-qubit not gate implemented with a single resonant driving pulse. It is shown that the upper bound approaches unity inversely proportionally to the increasing mean photon number of the pulse. Furthermore, we find that the upper bound is achieved with an optimal superposition of squeezed states. The typically employed coherent state produces twice as high gate error as the corresponding optimal state. In addition, we present and numerically study a correction protocol that allows using the same drive state for multiple qubit operations. This sustained state is refreshed by sequentially coupling ancillary qubits to it, effectively resetting it and removing entanglement with the previously operated qubits. Thus our protocol allows using the same drive state to implement not gates for different qubits indefinitely, and hence provides a possible route to energy-efficient large-scale quantum computing.
We simulate the implementation of a
T gate, or $\frac{\ensuremath{\pi}}{8}$ gate, for a [7,1,3] encoded logical qubit in a nonequiprobable error environment. We demonstrate that the use of certain non-fault-tolerant methods in the implementation may nevertheless enable reliable quantum computation while reducing basic resource consumption. Reliability is determined by calculating gate fidelities for the one-qubit logical gate. Specifically, we show that despite using a non-fault-tolerant procedure in constructing a logical zero ancilla to implement the
T gate, the gate fidelity of the logical gate, after perfect error correction, has no first order error terms. Meaning, any errors that may have occurred during implementation are ``correctable'' and fault tolerance may still be achieved.
A major challenge in practical quantum computation is the ineludible errors caused by the interaction of quantum systems with their environment. Fault-tolerant schemes, in which logical qubits are encoded by several physical qubits, enable to the output of a higher probability of correct logical qubits under the presence of errors. However, strict requirements to encode qubits and operators render the implementation of a full fault-tolerant computation challenging even for the achievable noisy intermediate-scale quantum technology. Especially the threshold for fault-tolerant computation still lacks experimental verification. Here, based on an all-optical setup, we experimentally demonstrate the existence of the threshold for the fault-tolerant protocol. Four physical qubits are represented as the spatial modes of two entangled photons, which are used to encode two logical qubits. The experimental results clearly show that when the error rate is below the threshold, the probability of correct output in the circuit, formed with fault-tolerant gates, is higher than that in the corresponding non-encoded circuit. In contrast, when the error rate is above the threshold, no advantage is observed in the fault-tolerant implementation. The developed high-accuracy optical system may provide a reliable platform to investigate error propagation in more complex circuits with fault-tolerant gates.