Summary

The purpose of this article is to analyze the 0/1 Knapsack Problem and explore possible quantum algorithms for its computation on a quantum computer. The Knapsack problem is an interesting computer science problem where one has to maximize the total value of items in a knapsack of known capacity when given a list of items to select from. This article shows that a modified Grover’s search algorithm and the Quantum approximate optimization algorithm (QAOA) that can be used in exploring the creation a Quantum algorithm for the 0/1 Knapsack Problem.

Introduction

The rise in the popularity of Quantum computers and the success of Grover’s algorithm [1] for sorting and Shor’s algorithm [2] for factorization has raised questions on whether Quantum computing will bring forth solutions to other classically hard problems like combinatorics. However, scientists do not believe that quantum computing will be able to solve NP-Hard problems [3] but will be able to speed up operations involving searching [4]. The 0 1 Knapsack Problem is an optimization problem, which seeks the best solution from among many other solutions. It is an NP-complete problem and will be NP-hard in a Quantum computer [3]. However, Quantum computers have the capacity to improve time complexity.

Problem definition

The problem definition is: Given a knapsack and a set of N objects, each (i, i ∈ N) having a weight Wi and associated profit Pi, maximize (in profit) the set of items that are added to the knapsack. The knapsack has a maximum capacity of V and the maximized set must be less or equal to V. When an item is picked, it has a value 1 in the knapsack and 0 when it is not.

Brief Review

The typical structure of a quantum algorithm is as follows. The first part of the algorithm is to make an equal superposition of all 2^n states by applying Hadamard gates [5]. The second part is to encode the problem into states, perform gate logic, and put phases on all 2^n states [5]. The last part is to minimally superpose (interfere) all these states back to a few outcomes for measurement [5].

Quantum parallelism arises from superposition. A function performed once on the register in a superposition of states is performed on each of the components of the superposition [6].

Previous work

Schuler and Arvind [7] put forth an ~O(2^n/3 ) quantum algorithm for the 0-1 Knapsack problem with n variables using a generalization from Integer Linear Programs. The algorithm includes Grover’s search algorithm and the powerful method of amplitude amplification [7]. This algorithm defines a unitary transformation for a subroutine that is used to calculate the value of combinations for the knapsack. These values are then used in a modified Grover’s search. The various combinations are then sent to the Grover operator as a function which is equal to 1 when it is the optimal solution [7].

Proposed 0 1 Knapsack Algorithms

Modified Grover's algorithm

Following closely the work of [5], These are the steps for our proposed algorithm 1. Using N qubits, each basis state will represent a possible set. {|00000>,|00001> …|11111>} 2. Two prepared state vectors will represent the profit and weight vectors. 3. Inner product will be used to calculate the profit and weight of each possible solution set. 4. Sets with weights > V will be eliminated. 5. A modified Grover’s search is then applied to the remaining sets, using the profit value calculated in step 3.

Quantum parallelism and the efficiency of Grover’s algorithm will definitely give a speedup for this problem (Step 1-3 can be done simultaneously), however, we theorize that gate complexity for the functions necessary for implementing steps 2 and 3 will be exponentially large depending on the value of N. The time complexity of this algorithm is speculated to be about ~O(2^ (n/3)+n ).

The Quantum approximate optimization algorithm (QAOA)

Conclusion

The Modified Grover’s algorithm and the QAOA are two potential Quantum algorithms for the 0 1 Knapsack problem. Future work on this topic should involve in-depth algorithm analysis and circuit construction. This is my last article for the term, and I want to especially thank Professor. Parimala Thulasiraman for her guidance.

References

[1] Grover, L. K. (1996, July). A fast quantum mechanical algorithm for database search. In Proceedings of the twenty-eighth annual ACM symposium on Theory of computing (pp. 212-219).

[2] Ekert, A., & Jozsa, R. (1996). Quantum computation and Shor's factoring algorithm. Reviews of Modern Physics, 68(3), 733.

[3] Preskill, J. (2018). Quantum Computing in the NISQ era and beyond. Quantum, 2, 79.

[4] Grover, L. K. (1997). Quantum mechanics helps in searching for a needle in a haystack. Physical review letters, 79(2), 325.

[5] https://www.siam.org/conferences/cm/program/minitutorials/pp20- minitutorials

[6] https://quantum-algorithms.herokuapp.com/433/shor-par/node11.html

THE IMPORTANCE OF FACTORIZATION

The integer factorization problem is about finding two factors N1 and N2 which when multiplied gives the number N (N, N1, N2 > 1) [1]. When N1 and N2 are primes, this becomes especially hard. The problem is useful in the scientific community. The public and private key of the RSA cryptosystem are modern implementations of integer factorization problem with primes [2]. There is no known classical polynomial-time algorithm currently for this problem [1]. Currently, integers with 1000 or more bits are impossible to factor using known algorithms and classical hardware. Quantum computing is believed to have the potential to change this. Meanwhile, Shor’s algorithm is a breakthrough for this problem, factoring small numbers at time O(n^3logn) [1].

A SIMPLE EXPLANATION

Shor’s algorithm uses using modular exponentiation. Consider an odd N = N1*N2, 1 < N1, N2 < N. If we pick k < N such that gcd(k, N) = 1, we can show that there is a p > 0 such that k^p ≡ 1 (mod N) [1]. Using modular arithmetic definition, x ≡ y (mod m) iff m divides x – y, we can say N divides k^p − 1 = (k^(p/2) − 1)(k^(p/2) + 1) if p is even. n1 = k^(p/2) + 1 and n2 = k^(p/2) – 1 are greater than zero and have no common factor greater than 2 because |n1-n2| = 2 [1]. Since N = N1N2 was assumed to be odd, then N1 is a factor of either n1 or n2. If N1 is a factor of n1 and N, then N1 divides both n1 and N and one can find N1 by computing gcd(n1, N) [1]. The same goes for N2.

Here is an example. Given N = 15 and k = 7, a modular exponentiation sequence [3] is 1, 7, 4, 13, 1, 7, 4, 13, 1, . . . with period 4. Since the period 4 is an even number, 74 mod 15 ≡ 1 ⇒ 74 − 1 mod 15 ≡ 0 ⇒ (72 − 1)(72 + 1) mod 15 ≡ 0 . This means 15 divides 48*50, which can be used to factorize 15 as gcd(48, 15) = 3 and gcd(50, 15) = 5.

QUANTUM FOURIER TRANFORM

Finding the period of a modular exponentiation sequence is not classically easy, but with quantum computing, the period can be found in polynomial time using the Quantum Fourier Transform (QFT).

The classical Fourier transform has the following equation: Where

• yk and xj are complex numbers. • j and k are indices, ranging from 0 to N-1. • N is the length of the data set x.

The quantum Fourier transform has the same equation but with one difference. The data set is a vector, with each element in the vector representing the probability of the state being measured as that combination of 0 and 1 and is often called ψ instead of x [4]. |ψ> = α1 |00…0>⋯αn |11..11> This can be represented as a matrix. Eg. For a 2-qubit state ψ, The magnitude of the state vector ψ remains unchanged but is rotated using a series of operations of the form e^(iθ) [4]. Our matrix now looks like this. Phase rotations can be implemented using the quantum R gate: The factorization algorithm uses QFT because it can “compute” the period of a periodic input. One can find the period of the corresponding modular exponentiation sequence using QFT if one is able to encode its period in the amplitudes of a quantum state (the input to QFT) [1]

ILLUSTRATION OF A PERIOD FINDING CIRCUIT

The following is a high-level illustration of the circuit. 1. The first QFT on register A produces an equal superposition of the qubits from A. The current state is 2. The function f (i) = X_i (mod N) is used on the second register B. The current state is
3. In the last QFT transform, register A is a superposition with only equal non-zero amplitudes of |i⟩ for which f (i) = s. F(i) is in a periodic superposition with period r.

REFERENCES

[1] Coles, P. J., Eidenbenz, S., Pakin, S., Adedoyin, A., Ambrosiano, J., Anisimov, P., ... & Gunter, D. (2018). Quantum algorithm implementations for beginners. arXiv, arXiv-1804.

[2] Boneh, D. (1999). Twenty years of attacks on the RSA cryptosystem. Notices of the AMS, 46(2), 203- 213.

[3] https://www2.math.upenn.edu/~mlazar/math170/notes06-3.pdf

[4] https://medium.com/@sashwat.anagolum/qftaddition-ce0a0b2bc4f4

In this PowerPoint presentation, I analyze the paper “An artificial neuron implemented on an actual quantum processor” by Tacchino et al. and the Quantum Perceptron circuit created.

Click this link to view the presentation. https://1drv.ms/p/s!Akjbt9MJE26teAndpQ5zo6GDWWc?e=U2niLE

Change of direction for project.

I'll focus my attention on Quantum algorithms and pick one for a final article.

more background information Quantum states (|0⟩, |1⟩, |+⟩, |-⟩) can be represented as a superposition. |ψ⟩= α|0⟩+ β|1⟩

|α|^2+ |β|^2=1

α=√(1-p,) β=e^jφ √p, 0≤p≤1,0≤φ<2π

|ψ⟩=√(1-p)|0⟩+ e^jφ √p,|1⟩

e^jφ is the phase

The phase can be used to offset the qubit. There are different gates we can use to do the offsets (T, S, Z etc.)

A phase change example can be found here. https://quantum-computing.ibm.com/composer/d065727b7bdddc3f658e2ad8badeb1ba.

Grover's Algorithm

Grover's algorithm shows the exponential advantage of a quantum computer. It is a search algorithm that provides a huge improvement to a regular classical sorting algorithm. This is because Quantum Mechanics systems can be in a state of superposition and algorithms can simultaneously examine multiple states. A search for an item from a random list of n items can be obtained in O(√n)steps.

Basically, all the states (right and wrong answers) are superposed together using a function and then phase angle change operations are applied to the superposition. This makes the probability of the right answer a lot higher than the other answers making it more probable to be measured.

Grover's Algorithm Encoding

The search list is provided in superposition to a function f which returns f(x) = 1 for the right answer and f(x) = 0 for the wrong answer. We binary encode the items as qubits x,w ∈ {0,1}^(n) so that N = 2^n.

We define an oracle matrix to act on any single. U|x⟩= (-1)^f(x)|x⟩, which is –|x⟩ if the item is found.

Grover's Algorithm Function

1. Uniform superposition
2. Oracle refection
3. Additional reflection

The two reflections equal to a rotation. The whole procedure ( 3 steps ) is repeated several times until the answer is the focus. This is approximately √n times. You can find an example of this algorithm here. Grover N=2 A=00 https://quantum-computing.ibm.com/composer/39354dfd1bb6ac3edb8f9a9659c834d4

𝑈𝜔|𝑥⟩=(−1)^𝑓(𝑥)|𝑥⟩ is the oracle. Inputs are represented by this function but in a superposition.

The superposition of all inputs |s⟩

|𝑠⟩=sin𝜃|𝑤⟩+cos𝜃|𝑠′⟩, where 𝜃=arcsin⟨𝑠|𝑤⟩=arcsin√N superposition of the right answer and all the wrong answers.

Amplitude amplification singles out the right answer in the superposition by using quantum gate circuitry to adjust the amplitude of the right answer.

1. Superposition is done by a Hadamard gate. 𝜃=arcsin(½)=𝜋/6.

all the states = ½(|00⟩+|01⟩+|10⟩+|11⟩)

The circuit currently.

1. We apply the oracle reflection (see equation above)

Oracle for |𝜔⟩=|11⟩

Let's look at the case |𝑤⟩=|11⟩

. The oracle 𝑈𝜔 in this case acts as follows:

𝑈𝜔|𝑠⟩=𝑈𝜔.½(|00⟩+|01⟩+|10⟩+|11⟩)=½(|00⟩+|01⟩+|10⟩−|11⟩)

This is gotten by the controlled z gate = H gate + CNOT gate + H gate. The CNOT applies an 𝑋 to its target qubit whenever its control is in state |1⟩

see full circuit https://quantum-computing.ibm.com/composer/89fe6d3a014ad268b44b5f8b4a5f4b9c

###Reference https://quantum-computing.ibm.com/docs/iqx/guide/

1. How to sum two numbers using a quantum processor

2. The structure of Quantum algorithms. How different are they from classical ones?

How to sum two numbers using a quantum processor

The above is a picture of the classical adder circuit. We would like to reproduce this on a quantum processor. We'll be using the QISKit library. https://qiskit.org. Before we start, we have 3 questions to answer. 1. How do we store the input bits? 2. What quantum gates can we use here? 3. How can we measure the results?

How do we store the input bits?

Qubits are normally in the |0> default state and we can use the X gate to change it to the |1> state. We can assign one qubit to represent a classical bit. We'll need two sets of these qubits. One each for the first and second number.

Supposing we make a superposition of each bit, then we can store multiple bits at one!

What quantum gates can we use here?

We need to use universal reversible gates to construct more complex gates like the XOR and AND classical gates. We will use the CNOT and CCNOT gates to build them. We will perform a little algebra to find the carry bit and sum.

How can we measure the results?

We'll use the measurement operator in the QISKit library and will store the results in the register of the second number.

You can find the full code here. https://quantum-computing.ibm.com/jupyter/user/Sum%20of%20binary%20numbers.ipynb

INTRODUCTION TO QUANTUM COMPUTING

(Using the IBMQ Environment (https://quantum-computing.ibm.com))

Learning to build or program a quantum circuit requires the following knowledge

Qubit – A qubit (or quantum bit) is the quantum-mechanical analog of a classical bit. It has two basis states: |1⟩ and |0⟩ and can be in state |1⟩ or |0⟩ in a linear combination of both.

Superposition – This is when a qubit (or cubits) is in a linear combination of both states. A quantum computer consisting of n qubits can exist in a superposition of 2^n states. However, when this qubit is measured, it can only have one value. With information stored in superposition, some problems can be solved exponentially faster.

Entanglement -This is a phenomenon when the outcome of the measurement on one qubit is always correlated to the measurement on the other qubit. It enables correlations in systems.

I'll explain more concepts as I go on

Building a circuit in Quantum computers works (almost) the same way as the classical computer. We use logic gates as building blocks.

SIMPLE CIRCUIT EXAMPLES 1. Create a superposition state from a single input qubit. Steps: -prepare a qubit in the state |0⟩

-Apply a Hadamard Gate (This gate is a single qubit operation that maps the basis state |0⟩ to ( |0⟩+|1⟩ )/2 and |1⟩ to ( |0⟩-|1⟩ )/2 creating an equal superposition of the two states.)

If we measure this circuit, we get only one basis value with a 50% probability.

1. Entangle two qubits -Use a CNOT gate to entangle a target qubit (q0) with a control qubit (q0). The CNOT gate does logic calculations to ensure that the q1 correlates to q0 when measured. When we measure the values of the two qubits after the circuit is run, even though their values are random measurements, they will correlate to be the same value.

References

1. Coles, P. J., Eidenbenz, S., Pakin, S., Adedoyin, A., Ambrosiano, J., Anisimov, P., ... & Gunter, D. (2018). Quantum algorithm implementations for beginners. arXiv, arXiv-1804. 2.https://quantum-computing.ibm.com/docs/iqx/guide/

REVIEW OF ARTIFICIAL NEURAL NETWORKS

Artificial neural networks (ANN) hold the key to new technologies like driverless cars and voice control. It stems from bio-inspired computing. ANN is an information processing model that is inspired by the way the biological nervous system such as the brain processes information. It is composed of highly interconnected neurons that are processing elements. These elements work together to solve a specific problem.

The general model of an ANN is called a perceptron. Perceptron was introduced by Frank Rosenblatt in 1957. It has inputs of different weights, a bias value, and an activation function. This function converts the inputs of a node to an output signal which is used as an input to the next neuron in the system. The perceptron is active if the output is 1. The activation function applies a step rule (convert the numerical output into +1 or -1) to check if the output of the weighting function is greater than zero or not.

Perceptrons are building blocks that artificial neural networks use to learn (Deep learning). Perceptrons can also be used to construct logic gates.

References

1. https://medium.com/towards-artificial-intelligence/building-neural-networks-from-scratch-with-python-code-and-math-in-detail-i-536fae5d7bbf
2. https://medium.com/analytics-steps/understanding-the-perceptron-model-in-a-neural-network-2b3737ed70a2
3. https://www.simplilearn.com/what-is-perceptron-tutorial
4. https://en.wikipedia.org/wiki/Biological_neuron_model

PROJECT INTRODUCTION

Artificial neural networks are a class of computational models whose architecture is biologically inspired. They are useful in topics such as pattern recognition, image classification, and decision making. In the paper “An artificial neuron implemented on an actual quantum processor” by Tacchino et al., a quantum information-based algorithm was used to implement a “qubit neuron” (quantum binary neuron). This type of artificial neuron has each qubit (the computational unit in quantum computers) acting as an individual neuron within the network. A 2 qubits version of the algorithm was implemented on the IBM quantum processor and used in a pattern recognition process. The results show an exponential advantage in terms of storage capabilities over classical perceptron (a simple neuron) models and can be trained in a hybrid quantum-classical scheme.

The focus for my honours project is to investigate and attempt to replicate this experiment. I would like to explore other papers with similar content in relations to quantum computing and machine learning. I would also like to build a circuit similar to the one outlined in the paper by using IBM Q quantum processor and Qiskit. As I look into this topic, I hope to find out more about the quantum information-based algorithm and how best to implement it. I hope that I can contribute towards the research on practical quantum neural networks, with the hope of implementation on quantum processing hardware.