1,366 research outputs found
Quantum Algorithm Implementations for Beginners
As quantum computers become available to the general public, the need has
arisen to train a cohort of quantum programmers, many of whom have been
developing classical computer programs for most of their careers. While
currently available quantum computers have less than 100 qubits, quantum
computing hardware is widely expected to grow in terms of qubit count, quality,
and connectivity. This review aims to explain the principles of quantum
programming, which are quite different from classical programming, with
straightforward algebra that makes understanding of the underlying fascinating
quantum mechanical principles optional. We give an introduction to quantum
computing algorithms and their implementation on real quantum hardware. We
survey 20 different quantum algorithms, attempting to describe each in a
succinct and self-contained fashion. We show how these algorithms can be
implemented on IBM's quantum computer, and in each case, we discuss the results
of the implementation with respect to differences between the simulator and the
actual hardware runs. This article introduces computer scientists, physicists,
and engineers to quantum algorithms and provides a blueprint for their
implementations
Simulating chemistry efficiently on fault-tolerant quantum computers
Quantum computers can in principle simulate quantum physics exponentially
faster than their classical counterparts, but some technical hurdles remain.
Here we consider methods to make proposed chemical simulation algorithms
computationally fast on fault-tolerant quantum computers in the circuit model.
Fault tolerance constrains the choice of available gates, so that arbitrary
gates required for a simulation algorithm must be constructed from sequences of
fundamental operations. We examine techniques for constructing arbitrary gates
which perform substantially faster than circuits based on the conventional
Solovay-Kitaev algorithm [C.M. Dawson and M.A. Nielsen, \emph{Quantum Inf.
Comput.}, \textbf{6}:81, 2006]. For a given approximation error ,
arbitrary single-qubit gates can be produced fault-tolerantly and using a
limited set of gates in time which is or ; with sufficient parallel preparation of ancillas, constant average
depth is possible using a method we call programmable ancilla rotations.
Moreover, we construct and analyze efficient implementations of first- and
second-quantized simulation algorithms using the fault-tolerant arbitrary gates
and other techniques, such as implementing various subroutines in constant
time. A specific example we analyze is the ground-state energy calculation for
Lithium hydride.Comment: 33 pages, 18 figure
A Quantum Algorithm To Locate Unknown Hashes For Known N-Grams Within A Large Malware Corpus
Quantum computing has evolved quickly in recent years and is showing
significant benefits in a variety of fields. Malware analysis is one of those
fields that could also take advantage of quantum computing. The combination of
software used to locate the most frequent hashes and -grams between benign
and malicious software (KiloGram) and a quantum search algorithm could be
beneficial, by loading the table of hashes and -grams into a quantum
computer, and thereby speeding up the process of mapping -grams to their
hashes. The first phase will be to use KiloGram to find the top- hashes and
-grams for a large malware corpus. From here, the resulting hash table is
then loaded into a quantum machine. A quantum search algorithm is then used
search among every permutation of the entangled key and value pairs to find the
desired hash value. This prevents one from having to re-compute hashes for a
set of -grams, which can take on average time, whereas the quantum
algorithm could take in the number of table lookups to find the
desired hash values.Comment: IEEE Quantum Week 2020 Conferenc
Adaptive weight estimator for quantum error correction
Quantum error correction of a surface code or repetition code requires the
pairwise matching of error events in a space-time graph of qubit measurements,
such that the total weight of the matching is minimized. The input weights
follow from a physical model of the error processes that affect the qubits.
This approach becomes problematic if the system has sources of error that
change over time. Here we show how the weights can be determined from the
measured data in the absence of an error model. The resulting adaptive decoder
performs well in a time-dependent environment, provided that the characteristic
time scale of the variations is greater than , with the duration of one error-correction cycle and
the typical error probability per qubit in one cycle.Comment: 5 pages, 4 figure
Statistical Assertions for Validating Patterns and Finding Bugs in Quantum Programs
In support of the growing interest in quantum computing experimentation,
programmers need new tools to write quantum algorithms as program code.
Compared to debugging classical programs, debugging quantum programs is
difficult because programmers have limited ability to probe the internal states
of quantum programs; those states are difficult to interpret even when
observations exist; and programmers do not yet have guidelines for what to
check for when building quantum programs. In this work, we present quantum
program assertions based on statistical tests on classical observations. These
allow programmers to decide if a quantum program state matches its expected
value in one of classical, superposition, or entangled types of states. We
extend an existing quantum programming language with the ability to specify
quantum assertions, which our tool then checks in a quantum program simulator.
We use these assertions to debug three benchmark quantum programs in factoring,
search, and chemistry. We share what types of bugs are possible, and lay out a
strategy for using quantum programming patterns to place assertions and prevent
bugs.Comment: In The 46th Annual International Symposium on Computer Architecture
(ISCA '19). arXiv admin note: text overlap with arXiv:1811.0544
Optimising the Solovay-Kitaev algorithm
The Solovay-Kitaev algorithm is the standard method used for approximating
arbitrary single-qubit gates for fault-tolerant quantum computation. In this
paper we introduce a technique called "search space expansion", which modifies
the initial stage of the Solovay-Kitaev algorithm, increasing the length of the
possible approximating sequences but without requiring an exhaustive search
over all possible sequences. We show that our technique, combined with a GNAT
geometric tree search outputs gate sequences that are almost an order of
magnitude smaller for the same level of accuracy. This therefore significantly
reduces the error correction requirements for quantum algorithms on encoded
fault-tolerant hardware.Comment: 9 page
- …