Simulated Quantum Annealer

Transcription

1 Simulated Quantum Annealer Department of CIS - Senior Design Danica Bassman danicab@seas.upenn.edu University of Pennsylvania Philadelphia, PA ABSTRACT Quantum computing requires qubits, which obey the laws of quantum mechanics and therefore behave very differently from classical bits. This difference can allow quantum computers to achieve massive levels of parallelism impossible on a classical computer. As a result, certain problems that are in NP but highly parallelizable can be solved by quantum computers in polynomial time. Quantum computers have the capacity to drastically change the computing world, but they are complex and difficult to implement; to study them, we often look to simulators that can bypass many of the roadblocks inhibiting our path to a true quantum computer. A simulated quantum annealer takes advantage of the adiabatic theorem to solve problems by transitioning from a simple to complex quantum state while maintaining minimal energy. We simulate these quantum states, energies, and transitions on classical machines by mathematical abstractions for proof of concept and to circumvent the complications of physical implementation. To do this, we solve 3SAT on a classical machine simulating how it would be solved by quantum annealing. 1. INTRODUCTION At the heart of quantum computing is the quantum bit, or qubit. In mathematical terms, a qubit is a complexvalued -dimensional unit vector. This vector represents a -dimensional wave function, spinor, that gives the probabilities that a given electron has a given spin state [9]. For our purposes, however, we can think of it simply as a - dimensional unit vector that describes the probability that the value of the bit is a 1 and the probability that the bit is 0. It is important to note that the qubit does not have to be either 1 or 0, but can be in a superposition of both simultaneously. This means that it has given probability of collapsing into 0 and probability of collapsing into 1, but before measurement, it hovers in superposition in both states [9]. At some point, however, we must actually extract the data from the qubit, which means we must measure a 1 or 0. The state of superposition ends when we take a measurement of the qubit, and the qubit collapses into either state (1 or 0), and holds this value with 100 percent certainty. Figure 1 [3] shows the vector representation for a qubit, highlighting the wider range of values a qubit can take on as opposed to a classical bit. Another key quantum mechanical property relevant to quantum computing that is a direct result of superpo- Advisor: Max Mintz (mintz@cis.upenn.edu). Figure 1: Classical Bit vs. Qubit sition is entanglement. Instead of looking at one qubit in isolation, let us consider two qubits. These qubits can be such that if one s spin is upward, the other s must be downward, and vice versa. These two qubits are said to be entangled because each qubit s state is directly correlated to the other s [9]. Note that this is feasible when the values of the qubits are known, but as we discussed earlier, until we measure the qubits, we do not know their values. Let qubit A be 1 or 0 with certain probabilities and be entangled with qubit B. We will not know the value of A until we measure it, but the moment we do measure A, and say that we discover its value is 1, we instantly know that B must be 0. This correlation occurs even when A and B are on opposite ends of the universe. This relationship is puzzling, and one for which there is still no clear explanation [9]. Nevertheless, it is generally accepted that this relationship exists, and therefore we can utilize it in our computations with qubits. Many qubits can be entangled at a given time, which means that if we act upon a single qubit, we are also acting on all qubits that are entangled with it. This gives us a level of parallelism unfathomable on classical computers. Now that we see the benefits that using qubits as hardware can provide, we must examine the new opportunities and challenges that arise when programming for a quantum computer. We noted that quantum computing allows us a great level of parallelism heretofore unrealized in classical computing. This parallelism allows a quantum machine to act almost non-deterministically. This gives us the potential to tackle a whole new set of problems efficiently that were impossible before, this set of problems being nondeterministically polynomial, those in NP. Not all problems in NP can instantly be solved in polynomial time using a quantum computer. Algorithms exist, such as Shor s, which tackles prime factorization, but we

2 do not yet have quantum machines powerful enough to run these on a large enough scale. Still, it is exciting to consider the possibility of being able to prime factorize in polynomial time since this would allow us to decode anything encrypted using the RSA algorithm, the most widely used encryption algorithm today. While the original impetus and biggest implication of studying and successfully implementing a quantum computer stems from prime factorization, we are still some distance from successfully running Shor s algorithm on a functional and robust quantum machine. Quantum annealing can only be used for combinatorial optimization problems such as exact cover, 3SAT, and the traveling salesman problem. Many of these problems are in NP, which means there are major implications to being able to solve them in polynomial time. Quantum annealing may provide this speedup; however, it is not yet certain because of limitations of physical implementations. A simulated quantum annealer can bypass the obstacles a physical machine faces in the real world, allowing for proof of concept for quantum annealing in an ideal world. This simulation solves 3SAT on a classical computer by simulating the method of a quantum annealer. Existing quantum machines are not yet powerful enough to tackle large scale problems or robust enough to solve a wide range of problems. They potentially can solve some types of problems in NP, and many studies indicate that they can, in fact, solve these problems in polynomial time. Many real-world factors inhibit our ability to run these machines on large scale problems successfully, so constructing a simulator allows us to explore the best possible routes that may eventually lead to successful, tangible implementations.. RELATED WORK.1 True Quantum Annealers When considering quantum computers, the biggest and most relevant player in the industry is D-Wave. D-Wave produces and sells the D-Wave Two System, a machine with a 51 qubit processor that appears to be a functional quantum computer []. This claim, however, is not taken at face value by some scientists in the quantum computing field [1]. D-Wave is a commercial company and whose best interest is served by presenting the D-Wave Two in the best light possible. Furthermore, the field of quantum computing is so nascent, and D-Wave is the only real player, so there are no clear benchmarks on which to judge its success. Academics have compared results to both classical machines and simulated quantum computers. Understanding the theory behind quantum computing, previous simulations, and their standing against classical machines is key to building a quantum computer simulator. D-Wave s machines work through a method called quantum annealing. This sets them apart from past quantum computing models because it allows the machines to be more error-tolerant [8], a factor we will examine in more detail when discussing simulators. Quantum annealing is a type of adiabatic quantum computation, a method designed by Farhi, Goldstone, and Gutmann in 000 [6]. McGeoch and Wang compared the results of quantum algorithms used to solve three NP-hard problems run on a special purpose D- Wave Two with 439 qubits and on three software solvers. The results showed that the software was 3600 times slower than the D-Wave Two using quantum annealing. McGeoch and Wang note that this is just one instance and should not be taken as evidence that D-Wave is completely effective in every instance for every problem [8], but nonetheless, these results are heartening to supporters of D-Wave. For our purposes, however, the efficacy and efficiency of D-Wave machines is not important; we are more concerned with the methods used by D-Wave, and how we can simulate quantum annealing on a classical machine since it appears to provide significant speedup.. The Adiabatic Theorem Understanding the underpinnings of quantum annealing requires some physics and mathematics. First, consider Schrödinger s equation, which describes quantum behavior and gives solutions that are complex-valued functions of space and time: i d ψ(t) = H(t)ψ(t) [8] [6]. The adiabatic theorem applies when H(t) is slowly varying. H is d(t) the Hamiltonian, which represents the total energy of the system [9]. A Hamiltonian system describes a process that evolves continually over time, in our case, a process that involves n binary-valued particles. So let H(t) = a n x n matrix, where the eigenvectors of H(t) correspond to measureable states in the system and each eigenvalue is the corresponding energy. We are interested in the ground state, the eigenstate with the lowest energy [8]. We want to solve a minimization problem where the lowest energy state described above corresponds to the lowest cost solution. Recall that we are using qubits, so each is represented by a vector (u, v) such that u + v = 1, u = the probability that the qubit = 1, and v = the probability that the qubit = 0. We choose an initial ground state H(0) such that φ(0) has minimal energy, where φ(t) = the eigenstate with the lowest energy at time t [8]. Next, we set our end point H(1) such that φ(1) = an optimal minimization solution. Finally, we need a method for the system to slowly evolve from H(0) to H(1), which McGeoch and Wang describe. The adiabatic theorem, originally presented by Born and Fock, states that φ(t) will remain constant if the changes acting on the system are slow enough and there is a difference between the eigenvalue of H(t) and the rest of the Hamiltonian s spectrum [6]. This ensures that in the example above, we end the process with the lowest possible energy (the same that we started with), but the system has evolved to an optimal solution of our minimization problem, so our result is the lowest-costing minimum [8]. Quantum annealing stems form the physical process of annealing, which invovles the slow cooling of a liquid to freeze it in an optimal state. Both are products of the adiabatic theorem. Figure depicts how this occurs in physical annealing, which is analogous to how it works in quantum annealing. The image on the left shows a liquid cooled slowly, freezing in its optimal lattice structure. The image on the right shows what happens if we cool too quickly. The liquid freezes before it has had time to transform into an optimal formation. This is analogous to quantum annealing Should the transition of the Hamiltonian occur to quickly, the system will no longer be at minimal energy, but rather a less ideal, higher energy state, like the images in Figure. Quantum annealing is the method that D-Wave s machine used in McGeoch and Wang s experiment. We examine how simulated annealing [5] works to better understand the implementation and how we go about simulating it on

3 Figure : Physical Annealing our quantum computer simulator. Start with any randomly chosen initial state and store the energy of this state. The process could continue indefinitely, so we must set a time limit or other bound. For example, if the ideal energy value is known, it can be compared to our current best solution to that. Next, pick a random neighbor (neighbor being some other possible state) and compare its energy to the current state s energy. If it is a lower energy, then set the current energy to that of the neighbor. Next, check if this new current energy is better than the running best energy, and if it is, set the best to this value as well. As time goes on, we zero in closer and closer on our solution, finding better and better energies until finally we end with the optimal solution [5]. A graphical representation of this process from D-Wave is shown in Figure 3 []. Figure 3: Simulated Annealing Process.3 Simulation Under the Quantum Gate Model Quantum annealing is only one strategy that proves to be successful in some cases; however, there are other methods that can be employed. These methods are particularly relevant for simulations since they cannot always be implemented in practice. Instead of annealing, we can look at gate level simulations. First, consider ideal quantum computer simulations. These are ideal in the sense that the qubits perfectly utilize superposition and entanglement [11]. There are 1-qubit gates such as Pauli-X, Pauli-Y, and PauliZ, which are rotations around the Bloch Sphere (the sphere in complex space that depicts possible values for a qubit). The Hadamard gate takes a well defined qubit to a superposition (defined with probabilities). There also exist gates that act on two or more qubits to realize interactions between qubits. These include the controlled-not (CNOT), which is analogous to an XOR gate in classical computing. DiVincenzo showed that using only these gates, any unitary operation can be approximated to any accuracy. [11] Simulation is based on the assumption that each operation is done (1) instantaneously and () without error, but this is always the case. In the real world, experiments are compromised by issues such as imperfect spin rotations, unwanted interactions, and decoherence [11]. Quantum coherence is the transition from quantum states to classical states, which occurs when we make a measurement of a specific qubit. Decoherence occurs when the qubit collapses from superposition into a classical state from external or environmental factors, which can result in the loss of information. To account for these issues, the error model was developed [11]. To address decoherence Nielsen and Chuang developed the depolarizing channel [11]. Here, we map general errors to linear combinations of basic errors such as a bit flip, phase flip, or both. The channel assumes that each of these errors has an equal probability of occurring, while also taking into account the possibility of being error-free. We then run the operation and let the decoherence operation described above affect the qubit at each step. A simulation must only deal in pure states, so we run our algorithm many times, assigning the results of each run a probability based on the errors we think might occur [11]. In the field of simulation, work in fault-tolerant machines has led to the accuracy threshold theorem. Developed by Aharonov and Ben-Or, it states that arbitrarily long quantum calculations are possible if the probability of a single qubit being erroneous is below a given threshold [11]. This implies that in theory, large scale quantum computers should be possible, but there are roadblocks to realizing them. Real-world implementation of a machine using quantum gates and registers is currently unrealistic because there are so many sources of error that the machine is unlikely to operate properly. The factors that cause these imperfections, however, are a result of operating in nature, and we can ignore them when working in simulation. Quantum computation is a rapidly advancing field with no official benchmark industry standards. There is no best method to simulate a quantum computer. Furthermore, we cannot say for certain that a functional quantum computer exists because not all experts agree that D-Wave s results demonstrate success. Therefore, any attempt to simulate a quantum computer adds something new to the field. Each model, built from a different perspective or with new goals in mind, provides new insight. While we can represent an ideal quantum computer with no decoherence in simulation, this is not necessarily helpful since it cannot be translated to a physical machine. There exist possibilities for incorporating these errors, and methods for correcting and accounting for them. Instead, we bypass this strategy entirely and choose to simulate quantum annealing, which allows for more error

4 within the individual qubits. This is the most reasonable path to pursue since D-Wave has shown that this strategy might be translated to a real-world machine successfully [8]. 3. SYSTEM MODEL 3.1 Case Study: Simulation Under the Quantum Gate Model While no physical implementations yet exist under the quantum gate model, the majority of simulations follow this paradigm. It is an exact analogy between the classical bit to the qubit, the classical gate to the quantum gate. By understanding this model and studying the tools used to simulate it on a classical machine, we can apply the same techniques to simulate a quantum annealer Simulated Qubit For annealing, the qubits will comprise the quantum system and are analogous to the quantum registers. Consider implementing a quantum register on a classical machine. These registers are best described in mathematical terms based on the linear algebra that dictates their behavior. A single qubit is a two-dimensional unit vector in complex space, so we can define all aspects of it in linear algebraic terms. A basis is a set of linearly independent vectors that describe a vector space. Any vector in that vector space can be written as a linear combination of the basis vectors. The coefficients of the basis vectors for a given vector are called the coordinates. In the case of qubits, the basis is made up of all n possible states and the coordinates are the probabilities that the qubit will collapse into that state. Examine this mathematical abstraction in more concrete terms.consider the two dimensional complex vector ( ) x y where x = the probability that the qubit will collapse into 0 and y = the probabilility that the qubit will collapse into 1. If the qubit is defined as 0 or 1, it is not in superposition, i.e., it has a 100 percent chance of collapsing into 0 (or 1). To represent 0 as a two-dimensional vector, then clearly the vector representation = ( ) 1 0 This can be expanded for the case where the qubit is in superposition. The vector must lie in the Bloch sphere, which is to say that it must be of unit length, or its length must be 1. Consider the common case, where the qubit has equal likelihood of collapsing into either 1 or 0. In the - dimensional unit vector above, this means x = y. Using this information, we know that the normal two dimensional vector where x = y must be ( ) 1 1 We can infer from these two examples how any other qubit would be represented: determine the relationship between x and y, and then normalize the vector. This is for a single qubit in isolation, but the mathematical abstraction can be easily explanded to incorporate many entangled qubits. This expansion is how we simulate both a register and for a quantum system. A true quantum annealer has a system of qubits that are coupled, which in essence means the same thing as entangled, except that in coupling, spacial locality is necessary for the properties to take effect (entanglement prevails regardless of proximity in space). Recall that representing n qubits required n classical bits. We will now show a mathematical justification for this that explains how we go about encoding this property in simulation. A vector for a set of entangled qubits exists in n dimensional complex space. To define a vector space, use a set of vectors known as a basis, and the basis for a set of entangled qubits corresponded to the possible states into which the entangled vectors could collapse. Each qubit can take on the state 1 or 0. If there are n qubits, and each can take on 1 of states, then combinatorically, there are n possible states of collapse. Our basis is defined by these possible states. Next, the coordinates of any vector with respect to the basis are the probabilities of the entire system collapsing into that state. Therefore the representation of some arbitrary set of entangled qubits is simply a n dimensional coordinate vector in the computational basis described above, with each coordinate indicating the probabilities of collapse into that basis vector state. This follows in mathematical terms, but we must encode this using classical programming tools. A vector is analagous to an array. For any n dimensional qubit, simply create a n array where the i th value indicates the probability of collapse into state i. The value of the index in binary is equivalent to the state of collapse, so this maps perfectly. We use this representation for qubits on a classical machine in both simulated quantum annealing and simulated quantum computer to represent quantum registers [4] Simulated Quantum Gate In a classical computing model, we pass the information through gates to perform given operations. There are gates that act on a single bit (e.g., the NOT gate) and gates that can act on multiple bits, taking multiple bits as input (e.g., AND gate, OR gate, XOR gate). Similarly, there are quantum gates to perform similar operations. For acting upon a single qubit, there are the Pauli X, Pauli Y, and Pauli Z gates. These are named for the axes around which they rotate the qubit s vector in the Bloch Sphere. Pauli X is the quantum equivalent of the classical NOT gate. In addition to these rotations, there is the Hadamard gate, which essentially takes a qubit that is in a classical state into an equally weighted superposition. More precisely, it takes 0 to and 1 to 0 1. Consider the Hadamard gate. It can be represented in simulation as the Hadamard matrix: H = ] [ In order to perform an operation on a quantum register, which is simply a two dimensional coordinate vector, we simply perform matrix multiplication. Similar matrix representations of the Pauli gates exist, and since these are all simple x matrices and are operating on single bits, which are two dimensional vectors, this multiplication can be implemented for simulation [4]. As mentioned above, there are also gates that act upon

5 multiple qubits. One such class of gates are the controlled gates. These are gates that act on or more qubits. They are called controlled gates because one of the input qubits is used as a control, meaning that whether some operation occurs is dependent on this qubit. As an example, consider the controlled-not gate. Figure 4 shows the physical representation for the CNOT gate. It takes two qubits as inputs: Figure 4: Physical CNOT Gate the control and the target. It performs the NOT operation on the target of the control bit is 1, otherwise, it does nothing. As with the single bit gates above, these gates can also be represented as matrices. The CNOT gate operates on two bits, therefore it will be represented as a x, or 4x4 matrix. CNOT = Note the x matrix in the bottom right corner: [ ] This is the matrix representation the Pauli-X gate mentioned above, which is analagous to the NOT gate in classical computing. Based on this pattern, we can generalize the above template for any controlled-u gate. A controlled- U gate will perform operation U on the target qubit if the control is 1, otherwise, it will leave the control and target unchanged. As above, its matrix representation will be: where u 1 u 0 0 u 3 u 4 [ ] u1 u u 3 u 4 is the matrix representation for some single bit gate. As in the single bit case, we simple multiply this matrix by the 4 dimensional coordinate vector of the two input qubits to simulate data passing from a register through this gate [4]. 3. Simulated Quantum Annealing We can apply the strategy of using mathematical abstraction to represent quantum state on a classical machine using linear algebraic structures. We examined how this is done in the simulation of the quantum gate model, and will apply these same techniques when implementing the simulation. Now we examine at a high level the system design and components needed for quantum annealing. This illuminates what components are needed to simulate and define linear algebraic abstractions in the System Implementation Section. Quantum annealing is based on the adiabatic theorem, which states that if we slowly change the Hamiltonian, a quantum system remains in the ground state of the instantaneous Hamiltonian [1]. Apart from why this process works, this theorem also tells us what components we would need to run a true quantum annealer, and therefore the components we need for a quantum annealer. The first component is a quantum system. The first step is to simulate a qubit. A quantum system requires more than one qubit, specifically a set of entangled qubits. This is analagous to a quantum register in the register and gate model. We will go into more detail in the System Implementation section, but because qubits are two-dimensional unit vectors in complex Hilbert space, mapping the physical qubits to a mathematical abstraction is a fairly simple application of linear algebra. Next for annealing, transition from a simple state to a more complex state, and this requires many factors for our model. First, we need a ground state that is relatively simple. Since the state is a Hermitian matrix, simple here means a matrix whose eigenvectors and eigenvalues are easy to calculate [10]. How to find such a matrix will be discussed in more detail in the System Implementation section. In addition to an initial state, we also need an end state that will represent the optimal solution to our problem. This means a matrix such that the eigenvector corresponding to minimal energy maps to the optimal solution. This further requires that we define an energy function such that minimal energy maps to optimality. This too will be discussed in more delatil in the System Implementation section. Finally, define a transition function this defines how we move from one state to the next. The challenge here is twofold: how is this function defined, and how do we simulate this physical shift happening. The function definition is dependent on the problem, so for implementation, we will discuss examples and methods for determining a proper function based on the problem. We will also examine how this transition occurs in a simulated (nonquantum) annealer to enlighten how one could approach this transition in a quantum simulation. In summary, the basic process of quantum annealing in layman s terms is: 1. Choose a simple Hamiltonian with easily calculated ground state and minimal energy.. Define a complex Hamiltonian whose ground state will encode the solution. 3. Define a slow-moving transition function between the two such that quantum state maintains minimal energy.

6 4. When minimal gap is reached between complex Hamiltonian and current state (or enough time has passed), calculate ground state for current state, which will have minimal energy according the adiabatic theorem. Figure 5: Block-Flow Diagram The process is outlined in Figure 5. According to the adiabatic theorem, the system will have transitioned to a more complex state, but will have maintained its minimal energy. The eigenvectors in this state corresponding to eigenvalues for minimal energy is the optimal solution. We can identify the factors needed in our system model to be a Hamiltonian, its simple initial state, its complex final state, definition for its minimal energy, and its slowly moving transformation function. In addition to implementing these components using classical tools in isolation, which is a challenge, we must also encode methods for their relationships and interactions with each other. 4. SYSTEM IMPLEMENTATION Quantum annealing can only be used for combinatorial optimization problems, such as exact cover, 3SAT, and the traveling salesman problem. We define Hamiltonians for quantum annealing on a problem by problem basis. 3SAT lends itself to annealing because we can intuitively define simple and complex Hamiltonians such that the ground state of the complex Hamiltonian is equivalent to solving 3SAT. We implement a method for solving 3SAT, simulating how a quantum annealer would solve the problem on a classical machine. We do so using Java and the Jama library for the linear algebraic structures. As described in the System Design Section, we first define mathematical abstractions for quantum state and components, then discuss how these will be implemented in a classical program. 4.1 Mathematical Abstraction We consider the 3SAT problem, a Boolean satisfiability problem with the restriction that each clause has 3 elements. A clause is simply 3 Boolean variables strung together with OR statements. Start at the lowest level, defining h C(z ic, z jc, z kc ) = 0 if the Boolean variables (z ic, z jc, z kc ) satisfy clause C, otherwise it equals 1. W determine whether an expression, comprised of clauses, is satisfied by some Boolean variables (z 1, z,..., z n), therefore the total energy of the system will be defined as the sum of the energy of all clauses in the expression, i.e., h(z 1, z,..., z n) = Σ Ch C [10]. With an energy function now defined, we define the Hamiltonian matrix of the transformation. In doing this, we also define our final state H p and our initial state H b. Recall that an n qubit state ψ > is a n dimensional vector. That means that the Hamiltonian matrix of transformation must take n dimensional input. Generate this by taking the tensor product of the states of the Boolean variables, i.e., z 1 z 1 z z... z n z n. This will be n dimensional because z i is Boolean. Results of H must also be n dimensional, but the values we want are the scalar values 1 or 0 calculated with the function h defined above. To move these values into n space, multiply them using the tensor product z 1 z... z n. This will give an energy value for each clause H P,C equivalent to h c, but in different dimensional space. Therefore, we perform the same summation over all clauses to get the total energy of the system, H p. Note that H P will be equal to 0 if and only if all clauses are satisfied; otherwise, it will equal the number of clauses that are not satisfied. Therefore, not only is energy minimal at our solution, but energy level is directly tied and proportional to how close our possible solution is [10]. This H P represents the final, complex Hamiltonian structure in which we wish to end. The process of quantum annealing requires us to start at a simple Hamiltonian and transition slowly to a more complex one, maintaining minimal energy along the way. H P is the complex end state whose eigenvector corresponding to the eigenvalue of minimal energy is the optimal result, so we define H B to be a simple start state. Simple in this context means that the eigenvectors and eigenvalues are easy to calculate. These are easy to find when H is in a state such that all Boolean variables are in a quantum superposition where collapse into either 1 or 0 is equally likely. When defined this way, the eigenvectors are 1 ( ) and 1 ( 0 1 ) [10]. These definitions for h C, H P, and H B were defined by Max Mintz in his class notes for CIS398 [10], and largely inform this implementation of simulated quantum annealing. This is highly informative in terms of implementation. It serves as a template for other Hamiltonians since most combinatorial optimization problems are Boolean satisfiability problems. It also acts as a guide to implementation since 3SAT is NP complete, and therefore many problems in NP can be reduced to it. The final aspect of implementation will be performing the transformation from the initial state to the end state, or H B to H P in terms of the variables above. Quantum annealing is in essence a glorified guess and check methodology, so at a very basic level, we are essentially picking slight variations on the structure of H and deciding if it is better than our current structure. Of course in practice, it is much more complex than this. In terms of simulation, there are two aspects to consider: (1) how is this transformation defined; how would it operate, regardless of what it is running in simulation or a true quantum annealer. This should be well defined and essentially the same in both cases; and () how to map a transformation of a quantum system state onto a simulation by a classical machine. First, consider how this transformation is defined. To think about how this transformation process occurs, we can analyze the basic framework of the algorithm in a simulated (non quantum) annealer. A quantum annealer (and therefore our simulator) should have the same functionality. The general algorithm for transitioning between states is defined as follows: select a neighbor that can be found by making a small modification to the current state; decide whether this solution is closer to the optimal solution than the current; if

7 so, then move to this neighbor, else remain at current state; increment timer. Iterate through this process until we have either reached our time limit or found a good enough solution; here, good enough means the gap between the energy level of what we know our optimal solution to be and the current energy level is sufficiently small [7]. This is the process for simulated annealing, and it is essentially the same for quantum annealing. The only difference is in the area from which the system is selecting neighbors. In quantum annealing the radius of this neighborhood changes dynamically, while in simulated annealing, the size of the neighborhood is set at the beginning and remains the same throughout the process. 4. Physical Implementation 4..1 Input Parameters We have implemented a program that will solve the 3SAT problem using the quantum annealing paradigm, simulating quantum state on a classical machine using linear algebraic abstractions. The method has 3 paramaters: 1. Time: the purpose of this paramater is twofold. First, since annealing is essentially a guess and check method, we need a parameter to ensure that our program will eventually terminate. In a true quantum annealer, this can arise from issues of decoherence discussed in the Related Work Section or from simply making bad guesses. The longer the simulation runs, the odds of finding a state with minimal gap increases, but it is not guaranteed. This time check ensures that the program does indeed terminate, and that it finishes efficiently. Second, we noted earlier that quantum annealing is a method that can only be used to solve combinatorial opitimization problems. For some of these problems, however, it is possible that no optimal solution exists in the case of 3SAT, this means that there is no assignment of variables such that the entire expression is satisfied. In this case, the program would run forever. The simulation program deals with this issue in the same way that a true quantum annealer would. The program will run to the time limit, at which point it will return its current state. It also prints a message explaining that this is not a solution, but its best guess, i.e., the lowest possible energy state it could reach. It notes that it still could not reach minimal energy (in the case of the definitions for 3SAT described above, it should have reached energy = 0), but got as close as is possible given the unsatisfiable expression.. Variable Number: in the 3SAT problem definition, we are allowed to have repeating variables in different clauses or even in the same clauses. The simulation implementation, however, iterates over variables, not clauses, therefore we must know this information before hand. 3. Clauses: this contains the list of clauses in the expression we are trying to satisfy. This contains information on the variables in each clause and whether the clause is negated or not. The simulation implementation also must iterate over clauses and uses the number of clauses to define energy (and more importantly, when energy is minimal), but we can extract that information by simply measuing the size of this list. 4.. Method Implementation The simulation starts with each variable z i in equal superposition of 1 and 0. This is simulated by equally weighted unit vectors as described above. We then iterate through variables, systematically collapsing the simulated qubits out of superposition in classical states in order to transition to a more complex state of lower energy. We loop over all z i until either we have reached a state such that all clauses are satisfied (i.e., of minimal energy, as described above), or until time T has elapsed. For each z i, we measure the number of clauses that would be satisfied if z i = 0 and if z i = 1. We check both since the qubit is in an equally weighted superposition, so collapse in either state is equally likely. We compare this to the number of clauses satisfied in the current assignment structure for all z s. In the beginning, this means before z i s collapse; as the algorithm progresses, this means with each z i set to either 0 or 1 or still in superposition. According to our definition above for the complex Hamiltonian, energy is equivalent to clauses satisfied. If setting z i to 0 or 1 results in a lower energy (i.e., more clauses satisfied) than the current state, then we set our current state include that new assignment for z i that resulted in minimal energy. This constitutes the small change to a neighboring state, or the slow transition function. Most 3SAT problems contain clauses with multiple variables and duplicated varaibles across clauses. This means that when all other variables are in superposition, setting a single z i to either 0 or 1 will not result in a lower energy. Therefore we will run infinitely, or until time T has passed, keeping all variables in superposition. To ensure that progress is made, we add a second check. If setting z i to 0 or 1 did not decrease the overall energy of the expression, we randomly set z i to 0, 1, or z i, i.e., keep it with its original value. If z i was in superposition, this ensures that if it is collapsed into a classical value, it still maintains is property of being equally weighted and being measured as 0 or 1 with equal likelihood. To ensure that the changes are occurring slowly enough, we also potentially leave z i unchanged. All three of these random assignments have equal likelihood of occurring. This guarantees that the neighboring quantum states we transition to are not too far from the current state. We iterate through this process until we reach a quantum state whose energy is 0. This is equivalent to an assignment for all variables such that every clause in the expression evaluates to true. As discussed, this assignment is not always possible, so the iteration will also terminate when the input time has elapsed. The simulation of the random collapse of qubits in superposition into states with given probabilities is simulated using Java s Math class random numbers Output In all cases, the system will output a visual expression defining the input expression. It will also output the number of clauses in the expression and the number of clauses satisfied. In situations where the satisfying exists, and can be found in the time limit, these will be equal, and the system will simply output the varaible assignments. In cases where

8 the expression is not satisfiable within the time limit, the user will see that clauses in the expression are not equal to the number of clauses satisfied. To justify this discrepency, the system will output a message explaining that time T has elapsed, but no satisfying solution could be found. It is likely that no solution exists, but this is the system s best guess for minimal energy assignments. Figure 6 shows sample output from the simulated quantum annealer. Figure 6: Sample Output 5. SYSTEM PERFORMANCE 5.1 Quantum Annealing Performance One can judge performance based on two factors: accuracy and efficiency. Accuracy is fairly easy to test. Since the main impetus for studying quantum computational methods is to tackle problems in NP and find polynomial solutions, we will likely be testing the simulation on problems in NP. Further, as mentioned above, annealing works for problems whose solutions lie in optimal combinations, which are usually Boolean satisfiability problems. These are often in NP, so they are likely the class of problems attacked. Luckily, since these problems are in NP, we can check if our solutions are correct in polynomial time. Further, since we are simulating quantum states on a classical machine, the scale of the problems is small. Recall the exponential growth in terms of space needed to store qubits. For an n qubit register, we needed a n dimensional coordinate vector corresponding to the basis of the n possible states. Therefore, to represent linearly more qubits, we need exponentially more space, which on a classical computer quickly becomes impossible. Since the problems we seek to solve will be on a small scale and our solutions can be verified in polynomial time, measuring accuracy will be relatively simple. Next, we look to measure efficiency, and this is less straight forward. The algorithm for simulated annealing iterates until either a pre-determined time limit has elapsed or until we are close enough to an optimal solution. This makes efficiency difficult to calculate since this is not a normal algorithm we can run to completion and track the runtime. First, track many different runs with different metrics to determine a solution s legitimacy. The algorithm will complete if the gap between our noted optimal state and current state in the annealer is small enough, but measuring small enough is not clear. The small enough gap can be extrapolated by trying several different values and finding a middle ground between efficient runtime and an accurate solution. If good enough is too loosely defined, our returned solution may be suboptimal, but if it is too strict in our definition, then we will find ourselves always running to the end of the pre-determined clock limit when we may have found a reasonable solution much earlier. Second, examine the time limit. If this time limit is too short, we output sub-optimal solutions, however, if the time limit is too long, the system runs longer than necessary if it already has found a good enough solution. As was the case with the definition for good enough, finding a happy medium between these two extremes comes about through trials of many possible values and finding which best optimizes both factors. Finally, one of the criteria for quantum annealing to work was that we transition from one state too the next slowly enough, yet up until now we have left this undefined. Mathematically, we can define what is optimally slowly enough. We define g min = min 0 s 1 (λ (s) λ 1(s)). Here, λ still represents the eigenvalues, which is equivalent to energy, so this formula gives us the difference between the two lowest energy states of a given Hamiltonian. Next define ɛ =max 0 s 1 φ (s) dh φ1(s). Recall that φ is ds the eigenvector, and in this case φ i is the eigenvector corresponding to the eigenvalue λ i. Also recall that when we reach the final complex state through annealing, the eigenvector corresponding to the minimal eigenvalue is the solution. This means that ɛ is defining the maximal change in energy between two quantum states [10]. To move slowly enough is to change at a rate such that T ɛ g min. This is clear theoretically, but in practice, may not be a good baseline. Note that if these eigenvectors and eigenvalues were easy to find all along, we would have no need for a quantum annealer. The usefulness of an annealer comes from the fact that we start in a simple case for which these values can be calculated and end in a complex state where we maintained minimal energy. If the eigenvectors and eigenvalues were easy to calculate all along, we would have just done that from the offset and disregarded the complexities of a quantum annealer. However, the eigenvalues and eigenvectors are what determine g min and ɛ respectively. Therefore, we may not always be able to calculate these, and consequently may not be able to find the exact speed that is slowly enough [10]. As with the two other metrics for efficiency, use many different speeds in search of the best one that is both moving quickly enough to give efficient solutions but moving slowly enough such that the adiabatic theorem still holds and our final solution is correct. 5. Simulator Performance While most of these metrics still apply to the simulated quantum annealing system, some are trivial and some are not applicable. First, examine accuracy. We test this as described above. Test cases were written to cover all equivalence classes and edge cases. Each time, the program has either returned a satisfying assigment or a best guess as expected. Therefore, the system is always returning accurate results. In many combinatorial optimization problems, sometimes having a very close to perfect solution is good enough; the solution does not have to be exactly optimal to be useful. For instance, for the traveling salesman problem, having a solution that is close to the optimal pat is still advantageous. In the case of 3SAT, however, a non-optimal solution means nothing. Though the system will return an assignment of

9 minimal energy possible for a non-satisfiable expression, it is not useful since having no clauses evaluating to true is arguably just as bad as having all clauses except for one evaluate to true. In these terms, it does not make sense to evaluate the system s efficiency based on changes in the minimal gap. The optimal state is a solution with energy 0, and anything other than that is not a relevant or informative solution. Therefore, the minimal gap must always be 0. The paramater time inputed to the system is a constant that is multiplied by the number of clauses. Most test cases are fairly small in scale, so this is not a hugely helpful metric. For test cases with satisfying assignments, these assignments are usually found far under the time limit. In cases where there is no sastisfying assignment, it is usually clear that no solution exists before time runs out, but the system will still run to completion, when time T has expired. In either case, the runtimes are usually so fast that it is negligible, even when the input time is a very large constant. We have never yet encountered a case where a satisfying assignment exists, but cannot be found in a reasonably large input time. In the Future Work Section, we will explore possibilities for generating test cases in which this might occur. A key component of the adiabatic theorem is that the transition between Hamiltonians is slow enough. Described above is the equation for this in a true quantum system. In a small scale simulation, this is not highly informative or helpful. The changes in the simulation are highly quantized, i.e., they are discrete changes in the variable assignments. The slowest the transition can occur is by making one of these at a time. Under these conditions, the system still solves 3SAT in reasonable time, although as stated above, this is hard to guage since it is on such a small scale. We will explore opportunities for scaling up the test sets in the Future Work Section. 6. FUTURE WORK 6.1 Scaling System Testing One of the biggest obstacles for judging the system performances was the small scale of the tests. While we noted that cases could not be run a massive scale since space increases exponentially when simulated, we still must test at a large scale to ensure the correctness of the system. Further for the simulator to have any real-world implications, it must be able to perform at scale. The purpose of the simulator is to show that a large-scale true quantum annealer could be used to solve large scale problems efficiently. Therefore, we must be able to solve these large problems on the simulator. As of now, the tests were generated by hand to fit the specific format and data types required by the simulator. In the future, an automatic test case generator formatted specficially for the syntax of the simulator. In terms of scaling, this entails test cases that grow in both size and variety. While all equivalence classes were covered in current tests, running a wider variety of tests would further prove the robustness of the system. Increasing in size would not only show that the system operates at scale, but also would help in efficiency analysis. We would be able to better analyze the optimal input time and rate of change in the Hamiltonian and quantum state. Scaling the test cases will allow for this further analysis. 6. System Robustness We explored how the simple and complex Hamiltonians must be defined on a per-problem basis; as such, this system only simulates quantum annealing specifically for the 3SAT problem. In the future, the simulator could be expanded to solve a wide variety of combinatorial optimization problems, particularly those in NP. While a simulated annealer must be tailored specifically to the problem, the system design still applies to all problems that can be solved using quantum annealing. 3SAT is a relatively academic problem, and it does not have obvious practical implications. On the other hand, being able to solve a problem like traveling salesman efficiently using a simulated quantum annealer has many more tangible business, entrepreneurial, and economic implications. The brunt of the work in terms of the annealing model and the simulation by mathematical abstraction techniques has been done, and the system can be expanded to address a wider scope of combinatorial optimization problems. 6.3 Ethics There are no major ethical implications for a simulated quantum annealer, but the simulated system is a stepping stone for a physical quantum annealer, and a true quantum annealer paves the way for a large scale, robust quantum computer. Given a true quantum computer, we would have a machine capable of running Shor s polynomial time prime factorization algorithm. Almost all data today is encrypted using the RSA algorithm. The RSA algorithm keeps data safe contigent on the fact that it is hard to prime factorize large numbers, i.e., we do not yet have a polynomial time algorithm that runs on classical machines. Using Shor s algorithm, however, a quantum computer could quickly prime factorize, thus enabling decryption of almost all encrypted information that travels across the Internet. This would include everything from financial information to medical records to personal s. Obviously there would be enormous ethical and legal ramifications if a functional quantum computer were to be developed that could properly execute this algorithm at scale. If it were public knowledge that the RSA algorithm could be cracked using a quantum computer running Shor s algorithm, shockwaves would be sent throughout the computer science community as a search for a new method of encryption would become necessary. The bigger ethical concern comes from an organization owning a functional quantum computer and thus being able to view all encrypted data, but unbeknownst to the senders, receivers, or owners of the data. The idea of a large corporation or government who has much to gain from a new method of data mining and collection is formidable. This is particularly relevant considering that Google has purchased a D-Wave machine and reports were leaked that the NSA is conducting extensive research on quantum computing; however, issues such as these are not an immediate concern given the current state of quantum computation technology. 7. CONCLUSION The goal of the simulated quantum annealer is simulate quantum state on a classical machine and explore the possibilities of applying the adiabatic theorem to quantum computation. We explored the foundations of quantum computing and the mathematics and physics that allow us to