Christian Wesseler

Abstract

Using quantum computing, it is possible to design algorithms for computers that handle

problems in ways that were previously unimaginable. The uncertain nature of a particle in a

magnetic field allows for us to handle multiple data sets simultaneously. The string of quantum

bits can act as all values that a classical computer would be able to represent with the same

number of bits. By manipulating this property of quantum computing, exceedingly complex

algorithms can be computed in more reasonable time. Solving complex algorithms of this

nature would change the very nature of computer science we have established. All research is

explained relative to the maximum clique problem, an example of an NP-Complete problem.

Introduction to Computation Time Complexity

In the world of computing, programming

problems can be broken down into categories

that represent their difficulty and time

complexity for obtaining a solution. These

categories are defined initially as either

possessing polynomial deterministic time (P),

Sets of Computation Time Complexity (GeeksForGeeks)
or non-polynomial deterministic time (NP). A

polynomial time indicates that the expected runtime can be reduced to a polynomial equation

based on the size of the problems inputs (Fortnow 2009). Non-polynomial problems are
 Christian Wesseler

inversely unable to be solved in polynomial time, and are broken down into categories NP, NP-

Hard and NP-Complete. Problems defined as NP have an answer that can be verified in

polynomial time. Given an array of size n, a quicksort algorithm can sort the array in O(n*log(n))

time, but the solution can be verified in linear time. In this regard, algorithm analysis becomes

more heavily based on proof of concept than algorithm design. Using proofs, it is possible to

show that problems in NP can be transformed into similarly difficult or harder problems.

Algorithms with this property are classified as NP-Hard, a set of problems that can represent

any NP problem with a polynomial transformation time. If a problem can represent all problems

within NP, and is verifiable in polynomial time, it is said to be NP-Complete. Defining the time

complexity of an algorithm is one of the fundamental aspects of describing computable

functions for Turing machines (Cook 2006).

Usefulness of NP-Complete Problems

NP-Complete problems offer an advantage

over their NP-Hard counterparts. Because all

components of NP-Complete are also a

member of NP, they can be freely transformed

into any other NP-Complete problem. Proving

a solution for one NP-Complete problem

proves matching solutions for every other NP- Graph of an Unsolved Clique Problem (Skipperkongen)

Complete problem. Due to their non-polynomial nature, many researchers have tried to find a
 Christian Wesseler

way to prove that NP is the same as P, and that a polynomial time solution exists for problems

in this category. To better explain the significance of proving the two to be the same, it is the

idea of removing the need to search for the next component of the answer in a search problem.

Many problems in NP-Complete are difficult search problems with many potential solutions to

search through. The best example is the maximum clique problem which, given a graph with V

nodes and E edges, must find the largest collection of nodes with every member sharing an

edge with every other member. Each addition to the collection requires one more check than

the previous node. Each collection must be compared with every other collection to see if more

nodes might have fit if specific nodes were excluded. Simplifying the list of potential solutions,

nodes can be represented as a state of included or excluded, creating 2 V possibilities. Taking

advantage of the unrealistic computation times for NP-Complete problems, much of modern

cryptology hides data encoded as one of these problems, where it is quick to verify the solution

but nearly impossible to compute it. In this sense, solving NP-Complete problems would allow

for users to programmatically break any public key cryptography (Fortnow 2009). Solving NP

problems in polynomial time would allow for an optimization of the world in more ways we

could imagine. To best state the importance of efficiently solving an NP problem, what we will

gain from P = NP will make the whole Internet look like a footnote in history (Fortnow 2009).

Practicality of Solving NP-Complete Problems

Since the P vs NP problem first appeared in Gdels letter to Von Neumann in 1956,

mathematicians have worked tirelessly to create evidence as to the whether P is equal to NP, or
 Christian Wesseler

if the two remain distinctly separate (Gdel 1956). In attempting to find a definitive answer, the

only concise proof regarding P vs NP is that no relativizable proof can settle the P versus NP

problem in either direction (Fortnow 2009). It is important to break away from the ideology of

merging the two categories, and instead find a way to transform NP-Complete into an a

problem more closely resembling an equivalent classical polynomial time problem. A solution

would require a reduction in the number of steps involved for finding the optimal solution given

some arbitrarily sized collection of data. The best way to trivialize searching for a solution in this

case is to reduce the impact from the number of inputs on the computation time for the

algorithm. In this case, it would be better to compute all potential solutions simultaneously; a

computation only capable with the properties of quantum computing.

Mechanics of Quantum Computing

In classical computing, data is stored as a

binary encoding of ones and zeros which is

manipulated through logic gates to

perform computations. Each computation

is the result of two particular strings of

binary interacting to add, subtract, Superposition compared to classical bits (QOQMS)

perform bitwise functions, or provide input to other components of the computer. In this

regard, classical computers are limited in their throughput by how quickly they perform the

operation and load the next instruction to process. Sequential data accesses and computations
 Christian Wesseler

are the very concept of the original Turing machine of which the P vs NP problem is based.

Quantum computing stands to revolutionize classical computing in situations where

computations do not depend on data resulting from previous instructions. Where the classical

bit can encode either a one or a zero, the quantum equivalent, known as a qubit, can represent

both simultaneously through either spinning up or spinning down. This state, known as a

superposition, is an ambiguous linear combination of both classical states (McMahon 2007).

Using qubits, computations can act on all possible states representable by a string of classical

bits. Superposition is achieved by placing a particle in a suspended state, within a magnetic field

so that it exists between both possible spins (Beth and Leuchs 2005). When measured, the spin

is determined to be either up or down, representing a classical bit. The indeterminate state the

bit is in until measured is what gave rise to the infamous Schrdingers Cat thought experiment,

where the fate of the cat is unknown until observed and the box contains both possible

outcomes. The collapse of the possibilities for the particles spin when observed is the basis for

converting qubits into classical bits to decode the information stored. The limitation of

quantum computing is the amount of isolation necessary to prevent the qubit from being

observed before the computation is completed. Any interaction with environmental variables

could prematurely collapse the wave function and prevent further calculations.

Isolating an NP-Complete Problem for Computation

In a typical computer system, the processor is unable to function without input from

instructions and data being passed in from memory. The data is stored in registers, passed into
 Christian Wesseler

the processor, and performs the instruction pointed to by the program counter. In quantum

computing, each stage in a classical computer would destroy the superposition of the bits in

use. The processor would need to analyze the bits to create the correct output, and the register

would have to check what values to pass to the processor. In order to compute data similar to

the way a classical computer would, the qubits must be isolated from the rest of the system,

and any interactions with them must be independent of the particles spin as to avoid

measuring it. To avoid accessing the data, the qubits would need to act like a cache on a

processor, holding the values locally without external references. The entire dataset for the

problem would need to be encoded as a set of qubits of sufficient size so that no memory

accesses are needed to store the entirety of the NP-Complete problem. Considering the cost of

cache memory deters manufacturers from eliminating random access memory from classical

computers, creating enough isolated qubits to recreate an NP-Complete problem may be an

unrealistic vision for the near future (Bryant and O'Hallaron 2013).

Runtime Improvement from Step Reduction

Given the amount of work in creating a system that could reasonably isolate enough particles

to recreate an NP-Complete problem, the question remains what would be the improvement

for runtime performance? Reusing the example of the clique problem, where V represents the

number of vertices present in the graph, we can do a proof by induction to find that every

clique problem has a collection of subgraphs twice the size of a clique problem with one less

vertex. This is further reinforced if imagining all subgraphs of V-1 size alongside each similar
 Christian Wesseler

subgraph containing the new vertex. We know that the solution will be one of the 2V sets of

states. Similarly, many sets within the collection are unsuitable to be considered a clique. To

remove an incompatible set from the collection of possibilities, two active nodes in the set

need to be found without an edge connecting them. Eliminating the need to analyze each set

separately, a new collection of sets can be computed where each set is a completed clique

subgraph. Reducing the collection through quantum computing would eliminate the 2V

coefficient from the algorithms classical complexity and vastly simplify the algorithms

quantum complexity. Each active node would then only need to be compared with every other

active node in the current set to confirm or reject the clique, and the algorithms runtime would

only take as long as the time to verify the largest clique in the graph has no missing edges. Once

a collection has removed all invalid cliques, potential solutions can be parsed for the greatest

number of vertices for the largest clique, and the collection can be sorted like an array for an

ordered list of clique sizes. Through the transformation of the clique problem into a quantum

computing algorithm, it becomes a transformation of the problems complexity itself. Such a

transformation would not prove polynomial computation time in a classical setting equal to

non-polynomial computation time, but rather a function that converts the problem into a

significantly more time efficient algorithm.

Conclusion

Using the superposition property of particles, it is possible to develop a quantum computer that

can efficiently solve clique problems. Using the transformations of NP problems into NP-
 Christian Wesseler

Complete problems, a quantum computer would be able to efficiently calculate any other

problem in NP by converting it into the clique problem. Once a solution has been calculated, it

can be used to answer the original problem provided as an input. In this regard, there is

potential for quantum computers to work alongside classical computers to convert, compute,

and analyze problems we deemed too complex for Turing machines nearly sixty years ago.
 Christian Wesseler

References:

1. Fortnow, Lance. "The status of the P versus NP problem." Communications of the

ACM 52.9 (2009): 78-86.

2. Cook, Stephen. "The P versus NP problem." The millennium prize problems (2006): 87-

104.

3. "The Gdel Letter." Gdel's Lost Letter and P=NP. N.p., 12 Feb. 2009. Web. 01 May

2017.

4. McMahon, David. Quantum computing explained. John Wiley & Sons, 2007.

5. "NP-Completeness | Set 1 (Introduction)." GeeksforGeeks. N.p., 29 Oct. 2015. Web. 01

May 2017.

6. Kostas, Author. "Month: November 2010." Skipperkongen. N.p., n.d. Web. 01 May 2017.

7. Beth, Thomas, and Gerd Leuchs. Quantum Information Processing. Weinheim: Wiley-

VCH, 2005. Web. 30 Apr. 2017.

8. "Quantum Optics and Quantum Many-body Systems." QOQMS | Research - Quantum

Computing. N.p., n.d. Web. 01 May 2017.

9. Bryant, Randal E., and David R. O'Hallaron. "Cache Performance." SpringerReference

(n.d.): n. pag. 2013. Web.