arXiv subjects

Krysta M. Svore

Publications and source records attributed to Krysta M. Svore.

At least 37 records · Page 2Linked to original sources

arXiv2017

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.

quant-ph↗

arXiv2016

Optimal Circuit-Level Decoding for Surface Codes

Surface codes exploit topological protection to increase error resilience in quantum computing devices and can in principle be implemented in existing hardware. They are one of the most promising candidates for active error correction, not least due to a polynomial-time decoding algorithm which admits one of the highest predicted error thresholds. We consider the dependence of this threshold on underlying assumptions including different noise models, and analyze the performance of a minimum weight perfect matching (MWPM) decoding compared to a mathematically optimal maximum likelihood (ML) decoding. Our ML algorithm tracks the success probabilities for all possible corrections over time and accounts for individual gate failure probabilities and error propagation due to the syndrome measurement circuit. We present the very first evidence for the true error threshold of an optimal circuit level decoder, allowing us to draw conclusions about what kind of improvements are possible over standard MWPM.

quant-ph↗

arXiv2016

Improved Quantum Ternary Arithmetics

Qutrit (or ternary) structures arise naturally in many quantum systems, particularly in certain non-abelian anyon systems. We present efficient circuits for ternary reversible and quantum arithmetics. Our main result is the derivation of circuits for two families of ternary quantum adders, namely ripple carry adders and carry look-ahead adders. The main difference to the binary case is the more complicated form of the ternary carry, which leads to higher resource counts for implementations over a universal ternary gate set. Our ternary ripple adder circuit has a circuit depth of $O(n)$ and uses only $1$ ancilla, making it more efficient in both, circuit depth and width than previous constructions. Our ternary carry lookahead circuit has a circuit depth of only $O(\log\,n)$, while using with $O(n)$ ancillas. Our approach works on two levels of abstraction: at the first level, descriptions of arithmetic circuits are given in terms of gates sequences that use various types of non-Clifford reflections. At the second level, we break down these reflections further by deriving them either from the two-qutrit Clifford gates and the non-Clifford gate $C(X): |i,j\rangle \mapsto |i, j + δ_{i,2} \mod 3\rangle$ or from the two-qutrit Clifford gates and the non-Clifford gate $P_9=\mbox{diag}(e^{-2 π\, i/9},1,e^{2 π\, i/9})$. The two choices of elementary gate sets correspond to two possible mappings onto two different prospective quantum computing architectures which we call the metaplectic and the supermetaplectic basis, respectively. Finally, we develop a method to factor diagonal unitaries using multi-variate polynomial over the ternary finite field which allows to characterize classes of gates that can be implemented exactly over the supermetaplectic basis.

quant-ph↗

arXiv2015

Efficient Approximation of Diagonal Unitaries over the Clifford+T Basis

We present an algorithm for the approximate decomposition of diagonal operators, focusing specifically on decompositions over the Clifford+$T$ basis, that minimize the number of phase-rotation gates in the synthesized approximation circuit. The equivalent $T$-count of the synthesized circuit is bounded by $k \, C_0 \log_2(1/\varepsilon) + E(n,k)$, where $k$ is the number of distinct phases in the diagonal $n$-qubit unitary, $\varepsilon$ is the desired precision, $C_0$ is a quality factor of the implementation method ($1<C_0<4$), and $E(n,k)$ is the total entanglement cost (in $T$ gates). We determine an optimal decision boundary in $(k,n,\varepsilon)$-space where our decomposition algorithm achieves lower entanglement cost than previous state-of-the-art techniques. Our method outperforms state-of-the-art techniques for a practical range of $\varepsilon$ values and diagonal operators and can reduce the number of $T$ gates exponentially in $n$ when $k << 2^n$.

quant-ph↗

arXiv2015

Reversible circuit compilation with space constraints

We develop a framework for resource efficient compilation of higher-level programs into lower-level reversible circuits. Our main focus is on optimizing the memory footprint of the resulting reversible networks. This is motivated by the limited availability of qubits for the foreseeable future. We apply three main techniques to keep the number of required qubits small when computing classical, irreversible computations by means of reversible networks: first, wherever possible we allow the compiler to make use of in-place functions to modify some of the variables. Second, an intermediate representation is introduced that allows to trace data dependencies within the program, allowing to clean up qubits early. This realizes an analog to "garbage collection" for reversible circuits. Third, we use the concept of so-called pebble games to transform irreversible programs into reversible programs under space constraints, allowing for data to be erased and recomputed if needed. We introduce REVS, a compiler for reversible circuits that can translate a subset of the functional programming language F# into Toffoli networks which can then be further interpreted for instance in LIQui|>, a domain-specific language for quantum computing and which is also embedded into F#. We discuss a number of test cases that illustrate the advantages of our approach including reversible implementations of SHA-2 and other cryptographic hash-functions, reversible integer arithmetic, as well as a test-bench of combinational circuits used in classical circuit synthesis. Compared to Bennett's method, REVS can reduce space complexity by a factor of $4$ or more, while having an only moderate increase in circuit size as well as in the time it takes to compile the reversible networks.

quant-ph↗

arXiv2015

Quantum Deep Learning

In recent years, deep learning has had a profound impact on machine learning and artificial intelligence. At the same time, algorithms for quantum computers have been shown to efficiently solve some problems that are intractable on conventional, classical computers. We show that quantum computing not only reduces the time required to train a deep restricted Boltzmann machine, but also provides a richer and more comprehensive framework for deep learning than classical computing and leads to significant improvements in the optimization of the underlying objective function. Our quantum methods also permit efficient training of full Boltzmann machines and multi-layer, fully connected models and do not have well known classical counterparts.

quant-ph↗

arXiv2014

Repeat-Until-Success: Non-deterministic decomposition of single-qubit unitaries

We present a decomposition technique that uses non-deterministic circuits to approximate an arbitrary single-qubit unitary to within distance $ε$ and requires significantly fewer non-Clifford gates than existing techniques. We develop "Repeat-Until-Success" (RUS) circuits and characterize unitaries that can be exactly represented as an RUS circuit. Our RUS circuits operate by conditioning on a given measurement outcome and using only a small number of non-Clifford gates and ancilla qubits. We construct an algorithm based on RUS circuits that approximates an arbitrary single-qubit $Z$-axis rotation to within distance $ε$, where the number of $T$ gates scales as $1.26\log_2(1/ε) - 3.53$, an improvement of roughly three-fold over state-of-the-art techniques. We then extend our algorithm and show that a scaling of $2.4\log_2(1/ε) - 3.28$ can be achieved for arbitrary unitaries and a small range of $ε$, which is roughly twice as good as optimal deterministic decomposition methods.

quant-ph↗

arXiv2014

Efficient synthesis of probabilistic quantum circuits with fallback

Recently it has been shown that Repeat-Until-Success (RUS) circuits can approximate a given single-qubit unitary with an expected number of $T$ gates of about $1/3$ of what is required by optimal, deterministic, ancilla-free decompositions over the Clifford+$T$ gate set. In this work, we introduce a more general and conceptually simpler circuit decomposition method that allows for synthesis into protocols that probabilistically implement quantum circuits over several universal gate sets including, but not restricted to, the Clifford+$T$ gate set. The protocol, which we call Probabilistic Quantum Circuits with Fallback (PQF), implements a walk on a discrete Markov chain in which the target unitary is an absorbing state and in which transitions are induced by multi-qubit unitaries followed by measurements. In contrast to RUS protocols, the presented PQF protocols terminate after a finite number of steps. Specifically, we apply our method to the Clifford+$T$, Clifford+$V$, and Clifford+$π/12$ gate sets to achieve decompositions with expected gate counts of $\log_b(1/\varepsilon)+O(\log(\log(1/\varepsilon)))$, where $b$ is a quantity related to the expansion property of the underlying universal gate set.

quant-ph↗

arXiv2014

Efficient synthesis of universal Repeat-Until-Success circuits

Recently, it was shown that Repeat-Until-Success (RUS) circuits can achieve a $2.5$ times reduction in expected $T$-count over ancilla-free techniques for single-qubit unitary decomposition. However, the previously best known algorithm to synthesize RUS circuits requires exponential classical runtime. In this paper we present an algorithm to synthesize an RUS circuit to approximate any given single-qubit unitary within precision $\varepsilon$ in probabilistically polynomial classical runtime. Our synthesis approach uses the Clifford+$T$ basis, plus one ancilla qubit and measurement. We provide numerical evidence that our RUS circuits have an expected $T$-count on average $2.5$ times lower than the theoretical lower bound of $3 \log_2 (1/\varepsilon)$ for ancilla-free single-qubit circuit decomposition.

quant-ph↗

arXiv2014

Low-distance Surface Codes under Realistic Quantum Noise

We study the performance of distance-three surface code layouts under realistic multi-parameter noise models. We first calculate their thresholds under depolarizing noise. We then compare a Pauli-twirl approximation of amplitude and phase damping to amplitude and phase damping. We find the approximate channel results in a pessimistic estimate of the logical error rate, indicating the realistic threshold may be higher than previously estimated. From Monte-Carlo simulations, we identify experimental parameters for which these layouts admit reliable computation. Due to its low resource cost and superior performance, we conclude that the 17-qubit layout should be targeted in early experimental implementations of the surface code. We find that architectures with gate times in the 5-40 ns range and T1 times of at least 1-2 us range will exhibit improved logical error rates with a 17-qubit surface code encoding.

quant-ph↗

arXiv2014

LIQUi|>: A Software Design Architecture and Domain-Specific Language for Quantum Computing

Languages, compilers, and computer-aided design tools will be essential for scalable quantum computing, which promises an exponential leap in our ability to execute complex tasks. LIQUi|> is a modular software architecture designed to control quantum hardware. It enables easy programming, compilation, and simulation of quantum algorithms and circuits, and is independent of a specific quantum architecture. LIQUi|> contains an embedded, domain-specific language designed for programming quantum algorithms, with F# as the host language. It also allows the extraction of a circuit data structure that can be used for optimization, rendering, or translation. The circuit can also be exported to external hardware and software environments. Two different simulation environments are available to the user which allow a trade-off between number of qubits and class of operations. LIQUi|> has been implemented on a wide range of runtimes as back-ends with a single user front-end. We describe the significant components of the design architecture and how to express any given quantum algorithm.

quant-ph↗

arXiv2013

Asymptotically Optimal Topological Quantum Compiling

In a topological quantum computer, universality is achieved by braiding and quantum information is natively protected from small local errors. We address the problem of compiling single-qubit quantum operations into braid representations for non-abelian quasiparticles described by the Fibonacci anyon model. We develop a probabilistically polynomial algorithm that outputs a braid pattern to approximate a given single-qubit unitary to a desired precision. We also classify the single-qubit unitaries that can be implemented exactly by a Fibonacci anyon braid pattern and present an efficient algorithm to produce their braid patterns. Our techniques produce braid patterns that meet the uniform asymptotic lower bound on the compiled circuit depth and thus are depth-optimal asymptotically. Our compiled circuits are significantly shorter than those output by prior state-of-the-art methods, resulting in improvements in depth by factors ranging from 20 to 1000 for precisions ranging between $10^{-10}$ and $10^{-30}$.

quant-ph↗

arXiv2013

A 2D Nearest-Neighbor Quantum Architecture for Factoring in Polylogarithmic Depth

We contribute a 2D nearest-neighbor quantum architecture for Shor's algorithm to factor an $n$-bit number in $O(\log^2(n))$ depth. Our implementation uses parallel phase estimation, constant-depth fanout and teleportation, and constant-depth carry-save modular addition. We derive upper bounds on the circuit resources of our architecture under a new 2D nearest-neighbor model which allows a classical controller and parallel, communicating modules. We also contribute a novel constant-depth circuit for unbounded quantum unfanout in our new model. Finally, we provide a comparison to all previous nearest-neighbor factoring implementations. Our circuit results in an exponential improvement in nearest-neighbor circuit depth at the cost of a polynomial increase in circuit size and width.

quant-ph↗

arXiv2013

Faster Phase Estimation

We develop several algorithms for performing quantum phase estimation based on basic measurements and classical post-processing. We present a pedagogical review of quantum phase estimation and simulate the algorithm to numerically determine its scaling in circuit depth and width. We show that the use of purely random measurements requires a number of measurements that is optimal up to constant factors, albeit at the cost of exponential classical post-processing; the method can also be used to improve classical signal processing. We then develop a quantum algorithm for phase estimation that yields an asymptotic improvement in runtime, coming within a factor of log* of the minimum number of measurements required while still requiring only minimal classical post-processing. The corresponding quantum circuit requires asymptotically lower depth and width (number of qubits) than quantum phase estimation.

quant-ph↗

arXiv2013

Efficient Decomposition of Single-Qubit Gates into $V$ Basis Circuits

We develop the first constructive algorithms for compiling single-qubit unitary gates into circuits over the universal $V$ basis. The $V$ basis is an alternative universal basis to the more commonly studied $\{H,T\}$ basis. We propose two classical algorithms for quantum circuit compilation: the first algorithm has expected polynomial time (in precision $\log(1/ε)$) and offers a depth/precision guarantee that improves upon state-of-the-art methods for compiling into the $\{H,T\}$ basis by factors ranging from 1.86 to $\log_2(5)$. The second algorithm is analogous to direct search and yields circuits a factor of 3 to 4 times shorter than our first algorithm, and requires time exponential in $\log(1/ε)$; however, we show that in practice the runtime is reasonable for an important range of target precisions.

quant-ph↗

arXiv2012

A State Distillation Protocol to Implement Arbitrary Single-qubit Rotations

An important task required to build a scalable, fault-tolerant quantum computer is to efficiently represent an arbitrary single-qubit rotation by fault-tolerant quantum operations. Traditionally, the method for decomposing a single-qubit unitary into a discrete set of gates is Solovay-Kitaev decomposition, which in practice produces a sequence of depth O(\log^c(1/ε)), where c~3.97 is the state-of-the-art. The proven lower bound is c=1, however an efficient algorithm that saturates this bound is unknown. In this paper, we present an alternative to Solovay-Kitaev decomposition employing state distillation techniques which reduces c to between 1.12 and 2.27, depending on the setting. For a given single-qubit rotation, our protocol significantly lowers the length of the approximating sequence and the number of required resource states (ancillary qubits). In addition, our protocol is robust to noise in the resource states.

quant-ph↗

arXiv2012

A Depth-Optimal Canonical Form for Single-qubit Quantum Circuits

Given an arbitrary single-qubit operation, an important task is to efficiently decompose this operation into an (exact or approximate) sequence of fault-tolerant quantum operations. We derive a depth-optimal canonical form for single-qubit quantum circuits, and the corresponding rules for exactly reducing an arbitrary single-qubit circuit to this canonical form. We focus on the single-qubit universal H,T basis due to its role in fault-tolerant quantum computing, and show how our formalism might be extended to other universal bases. We then extend our canonical representation to the family of Solovay-Kitaev decomposition algorithms, in order to find an ε-approximation to the single-qubit circuit in polylogarithmic time. For a given single-qubit operation, we find significantly lower-depth ε-approximation circuits than previous state-of-the-art implementations. In addition, the implementation of our algorithm requires significantly fewer resources, in terms of computation memory, than previous approaches.

quant-ph↗

arXiv2006

Noise Threshold for a Fault-Tolerant Two-Dimensional Lattice Architecture

We consider a model of quantum computation in which the set of operations is limited to nearest-neighbor interactions on a 2D lattice. We model movement of qubits with noisy SWAP operations. For this architecture we design a fault-tolerant coding scheme using the concatenated [[7,1,3]] Steane code. Our scheme is potentially applicable to ion-trap and solid-state quantum technologies. We calculate a lower bound on the noise threshold for our local model using a detailed failure probability analysis. We obtain a threshold of 1.85 x 10^-5 for the local setting, where memory error rates are one-tenth of the failure rates of gates, measurement, and preparation steps. For the analogous nonlocal setting, we obtain a noise threshold of 3.61 x 10^-5. Our results thus show that the additional SWAP operations required to move qubits in the local model affect the noise threshold only moderately.

quant-ph↗