Designing Scalable Quantum Computer Architectures: Layout and Initialization

Transcription

1 Designing Scalable Quantum Computer Architectures: Layout and Initialization By DEAN ELBERT COPSEY B.S. (University of California, Davis) 1986 M.S. (University of California, Davis) 1996 DISSERTATION Submitted in partial satisfaction of the requirements for the degree of DOCTOR OF PHILOSOPHY in Computer Science in the OFFICE OF GRADUATE STUDIES of the UNIVERSITY OF CALIFORNIA DAVIS Approved: Committee in charge 2005 i

2 Designing Scalable Quantum Computer Architectures: Layout and Initialization Copyright 2005 by Dean Elbert Copsey

3 To Michael ten years and still going strong, May the road rise up to meet you. and, in loving memory of Homer Copsey-Waggoner Until we meet again. ii

4 Dean Elbert Copsey September 2005 Computer Science Designing Scalable Quantum Computer Architectures: Layout and Initialization Abstract As the complexity of quantum computers increases, typical architectural issues such as communication, layout, and efficient design need to be addressed. This document addresses some basic architectural ideas for quantum computers. To be useful in reasonable calculations, quantum states will need constant error correction. This need guides how best to lay out physical components to minimize errorcorrection overhead. I propose a layout that minimizes communication overhead, and discuss the implementation of error-correction algorithms on that layout. I compare the cost overhead of purely local communication to communication by teleportation, and calculate the break-even point at which teleportation becomes efficient. Additionally, the overhead of error correction can be reduced by using a memory hierarchy to more efficiently store data not currently being computed on. The main requirement is the same as for a classical computer s cache: temporal locality. I show that an important quantum routine can be rearranged to take advantage of a small quantum memory cache, and compute the achieved savings. In a quantum system, complex operators are built up from the basic operators allowed by a given technology model. I show that the set of operators required to implement any complex operator in an error-corrected system can be approximated to arbitrary precision, given two elementary operators. I give results for all the operators in the set. Finally, I examine methods to initialize a quantum system. Quantum operators are reversible, so data cannot simply be written over. Instead, initialization entails compressing iii

5 the entropy of a set of quantum bits into a small subset of those bits, leaving the rest of the bits in a known, non-random state. I examine three such compression algorithms. The best of these itself requires a pool of known states, and so cannot be used directly. The other two algorithms, however, produce less-than-optimal results. I explore why they produce suboptimal results, and propose that one of the suboptimal algorithms be used to compress the entropy of a subsystem, using the resulting known state to run the optimal algorithm. iv

6 Contents List of Figures List of Tables v vii 1 Introduction Design Issues Document Structure Background Quantum Computer Basics Quantum Error Correction Fault-tolerant Computation Quantum Algorithms Shor s Factoring Algorithm Teleportation Teleporting Encoded Data EPR Generation and Purification Some Potential Quantum Computer Systems NMR Ion Traps Solid-State Technologies: The Skinner-Kane Model Gates for the Skinner-Kane Model Two Qubit Operators Single Qubit Operators Methodology and Results Future Directions Quantum Memory Hierarchy Motivation Background Memory Hierarchy Error-Correction and Circuit Design Error Correction Algorithms The [[7,1,3]] Code Concatenated Codes v

7 5.2 Communication Costs and Error Correction Error Correction Costs Multilevel Error Correction Avoiding Correlated Errors Teleportation System Initialization: An Analysis of the Schulman-Vazirani Algorithm Introduction The Schulman-Vazirani Heat Engine The Simplified Schulman-Vazirani Algorithm Expected Values and Variance Correlation and Covariance Akira and Kitagawa s Model The Simulator Analysis The Distillation Model Size and Number of Trays How Cold is Cold Enough? Effects of Correlation Simulation Setup and Results The Schumacher Operator Conclusions Future Directions Conclusions and Future Work The Future of Quantum Computing A Operator Approximation 80 B Hand-modeling the H-Tree Layout 90 C Modeling the Schulman-Vazirani Algorithm 93 C.1 sim.cc: C++ Code for Simulating the Distill Variant of the Schulman-Vazirani Algorithm C.1.1 FindAlt.tcl C.1.2 FindMax.tcl C.1.3 SimAlt.sh C.1.4 sim.cc C.2 akira.cc: C++ Code for Simulating the Akira-Kitagawa Variant C.3 schumacher.cc: C++ Code for Simulating Cleve and DiVincenzo s Implementation of the Schumacher Operator Bibliography 151 vi

8 List of Figures 2.1 Bloch sphere representation of a qubit Basic quantum operations Creating a cat state Measuring X 12, the difference between (parity of) ψ 1 and ψ Syndrome Measurement for 3-bit Code. The meter boxes indicate measurement, and the double lines indicate classical communication controlling the application of the Z operator Tree structure of concatenated codes Summing over the Quantum Fourier Transform Vectors Quantum Teleportation The basic quantum bit technology proposed by Kane, with modifications by Skinner. Qubits are embodied by the coupled nuclear and electronic spin of a phosphorus atom embedded in silicon under high magnetic field (2T) at low temperature (100mK) Implementation of a rotation about the swap axis in the Skinner-Kane model Approximating an operator Pulse sequence to approximate an H operator Trading computational ease for density Quantum Fourier transform on nine qubits Locality in the quantum Fourier transform Two-rail layout for the three-qubit phase-correction code Schematic layout of the H-tree structure of a concatenated code. The branches labeled D i are for logical data qubits, and consist of two rails of eleven qubits each seven qubits for data and four for ancillae. The branch labeled A 1 is for creating, verifying, and uncreating the cat state Measuring the error syndrome for the [[7, 1, 3]] error-correction code Swap channel Cost of teleportation compared to swapping. The B-values chosen illustrate breakeven points for different levels of recursion Simplified Schumacher-Vazirani Algorithm Distribution of an a i,b i pair before CNOT (left), and after (right) Distribution of qubits after one application of the Schulman-Vazirani algorithm vii

9 6.4 Distributions of a, b with correlation (left) and (right). (The dashed line is the distribution for independent qubits.) The Schulman-Vazirani boost operator: a CNOT followed by a controlled-swap ( ) between a and b with inverted control by c Results of applying the Akira-Kitagawa algorithm through several iterations Correlation between qubits after a single application of the boost operator. The correlation value is maximum correlation between this qubit and any other The Distillation Model The Distillation Algorithm Effects of correlation between a i s, between b i s, and between a i and b i Removal of highly correlated bits. Bits with correlation > 0.1 were relocated to the right end of the graph. Three iterations resulted in twelve cold (P 1,out < 0.01) qubits The Schumacher operator. The input bits have a probability of 0.2 of measuring to 1. Successive iterations discard most of the hot bits, to extract more cold bits. Ancilla bits consumed by the process are not shown B.1 Counting operators for a parity measurement in [[7,1,3]] viii

10 List of Tables 2.1 Phase correction for a 3-qubit code Overhead of recursive error correction for a single qubit operator Overhead of [[8, 3, 3]] concatenated with [[7, 1, 3]]on a per-qubit basis Comparison of the cost of swapping an encoded qubit to the cost of teleporting it. The B-values are the distance between adjacent qubits Schumacher Operator for Five Qubits Results of applying the Schulman-Vazirani boost operator, and the three-bit Schumacher operator Distillation results for 128, 256, and 384 bits ix

11 Acknowledgments I thank my committee members, especially my adviser, Fred Chong for his unfailing optimism and encouragement, and his many lessons in research, teaching, and community work. I also to thank the other faculty with whom I co-wrote papers, John Kubi Kubiatowicz, Isaac Chuang, and Mark Oskin, for teaching me much about research. Additionally, I thank the other students I ve worked with, both at U.C. Davis and in the Quantum Architecture Research Center: my lab mates and fellow architects Tzvetan Metodiev, Darshan Thaker, Jedediah Crandall, Paul Sultana, Ravishankar Rao and John Oliver; the Berkeley crowd under Kubi, including Mark Whitney, Nemanja Isailovich, and Yatish Patel; and the folks at MIT under Isaac Chuang: Ken Brown, and Andrew Cross. Finally, I would like to thank Venkatesh Akella, Khaled Abdel-Ghaffar, Charles Chip Martel, and Umesh Vazirani, all of whom have influenced my research. In addition, I thank Matt Farrens for his advice and guidance on teaching. I thank the department s wonderful administrative staff who kept things running smoothly, but especially the graduate coordinators, who made sure I stayed on the true path to doctorhood: Barbara Weston, Kim Reinking and Mary Reid. I thank Hewlett-Packard Company for allowing me the opportunity of returning to college to finish my degree. If it hadn t been for their massive layoffs, I would still be happily plugging away, writing firmware and programming FPGAs. I thank my parents, for their continued financial and emotional support during the twentyplus years and two careers this degree has taken. And, finally, I thank my partner Michael for putting up with my moods, sharing coffee and comics on the porch, and enduring the lean times to make my dream come true. x

12 1 Chapter 1 Introduction The only known solutions to many important problems require exponential resources on a classical computer. Quantum computers can solve some of these problems with polynomial resources, which has led a great number of researchers to explore quantum information processing technologies [6, 14, 15, 30, 31, 35, 32]. The largest quantum computers to date have involved only a small number of components (less than 10). Several different technologies have been demonstrated, the two most successful being liquid-phase nuclear magnetic resonance and trapped ions [27, 29, 40, 50]. As the complexity of quantum computers increases, typical architectural issues such as communication and layout will need to be addressed. The goal of computer architecture is to structure the individual bits and wires of a computer system into modules, thus allowing architects to reason about how to best implement the modules (top-down design), as well as how to facilitate the interworking of the modules (glue logic). Quantum computation is still in its infancy. Physicists are still grappling with ways to produce sufficient numbers of interacting quantum devices to be able to solve non-trivial problems. When they succeed, the next step will be to assemble the devices into something useful. This document addresses some basic architectural ideas for quantum computers.

13 CHAPTER 1. INTRODUCTION Design Issues Quantum states are fragile compared to classical bits. The probability of introducing an error while applying a quantum operator (the quantum equivalent of a logic gate) is around ten orders of magnitude greater than for a classical logic gate. Quantum data can be protected via error correction using more physical components to represent the data but at a cost of increased complexity for operators. This has profound implications about how best to lay out the physical components to minimize error-correction overhead. I propose a layout that minimizes communication overhead, given some assumptions about the underlying technology model, and discuss the implementation of an error-correction algorithm using the layout. Additionally, I show that there is a break-even point at which using teleportation a mechanism to communicate quantum data over large distances is more efficient than strictly local communication. Other classic architectural ideas can be leveraged to further reduce the overhead of error correction. One such idea is using a memory hierarchy to more efficiently store data that is not currently being computed on. The issues involved are similar to those of a classical computer; in particular, arranging the sequence of operators to take advantage of spatial and temporal locality. I show that an important quantum routine can efficiently use cache blocks, and I compute the reduction of complexity. In a quantum system, complex operators are built up from the basic operators allowed by the particular technology model. There are many open questions about efficiently building complex operators. I chose the following goal: showing that a standard set of universal operators required to implement any operator in an error-corrected system can be efficiently approximated to the precision required for a given technology model. I give results for all of the necessary operators. One last design issue is how to initialize a quantum system. Classical system initialization usually includes a memory check, in which patterns are written to memory to ensure its integrity. If a particular value is required in a location, it is simply written to that location. Quantum systems are not, in general, so easy. Quantum operators are reversible, so data cannot be simply written over. An arbitrary state can only be created from a known starting point. The goal of initialization in a quantum system, then, is creating a pool of known zeroes that can be manipulated to perform calculations. I examine three algorithms to do this. The best requires a pool of known states in order

14 CHAPTER 1. INTRODUCTION 3 to run, whereas the other two produce less-than-optimal results. I explore why the latter algorithms produce suboptimal results, and propose a combination of the first algorithm with one of the others to bootstrap system initialization. 1.2 Document Structure For reference and nomenclature, Chapter 2 gives background material, including: terminology and concepts; an overview of error correction and fault-tolerant quantum computing; some important algorithms, including applications (factoring, solution-space searches) and utility routines (teleportation, EPR pair generation and purification). And, finally, a discussion of technologies, including: nuclear magnetic resonance, which, while not scalable, was used for the most successful implementation to date and serves as a good introductory point; ion traps; and, phosphorus in silicon. Chapter 3 looks more closely at efficiently implementing operators for the phosphorusin-silicon models. Chapter 4 explores the implications of using a memory hierarchy in a quantum computer, focusing on the factoring algorithm from Chapter 2. Chapter 5 provides detailed error correction algorithms, and discusses tradeoffs for using teleportation as a communication scheme. Finally, Chapter 6 compares three system initialization schemes.

15 4 Chapter 2 Background While a bit in a classical computer represents either zero or one, a quantum bit (qubit) can be thought of as simultaneously representing both states. More precisely, the state of a qubit is described by probability amplitudes for measuring states representing zero or one. The amplitudes are complex values, with real and imaginary parts, and only turn into real probabilities upon external observation. Unlike classical probabilistic computation, the amplitudes for different computational pathways can cancel each other out through interference. The actual probabilities are determined by the modulus of the amplitude, which is the amplitude multiplied by its complex conjugate (hereafter referred to, somewhat inaccurately, as the square of the amplitude). The key to achieving exponential speedup is that quantum computers directly and simultaneously manipulate probability amplitudes to perform a computation. A system with n qubits has the ability to be in 2 n states simultaneously, each with its own probability amplitude. For example, two qubits can be in a superposition of the states 00, 01, 10, and 11. The work of a quantum computer is to manipulate qubits and the associated amplitude vectors in a useful manner. Any operation on a single qubit can affect all 2 n states. This is often called quantum parallelism, and is a useful way to think about what gives quantum computers such high potential speedups over classical computers. However, only one of these 2 n states can ever be measured. More precisely, measuring a qubit vector is equivalent to calculating the squares of the amplitudes, and probabilistically choosing one state. The amplitude vector then collapses, with a value of one for the chosen state, and zeroes for all other states. For this reason, quantum computers

16 CHAPTER 2. BACKGROUND 5 are best at NP problems where only a single answer is needed, and the answer can be verified in polynomial time. Designers of quantum algorithms must be very clever about how to get useful answers out of their computations. Grover s search algorithm [22], for example, iteratively skews probability amplitudes in a qubit vector until the probability for the desired value is near 1 and the probability for other values is close to 0. The algorithm can be used to search the entire solution space of an NP problem for a solution. It iterates n times, at which point a qubit vector representing the keys can be measured. The desired key is found with high probability. Another option is to arrange the computation such that it does not matter which one of many highly probable results is measured from a qubit vector. This method is used in Shor s algorithm for prime factorization of large numbers [43] (see Section 2.4.1), building upon modular exponentiation of all states and the quantum Fourier transform, an exponentially fast version of the classical discrete Fourier transform. Essentially, the factorization is encoded within the period of a set of highly probable values, from which the desired result can be obtained no matter which value is measured. Since prime factorization of large numbers is the basis of many modern cryptographic security systems, Shor s algorithm has received much attention. 2.1 Quantum Computer Basics In general, qubits are denoted in Dirac s bra, ket notation. 0 represents a qubit in the zero state 1, and is pronounced ket zero. A generic qubit, ψ, is represented by α 0 +β 1, where α 2 and β 2 are the probabilities of measuring 0 or 1, respectively. 0 and 1 are also sometimes referred to as the computational basis. Another useful way of thinking about a qubit is the Bloch sphere (see Figure 2.1). 0 is up along the ẑ-axis, and 1 is down. Generically, ψ = cos φ 2 0 +sin φ 2 eiθ 1. Operations on a qubit are equivalent to rotations of the Bloch sphere represents the column vector [ 1 0 ], where the values are the amplitudes of the possible states. Similarly, 1 represents [ 0 1 ]. The bra notation is used to represent the adjoint (conjugate transpose) of the ket notation. 2 It is interesting to note that a vector on the Bloch sphere only has two degrees of freedom. This is because all operators are unitary they preserve a total probability of unity. Hence, the phase for 0 can be divided out, and kept as a constant. All operators are multiplicative, so this global constant makes no difference, and cannot actually be observed. In general, the zero state for any set of qubits can be thought of having a real, non-negative value. Unfortunately, the Bloch sphere model does not scale to multiple qubits, but it is useful as a visualization tool for single-qubit operations on

17 CHAPTER 2. BACKGROUND 6 z 0 φ ψ x θ y 1 Figure 2.1: Bloch sphere representation of a qubit X Gate Bit flip, Not X α β = β 0 + α 1 Z Gate Phase flip Z α β = α 0 β 1 H Gate Hadamard H α β = α+β α β 1 T Gate T e i π /4 α β = α e i π /4 β Controlled Not Controlled X CNot X a b c d = a 00 + b 01 + d 10 + c 11 Swap a b c d = a 00 + c 01 + b 10 + d 11 Figure 2.2: Basic quantum operations

18 CHAPTER 2. BACKGROUND 7 Figure 2.2 gives a few basic quantum operations that are used throughout this text. These include one-bit operations such as the bit-flip (X), phase-flip (Z), Hadamard (H), and π/8 (T ) gates, as well as the two-bit controlled-not, CNOT. These are given in both their circuit and matrix representations. The matrix representation involves multiplying the operator by the amplitude vector of the quantum states. The X, Y, and Z operators are equivalent to rotating the Bloch sphere by π around the ˆx-, ŷ-, and ẑ-axes, respectively. The T operator rotates around the ẑ-axis by π/4 (it is called π/8 since it is equivalent to [ e iπ/8 0 ] 0 e iπ/8 up to a global phase). Any n-qubit unitary operator may be composed from single-qubit operators and the CNOT operator. A minimal universal set of operators, able to approximate any unitary operator to arbitrary precision, is CNOT, H, and T. Another interpretation of the above operators is that the bit-flip exchanges the probabilities of the two states, while the phase flip changes the sign (phase) between them. The Hadamard takes the two states and mixes them to a halfway state. The controlled-not does a bit-flip if the control qubit is 1: CNOT xy x,x y, where is the usual XOR operator. These basic gates, along with qubit measurement, form the set of operations used for quantum computation. To illustrate that quantum computation is potentially more powerful than classical computation, it useful to look at entanglement. If two qubits are joined to form a system, x y xy, the result is the tensor product (denoted by ) of the vector representations: (α 0 +β 1 ) (γ 0 +δ 1 ) αγ 00 +αδ 01 +βγ 10 +βδ 11 Any single-qubit operator, or tensor product of single-qubit operators, may be applied to the system and the qubits remain independent. However, if one starts with 00 and applies a Hadamard operator to the first qubit, and then uses that qubit as the control in a CNOT on the second qubit (see Figure 2.3), the resulting superposition of states, , cannot be split into the tensor product of two qubits. The two qubits share information that neither qubit has alone, and there is no concept of state for the individual qubits. The qubits are now tied together, or entangled: whatever value is measured for the first qubit will also be measured for the second qubit. The amplitudes for 01 and 10 are zero. This particular state is known as an EPR pair (after Einstein, Podolsky and Rosen, who were among the first to investigate such states). It is also called a Bell state, or a cat state, after Schrödinger s infamous thought experiment. Cat states are very important, and are used sets of qubits.

19 CHAPTER 2. BACKGROUND 8 00 H Figure 2.3: Creating a cat state extensively in quantum computation. The group of operators given above are sufficient to approximate an arbitrary n-qubit unitary operator to any desired accuracy. For n > 1, however, the approximation is not necessarily efficient, and may be exponential in n. That said, a few more operators are generally used for descriptions of computations. They are R x (θ), R y (θ), and R z (θ), rotations by θ about the ˆx-, ŷ-, and ẑ-axes. R z (π/2) is used often enough to deserve its own name, S. Any two of the arbitrary-rotation operators can be used to efficiently implement any single-qubit unitary operator, U: U = R x (α)r y (β)r x (γ). for some α, β, and γ. that are important 3 : Much like classical gates, there are some basic relationships between quantum operators X 2 = Y 2 = Z 2 = H 2 = I X = X Y = Y Z = Z XZ HZH HXH S 2 = iy = X = Z = Z T 2 = S 3 The symbol indicates the adjoint (conjugate transpose) of the operator. Since all quantum operators are unitary, the operator s adjoint is also its inverse.

20 CHAPTER 2. BACKGROUND 9 SZ = ZS = S SXS = Y There are also several relationships involving CNOT: 1. X applied to the control input is equivalent to applying X to both outputs. 2. X applied to the target input is equivalent to applying X to the target output. 3. Z applied to the control input is equivalent to applying Z to the control output. 4. Z applied to the target input is equivalent to applying Z to both outputs. 5. H s applied before and after to the target bit converts a CNOT to a controlled-z operator. 6. Two qubits may be swapped with three CNOT s, with the middle CNOT applied in the opposite direction (swapping target and control). One final operator is needed to make quantum computation useful: measurement. Measurement is the one operation allowed in quantum computation that has no inverse. For a quantum system, any observable, such as energy or momentum, can be projected onto one of the eigenstates (basis states) of the measurement operator. Measurement is equivalent to choosing one of the states represented by the qubit(s) based on the probabilities determined by the amplitude vector. For example, if a system of two qubits is in the state , the probability of measuring either 00 or 01 is 1 4 ; the probability of measuring 11 is 1 2. If only the first qubit were measured, the probability of measuring 0 is 1 1 2, and the system would be in the state 2 ( ) (see footnote 4); if a 1 were measured (also with probability 1 2 ), the system will be in the state 11. Note that measurement collapses the wave function representing the superposition of states, leaving the system in a state consistent with the measured value: if a qubit is measured as zero, it will be measured as zero from then on, unless another operator is applied (but see the footnote 4 ); if only part of a set of entangled qubits is measured, the rest of the qubits will be in a superposition of states consistent with the value(s) measured. 4 In some schemes, measurement may be destructive, effectively randomizing the qubit. Subsequent measurements may not give the same result, and the resulting state is different than the state before the measurement.

21 CHAPTER 2. BACKGROUND 10 Measurements are possible in something other than the computational basis. In terms of the Bloch sphere, the usual measurement operator described really measures zero for up and 1 for down, but could just as easily measure left and right (along the ŷ-axis). Usually, though, such a measurement is made by rotating the ŷ-axis to the ẑ-axis (R x (π/2)), using the usual measurement operator, and rotating back. Measuring in the up-down direction is the equivalent of measuring the Z operator, and in the left-right direction, the Y operator. It is also possible to measure a more complicated operator, using a basis with multiple qubits. An example using measurement in other bases is quantum error correction (see the next section), where multi-qubit operators are measured to extract partial information about a block of qubits. The measurement operators essentially return the parity of a sub-block of qubits, rotated to appropriate bases. Much like measuring one qubit of a cat state completely determines the state of the other qubit, the series of parity measurements completely determines the value of the error, which can then be corrected. 2.2 Quantum Error Correction Classical bits are highly immune to noise. One can expect a classical bit to fail every operations (about one bit per year, in a typical system). Qubits, on the other hand, can be expected to fail on one out of every operators. Quantum phenomena are constantly evolving with time. Atoms decay. Electrons change orbitals by absorbing or emitting photons. Magnetic spin states of nuclei and electrons flip due to external magnetic fields. A quantum system cannot be isolated to the point where it is completely stable. Hence, if qubits are entangled, they will slowly decohere (lose their unique state properties) due to entanglement with the environment. Since quantum states form a continuum, errors are not limited to full phase- or bit-flips. An error can be a slight deviation from the intended quantum state. As errors accumulate, quantum data stored on the qubits is corrupted and lost. The environment, in the form of a classical controller, acts on a qubit with each application of an operator. The actual applied operator is an approximation of the desired operator, implemented by a classically-controlled physical process, so the operator itself has a non-zero chance of introducing error 5. 5 Non-operator decoherence also occurs. The major mode of non-operator decoherence is dephasing, which has im-

22 CHAPTER 2. BACKGROUND 11 One way to reduce the effect of decoherence is to encode the state of a single logical qubit over several physical qubits. Peter Shor originally proved the feasibility of quantum error correction [44], by using a three-qubit repetition code to show the feasibility of encoding either quantum amplitude or phase. He then showed that the qubits comprising a three-qubit code for protecting amplitude could each be encoded in the three-qubit code for protecting phase. Here is how: A logical qubit representing 0 ( 0 L ) can be encoded as 000 and 1 L as 111. The superposition α 0 L + β 1 L is encoded as α β 111 When the logical qubit is measured, if one of the physical qubits is different than the other two, one can assume that it was inadvertently flipped along the way. However, it would be better to determine that a physical qubit had been flipped without having to measure it, since measurement destroys the quantum state. One can measure the difference in value (parity) between any two physical qubits using an ancilla an extra 0 and a circuit like the one in Figure 2.4. By performing two such measurements (see Figure 2.5) one can determine if a single qubit s value is different than the other two, and correct it (see Table 2.1). Protecting amplitude information is not enough, however, since phase information is just as important. Shor noted that a similar circuit (without the Hadamard gates, and turning the CNOT s around) could be used to measure the difference in phase between two qubits. By encoding each of the three qubits in the amplitude-flip code with the three-qubit phase-flip code (nine qubits total), one can measure and correct any single phase or amplitude error. Furthermore, the process of interacting the ancilla qubits with the encoded qubits produces an entangled state. After the measurement, the remaining qubits are in a state consistent with the measurement. That is, if qubit 2 is out of phase with the others, then applying a Z gate will exactly fix the error! The nine-qubit logical codewords for the states 0 L and 1 L are ( ) ( ) ( ) 0 L = 2 2 ( ) ( ) ( ) 1 L = 2 2 To convert 0 L to 1 L requires three single-qubit operators, meaning that at least three independent errors would have to occur before the error-correction scheme fails. Hence, any single error can be reliably corrected. plications for error-correction strategies for stored data.

23 CHAPTER 2. BACKGROUND 12 0 H H Z 12 ψ2 X ψ 2 ψ1 X ψ 1 Figure 2.4: Measuring X 12, the difference between (parity of) ψ 1 and ψ 2 0 H H Z 12 0 H H Z 23 ψ 3 X Z ψ3 ψ 2 X X Z ψ2 ψ 1 X Z ψ1 Figure 2.5: Syndrome Measurement for 3-bit Code. The meter boxes indicate measurement, and the double lines indicate classical communication controlling the application of the Z operator. The amazing thing about the code is that applying a Z (phase change) operator to each of the nine qubits takes 0 L to 1 L and vice versa. It is the same as applying an X (logical X) operator to the encoded qubit! Similarly, applying an X operator to each of the physical qubits performs a Z operation. Shor s code, based on the classical error correction method of repetition, is termed a [[9, 1, 3]] code nine physical qubits, encoding one logical qubit, with a Hamming distance of three. A code with a distance d is able to correct (d 1)/2 errors. The [[9,1,3]] code contains all of the elements of the quantum error-correcting codes presented in this document. To avoid actually measuring the state of the individual qubits, ancilla qubits are used for parity measurements. In addition, the measurement of the ancillae determines a unique error syndrome, a mapping from the Z 01 Z 12 Error Type Action 0 0 no error no action 0 1 qubit 3 flipped flip qubit qubit 1 flipped flip qubit qubit 2 flipped flip qubit 2 Table 2.1: Phase correction for a 3-qubit code

24 CHAPTER 2. BACKGROUND 13 measured values to the operations necessary to correct the error(s). Much like classical linear error codes, measuring the parity of subsets of the bits determines the error syndrome. The parity measurement tells nothing about the absolute value of the bits, just the relative value. Unlike a classical code, however, the parity measurements are made in a variety of bases: the parity measurement in the computational basis tells which bits have amplitude errors, and the parity measurement in the Hadamard-rotated basis tells which bits have phase errors. Shortly after Shor described the [[9, 1, 3]] code, many researchers [8, 46] showed how to create quantum error correction codes based on classical block codes. One important code is the Steane [[7, 1, 3]] code, which is used throughout most of this document. A generalization of block codes resulted in stabilizer codes, such as the [[5,1,3]] code [28], which is the smallest (densest) known encoding of a single qubit; and the [[8,3,3]] code [1, 17, 47], the densest code encoding three qubits. Larger codes such as [[16, 10, 3]] or [[23, 1, 7]] give greater density or larger Hamming distances. For more on quantum error-correction codes, the reader is directed to the literature [7, 34]. To summarize, errors in quantum circuits are not limited to full phase or bit flips, but can be any complex-valued linear combination of the two. However, when the error syndrome of an error code is determined, the parity measurements collapse the error waveform in the errormeasurement basis. Measuring the error effectively quantizes it so that only X, Y, and Z operators need be applied to correct it Fault-tolerant Computation Qubits are subject to decoherence when they interact with the environment. Applying an operator to a qubit is just such an interaction. On the other hand, if an operator could be applied directly to the encoded qubit(s), errors could be detected and corrected. Some stabilizer codes allow easy application of some logical operators, as the nine-qubit code demonstrated. The Steane [[7,1,3]] code is even more flexible, in that X is applied by applying X to all seven encoding qubits. The same is true for the Z, H, Y, and CNOT operators. The S operator requires applying ZS(= S 1 ). The last operator required to create a universal set, the T operator, requires a slightly more 6 This is not entirely true. The measurement and correction will return a valid codeword, or superposition of codewords. If more than (d 1)/2 errors occur, where d is the Hamming distance, then the error syndrome may indicate that no reliable correction is possible. If more than (d + 1)/2 errors occur, the corrections indicated by the error syndrome may take the code to some erroneous superposition of codewords.

25 CHAPTER 2. BACKGROUND 14 Logical qubit First level of encoding... Second level of encoding Figure 2.6: Tree structure of concatenated codes complicated procedure. Any logical operator may be applied in a fault tolerant manner, as long as p, the probability of an error for a physical operator, is smaller than, 1/c, where c is the number of ways two errors can cause an erroneous result during the logical operator application and subsequent error correction. Hence, the overall probability of a non-recoverable error for the logical operator is cp 2, an improvement when p is less than the threshold of 1/c. For the [[7,1,3]] code, c is about , assuming a CNOT operator can be applied to any two qubits in the system. If a logical qubit is encoded in n physical qubits, it is possible to encode each of those n qubits with an m-qubit code to produce an mn encoding. Such concatenation of codes can reduce the overall probability of error even further. For example, concatenating the [[7, 1, 3]] with itself gives a [[49,1,7]] code with an overall probability of error of c(cp 2 ) 2 (see Figure 2.6). Concatenating it k times gives (cp)2k c, while the size of the circuit increases by d k and the time complexity increases by t k, where d is the increase in circuit complexity for a single encoding and t is the increase in operation time for a single encoding. For a circuit of size p(n), and a desired probability of success of 1 ε, k must be chosen such that [34]: (cp) 2k c ε p(n) The number of operators to achieve this result is O(poly(log p(n)/ε)p(n)), provided p is below the threshold 1 c. The same results hold for codes other than [[7,1,3]], although there is no guarantee that performing logical operators on these other codes is efficient. For instance, stabilizer codes allow fairly easy application of the operators X, Y, and Z to the encoded qubits. However, for a given stabilizer code, an arbitrary operator may be difficult to perform in a fault tolerant manner. It is important to note that interacting two qubits in a logical encoding is not fault-tolerant. An error on one qubit can propagate through such interactions, even using an intermediate ancilla,

26 CHAPTER 2. BACKGROUND 15 permanently corrupting the encoded data. For example, in Shor s three qubit example in Section 2.2, a phase error on the ancilla can back-propagate across the CNOT, causing a phase error on the second qubit. Although the measured value of the ancilla would be correct, the data would be left with an uncorrected error. One solution, outlined in detail in Chapter 5, is to use a cat state in place of the ancilla. The cat state can be verified beforehand, since its properties are known. After the parity-calculating CNOT s, the cat state is uncreated (by reversing the order of the CNOT and H operators used to create it), condensing the parity onto a single qubit that can then be measured. 2.4 Quantum Algorithms There are many problems with quantum solutions whose theoretical asymptotic running time is better than the best known classical algorithm for the same problem. In general, the speedup of quantum algorithms is due to quantum parallelism, the ability to change the amplitudes of all states with a single operator. The downsides to quantum algorithms are (1) the answer is a single value, and (2) certain self-referential operations are not permissible ( if i then i = 0 ), since all operators must be reversible. Because the result of a quantum algorithm is a single value, quantum algorithms are best at hard problems whose answers are simple to verify, such as NP-decision problems. Two algorithms that solve NP-decision problems are Shor s order-finding algorithm (2.4.1) and Grover s unorderedsearch algorithm. Shor s algorithm can be used to factor n-bit numbers in O(n 3 ) time. Grover s algorithm can be used to find a pattern that meets some criterion from all possible patterns, and so can be used to solve NP-hard problems. The running time for Grover s algorithm is O(2 n/2 ) for a problem whose solution space is O(2 n ). A classical algorithm solving the same problem has to search through the entire solution space, giving a running time of O(2 n 1 ). While not as dramatic an improvement as Shor s algorithm, Grover s algorithm still out-performs any known classical algorithm for NP-hard problems. Because of the requirement for reversibility of operators, certain algorithms are not feasible. For example, Chapter 6 discusses several randomized methods for sorting 0 and 0 +eiθ 1 2 qubits to opposite ends of a register as a mechanism for system initialization. A better systeminitialization algorithm might be to simply sort the 0 and 1 qubitsr; unfortunately, doing so

27 CHAPTER 2. BACKGROUND 16 requires a statement of the form if ψ i = 0 then SWAP( ψ i, ψ i 1 ). The resultant absolute ordering retains no information about the initial order of the values, and so is not reversible. A brief description of Shor s algorithm is in the next subsection. Grover s algorithm, adiabatic algorithms, and numerous others, though important, are not discussed here. The interested reader is referred to [22] and [34] for a discussion of Grover s algorithm, and to any of several excellent web-based encyclopedias for discussions of the remainder Shor s Factoring Algorithm Perhaps the biggest motivation for research into quantum computation is due to Peter Shor s algorithm for factoring large numbers. Factoring is considered to be a hard problem: the best classical algorithms known require exponential time in the number of bits. Rivest, Shamir, and Adleman [39] have used it for the trapdoor function for RSA security: A message is encrypted by representing it as a number M, raising M to a publicly specified power e, and then taking the remainder when the result [is] divided by the publicly specified product, n, of two large secret prime numbers p and q. Decryption is similar; only a different, secret, power d is used, where e d = 1 (mod ((p 1) (q 1))). The security of the system rests in part on the difficulty of factoring the published divisor, n. Clearly, an algorithm that makes factoring exponentially easier is of immense interest. Shor s algorithm [43] can factor large numbers in polynomial time on the size of the representation (i.e., the number of bits), using modular exponentiation and an inverse quantum Fourier transform. The algorithm factors a large composite number, n, by finding the order of an element x of the group Z n. That is, for some integer x that is relatively prime to and smaller than n, the algorithm finds r such that x r = 1 (mod n). If r is even, and x r/2 1 (mod n), then (x r/2 +1)(x r/2 1) = kn, where k is an integer, since x r = kn+1. With very a low probability of failure, O( 1 n ), at least one of (x r/2 + 1) or (x r/2 1) divides n. The algorithm relies on the fact that if x r = 1 (mod n), then x br+k = x k (mod n), for any positive integers b and k. That is, f(a) = x a (mod n) is a periodic function, with a period of r, or equivalently, a = br+k, for some b and k.

28 CHAPTER 2. BACKGROUND 17 The first step of the algorithm is to make sure that n is not prime, and has more than one prime factor, since the probability of success also depends on the number of prime factors. Both of these requirements have polynomial-time tests. The algorithm proceeds as follows: 1. Start with two quantum registers, A and B. B should have log 2 n qubits (large enough to hold n), while A should have log 2 q = 2 log 2 n +1 qubits, where q is the smallest power of 2 greater than 2n 2. (Notice that the largest value that can be held by A is q 1.) 2. Put A B into the uniform superposition, 1 qubit in A. q 1 2 q 1 a=0 a 0, by applying an H-operator to each 3. Calculate x a (mod n) in the B register: 1 q 1 2 q 1 a=0 a xa (mod n). This can be done using standard arithmetic: modular multiplication is built up from modular addition, and modular exponentiation from modular multiplication, in O((log n) 3 ) time. 4. Finally, apply the quantum Fourier transform 7, a x a 1 q q 1 c=0 e2πiac/q c x a, and measure A to get c. To find r from c, it is important to look at the result of the Fourier transform, to see what values of c are most probable. The system A,B after the transform is in the following state: A,B = 1 q q 1 q 1 a=0 c=0 e 2πiac/q c x a Remembering that a = br+k for integers b and k, the probability of measuring a particular c and x k is 1 q 2 e 2πiac/q a:x a =x k = 1 q (q k 1)/r 2 e 2πi(brc+kc)/q = b=0 1 q e2πikc/q (q k 1)/r 2 e 2πibrc/q b=0 where the term e 2πikc/q is a constant with magnitude 1, and can be factored out of the summation. The terms being summed are all vectors on a unit circle in the complex plain (see Figure 2.7). If rc/q is close to 1, then the terms in the summation are about the same (that is, close to 1+0i), and constructively interfere. However, if rc/q is not close to 1, the terms are spread out over a unit circle on the complex plain, and destructively interfere to a sum close to 0. 7 The quantum Fourier transform is analogous to the discrete fast Fourier transform, and can be applied bit-wise, using controlled rotations. See Figure 4.2 on p.40 for an example. For an in-depth discussion, see [34]. The running time for the fast quantum Fourier transform is O((logn) 2 ).

29 CHAPTER 2. BACKGROUND 18 (a) (b) Figure 2.7: Summing over the Quantum Fourier Transform Vectors The two graphics above show 32 vectors being summed together. In (a), the vectors cover from 2ibrc/q = 0 to pi/2 (1/4 revolution), while in (b), the vectors cover from 2ibrc/q = 0 to 5π/2 (1-1/4 revolutions). The center of the small white circle indicates the resulting mean of the vectors (sum of the vectors divided by the number of vectors). Notice in (a), the small white circle is close to the outside of the unit circle, indicating an amplitude close to 1, whereas in (b), the amplitude is much smaller. The terms constructively interfere when rc mod q < r 2, or, equivalently, when r 2 < rc sq < r 2, for some integer s. Rearranging gives c q s r < 1 2q, implying that c q approximates s r. One can find the closest approximation s r, r < n for c q by truncating the continued fraction8. Given r, both x r/2 ± 1 can easily be calculated, and tested as divisors for n Teleportation It is possible to use many quantum error correction codes in a quantum computer, but converting between them can be problematic. Decoding and re-encoding can randomly propagate errors across qubits and compromise reliability. Fortunately, there is a special way to convert between codes that avoids this problem. This method involves the quantum primitive of teleportation [19]. As it turns out, teleportation is not only a good way to convert between codes, but it is also a good way to transport quantum data between different parts of the system. Quantum teleportation is the re-creation of a quantum state at a destination using the 8 Euler s continued-fraction algorithm uniquely represents a real number x as x = a a a 2 + where the a i are integers. If the series {a 0, a 1, a 2,... is truncated, the result is an approximation of x, with more terms giving a closer approximation. If x is rational, the series a i will terminate; if irrational, it won t.

30 CHAPTER 2. BACKGROUND 19 a H EPR Pair b c X Z a Figure 2.8: Quantum Teleportation shared quantum state of an EPR pair, , split between the source and the destination, and two measurement results that must be communicated as classical bits along conventional wires or other media. Figure 2.8 gives a schematic of the process, also described by this (typical) narrative: suppose Bob and Carol have the two qubits, b and c, of an EPR pair. Carol takes c to New York, leaving Bob (and b ) in Davis. Next Alice, who has the quantum state a, wants to send that state to Carol. She and Bob perform a CNOT, using a as the source, and then Alice performs an H operator on a. Next, they measure a and b, and send the two one-bit results to Carol over classical media. (In the figure, quantum data is denoted by the solid single lines, while classical data is represented by solid double lines.) Based on the sent bits, Carol applies either an X-gate, a Z-gate, or both to patch up c, which now has the original state of a. One way to think about what is happening is as follows. The CNOT operator transfers amplitude information from a to b (and phase information from b to a ), causing a partial rotation of b with respect to c. When b is measured, this angular difference is maintained, meaning that c has the amplitude characteristics of a, modulo a bit flip. The H operator applied to a rotates it so that its new phase (as rotated by the CNOT with b ) is measured. The two measurements provide information about the amplitude and phase errors of c relative to the original state of a, and the classical bits transmit that information. Two interesting asides are: 1. If the original state of a were not destroyed, teleportation would violate the no-cloning theorem [54]: duplicating both its phase and amplitude potentially allows enough information to be gathered to violate Heisenberg s uncertainty principal; and,