1,709 research outputs found
Quantum arithmetic operations based on quantum Fourier transform on signed integers
The quantum Fourier transform (QFT) brings efficiency in many respects,
especially usage of resource, for most operations on quantum computers. In this
study, the existing QFT-based and non-QFT-based quantum arithmetic operations
are examined. The capabilities of QFT-based addition and multiplication are
improved with some modifications. The proposed operations are compared with the
nearest quantum arithmetic operations. Furthermore, novel QFT-based
subtraction, division and exponentiation operations are presented. The proposed
arithmetic operations can perform nonmodular operations on all signed numbers
without any limitation by using less resources. In addition, novel quantum
circuits of two's complement, absolute value and comparison operations are also
presented by using the proposed QFT-based addition and subtraction operations.Comment: 23 pages, 38 figures, Accepted by International Journal of Quantum
Information on Sep 3, 2020, Online Ready on Oct 8, 202
Factoring with Qutrits: Shor's Algorithm on Ternary and Metaplectic Quantum Architectures
We determine the cost of performing Shor's algorithm for integer
factorization on a ternary quantum computer, using two natural models of
universal fault-tolerant computing:
(i) a model based on magic state distillation that assumes the availability
of the ternary Clifford gates, projective measurements, classical control as
its natural instrumentation set; (ii) a model based on a metaplectic
topological quantum computer (MTQC). A natural choice to implement Shor's
algorithm on a ternary quantum computer is to translate the entire arithmetic
into a ternary form. However, it is also possible to emulate the standard
binary version of the algorithm by encoding each qubit in a three-level system.
We compare the two approaches and analyze the complexity of implementing Shor's
period finding function in the two models. We also highlight the fact that the
cost of achieving universality through magic states in MTQC architecture is
asymptotically lower than in generic ternary case.Comment: 22 pages, 7 figures; v3: significant overhaul; this version focuses
on the use of true ternary vs. emulated binary encodin
Arithmetic on a Distributed-Memory Quantum Multicomputer
We evaluate the performance of quantum arithmetic algorithms run on a
distributed quantum computer (a quantum multicomputer). We vary the node
capacity and I/O capabilities, and the network topology. The tradeoff of
choosing between gates executed remotely, through ``teleported gates'' on
entangled pairs of qubits (telegate), versus exchanging the relevant qubits via
quantum teleportation, then executing the algorithm using local gates
(teledata), is examined. We show that the teledata approach performs better,
and that carry-ripple adders perform well when the teleportation block is
decomposed so that the key quantum operations can be parallelized. A node size
of only a few logical qubits performs adequately provided that the nodes have
two transceiver qubits. A linear network topology performs acceptably for a
broad range of system sizes and performance parameters. We therefore recommend
pursuing small, high-I/O bandwidth nodes and a simple network. Such a machine
will run Shor's algorithm for factoring large numbers efficiently.Comment: 24 pages, 10 figures, ACM transactions format. Extended version of
Int. Symp. on Comp. Architecture (ISCA) paper; v2, correct one circuit error,
numerous small changes for clarity, add reference
A logarithmic-depth quantum carry-lookahead adder
We present an efficient addition circuit, borrowing techniques from the
classical carry-lookahead arithmetic circuit. Our quantum carry-lookahead
(QCLA) adder accepts two n-bit numbers and adds them in O(log n) depth using
O(n) ancillary qubits. We present both in-place and out-of-place versions, as
well as versions that add modulo 2^n and modulo 2^n - 1.
Previously, the linear-depth ripple-carry addition circuit has been the
method of choice. Our work reduces the cost of addition dramatically with only
a slight increase in the number of required qubits. The QCLA adder can be used
within current modular multiplication circuits to reduce substantially the
run-time of Shor's algorithm.Comment: 21 pages, 4 color figure
Approximate encoded permutations and piecewise quantum adders
We present a paradigm for constructing approximate quantum circuits from
reversible classical circuits that operate on many possible encodings of an
input and send almost all encodings of that input to an encoding of the correct
output. We introduce oblivious carry runways, which use piecewise addition
circuits to perform approximate encoded additions and reduce the asymptotic
depth of addition to . We show that the coset representation of
modular integers (Zalka 2006) is an approximate encoded modular addition, and
that it can be used in combination with oblivious carry runways. We prove error
bounds on these approximate representations, and use them to construct
2s-complement adders and modular adders with lower costs than in previous work
at register sizes relevant in practice.Comment: 14 pages, 5 figure
A Fault Tolerant, Area Efficient Architecture for Shor's Factoring Algorithm
We optimize the area and latency of Shor's factoring while simultaneously
improving fault tolerance through: (1) balancing the use of ancilla generators,
(2) aggressive optimization of error correction, and (3) tuning the core adder
circuits. Our custom CAD flow produces detailed layouts of the physical
components and utilizes simulation to analyze circuits in terms of area,
latency, and success probability. We introduce a metric, called ADCR, which is
the probabilistic equivalent of the classic Area-Delay product. Our error
correction optimization can reduce ADCR by an order of magnitude or more.
Contrary to conventional wisdom, we show that the area of an optimized quantum
circuit is not dominated exclusively by error correction. Further, our adder
evaluation shows that quantum carry-lookahead adders (QCLA) beat ripple-carry
adders in ADCR, despite being larger and more complex. We conclude with what we
believe is one of most accurate estimates of the area and latency required for
1024-bit Shor's factorization: 7659 mm for the smallest circuit and seconds for the fastest circuit.Comment: Appears in International Symposium on Computer Architecture 2009
(ISCA09
Simulation of Quantum Circuits via Stabilizer Frames
Generic quantum-circuit simulation appears intractable for conventional
computers and may be unnecessary because useful quantum circuits exhibit
significant structure that can be exploited during simulation. For example,
Gottesman and Knill identified an important subclass, called stabilizer
circuits, which can be simulated efficiently using group-theory techniques and
insights from quantum physics. Realistic circuits enriched with quantum
error-correcting codes and fault-tolerant procedures are dominated by
stabilizer subcircuits and contain a relatively small number of non-Clifford
components. Therefore, we develop new data structures and algorithms that
facilitate parallel simulation of such circuits. Stabilizer frames offer more
compact storage than previous approaches but require more sophisticated
bookkeeping. Our implementation, called Quipu, simulates certain quantum
arithmetic circuits (e.g., reversible ripple-carry adders) in polynomial time
and space for equal superpositions of -qubits. On such instances, known
linear-algebraic simulation techniques, such as the (state-of-the-art)
BDD-based simulator QuIDDPro, take exponential time. We simulate quantum
Fourier transform and quantum fault-tolerant circuits using Quipu, and the
results demonstrate that our stabilizer-based technique empirically outperforms
QuIDDPro in all cases. While previous high-performance, structure-aware
simulations of quantum circuits were difficult to parallelize, we demonstrate
that Quipu can be parallelized with a nontrivial computational speedup.Comment: 15 pages, 18 figures, 3 table
Energy consumption by reversible circuits in the 130 nm and 65 nm nodes
We show that both 130 nm and 65 nm technologies
are suitable for reversible computation
ASIC-based Implementation of Synchronous Section-Carry Based Carry Lookahead Adders
The section-carry based carry lookahead adder (SCBCLA) topology was proposed
as an improved high-speed alternative to the conventional carry lookahead adder
(CCLA) topology in previous works. Self-timed and FPGA-based implementations of
SCBCLAs and CCLAs were considered earlier, and it was found that SCBCLAs could
help in delay reduction i.e. pave the way for improved speed compared to CCLAs
at the expense of some increase in area and/or power parameters. In this work,
we consider semi-custom ASIC-based implementations of different variants of
SCBCLAs and CCLAs to perform 32-bit dual-operand addition. Based on the
simulation results for 32-bit dual-operand addition obtained by targeting a
high-end 32/28nm CMOS process, it is found that an optimized SCBCLA
architecture reports a 9.8% improvement in figure-of-merit (FOM) compared to an
optimized CCLA architecture, where the FOM is defined as the inverse of the
product of power, delay, and area. It is generally inferred from the
simulations that the SCBCLA architecture could be more beneficial compared to
the CCLA architecture in terms of the design metrics whilst benefitting a
variety of computer arithmetic operations involving dual-operand and/or
multi-operand additions. Also, it is observed that heterogeneous CLA
architectures tend to fare well compared to homogeneous CLA architectures, as
substantiated by the simulation results.Comment: in the Book, Recent Advances in Circuits, Systems, Signal Processing
and Communications, Included in ISI/SCI Web of Science and Web of Knowledge,
Proceedings of 10th International Conference on Circuits, Systems, Signal and
Telecommunications, pp. 58-64, 2016, Barcelona, Spai
Quantum block lookahead adders and the wait for magic states
We improve the Toffoli count of low depth quantum adders, and analyze how
their spacetime cost reacts to having a limited number of magic state
factories. We present a block lookahead adder that parallelizes across blocks
of bits of size , instead of over all bits. The block lookahead adder
achieves a Toffoli count of for out of place addition (vs in
previous work by Thapliyal et al) and for in place addition (vs
in previous work by Thapliyal et al). The tradeoff is that the reaction
depth of these circuits depends linearly on , and they use additional
workspace. We estimate the spacetime volume of these adders, and adders from
previous work, for various register sizes and factory counts under plausible
assumptions for a large scale quantum computer based on the surface code and
superconducting qubits.Comment: 12 pages, 1 table, 5 figures, Q# source cod
- …