Grover's algorithm on IBM Quantum Experience

Grover’s algorithm on IBM Quantum Experience Felipe Rojo Amadeo email rojoamadeoa@gmail.com April 30, 2020 Abstract In 1996 Lov Grover built an unstructured quantum search probabilistic algorithm, quadratically more efficient than the best classical algorithm. Our goal is to show in detail the different phases of the algorithm. We are going to do a matrix development (of the Oracle) and we will show the geometric interpretation of the algorithm. Then we will build two Oracles, one with a single target and the other with two, and we will implement them on the IBM Quantum Experience platform. Anyone can create a free account in IBM platform and start playing with the circuit composer. [1] Contents 1 Grover’s algorithm 2 1.1 The algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2 Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.3 Phase inversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.4 Grover diffusion operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 1.5 Geometric interpretation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2 Implementation in IBM Quantum Experience 1 14 2.1 Algorithm with 3 qubit 2.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 2.1.1 Matrix development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.1.2 The algorithm in OPENQASM 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Algorithm with 3 qubit and two targets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.2.1 Matrix development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.2.2 The algorithm in OPENQASM 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 3 Conclusions 22 Bibliography 23 1 Grover’s algorithm Grover’s algorithm is a probabilistic quantum unstructured search algorithm that is based on the amplification amplitude technique. We will describe how the search is configured and we will develop this technique in detail. Suppose we have a function f : {1....N } → 0, 1 and there is only one element a : {1....N }, such that f (a) = 1, for all others, with x : {1....N }, f (x 6= a) = 0 For a solution of this type on a classic machine we have a complexity O(N ) while on a quantum computer √ this is of O( N ). This gives us a quadratic improvement. We will develop the algorithm, breaking it down into 3 parts, to which we will dedicate a section to each one and make reference so that the reader can go deeper into them. 1.1 The algorithm If we search in a list of N elements, we know that we can represent all the elements in n qubits, being n = log2 N . 2 We define the n qubits as follows: |ψ1 i = N X i=1 |0i (1) Then we will initialize them (see section 4.4.2) with the Hadamard gate to obtain uniform amplitudes: |ψ2 i = H |ψ1 i = with αi = N X i=1 αi |xi (2) √1 N The next step is to invert the phase of the state we are looking for (see section 4.4.3). We will use the Oracle transformation based on the function f as we described at the beginning. Therefore we need to build a unit operator Uf in order that it inverts the phase of the element we are looking for: |ψ3 i = Uf |ψ2 i = N X i=1 αi (−1)f (x) |xi (3) Once we have inverted the phase, we will proceed to extend the amplitude of the target state. This is done with what Grover called the Diffusion Operator or also known as inversion about the mean or simply amplification of the amplitude. We will call this operator Us . In section (4.4.4) we will demonstrate how it multiplies effectively the amplitude of the element we are looking for. On the other hand, we define the operator |si as follows: N 1 X |si = √ |xi N i=1 Us = 2 |si hs| − I Then we apply this operator Us to the qubits: 3 (4) (5) |ψ4 i = Us |ψ3 i (6) So far, we have finished the first iteration. The rest of the iterations will apply the operator Uf followed by Us . There will be a total of √ π N 4 iterations. , the algorithm is: 1. Algorithm input • Initial state PN i=1 |0i • Oracle Operator Uf 2. Initialize state |0i with H • PN i=1 3. For 1 a to αi |xi √ N • Apply operator Uf • Apply operator Us 4. Measure 1.2 Initialization After applying the Hadamard gate, all amplitudes are evenly distributed. It is evident that the average µ is equal to any amplitude, even to the sought element a. 4 Figure 1: α is the amplitude; µ is the average of all the amplitudes; a is the element we are looking for and N is the number of elements 1.3 Phase inversion As we mentioned at the beginning of the chapter, only for a the phase will only be inverted since (−1)f (a)=1 = −1, for all the others the phase will not be altered. 5 ′ Figure 2: α is the amplitude; µ is the average of all the amplitudes; a is the element we are looking for with the inverted amplitude and N is the number of elements 1.4 Grover diffusion operator As we can see in Figure 3, after applying the diffusion operator, the amplitude of the searched element has increased. 6 ′′ Figure 3: α is the amplitude, µ is the average of all the amplitudes; a is the element we are looking for whose amplitude has increased, (in opposition the other amplitudes, which have decreased); and N is the number of elements we start from the following equation to demonstrate why Us is the operator that increases the amplitude of the searched element. Us = (−1)H ⊗n (X ⊗n CZ ⊗n C ⊗n )H ⊗n n n It is easy to verify, the expression between H ⊗n is (I − 2 |0i h0| ) Therefore we replace it in the main equation: n n Us = (−1)H ⊗n (I − 2 |0i h0| )H ⊗n We distribute the H ⊗n terms n n Us = (−1)(H ⊗n IH ⊗n − 2H ⊗n |0i h0| H ⊗n ) We will call |si the following operation: 7 N 1 X n |si = H ⊗n |0i = √ |xi 2n i=1 And we know that H ⊗n IH ⊗n = I Replacing the last equation in Us we get: n n Us = (−1)(I − 2 |si hs| ) Finally we distribute the minus sign: n n Us = (2 |si hs| − I) We will start the diffusion operator demonstration[2] again, but in this case writing the matrices. Is easy to check that the operators X ⊗n CZ ⊗n C ⊗n are the result of the following matrix between H ⊗n .     Us = (−1)HN     −1 0 ··· 0 .. . 1 ··· .. . . . . 0 0 ··· 0    0  ..  HN .  1 We extract the identity matrix I and add it to maintain equality     = (−1)HN     −2 0 ··· 0 .. . 0 ··· .. . . . . 0 0 ···  0   0  ..  HN .  0 Then we just arrange just arrange the terms by taking the identity out as a sum 8     = (−1)HN     −2 0 ··· 0 .. . 0 ··· .. . . . . 0 0 ···  0   0  ..  HN − I .  0 I multiply the Hadamard Matrices on both sides  −2/N   −2/N = (−1)   ..  .  −2/N −2/N  −2/N ··· −2/N .. . ··· .. . −2/N ··· −2/N ··· 2/N 2/N − 1 .. . ··· .. . 2/N .. . 2/N ··· 2/N − 1   −2/N   ..  − I .   −2/N Then we get the following:  2/N − 1    2/N = ..   .  2/N         In the first iteration, after applying the phase inversion, our searched state αi will have opposite sign with respect to the other states   α1  .   .   .      −αi     .   ..    αN Now let’s apply the operator Us for each element of our state: 9  2/N − 1    2/N = ..   .  2/N 2/N ··· 2/N − 1 .. . ··· .. . 2/N ··· As it is the first iteration, all the amplitudes will be  2/N − 1    2/N = ..   .  2/N √1 , N   α1  .  2/N ..       2/N    −α  ..   i  .  .  .  .   2/N − 1  αN  with the amplitude i opposite sign. 2/N ··· 2/N 2/N − 1 .. . ··· .. . 2/N ···   √1 N        ...    2/N     − √1  ..    . N .  .   .   2/N − 1  √1 N The result is:  √1 N − 4 √   N N 1    ..   .     3  4  =  √N − N √N i    ..     .    4 √ √1 − N N N N We see that the amplitude of the term i increases by ∼ 3 times the original amplitude, while in the rest of the terms, their amplitudes are reduced by N 4 √ N This means that in each iteration we will have approximately an amplitude increment of 10 √2 N After ∼ √ N iterations, we will have an amplitude close to 1, therefore, there is a high probability the mea- surement will be successful. If we rewrite the final state amplitude i as follows: αi = N 2 X αk − αi N k=1 with the mean being µ = 1 N PN k=1 αk We can think the state αi as an inversion about the mean µ: αi = 2µ − αi In addition to what it was explained in figures 2 and 3, there is another way to represent each iteration, that is through reflections. This is cover in section 1.5. 1.5 Geometric interpretation There is a very intuitive geometric representation of the algorithm. As we can see in figure 4, the reflections of the vector |si correspond to the first iteration of the algorithm. We define |si as in equation 4. This state is the result of applying the Hadamard gate to the initial state n |0i , with n being the number of qubits. The vector a corresponds to the state we are looking for. The plane will be spanned by both vectors, |si and |ai, with an angle β between them. ′ On the other hand, we are going to define a state |s i that will be perpendicular to the vector |ai and will allow us to write any state |si as follows: ′ hs| = sin θ |ai + cos θ |s i By trigonometry we know that the formula to calculate the angle between two vectors, and in particular our angle β is the following: 11 Figure 4: Graphical representation of the first iteration of Grover’s algorithm. |ai is the state we are looking for, |si the initial state and, Uf and Us the two transformations. cos β = ha| |si kak ksk (7) We note that ha| |si is the inner product between vectors and, our vector |ai, is the state we are looking for. Therefore, the position of the vector representing this state will have an amplitude ∼ 1 and all other ∼ 0, since we remember that the sum of the square must give 1. For example, if I have two qubits, the Hilbert space will be 22 = 4, and if the element we are look for is 10i , we get the following: i For a 4-dimensional vector, position 0 equals the binary number 00, the next position value 01, the next position 10 and finally 11 12   ha| = 0 0 1 0 The state |si is the superposition of the states evenly distributed , each with amplitude √1 , N or √1 4 in our ex- ample. hs| =  √1 N √1 N √1 N The result of the internal product between these two vectors is √1 N √1 N  and √1 4 for our example: 1 1 1 1 1 ha| |si = 0. √ + 0. √ + 1. √ + 0. √ = √ N N N N N The magnitude of both vectors is 1, since by definition we know that the sum of all the squared amplitudes must be 1. The equation 7 to calculate the angle β is given by the following: 1 cos β = √ N 1 β = arccos √ N However we are more interested in the angle θ, hence, we will use the following relation: cos β = sin ( But since we have defined θ as π 2 π − β) 2 − β, by replacing it we have: 1 sin θ = √ N 13 1 θ = arcsin √ N The next thing to do is to apply the operator Uf on our state |si, which will not reverse the phase, as we saw ′ at the beginning of this section. The reflection will be on vector |s i with magnitude θ. But to see it clearer, what really happens is that the direction of |si is reversed on the axis where |ai is defined. Let’s remember that in the first iteration, the Uf transformation just inverts the sign of the position of the element I’m looking for. We apply the operator Us to finish the fist iteration. This will make a reelection on |si which, unlike Uf , invert all the states and, as We saw in section 4.4.4, it will duplicate the initial amplitude. Finally, from this representation we can estimate the exact number of iterations required by this algorithm. We will not do the analysis at this point, but we must say that will say that the objective is to bring |si closer to |ai. In the plane we have defined, this translates into the angle θ approximating as much as possible to ii . The result will equal 2 √ π N 4 π 2 iterations. Implementation in IBM Quantum Experience 2.1 Algorithm with 3 qubit We have prepared a 3 qubit algorithm whose Oracle function is defined in the following table: ii If we had more than one entry to search for, the number of iterations is It will be reduced to of elements that meets the search condition. 14 π 4 q N k , where k is the number |xi |yi |zi → O(f )) 000 → 0 001 → 0 010 → 0 011 → 0 100 → 0 101 → 0 110 → 0 111 → 1 As it is represented in the table above, the element sought is 111 which is unique, therefore the number of iterations of the algorithm will be √ 4 8 4 = 2, 221..., according to what we saw in Section 1., N = 2n , where n is the number of qubits, in this case 3. In conclusion, the number of iterations equals 2 We define the Oracle as the one that is enclosed between the first two barriers, according to the figure 5 Figure 5: Grover algorithm which element to search for is 111 The result of the simulator is figure 6, and as it was expected, there is a high probability that the result is 111 Figure 6: Result of the execution of the algorithm of figure 5 15 2.1.1 Matrix development We will begin by expressing the Oracle with matrixes. The Hadamard gate is applied on q[3], then, the Toffoli gate on all the qubits, and finally the Hadamard gate on qubit q[3] again The operations are performed from right to left, although, in this case, the Oracle operator is symmetric. We have to take both Hadamard gates to a matrix of 8x8. To achieve this, what we will do is use the tensor product of the 2x2 matrices of I ⊕ I ⊕ H.     1 0 1 0 1 1 ⊗ √  ⊗  2 1 0 1 0 1  1 −1   Developing the first two identity matrices we get:  1 0 0 0        0 1 0 0 1 1  ⊗ √    2 1  0 0 1 0   0 0 0 1 1   −1 We will call this result R1 :  1   1   0   1 0 R1 = √  8 0   0   1  1 1 0 0 0 0 0 0 0 0 0 0    0   1 1 0 0 0 0   1 −1 0 0 0 0    0 0 1 1 0 0   0 0 1 −1 0 0    0 0 0 0 1 1  0 0 0 0 1 −1 −1 0 0 0 0 Then we express the Toffoli or CCX matrix: 16 0 0 0  1 0 0 0 0 0 0 0   0   0   0   0   0   0  0    1 0 0 0 0 0 0   0 1 0 0 0 0 0   0 0 1 0 0 0 0   0 0 0 1 0 0 0   0 0 0 0 1 0 0   0 0 0 0 0 0 1  0 0 0 0 0 1 0 Now, we will proceed to calculate the Oracle operator as R1 .CCX.R1 :  1 1 0 0 0 0 0 0  1 0 0 0 0 0 0 0     1 −1 0 0 0 0 0 0  0     0 0 1 1 0 0 0 0  0     0 0 1 −1 0 0 0 0  0 1   Of = √   8 0 0 0 0 1 1 0 0  0     0 0 0 0 1 −1 0 0  0     1 0 0 0 0 0 1 1  0   1 0 0 0 0 0 1 −1 0   1 1     1 1 0 0 0 0 0 0     0 0 1 0 0 0 0 0     0 0 1 0 0 0 0 1  0 √    0 0 0 1 0 0 0 8  0     0 0 0 0 0 1 0 0      1 0 0 0 0 0 0 1   0 0 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0   1 −1 0 0 0 0   0 0 1 1 0 0   1 0 0 1 −1 0 0 Of = √  8 0 0 0 0 1 1   0 0 0 0 1 −1   1 0 0 0 0 0  1 0 0 0 0 0 0 0   1      1 0 0     0 0 0      0 0 1 0 √    0 0 8  0     0 0 0     1 1 1   −1 1 1 17 1 0 −1 0 0 0 0 0 0 0 0 0 0 0    0   1 1 0 0 0 0   1 −1 0 0 0 0    0 0 1 1 0 0   0 0 1 −1 0 0    0 0 0 0 1 1  0 0 0 0 1 −1 −1 0 0 0 We multiply the first two matrices:  0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 −1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 −1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 −1                     0 0 The result is the following matrix where the sign of the element on the last row and column was altered. After applying this operator to our state, clearly, the sign of the last element (111) will be modified.  1 0 0 0 0 0 0   0   0   0 1 Of =   4 0   0   0  0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0    0   0   0   0   0   0  −1 As we can see, with 3 qubits the operations become quit complex. Since our intention was only to show how the operations between gates are carried out, we will not proceed with the building of the Us operator in the present work. 2.1.2 The algorithm in OPENQASM 2.0 The algorithm is defined in the OPENQASM 2.0 language of the IBM simulation platform. OPENQASM 2.0; barrier q[0],q[1],q[2]; h q[0]; h q[1]; h q[2]; include ”qelib1.inc”; h q[2]; x q[0]; x q[1]; x q[2]; ccx q[0],q[1],q[2]; barrier q[0],q[1],q[2]; h q[2]; h q[2]; h q[0]; h q[1]; h q[2]; barrier q[0],q[1],q[2]; ccx q[0],q[1],q[2]; barrier q[0],q[1],q[2]; x q[0]; x q[1]; x q[2]; h q[2]; h q[2]; h q[0]; h q[1]; h q[2]; barrier q[0],q[1],q[2]; ccx q[0],q[1],q[2]; barrier q[0],q[1],q[2]; x q[0]; x q[1]; x q[2]; h q[2]; h q[2]; h q[0]; h q[1]; h q[2]; barrier q[0],q[1],q[2]; ccx q[0],q[1],q[2]; measure q[2] -¿ c[2]; h q[0]; h q[1]; h q[2]; h q[2]; measure q[1] -¿ c[1]; x q[0]; x q[1]; x q[2]; barrier q[0],q[1],q[2]; measure q[0] -¿ c[0]; qreg q[3]; creg c[5]; 18 2.2 Algorithm with 3 qubit and two targets In this case, we will implement an oracle function such that f (x) = 1 for two values of x. Let’s look at the following table: |xi |xi |xi → O(f )) 000 → 0 001 → 0 010 → 0 011 → 1 100 → 0 101 → 1 110 → 0 111 → 0 Our Oracle is built by two Controlled Z gates, as observed between the first two barriers of figure 7. In this case, unlike the previous exercise, there are two states that satisfy the search, therefore, the number q of interactions will be represented by: π4 Nk , where k is this number of elements. Hence the number of itera- tions, with N = 8 and k = 2 will be the following: π 4 r 8 = 1.5707... ∼ 1iii 2 Figure 7: Grover algorithm with 110 and 101 as target elements The result can be seen in the figure 8. iii On a classical computer, we would find these two elements in 8 steps, while with this quantum algorithm we will only require 1 iteration 19 Figure 8: Result of the execution of the algorithm of the figure 7 2.2.1 Matrix development As we can see in figure 7, the first gate of the Oracle operator is Controlled Z applied to the first qubit and the last qubit, without involving the second one, so we can no longer use the tensor product as we have been doing so far. For this, we will use the following structure:  CUn =  IM OM OM IM ⊗ U 2 2 2 4   Where M = 2n+2 and n, the number of qubits between the control qubit and the target qubit, O is the zero matrix and I is the identity matrix. In our case M = 21+2 = 8, with n = 1, since the number of qubits between q [0] and q [2] is 1. We solve the tensor product of I M ⊗ U , where U = P auli − Z 4  1 0 0 0      0 −1 0 0   = ⊗    0 0 1 0  0 −1 0 1   0 0 0 −1  1 0   1 0  Now we can write CU1 20  1 0 0 0 0   0   0   0   0   0   0  0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 −1 0 0 0 0 0 0 1 0 0 0 0 0 0 0    0   0   0   0   0   0  −1 The next gate is also a Controlled Z gate but applied on q [0] and q [1], therefore, it will be enough to apply the tensor product with the identity matrix I of 2x2 and, in this way we obtain a gate at 8x8 dimensions.   CZ ⊗ I2x2 1   0 =  0  0 0 0 1 0 0 1 0 0 1 0 0 0 0 0   0    0 0       0 0 1 0 ⊗ =   0 0 0 1    0 −1   0  0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 −1 0 0 0 0 0 0 Finally we multiply both gates (from right to left) and obtain the Oracle operator: 21 0 0    0   0   0   0   0   0  −1  1 0 0 0 0 0   0   0   0 Of =   0   0   0  0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 −1 0 0 0 0 0 0 0  1 0 0 0 0   0  0   0  0   0  0   0  0   0  0   0  0  −1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 −1 0 0 0 0 0 0 1 0 0 0 0 0 0 0   1 0 0 0 0     0  0     0  0     0  0 =   0  0     0  0     0  0   −1 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0  0   0 0 0   0 0 0   0 0 0   0 0 0   −1 0 0   0 −1 0  0 0 1 0 0 As we can see in the final matrix, the operator will alter the signs of the states 101 and 110. 2.2.2 The algorithm in OPENQASM 2.0 OPENQASM 2.0; barrier q[0],q[1],q[2]; barrier q[0],q[1],q[2]; include ”qelib1.inc”; h q[0]; h q[1]; h q[2]; x q[0]; x q[1]; x q[2]; x q[0]; x q[1]; x q[2]; h q[0]; h q[1]; h q[2]; barrier q[0],q[1],q[2]; measure q[2] -¿ c[2]; h q[2]; measure q[1] -¿ c[1]; ccx q[0],q[1],q[2]; measure q[0] -¿ c[0]; qreg q[3]; creg c[5]; h q[0]; h q[1]; h q[2]; barrier q[0],q[1],q[2]; cz q[2],q[0]; cz q[1],q[0]; 3 h q[2]; Conclusions There are many circuit composers available on the internet, but the IBM one seems very intuitive and reliable, at least to build didactic circuits. We have gone through Grover’s algorithm in detail and demonstrated the function of each of the two main operators: Uf and Us . Finally we have built two circuits with two different Oracles. We executed it and corroborated that it was much more efficient (quadratically) than other any classic search algorithm. 22 This work is simply for didactic purposes for those who want to get started in quantum computing. Bibliography [1] IBM. Ibm quantum experience. URL https://quantum-computing.ibm.com/. [2] Umesh Vazirani. Quadratic speedup for unstructured search - grover’s algorithm. UC Berkeley, course CS 294-2, Lecture 11, 2007. URL https://people.eecs.berkeley.edu/~vazirani/quantum.html. [3] Barton Zwiebach. Multiparticle states and tensor products. Part of the Quantum Physics II course at the Massachusetts Institute of Technology, December 2013. URL https://ocw.mit.edu/courses/ physics/8-05-quantum-physics-ii-fall-2013/lecture-notes/MIT8_05F13_Chap_08.pdf. [4] Craig Gidney. Grover’s quantum search algorithm. Twisted Oak Studios Blog, March 2013. URL http: //twistedoakstudios.com/blog/Post2644_grovers-quantum-search-algorithm. [5] Abraham Asfaw. Luciano Bello. Yael Ben-Haim. Sergey Bravyi. Lauren Capelluto. Almudena Carrera Vazquez. Jack Ceroni. Francis Harkins. Jay Gambetta. Shelly Garion. Leron Gil. Salvador De La Puente Gonzalez. David McKay. Zlatko Minev. Paul Nation. Anna Phan. Arthur Rattew. Joachim Schaefer. Javad Shabani. John Smolin. Kristan Temme. Madeleine Tod. James Wootton. Learn quantum computation using qiskit. Textbook in collaboration with IBM Research as a university quantum algorithms/computation course supplement based on Qiskit., 2020. URL https://qiskit.org/textbook/ preface.html. [6] Lov K. Grover. A fast quantum mechanical algorithm for database search. Bell Labs, Murray Hill NJ 07974, May 1996. URL https://arxiv.org/abs/quant-ph/9605043. [7] the free encyclopedia Wikipedia. Grover’s algorithm. March 2020. URL https://en.wikipedia.org/ wiki/Grover%27s_algorithm. [8] Sanjeev Arora and Boaz Barak. Computational complexity: A modern approach. Princeton University, January 2007. URL https://arxiv.org/abs/quant-ph/9605043. [9] Bruce MacLennan. Unconventional computation. Department of Electrical Engineering and Computer Science University of Tennessee, Knoxville, November 2018. URL http://web.eecs.utk.edu/ ~bmaclenn/Classes/494-594-UC/handouts/. 23 [10] Scott Aaronson. Doing my oracle duty. Scott Aaronson Blog, July 2010. URL https://www. scottaaronson.com/blog/?p=451. [11] Giacomo Nannicini. Quantum computing, lecture 5. IBM T.J. Watson, Yorktown Heights, NY nannicini@us.ibm.com, October 2019. URL https://researcher.watson.ibm.com/researcher/files/ us-nannicini/8100_lecture_5.pdf. 24