The exponential and Gaussian functions are among the most fundamental and important operations, appearing ubiquitously throughout all areas of science, engineering, and mathematics. Whereas formally, it is well-known that any function may in principle be realized on a quantum computer, in practice present-day algorithms tend to be very expensive. In this work, we present algorithms for evaluating exponential and Gaussian functions efficiently on quantum computers. The implementations require a (generally) small number of multiplications, which represent the overall computational bottleneck. For a specific, realistic NISQ application, the Toffoli count of the exponential function is found to be reduced from 15,690 down to 912, when compared against a state-of-the art competing method by Häner and coworkers [arXiv:1805.12445], under the most favorable conditions for each method. For the corresponding Gaussian function comparison, the Toffoli count is reduced from 19,090 down to 704. Space requirements are also quite modest, to the extent that the aforementioned NISQ application can be implemented with as few as 71 logical qubits. More generally, the methods presented here could also be equally well applied in a fault-tolerant context, using error-corrected multiplications, etc.
The exponential and Gaussian functions are among the most fundamental and important operations, appearing ubiquitously throughout all areas of science, engineering, and mathematics. Whereas formally, it is well-known that any function may in principle be realized on a quantum computer, in practice present-day algorithms tend to be very expensive. In this work, we present algorithms for evaluating exponential and Gaussian functions efficiently on quantum computers. The implementations require a (generally) small number of multiplications, which represent the overall computational bottleneck. For a specific, realistic NISQ application, the Toffoli count of the exponential function is found to be reduced from 15,690 down to 912, when compared against a state-of-the art competing method by Häner and coworkers [arXiv:1805.12445], under the most favorable conditions for each method. For the corresponding Gaussian function comparison, the Toffoli count is reduced from 19,090 down to 704. Space requirements are also quite modest, to the extent that the aforementioned NISQ application can be implemented with as few as 71 logical qubits. More generally, the methods presented here could also be equally well applied in a fault-tolerant context, using error-corrected multiplications, etc.
Quantum algorithms for scientific computing require modules implementing fundamental functions, such as the square root, the logarithm, and others. We require algorithms that have a well-controlled numerical error, that are uniformly scalable and reversible (unitary), and that can be implemented efficiently. We present quantum algorithms and circuits for computing the square root, the natural logarithm, and arbitrary fractional powers. We provide performance guarantees in terms of their worst-case accuracy and cost. We further illustrate their performance by providing tests comparing them to the respective floating point implementations found in widely used numerical software.
Efficient quantum realizations of arithmetic operations, such as multiplication/division, addition/subtraction, square root, and arcsine — are of utmost importance for several quantum algorithms of practical importance. In the literature, such implementations are reported with the objective of minimizing qubit count, Toffoli/T/CNOT gate count, logical depth, quantum volume, and other commonly used metrics. By extending the realm of quantum states to higher dimensions, it has been demonstrated recently that intermediate qutrits can be leveraged to reduce ancilla qubits, thereby reducing qubit count. In this paper, we have incorporated this approach to prepare efficient implementation for several quantum arithmetic operations, obtaining significantly lowered qubit count. As an exemplary application, we study derivative pricing, in which, quantum arithmetic circuits are necessary for path loading using the re-parameterization method, as well as the payoff calculation. The intermediate qutrit approach requires to access higher energy levels, making the design prone to errors. Nevertheless, we show that the overall decrease in the error probability of error is significant owing to the fact that we achieve circuit robustness compared to the qubit-only approach in this NISQ era. We also study how we may achieve possible effectiveness with fewer gate counts of the proposed approach in the fault-tolerant setting.
Abstract An important part of reaping computational advantage from a quantum computer is to reduce the quantum resources needed to implement a desired quantum algorithm. Quantum algorithms that are too large to be practical on noisy intermediate scale quantum devices will require fault-tolerant error correction. This work focuses on reducing the physical cost of implementing quantum algorithms when using the state-of-the-art fault-tolerant quantum error correcting codes, in particular, those for which implementing the T gate consumes vastly more resources than the other gates in the gate set. More specifically, in this paper we consider the group of unitaries that can be exactly implemented by a quantum circuit consisting of the Clifford + T gate set. The Clifford + T gate set is a universal gate set and in this group, using state-of-the-art surface codes, the T gate is by far the most expensive component to implement fault-tolerantly. So it is important to minimize the number of T gates necessary for a fault-tolerant implementation. Our primary interest is to compute a circuit for a given n -qubit unitary U , using the minimum possible number of T gates (called the T-count of unitary U ). We consider the problem COUNT-T, the optimization version of which aims to find the T-count of U . In its decision version the goal is to decide if the T-count is at most some positive integer m . Given an oracle for COUNT-T, we can compute a T-count-optimal circuit in time polynomial in the T-count and dimension of U . We give a provable classical algorithm that solves COUNT-T (decision) in time O N 2 ( c − 1 ) ⌈ m c ⌉ p o l y ( m , N ) and space O N 2 ⌈ m c ⌉ p o l y ( m , N ) , where N = 2 n and c ⩾ 2. This gives a space-time trade-off for solving this problem with variants of meet-in-the-middle techniques. We also introduce an asymptotically faster multiplication method that shaves a factor of N 0.7457 off of the overall complexity. Lastly, beyond our improvements to the rigorous algorithm, we give a heuristic algorithm that outputs a T-count-optimal circuit and has space and time complexity poly( m , N ), under some assumptions. In our heuristic algorithm we developed a novel way of pruning the search space. While our heuristic method still scales exponentially with the number of qubits (though with a lower exponent), there is a large improvement by going from exponential to polynomial scaling with m . We implemented our heuristic algorithm with up to 4 qubit unitaries and obtained a significant improvement in time. For all benchmark and random unitaries we studied, the T-count returned by our algorithm is at most the T-count of their circuits shown in previous papers.
Quantum algorithms for scientific computing require modules implementing fundamental functions, such as the square root, the logarithm, and others. We require algorithms that have a well-controlled numerical error, that are uniformly scalable and reversible (unitary), and that can be implemented efficiently. We present quantum algorithms and circuits for computing the square root, the natural logarithm, and arbitrary fractional powers. We provide performance guarantees in terms of their worst-case accuracy and cost. We further illustrate their performance by providing tests comparing them to the respective floating point implementations found in widely used numerical software.
Quantum computers hold the promise to solve some hard problems that are intractable for even the most powerful current supercomputers. One of the most famous examples is Shor's algorithm for factorizing large numbers, which has exponential speedup compared to its best classical counterparts. However, running such an algorithm will require to build a large-scale quantum computer consisting of thousands or even millions of qubits that include quantum error correction (QEC) and fault-tolerant (FT) mechanisms. Quantum computing is already a reality with the so-called Noisy Intermediate-Scale Quantum (NISQ) processors, some of them available in the cloud. Noisy refers to the imperfect control over the qubits and intermediate-scale to the relatively low number of quits (from fifty to a few hundred). Although current and near-term quantum devices will not have enough qubits for implementing large and fully corrected quantum computations, the use of small quantum error correction codes may extend the computation lifetime of NISQ devices. In this context and as a first step, it is important to test and demonstrate the fault-tolerance of these QEC codes. In this thesis, we explore the fault-tolerance of two small quantum correction codes that are good candidates to be applied to NISQ processors, the [[4,2,2]] code and the [[7,1,3]] Steane code. To this purpose, by following the FT criterion prosed by Daniel Gottesman in 2016, we tested both codes using two simulators, the stabilizer formalism simulator that includes quite simple error models and a full density matrix simulator called quantumsim, which includes more realistic noise. The simulations are performed under reasonable noise parameter values. For the [[4,2,2]] code, 235 circuits are tested based on the two simulators. The results show that in the stabilizer formalism simulation, the FT criterion is satised for all circuits, while not fully satisfied in the full density matrix simulation. For the [[7,1,3]] Steane code, we use a parallel-flag error correction implementation which is tested using the full density matrix simulator. Our results show that without applying any QEC cycle, for all circuits (84 circuits for 1 logical qubit simulation and 452 circuits for 2 logical qubits simulation), the error rate of the encoded circuits is lower than the unencoded ones. Adding a quantum error correction (QEC) cycle will in general increase the error rate of the computation.
The first-principles quantum simulation of the full electronic Hamiltonian of a material model of realistic size appears daunting even in a future era of fully fault-tolerant quantum computers. In contrast, classical simulations of material excited states rely on heuristic quasiparticle frameworks, such as the GW approximation and Bethe-Salpeter equation, where only a few quasiparticles are explicitly considered. Here we give a detailed description of quasiparticle quantum simulation for multi-excitonic states within the BSE. We develop an explicit first-quantized, orbital-based block encoding of the multi-exciton BSE Hamiltonian for qubitization, and reduce its cost using integral factorization and crystal symmetries. For a materials model of size N, and a fixed number of quasiparticles, the resulting algorithms require O(N) Toffoli gates and O(logN) logical qubits, or, using space-time tradeoffs, O(N) Toffoli gates and O(N) logical qubits, achieving up to a sixth power reduction in Toffoli count, or up to exponential reduction in qubit count, versus standard full Hamiltonian simulation techniques that have been explored in materials simulation. Resource estimates for the classically challenging problem of triexcitonic eigenvalue estimation across a range of semiconductor models of a realistic physical size of O(103) atoms, show that our Toffoli-optimized implementation reduces the Toffoli count by 106−107 relative to full Hamiltonian simulation estimates, while a qubit-optimized implementation requires only a few hundred logical qubits. More broadly, these results show that classical heuristic frameworks will be essential in the design of future fault-tolerant quantum algorithms for materials.