3,087 research outputs found
A Software Methodology for Compiling Quantum Programs
Quantum computers promise to transform our notions of computation by offering
a completely new paradigm. To achieve scalable quantum computation, optimizing
compilers and a corresponding software design flow will be essential. We
present a software architecture for compiling quantum programs from a
high-level language program to hardware-specific instructions. We describe the
necessary layers of abstraction and their differences and similarities to
classical layers of a computer-aided design flow. For each layer of the stack,
we discuss the underlying methods for compilation and optimization. Our
software methodology facilitates more rapid innovation among quantum algorithm
designers, quantum hardware engineers, and experimentalists. It enables
scalable compilation of complex quantum algorithms and can be targeted to any
specific quantum hardware implementation
From Ans\"atze to Z-gates: a NASA View of Quantum Computing
For the last few years, the NASA Quantum Artificial Intelligence Laboratory
(QuAIL) has been performing research to assess the potential impact of quantum
computers on challenging computational problems relevant to future NASA
missions. A key aspect of this research is devising methods to most effectively
utilize emerging quantum computing hardware. Research questions include what
experiments on early quantum hardware would give the most insight into the
potential impact of quantum computing, the design of algorithms to explore on
such hardware, and the development of tools to minimize the quantum resource
requirements. We survey work relevant to these questions, with a particular
emphasis on our recent work in quantum algorithms and applications, in
elucidating mechanisms of quantum mechanics and their uses for quantum
computational purposes, and in simulation, compilation, and physics-inspired
classical algorithms. To our early application thrusts in planning and
scheduling, fault diagnosis, and machine learning, we add thrusts related to
robustness of communication networks and the simulation of many-body systems
for material science and chemistry. We provide a brief update on quantum
annealing work, but concentrate on gate-model quantum computing research
advances within the last couple of years.Comment: 20 pages plus extensive references, 3 figure
A quantum compiler for qudits of prime dimension greater than 3
Prevailing proposals for the first generation of quantum computers make use
of 2-level systems, or qubits, as the fundamental unit of quantum information.
However, recent innovations in quantum error correction and magic state
distillation protocols demonstrate that there are advantages of using d-level
quantum systems, known as \emph{qudits}, over the qubit analogues. When
designing a quantum architecture, it is crucial to consider protocols for
compilation, the optimal conversion of high-level instructions used by
programmers into low-level instructions interpreted by the machine. In this
work, we present a general purpose automated compiler for multiqudit exact
synthesis based on previous work on qubits that uses an algebraic
representation of quantum circuits called phase polynomials. We assume Clifford
gates are low-cost and aim to minimise the number of M gates in a Clifford+M
circuit, where M is the qudit analog for the qubit T or pi/8 phase gate. A
surprising result that showcases our compiler's capabilities is that we found a
unitary implementation of the CCZ or Toffoli gate that uses 4 M gates, which
compares to 7 T gates for the qubit analogue
Complex instruction set computing architecture for performing accurate quantum rotations with less magic
We present quantum protocols for executing arbitrarily accurate
rotations of a qubit about its axis. Reduced instruction set computing
(\textsc{risc}) architectures typically restrict the instruction set to
stabilizer operations and a single non-stabilizer operation, such as
preparation of a "magic" state from which gates can be
teleported. Although the overhead required to distill high-fidelity copies of
this magic state is high, the subsequent quantum compiling overhead to realize
rotations in a \textsc{risc} architecture can be much greater. We develop a
complex instruction set computing (\textsc{cisc}) architecture whose
instruction set includes stabilizer operations and preparation of magic states
from which gates can be teleported, for . This results in a substantial overall reduction in the number
of gates required to achieve a desired gate accuracy for rotations. The key
to our construction is a family of shortened quantum Reed-Muller codes of
length , whose magic-state distillation threshold shrinks with
but is greater than 0.85% for .Comment: 13 pages, 4 figures. Resource metric now non-Clifford states.
Comparison now to Meier-Eastin-Knill distillation and (optimal) Selinger
compiling. Minor tweaks made to concatenated teleportation analysi
ScaffCC: Scalable Compilation and Analysis of Quantum Programs
We present ScaffCC, a scalable compilation and analysis framework based on
LLVM, which can be used for compiling quantum computing applications at the
logical level. Drawing upon mature compiler technologies, we discuss
similarities and differences between compilation of classical and quantum
programs, and adapt our methods to optimizing the compilation time and output
for the quantum case. Our work also integrates a reversible-logic synthesis
tool in the compiler to facilitate coding of quantum circuits. Lastly, we
present some useful quantum program analysis scenarios and discuss their
implications, specifically with an elaborate discussion of timing analysis for
critical path estimation. Our work focuses on bridging the gap between
high-level quantum algorithm specifi- cations and low-level physical
implementations, while providing good scalability to larger and more
interesting problemsComment: Journal of Parallel Computing (PARCO
OpenQL : A Portable Quantum Programming Framework for Quantum Accelerators
With the potential of quantum algorithms to solve intractable classical
problems, quantum computing is rapidly evolving and more algorithms are being
developed and optimized. Expressing these quantum algorithms using a high-level
language and making them executable on a quantum processor while abstracting
away hardware details is a challenging task. Firstly, a quantum programming
language should provide an intuitive programming interface to describe those
algorithms. Then a compiler has to transform the program into a quantum
circuit, optimize it and map it to the target quantum processor respecting the
hardware constraints such as the supported quantum operations, the qubit
connectivity, and the control electronics limitations. In this paper, we
propose a quantum programming framework named OpenQL, which includes a
high-level quantum programming language and its associated quantum compiler. We
present the programming interface of OpenQL, we describe the different layers
of the compiler and how we can provide portability over different qubit
technologies. Our experiments show that OpenQL allows the execution of the same
high-level algorithm on two different qubit technologies, namely
superconducting qubits and Si-Spin qubits. Besides the executable code, OpenQL
also produces an intermediate quantum assembly code (cQASM), which is
technology-independent and can be simulated using the QX simulator
Two-step approach to scheduling quantum circuits
As the effort to scale up existing quantum hardware proceeds, it becomes
necessary to schedule quantum gates in a way that minimizes the number of
operations. There are three constraints that have to be satisfied: the order or
dependency of the quantum gates in the specific algorithm, the fact that any
qubit may be involved in at most one gate at a time, and the restriction that
two-qubit gates are implementable only between connected qubits. The last
aspect implies that the compilation depends not only on the algorithm, but also
on hardware properties like connectivity. Here we suggest a two-step approach
in which logical gates are initially scheduled neglecting connectivity
considerations, while routing operations are added at a later step in a way
that minimizes their overhead. We rephrase the subtasks of gate scheduling in
terms of graph problems like edge-coloring and maximum subgraph isomorphism.
While this approach is general, we specialize to a one dimensional array of
qubits to propose a routing scheme that is minimal in the number of exchange
operations. As a practical application, we schedule the Quantum Approximate
Optimization Algorithm in a linear geometry and quantify the reduction in the
number of gates and circuit depth that results from increasing the efficacy of
the scheduling strategies.Comment: Edited text. Added figure summarizing the two-step approac
Extracting Success from IBM's 20-Qubit Machines Using Error-Aware Compilation
NISQ (Noisy, Intermediate-Scale Quantum) computing requires error mitigation
to achieve meaningful computation. Our compilation tool development focuses on
the fact that the error rates of individual qubits are not equal, with a goal
of maximizing the success probability of real-world subroutines such as an
adder circuit. We begin by establishing a metric for choosing among possible
paths and circuit alternatives for executing gates between variables placed far
apart within the processor, and test our approach on two IBM 20-qubit systems
named Tokyo and Poughkeepsie. We find that a single-number metric describing
the fidelity of individual gates is a useful but imperfect guide. Our compiler
uses this subsystem and maps complete circuits onto the machine using a beam
search-based heuristic that will scale as processor and program sizes grow. To
evaluate the whole compilation process, we compiled and executed adder
circuits, then calculated the KL-divergence (a measure of the distance between
two probability distributions). For a circuit within the capabilities of the
hardware, our compilation increases estimated success probability and reduces
KL-divergence relative to an error-oblivious placement.Comment: 15 pages, 18figure
A framework for exact synthesis
Exact synthesis is a tool used in algorithms for approximating an arbitrary
qubit unitary with a sequence of quantum gates from some finite set. These
approximation algorithms find asymptotically optimal approximations in
probabilistic polynomial time, in some cases even finding the optimal solution
in probabilistic polynomial time given access to an oracle for factoring
integers. In this paper, we present a common mathematical structure underlying
all results related to the exact synthesis of qubit unitaries known to date,
including Clifford+T, Clifford-cyclotomic and V-basis gate sets, as well as
gates sets induced by the braiding of Fibonacci anyons in topological quantum
computing. The framework presented here also provides a means to answer
questions related to the exact synthesis of unitaries for wide classes of other
gate sets, such as Clifford+T+V and SU(2) level k anyons.Comment: 40 pages, preliminary versio
QAOA for Max-Cut requires hundreds of qubits for quantum speed-up
Computational quantum technologies are entering a new phase in which noisy
intermediate-scale quantum computers are available, but are still too small to
benefit from active error correction. Even with a finite coherence budget to
invest in quantum information processing, noisy devices with about 50 qubits
are expected to experimentally demonstrate quantum supremacy in the next few
years. Defined in terms of artificial tasks, current proposals for quantum
supremacy, even if successful, will not help to provide solutions to practical
problems. Instead, we believe that future users of quantum computers are
interested in actual applications and that noisy quantum devices may still
provide value by approximately solving hard combinatorial problems via hybrid
classical-quantum algorithms. To lower bound the size of quantum computers with
practical utility, we perform realistic simulations of the Quantum Approximate
Optimization Algorithm and conclude that quantum speedup will not be
attainable, at least for a representative combinatorial problem, until several
hundreds of qubits are available
- …