Probabilistic Fault-Tolerant Universal Quantum Computation and sampling problems in Continuous Variables

During recent years, quantum computers have received increasing attention, primarily due to their ability to significantly increase computational performance for specific problems. Computational performance could be improved for mathematical optimization by quantum annealers. This special type of quantum computer can solve quadratic unconstrained binary optimization problems. However, multi-energy systems optimization commonly involves integer and continuous decision variables. Due to their mixed-integer problem structure, quantum annealers cannot be directly used for multi-energy system optimization.To solve multi-energy system optimization problems, we present a hybrid Benders decomposition approach combining optimization on quantum and classical computers. In our approach, the quantum computer solves the master problem, which involves only the integer variables from the original energy system optimization problem. The subproblem includes the continuous variables and is solved by a classical computer. For better performance, we apply improvement techniques to the Benders decomposition. We test the approach on a case study to design a cost-optimal multi-energy system. While we provide a proof of concept that our Benders decomposition approach is applicable for the design of multi-energy systems, the computational time is still higher than for approaches using classical computers only. We therefore estimate the potential improvement of our approach to be expected for larger and fault-tolerant quantum computers.

This paper shows that quantum computation can be made fault-tolerant against errors and inaccuracies when $\eta$, the probability for an error in a qubit or a gate, is smaller than a constant threshold $\eta_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 $\eta$ 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 $\eta_c\simeq 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.

A quantum computer is a powerful machine that provides a new approach to information processing based on quantum mechanics. However, basically, qubits are very vulnerable to errors, thus a quantum error correction code (QECC) is needed to build a reliable quantum computer. Moreover, simply using QECCs is not sufficient in order that a quantum computer can tolerate errors. In quantum computation, each operation must be performed on the encoded states. Even when the gates used to perform these operations are noisy, the quantum computation must be tolerable to the errors. This is called fault-tolerant quantum computation and it is an essential condition for implementing a quantum computer. However, considering the fault tolerance, the overhead of the quantum computer increases exponentially. In this paper, we introduce fault-tolerant quantum computation and schemes to reduce the its overhead.

Fault-tolerant quantum error correction provides a strategy to protect information processed by a quantum computer against noise which would otherwise corrupt the data. A fault-tolerant universal quantum computer must implement a universal gate set on the logical level in order to perform arbitrary calculations to in principle unlimited precision. In this paper we characterize the recent demonstration of a fault-tolerant universal gate set in a trapped-ion quantum computer [Postler et al., Nature (London) 605, 7911 (2022)] and identify aspects to improve the design of experimental setups to reach an advantage of logical over physical qubit operation. We show that various criteria to assess the break-even point for fault-tolerant quantum operations are within reach for the ion trap quantum computing architecture under consideration. Furthermore, we analyze the influence of crosstalk in entangling gates for logical state preparation circuits. These circuits can be designed to respect fault tolerance for specific microscopic noise models. We find that an experimentally informed depolarizing noise model captures the essential noise dynamics of the fault-tolerant experiment that we consider, and crosstalk is negligible in the currently accessible regime of physical error rates. For deterministic Pauli state preparation, we provide a fault-tolerant unitary logical qubit initialization circuit, which can be realized without in-sequence measurement and feed-forward of classical information. Additionally, we show that nondeterministic state preparation schemes, i.e., repeat until success, for logical Pauli and magic states perform with higher logical fidelity over their deterministic counterparts for the current and anticipated future regime of physical error rates. Our results offer guidance on improvements of physical qubit operations and validate the experimentally informed noise model as a tool to predict logical failure rates in quantum computing architectures based on trapped ions.

One reason why building large-scale quantum computers will be particularly challenging is that quantum computers are far more susceptible to making errors than conventional digital computers. I will explain the principles of quantum error correction and fault-tolerant quantum computation, which can enable a properly designed quantum computer with imperfect components to achieve good reliability. Some recent developments in the theory of quantum fault tolerance will be reviewed, including quantum error-correcting codes for systems described by continuous quantum variables, robust storage of quantum information based on topological principles, and applications of quantum error-correcting codes to quantum cryptography.

In a ground breaking discovery in 1994, Shor has shown that quantum computers, if built, can factor numbers efficiently. Since then quantum computing has become a burgeoning field of research, attracting theoreticians and experimentalists alike, and regrouping researchers from fields like computer science, physics, mathematics and engineering. Quantum information is very fragile and prone to decoherence. Yet by the middle of 1996 it has been shown that fault-tolerant quantum computation is possible. We give a simple description of the elements of quantum error-correction and quantum fault-tolerance. After characterizing quantum errors we present several error correction schemes and outline the elements of a full fledged fault-tolerant computation, which works error-free even though all of its components can be faulty. We also mention alternative approaches to error-correction, so called error-avoiding or decoherence-free schemes.

From the Publisher: This book aims to provide a pedagogical introduction to the subjects of quantum information and computation. Topics include non-locality of quantum mechanics, quantum computation, quantum cryptography, quantum error correction, fault-tolerant quantum computation as well as some experimental aspects of quantum computation and quantum cryptography. Only knowledge of basic quantum mechanics is assumed. Whenever more advanced concepts and techniques are used, they are introduced carefully. This book is meant to be a self-contained overview. While basic concepts are discussed in detail, unnecessary technical details are excluded. It is well-suited for a wide audience ranging from physics graduate students to advanced researchers.

As quantum computing development advances closer toward achieving fault-tolerant error-corrected realisation, debates on applications, impacts, risks, and benefits of quantum computing are timely and due. While there is awareness of the potential power and complexity of quantum computers, there has been relatively little attention on the social impacts and ethical implications of this technology. In grappling with the social impacts of quantum computing, some stakeholders have turned to applied ethics, specifically (classical) computer and Artificial Intelligence (AI) ethics, for guidance. While computer and AI ethics are useful starting points for evaluating the ethical issues posed by quantum computing, uncritically applying existing sets of ethical principles risks overlooking how quantum computing differs from these technologies. We argue that borrowing of ethical principles and guidelines from AI and computing is inappropriate for several reasons: (1) quantum computing, classical computing, and AI are different technologies with significant material differences; (2) unlike AI and classical computers which have become established, quantum computing is an emerging technology, which has implications on the levels of accessibility and immediate impact in society; and (3) there are significant differences in the way AI and quantum computing have been developed and by whom. We also briefly summarise some of the unique risks and societ al impacts posed by quantum computing. We posit that these reasons support the argument for a new sub-field of quantum computing ethics, which would allow a relevant scholarship to develop and provide guidance as quantum computing technology continues to mature.

Continuous-variable measurement-based quantum computation, which requires deterministically generated large-scale cluster states, is a promising candidate for practical, scalable, universal, and fault-tolerant quantum computation. In this work, based on our compact and scalable scheme of generating a two-dimensional spatiotemporal cluster state, a complete architecture including cluster state preparation, gate implementations, and error correction, is proposed. First, a scheme for generating two-dimensional large-scale continuous-variable cluster state by multiplexing both the temporal and spatial domains is proposed. Then, the corresponding gate implementations by gate teleportation are discussed and the actual gate noise from the generated cluster state is considered. After that, the quantum error correction can be further achieved by utilizing the square-lattice Gottesman-Kitaev-Preskill (GKP) code. Finally, a fault-tolerant quantum computation can be realized by introducing bias into the square-lattice GKP code (to protect against phase-flip errors) and concatenating a repetition code (to handle the residual bit-flip errors), with a squeezing threshold of 12.3 dB. Our work provides a possible option for a complete fault-tolerant quantum computation architecture in the future.

<title>Abstract</title> We present a comprehensive end-to-end framework for simulating the real-time dynamics of chemical systems on a fault-tolerant quantum computer, incorporating both electronic and nuclear quantum degrees of freedom. An all-particle simulation is nominally efficient on a quantum computer, but practically infeasible. Hence, central to our approach is the construction of a first-quantized plane-wave algorithm making use of pseudoions. The latter consolidate chemically inactive electrons and the nucleus into a single effective dynamical ionic entity, extending the well-established concept of pseudopotentials in quantum chemistry to a two-body interaction. We explicitly describe efficient quantum circuits for initial state preparation across all degrees of freedom, as well as for block-encoding the Hamiltonian describing interacting pseudoions and chemically active electrons, by leveraging recent advances in quantum rejection sampling to optimize the implementations. To extract useful chemical information, we first design molecular fingerprints by combining density-functional calculations with machine learning techniques, and subsequently validate them through surrogate classical molecular dynamics simulations. These fingerprints are then coherently encoded on a quantum computer for efficient molecular identification via amplitude estimation. We provide an extensive analysis of the cost of running the algorithm on a fault-tolerant quantum computer for several chemically interesting systems. As an illustration, simulating the interaction between NH3 and BF3 (a 40-particle system) requires 808 logical qubits to encode the problem, and approximately 10^11 Toffoli gates per femtosecond of time evolution. Our results establish a foundation for further quantum algorithm development targeting chemical and material dynamics.

Quantum computation can solve certain problems much faster than classical computation. However, quantum computations are more susceptible to errors than conventional digital computations. Thus, a fault-tolerant (FT) quantum circuit design is required for a practical implementation. Quantum circuits consist of a cascade of quantum gates. These gates are themselves realized using primitive quantum operations that are supported by the quantum physical machine description (PMD). As different quantum systems are associated with different Hamiltonians, they have different PMDs. In addition, the quantum cost for implementing a quantum operation may differ from one PMD to another. Thus, a quantum logic circuit needs to be realized with and optimized for the set of primitive quantum operations supported by the given PMD. In this paper, an FT quantum logic synthesis (FTQLS) methodology and tool is described for six different PMDs. A methodology, such as this, which can be targeted at multiple PMDs, has not been attempted before, to the best of our knowledge. The input to FTQLS is an unoptimized quantum circuit realized using a set of commonly used gates and its output is an optimized FT quantum circuit that only comprises of primitive quantum operations supported by the given PMD. FTQLS does technology mapping for different PMDs and then converts non-FT circuits to FT circuits. For technology mapping, it utilizes an optimized quantum gate library targeted at various PMDs that decomposes gates into primitive operations. Efficient conversion to FT circuits is done by integrating two quantum compilers and an FT cache table into FTQLS. For improving the synthesis results, an FT set of gates that is directly supported by each PMD is proposed. Quantum circuit optimization is done by utilizing quantum identity rules. The performance of FTQLS is evaluated using two cost metrics: number of primitive operations (#ops) and execution cycles on the critical path (#cycles). Experiment results show that the decrease in #ops varies between 58.1% and 87.0% and in #cycles between 42.8% and 76.4%, on an average, depending on the PMD.

U(1) lattice gauge theories (LGTs) offer a way to simulate quantum electrodynamics, one of the three forces unified by the Standard Model of particles physics. Here we provide complete, quantum-gate-by-quantum-gate algorithms to simulate U(1) LGTs on a fault-tolerant quantum computer. We further perform rigorous error analysis in order to derive concrete estimates of the quantum computational resources required for an accurate simulation of U(1) LGTs using a second-order product formula. We show that U(1) LGTs in any spatial dimension can be simulated using non-Clifford T gates, where T is the simulation time, N is the number of lattice sites, Λ is the truncation parameter for the bosonic gauge fields, and ε is the simulation error. This work paves the way towards fault-tolerant quantum simulations of physical models closely related to the Standard Model of particle physics.

Stabilizer operations (SO) occupy a prominent role in fault-tolerant quantum computing. They are defined operationally by the use of Clifford gates, Pauli measurements, and classical control. These operations can be efficiently simulated on a classical computer, a result which is known as the Gottesman–Knill theorem. However, an additional supply of magic states is enough to promote them to a universal, fault-tolerant model for quantum computing. To quantify the needed resources in terms of magic states, a resource theory of magic has been developed. SO are considered free within this theory; however, they are not the most general class of free operations. From an axiomatic point of view, these are the completely stabilizer-preserving (CSP) channels, defined as those that preserve the convex hull of stabilizer states. It has been an open problem to decide whether these two definitions lead to the same class of operations. In this work, we answer this question in the negative, by constructing an explicit counter-example. This indicates that recently proposed stabilizer-based simulation techniques of CSP maps are strictly more powerful than Gottesman–Knill-like methods. The result is analogous to a well-known fact in entanglement theory, namely, that there is a gap between the operationally defined class of local operations and classical communication and the axiomatically defined class of separable channels.

In the world of computation, the invention of Computers has reduced human effort for accomplishing task. Depending on the type, size and nature of the work the computers are manufactured in different magnitudes. As the technology grows, it facilitated to manufacture high performing, high throughput, and high memory Classical computers. Classical computers store any information in the form of bits in the memory device, which can be either 1 or 0 (binary system) and all the processing will be done in the same logic i.e., high voltage/low voltage. Because of this logic the classical computers solve some problems by using more resources. Quantum computer are the next level computers which uses quantum theory principles for solving problems. The quantum computer uses Qubit as basic unit which uses principles of quantum computing such as superposition and entanglement, which gives qubit, the efficiency of exhibiting many logical states at a time. This paper shows a comparative study on classical and quantum computers and illustrates various problems in classical computers and respective solutions with use of quantum computers.

Compiling high-level quantum programs to machines that are size constrained (i.e. limited number of quantum bits) and time constrained (i.e. limited number of quantum operations) is challenging. In this paper, we present SQUARE (Strategic QUantum Ancilla REuse), a compilation infrastructure that tackles allocation and reclamation of scratch qubits (called ancilla) in modular quantum programs. At its core, SQUARE strategically performs uncomputation to create opportunities for qubit reuse. Current Noisy Intermediate-Scale Quantum (NISQ) computers and forward-looking Fault-Tolerant (FT) quantum computers have fundamentally different constraints such as data locality, instruction parallelism, and communication overhead. Our heuristic-based ancilla-reuse algorithm balances these considerations and fits computations into resource-constrained NISQ or FT quantum machines, throttling parallelism when necessary. To precisely capture the workload of a program, we propose an improved metric, the "active quantum volume," and use this metric to evaluate the effectiveness of our algorithm. Furthermore, our results show that SQUARE improves the average success rate of NISQ applications by 1.47X. Surprisingly, the additional gates for uncomputation create ancilla with better locality, and result in substantially fewer swap gates and less gate noise overall. SQUARE also achieves an average reduction of 1.5X (and up to 9.6X) in active quantum volume for FT machines.