18 research outputs found
Just Like the Real Thing: Fast Weak Simulation of Quantum Computation
Quantum computers promise significant speedups in solving problems
intractable for conventional computers but, despite recent progress, remain
limited in scaling and availability. Therefore, quantum software and hardware
development heavily rely on simulation that runs on conventional computers.
Most such approaches perform strong simulation in that they explicitly compute
amplitudes of quantum states. However, such information is not directly
observable from a physical quantum computer because quantum measurements
produce random samples from probability distributions defined by those
amplitudes. In this work, we focus on weak simulation that aims to produce
outputs which are statistically indistinguishable from those of error-free
quantum computers. We develop algorithms for weak simulation based on quantum
state representation in terms of decision diagrams. We compare them to using
state-vector arrays and binary search on prefix sums to perform sampling.
Empirical validation shows, for the first time, that this enables mimicking of
physical quantum computers of significant scale.Comment: 6 pages, 4 figure
Approximation of Quantum States Using Decision Diagrams
The computational power of quantum computers poses major challenges to new
design tools since representing pure quantum states typically requires
exponentially large memory. As shown previously, decision diagrams can reduce
these memory requirements by exploiting redundancies. In this work, we
demonstrate further reductions by allowing for small inaccuracies in the
quantum state representation. Such inaccuracies are legitimate since quantum
computers themselves experience gate and measurement errors and since quantum
algorithms are somewhat resistant to errors (even without error correction). We
develop four dedicated schemes that exploit these observations and effectively
approximate quantum states represented by decision diagrams. We empirically
show that the proposed schemes reduce the size of decision diagrams by up to
several orders of magnitude while controlling the fidelity of approximate
quantum state representations
Handling Non-Unitaries in Quantum Circuit Equivalence Checking
Quantum computers are reaching a level where interactions between classical
and quantum computations can happen in real-time. This marks the advent of a
new, broader class of quantum circuits: dynamic quantum circuits. They offer a
broader range of available computing primitives that lead to new challenges for
design tasks such as simulation, compilation, and verification. Due to the
non-unitary nature of dynamic circuit primitives, most existing techniques and
tools for these tasks are no longer applicable in an out-of-the-box fashion. In
this work, we discuss the resulting consequences for quantum circuit
verification, specifically equivalence checking, and propose two different
schemes that eventually allow to treat the involved circuits as if they did not
contain non-unitaries at all. As a result, we demonstrate methodically, as well
as, experimentally that existing techniques for verifying the equivalence of
quantum circuits can be kept applicable for this broader class of circuits.Comment: 7 pages, 4 figures, old title: "Towards Verification of Dynamic
Quantum Circuits", revised manuscript, added experimental result
Debugging of Toffoli networks
Abstract—Intensive research is performed to find post-CMOS technologies. A very promising direction based on reversible logic are quantum computers. While in the domain of reversible logic synthesis, testing, and verification have been investigated, debugging of reversible circuits has not yet been considered. The goal of debugging is to determine gates of an erroneous circuit that explain the observed incorrect behavior. In this paper we propose the first approach for automatic debugging of reversible Toffoli networks. Our method uses a formulation for the debugging problem based on Boolean satisfiability. We show the differences to classical (irreversible) debugging and present theoretical results. These are used to speed-up the debugging approach as well as to improve the resulting quality. Our method is able to find and to correct single errors automatically. I
Fast equivalence checking of quantum circuits of Clifford gates
Checking whether two quantum circuits are equivalent is important for the
design and optimization of quantum-computer applications with real-world
devices. We consider quantum circuits consisting of Clifford gates, a
practically-relevant subset of all quantum operations which is large enough to
exhibit quantum features such as entanglement and forms the basis of, for
example, quantum-error correction and many quantum-network applications. We
present a deterministic algorithm that is based on a folklore mathematical
result and demonstrate that it is capable of outperforming previously
considered state-of-the-art method. In particular, given two Clifford circuits
as sequences of single- and two-qubit Clifford gates, the algorithm checks
their equivalence in time in the number of qubits and number
of elementary Clifford gates . Using the performant Stim simulator as
backend, our implementation checks equivalence of quantum circuits with 1000
qubits (and a circuit depth of 10.000 gates) in 22 seconds and circuits
with 100.000 qubits (depth 10) in 15 minutes, outperforming the existing
SAT-based and path-integral based approaches by orders of magnitude. This
approach shows that the correctness of application-relevant subsets of quantum
operations can be verified up to large circuits in practice
Verifying Results of the IBM Qiskit Quantum Circuit Compilation Flow
Realizing a conceptual quantum algorithm on an actual physical device
necessitates the algorithm's quantum circuit description to undergo certain
transformations in order to adhere to all constraints imposed by the hardware.
In this regard, the individual high-level circuit components are first
synthesized to the supported low-level gate-set of the quantum computer, before
being mapped to the target's architecture---utilizing several optimizations in
order to improve the compilation result. Specialized tools for this complex
task exist, e.g., IBM's Qiskit, Google's Cirq, Microsoft's QDK, or Rigetti's
Forest. However, to date, the circuits resulting from these tools are hardly
verified, which is mainly due to the immense complexity of checking if two
quantum circuits indeed realize the same functionality. In this paper, we
propose an efficient scheme for quantum circuit equivalence
checking---specialized for verifying results of the IBM Qiskit quantum circuit
compilation flow. To this end, we combine characteristics unique to quantum
computing, e.g., its inherent reversibility, and certain knowledge about the
compilation flow into a dedicated equivalence checking strategy. Experimental
evaluations confirm that the proposed scheme allows to verify even large
circuit instances with tens of thousands of operations within seconds or even
less, whereas state-of-the-art techniques frequently time-out or require
substantially more runtime. A corresponding open source implementation of the
proposed method is publicly available at https://github.com/iic-jku/qcec.Comment: 10 pages, to be published at International Conference on Quantum
Computing and Engineering (QCE20
As Accurate as Needed, as Efficient as Possible: Approximations in DD-based Quantum Circuit Simulation
Quantum computers promise to solve important problems faster than
conventional computers. However, unleashing this power has been challenging. In
particular, design automation runs into (1) the probabilistic nature of quantum
computation and (2) exponential requirements for computational resources on
non-quantum hardware. In quantum circuit simulation, Decision Diagrams (DDs)
have previously shown to reduce the required memory in many important cases by
exploiting redundancies in the quantum state. In this paper, we show that this
reduction can be amplified by exploiting the probabilistic nature of quantum
computers to achieve even more compact representations. Specifically, we
propose two new DD-based simulation strategies that approximate the quantum
states to attain more compact representations, while, at the same time,
allowing the user to control the resulting degradation in accuracy. We also
analytically prove the effect of multiple approximations on the attained
accuracy and empirically show that the resulting simulation scheme enables
speed-ups up to several orders of magnitudes.Comment: 6 pages, 2 figures, to be published at Design, Automation, and Test
in Europe 202
How to Efficiently Handle Complex Values? Implementing Decision Diagrams for Quantum Computing
Quantum computing promises substantial speedups by exploiting quantum
mechanical phenomena such as superposition and entanglement. Corresponding
design methods require efficient means of representation and manipulation of
quantum functionality. In the classical domain, decision diagrams have been
successfully employed as a powerful alternative to straightforward means such
as truth tables. This motivated extensive research on whether decision diagrams
provide similar potential in the quantum domain -- resulting in new types of
decision diagrams capable of substantially reducing the complexity of
representing quantum states and functionality. From an implementation
perspective, many concepts and techniques from the classical domain can be
re-used in order to implement decision diagrams packages for the quantum realm.
However, new problems -- namely how to efficiently handle complex numbers --
arise. In this work, we propose a solution to overcome these problems.
Experimental evaluations confirm that this yields improvements of orders of
magnitude in the runtime needed to create and to utilize these decision
diagrams. The resulting implementation is publicly available as a quantum DD
package at http://iic.jku.at/eda/research/quantum_dd
Mixed-Dimensional Quantum Circuit Simulation with Decision Diagrams
Quantum computers promise to solve several categories of problems faster than
classical computers ever could. Current research mostly focuses on qubits,
i.e., systems where the unit of information can assume only two levels.
However, the underlying physics of most (if not all) of the technological
platforms supports more than two levels, commonly referred to as qudits.
Performing computations with qudits increases the overall complexity while, at
the same time, reducing the number of operations and providing a lower error
rate. Furthermore, qudits with different number of levels can be mixed in one
system to ease the experimental control and keep representations as compact as
possible. Exploiting these capabilities requires dedicated software support to
tackle the increased complexity in an automated and efficient fashion. In this
paper, we present a qudit simulator that handles mixed-dimensional systems
based on Decision Diagrams (DDs). More precisely, we discuss the type of
decision diagram introduced as underlying data structure as well as the
resulting implementation. Experimental evaluations demonstrate that the
proposed solution is capable of efficiently simulating mixed-dimensional
quantum circuits, with specific use cases including more than 100 qudits in one
circuit. The source code of the simulator is available via
github.com/cda-tum/MiSiM under the MIT~license.Comment: 12 pages, 5 figures, 1 tabl