Adiabatic-Quantum-Computing-to-solve-the-MaxCut-graph-problem

Adiabatic Quantum Computing to solve the MaxCut graph problemFenella McAndrew Supervisors: Prof Kate Smith-Miles & Dr Charles Hill The University of Melbourne School of Mathematics and S

Adiabatic Quantum Computing to solve the MaxCut graph problem

Fenella McAndrew

Supervisors: Prof Kate Smith-Miles & Dr Charles Hill

The University of Melbourne School of Mathematics

and Statistics

A thesis submitted in partial fulfilment of the requirements of the degree

of Master of Science (Mathematics and Statistics)

October 2020

MaxCut is an NP-hard graph theory problem which has been extensively researched

by computer scientists, data scientists and mathematicians As there are no polynomialtime algorithms for NP-Hard problems, there has been a great amount of research intoapproximation algorithms and heuristics

This research project focuses on using adiabatic quantum computing as a techniquefor solving MaxCut Quantum computing in general has been a fast growing field,with adiabatic quantum computing introduced as a useful technique to solve classicallyhard optimisation problems

The main aim of this project is to investigate if there exist any graph features thataffect the performance of adiabatic quantum computing By identifying such features it

is possible to gain insights into predicting the performance of the MaxCut algorithmbased off some prior feature extraction

A big thank you to all my friends inside and outside of university, listening to

me talk endlessly about MaxCut and quantum computing could not have been easy.Special shout out to my proofreaders DJ and Lukas

I want to thank my brothers Angus, Edward, Will and Fin and my dad Alasdair.You all call me smart when I feel the opposite and always put time aside for me when

I need it You’re all amazing and without you I’d be nowhere

Finally, I want to thank my mum Felicity, for being there in good times and badtimes Your love and our friendship has made this possible and I’m eternally grateful

1.1 Motivation 1

1.2 Outline 3

2 Literature Review 4 2.1 MaxCut Graph Problem 4

2.1.1 Problem Description 4

2.1.2 Solution Algorithms 6

2.2 Quantum Computing 8

2.2.1 Overview 8

2.2.2 Adiabatic Quantum Computing 11

2.3 Mapping MaxCut to an AQC Problem 13

2.3.1 Defining Initial Hamiltonian HB 13

2.3.2 Defining Problem Hamiltonian HP 15

3 Methodology 17 3.1 Instance Space Analysis 17

3.2 Instances 21

3.3 Graph Features 23

3.4 Simulating AQC 25

3.5 Performance Metrics 28

3.5.1 Probability of Success 29

3.5.2 Minimum Energy Gap 30

3.5.3 Entanglement 31

4 Results & Discussion 34 4.1 Experimental Results 34

4.2 Analysis of Results 40

4.2.1 Graph Features 40

4.2.2 Quantum Measurements 44

4.2.3 Algorithm Run-time 47

5 Conclusion 49 5.1 Potential Future Work 49

5.1.1 Expanding on MaxCut 49

5.1.2 Other NP-Hard Problems 50

5.2 Final Thoughts 51

A Assorted Definitions 53

List of Figures

2.1 MaxCut example The two partitions are S = {1, 4} and ¯S = {2, 3, 5}

The size of the cut is f (x) = 5 with x = (1, −1, −1, 1, −1) 6

2.2 Simple n = 3 node graph, with m = 2 edges 16

3.1 Instance Space Methodology as outlined in [29] 18

3.2 Table of graph features that are measured for each instance 24

3.3 Running AQC on 3 node graph for tstep= 0.1 and T = 5 27

4.1 Sources Distribution projected onto the instance space 35

4.2 Algorithm Performance based on probability of success Probability of success above 0.9 is considered Good, below 0.9 is considered Bad 37

4.3 Support Vector Machine performance prediction based on the definition of Good and Bad given in Figure 4.2 38

4.4 Distribution of features projected onto the instance space 39

4.5 The two graphs corresponding to the highest and lowest values of the log ratio of the two maximum eigenvalues of the normalized Laplacian matrix 42

4.6 Probability of Success vs Maximum Entanglement 46

parti-on the unweighted 2-MaxCut problem.

MaxCut is a well studied NP-Hard problem, with many researchers attempting

to find new and innovative algorithms These algorithms come in many forms fromrandom greedy approaches [35] to approximations through the graph’s spectra [39].Each algorithm offers different advancements in terms of approximation ratios as well

as spatial and time complexity This thesis will be concerned with only a single solutionmethod The sole method to be considered is Adiabatic Quantum Computing to solvethe MaxCut graph problem

Quantum computing is a fast evolving area from its original conception by Benioff

in 1980 [4] Since then the size and power of the physical quantum devices are seen to

1.1 Motivation

advance every year The specific form of adiabatic quantum computing was introduced

by Farhi [16] as a method to solve certain classically difficult optimisation problems.The algorithm was first introduced by solving the 3-satisfiability problem There havesince been a variety of extensions to further NP-Hard problems and even moving to-wards machine learning applications [31] Much research has been done around solvingMaxCut using adiabatic quantum computing, but there is yet to be any researcharound the analysis of graph features and how they relate to the performance of themethod

While certain algorithms do indeed perform better than others, we know that bythe “no free lunch” (NFL) theorem [40] for NP-Hard problems there really is no singlealgorithm that performs better on every problem instance than all other algorithms.This motivates the idea of a problem instance based investigation through an InstanceSpace Analysis [29] Instance Space Analysis is a recent methodology introduced tounderstand algorithm performance based on instances and their measurable features.The objective of this approach is concerned with examining what problem instancesare hard for some algorithms but easier for others Furthermore, what features makethese instances interesting and different from other instances in the space

As this thesis is entirely focused on a single algorithm the investigation will bearound simply what graph instances are easy and hard for adiabatic quantum com-puting when solving MaxCut The aim of this project is to run the algorithm on awide variety of different graph instances and take measurements of particular features

of these instances An Instance Space Analysis is a valuable tool that has been used forproblems such as Graph Colouring [37] and Machine Learning Classification [28] to un-derstand what measurable features impact algorithm performance This thesis will beconcerned with using this methodology to find certain features that greatly affect theperformance of adiabatic quantum computing when solving MaxCut Finding suchfeatures can offer valuable insight into predicting how the algorithm might performbased on prior feature extraction of the instance

1.2 Outline

1.2 Outline

The format of the remainder of this thesis will be as follows; Chapter 2 will be aliterature review of the MaxCut problem and quantum computing The chapter willalso contain relevant background material important to the remainder of the thesis.Chapter 3 will give an introduction to Instance Space Analysis and give an overview

of the experimental methodology used in simulating adiabatic quantum computing

to solve MaxCut This chapter will also cover the graph features chosen and outlinewhat metrics will be used to measure the success of the algorithm Chapter 4 will showthe results and discussion from running experiments Finally, Chapter 5 will concludethe thesis and offer relevant extensions to the project and direction of potential futureresearch

Chapter 2

Literature Review

2.1 MaxCut Graph Problem

MaxCut has long been a problem of interest and is often used as a classic example

to demonstrate NP-hardness This NP-hard quality of the problem means that it cannot be solved in polynomial time, but that it can be verified in polynomial time This

is what motivates researchers to solve the problem with innovative and interesting newapproximation methods

A cut is defined as the partition of the vertex set V into two disjoint subsets S and

¯

S := V \ S The size of the cut {S, ¯S} is the number of edges connecting the two sets,

2.1 MaxCut Graph Problem

which can be expressed as

W (S, ¯S) := X

i∈S,j∈ ¯ S

wij, (2.1)given that for an unweighted and undirected graph

This can be formulated as an integer programming problem:

2.1 MaxCut Graph Problem

side is a possible MaxCut solution It is important to note that in this example there

do exist multiple solutions (partitions with the same sized cut) and this is an example

of just one of them

3

2 1

MaxCut

5

3 2

wij is not strictly equal to 1

The MaxCut problem has many applications in a variety of different fields Acommon example given is the application in very-large scale integrated (VLSI) circuitdesign, in terms of pin preassignments and layer preferences Another common example

is the application of finding ground states of spin glasses with exterior magnetic fields.Both of these have been explored in detail by Barahona [3]

2.1.2 Solution Algorithms

MaxCut is a classic example of an NP-Hard problem, as shown by Karp [24] in hisseminal paper alongside 20 other NP-Hard problems Karp’s proof showed that theMaxCut problem was a reduction of the partition problem, a proven NP-Hard prob-lem This confirmed that MaxCut belongs to a class of problems for which thereexists no polynomial time algorithm to solve it exactly unless a proof is found to theMillennium Prize Problem “P=NP” At this time there is no proof that a polynomialtime algorithm exists to solve the problem, so all exact algorithms run in exponential

2.1 MaxCut Graph Problem

time which is computationally expensive As a consequence, a vast majority of research

in the field has been focused on approximation algorithms and developing ones withhigh approximation ratios

The definition of a ρ-approximation algorithm as given by Goemans and Williamson[18] is one that delivers a solution of value as least ρ times the optimal value This will

be the accepted definition used in the following discussion An early attempt of such

an algorithm by Sahni [35] in 1976 found a 1/k-approximation for k-MaxCut with animpressive time complexity of O(n + m + k) This algorithm iterates through the ver-tices of the graph and attempts to maximise the cut corresponding to that vertex Thesimplicity of this algorithm essentially corresponds to a randomized greedy algorithmwhere each vertex is assigned to one of two partitions with a 50/50 chance of being

in either For many years this was the leader in the field for a MaxCut heuristic.However, since then there have been many attempts at improving on this algorithm

In particular, Goemans and Williamson [18] boasted an approximation ratio of 87856for general MaxCut by use of semidefinite programming This is still considered thegold standard to which all other algorithms are compared to, with a polylogarithmictime complexity of O(n2log(n))

Since then there have been great advancements when it comes to algorithms for cific graph structures Feige, Karpinski and Langberg [17] considered bounded nodedegree graphs and found an approximation ratio 921 for graphs with maximal degree

spe-3, and an approximation ratio of 924 for cubic graphs Arora and Karger [1] exploredpolynomial approximation algorithms for δ-dense graphs, which are those with at least

δn2 edges In their research, they proved that for some  > 0 there exists an algorithm

of complexity nO(1/ 2 δ 2 ) with a (1 − )-approximation ratio

Whilst there has been no exact algorithm found for solving general MaxCut, lock [21] proved that planar MaxCut is the dual to the maximum matching problem.Here planar graphs are defined as graphs that are not reducible to complete 5 vertexgraph (K5) The maximum matching problem is in the class P, which means it can

Had-2.2 Quantum Computing

This implies that planar MaxCut can be solved in polynomial time It was latershown by Grötschel and Pulleyblank [19] that for weakly bipartite graphs the problemcan also be solved in polynomial time

It is clear to see that the structure of the graph does indeed impact the theoreticalworst case complexity for classical algorithms when solving MaxCut What remains

to be seen is how graph properties affect algorithm performance for individual graphinstances, in particular, how these instances affect quantum computing performancewhen solving for MaxCut This will be addressed in subsequent chapters, following

an introduction to quantum computing and adiabatic quantum computing

2.2 Quantum Computing

2.2.1 Overview

Quantum computation has been a growing area of interest since it was first formallyintroduced by Benioff [4] when he proposed the idea of a quantum Turing machine.This soon led to Deutsch’s proposal [13] of a universal quantum computing model, oftenreferred to a circuit model, which is still one of the most commonly used models today.The principle of this model is to apply a series of quantum logic gates to some preparedquantum state Since its original conception, there have been many advancements interms of the technology being used and the uses of the technology

It is important to introduce the fundamental differences that lie between classicaland quantum computing Whilst a classical computer is comprised of informationencoded by bits, 0s and 1s, quantum computers are comprised of information encoded

by quantum bits often referred to as qubits These qubits are written as |0i and |1i,referred to as bra-ket or Dirac notation, and can be viewed as two dimensional columnvectors

|0i =1

0

, |1i =0

1



2.2 Quantum Computing

An important distinction between classical computation and quantum computation

is the idea of superposition Described by Dirac [14], the principle of quantum perposition states that if a physical system may be in one of many configurations,arrangements of particles or fields, then the most general state is a combination of all

su-of these possibilities This description can simply be interpreted as a system being able

to exist in both qubit |0i and |1i at the same time These states can be written as alinear combination of qubits For a single qubit system the state can be written as

|ψi = α |0i + β |1i , α, β ∈ C (2.7)

The coefficients are complex numbers where |α|2 is the probability of |0i occurring and

|β|2 is the probability of |1i occurring From this a quantum state in its most generalform for an n qubit system is written as

|v1i ⊗ |v2i ⊗ · · · ⊗ |vni = |v1v2 vni (2.9)

For repeated values another simplified notation often used, assuming a configuration

is v1 repeated n times, is written as

|v1i ⊗ |v1i ⊗ · · · ⊗ |v1i = |v1v1 v1i = |v1i⊗n (2.10)The main underlying process of quantum computation is in terms of quantum logicgates These gates are often referred to as unitary operators, as the inverse of the

2.2 Quantum Computing

between vectors and can be considered as a type of rotation operator in the vectorspace The logic gates act on states to manipulate qubits These operators are repre-sented by matrices and the state |ψi is manipulated by the application (multiplication)

of these operators onto the state Simply, given some unitary operator made up bylogic gates U the state is manipulated as such |ψnewi = U |ψi The circuit model works

by iteratively applying these operators onto the state to eventually achieve the desiredfinal state

Quantum computing has been a rapidly developing area of interest for those terested in optimisation problems and techniques This interest stems from the idea

in-of quantum supremacy, which is the goal in-of demonstrating that a programmablequantum device can solve a problem that no classical computer can solve in any fea-sible amount of time Theoretically, this was first demonstrated by Shor in 1994[36] with his groundbreaking log time factorising algorithm The algorithm takesO((log n)2(log log n)(log log log n)) steps on a quantum computer and O(log n) postprocessing time on a classical computer This is compared to the classical exponentialtime equivalents However, the quantum advantage is yet to be confirmed on a physicalquantum device and the advantage shown is purely theoretical at this time Furtheradvancements were made in 1996 with Grover’s search algorithm [20] exhibiting a com-plexity of O(√

N ) over the worst case classical complexity of O(N ) Whilst Grover’ssearch algorithm certainly does not exhibit as impressive a speedup in terms of com-plexity as Shor’s factorising algorithm, both algorithms were important to demonstratethe future potential to find further examples where a quantum computer can theoreti-cally achieve a speedup that a classical computer simply cannot Since then an area ofgreat interest has been in mapping known NP-Hard problems onto a quantum device

to potentially exhibit quantum supremacy

2.2 Quantum Computing

2.2.2 Adiabatic Quantum Computing

The term Adiabatic Quantum Computation (AQC) was first introduced by Farhi [16].However, much research previously had been completed around the similar idea ofquantum annealing The method differs a fair bit from the previously proposed circuitmodel The main driver for this method is the physical principle of the AdiabaticTheorem Its original form, introduced by Born and Fock [5] in 1928, was stated as:Theorem 2.3 (Adiabatic Theorem) A physical system remains in its instantaneouseigenstate if a given perturbation is acting on it slowly enough and if there is a gapbetween the eigenvalue and the rest of the Hamiltonian’s spectrum

Essentially, as stated by Roland [34], given a Hamiltonian describing the energy of

a system; if this Hamiltonian is time-independent and the system is initially in itsground state, then it will remain in this state The Adiabatic Theorem expresses that

if the Hamiltonian varies slowly enough, the state of the system will stay close to theinstantaneous ground state of the Hamiltonian at each time t

The largest difference between AQC and the circuit model is instead of iterativelyapplying a series of logic gates the system is evolved continuously The quantum system

is evolved by Schrodinger’s equation

id

dt|ψ(t)i = H(t) |ψ(t)i , (2.11)where H(t) is the Hamiltonian of the system A Hamiltonian describes the entireenergy of a system whose eigenvectors represent the eigenstates of the system Eacheigenvalue corresponds to different energies of the system where the eigenvector withthe smallest eigenvalue is referred to as the ground state of the system

In AQC two Hamiltonians are required; an initial Hamiltonian (HB) that is easy

to prepare, and a final Hamiltonian (HP) whose ground state encodes to the solution

2.2 Quantum Computing

to the problem The evolution can simply be described by the equation

eH(s) = (1 − s)HB+ sHP, 0 ≤ s ≤ 1 (2.12)

At s = 0 the system is described completely by the initial Hamiltonian, and at s = 1the system is described completely by the final Hamiltonian

There are many different proposed conditions on s to ensure the evolution is slowenough to stay in a ground state The most commonly quoted criterion to ensure this

is the Approximate Adiabatic Criterion [27]

Definition 2.4 (Approximate Adiabatic Criterion) Given a system evolved bythe Schrödinger equation

i¯hd

dt|ψ(t)i = H(t) |ψ(t)i , (2.13)the criterion required for adiabaticity is given as

X

m6=n

¯h

¯

h hm| ˙ni

En− Em

 1 (2.14)

Here ¯h is Planck’s constant and Ek is the kth energy level of H(t)

There has been significant research suggesting it is insufficient to ensure adiabaticity[8] However, it is still the most commonly cited and accepted criterion

By the Adiabatic Theorem, if the change in s is slow enough such that it satisfiesthe Approximate Adiabatic Criterion, the instantaneous Hamiltonian eH(s) will remain

in its ground state The goal of the process is that eH(s) will remain in the groundstate for the entire evolution, meaning it will not jump to an excited state This meansthat by time s = 1 the instantaneous Hamiltonian eH(s) = Hp will be in its groundstate and encode the solution to the problem

At present, the leaders in the field in terms of physical adiabatic quantum ers are those at D-Wave Systems They first debuted their Orion prototype in 2007[32], which was termed a 16-qubit superconducting adiabatic quantum computer pro-

comput-2.3 Mapping MaxCut to an AQC Problem

cessor Since then D-Wave Systems have steadily released a variety of upgraded devicesincreasing the number of qubits and connection between qubits Early in 2019 D-WaveSystems excitedly announced of their plans to soon release a 5000-qubit processor withover triple the amount of connections between qubits than any of their previous devices[10]

2.3 Mapping MaxCut to an AQC Problem

The MaxCut graph problem can naturally be transformed to an AQC problem fromthe formulation given To do so, an initial Hamiltonian and final Hamiltonian must bedefined The final Hamiltonian will be referred to as the problem Hamiltonian fromhere onwards

2.3.1 Defining Initial Hamiltonian HB

As stated before, the initial Hamiltonian is one that is easy to prepare on a quantumcomputer with a known ground state The initial Hamiltonian is not necessarily specific

to a singular optimisation problem, but instead can be used for a variety of differentproblems For MaxCut it is standard to use the initial Hamiltonian as proposed byFarhi [16] The Hamiltonian is typically chosen as

HB = −X

i

σxi (2.15)The term σx is the Pauli matrix/operator

σx =0 1

1 0



which can be interpreted as a π rotation about the x axis inR3 The subscript i refers

to the qubit on which the operator is being applied For example, considering a system

2.3 Mapping MaxCut to an AQC Problem

of three qubits, n = 3, HB is given as

Here I is the dimension 2 × 2 identity matrix

The ground state of this initial Hamiltonian is known and easy to prepare Thestate begins in an equal superposition over all possible states This is often referred to

as the Hadamard basis with representations

|+i := √1

2(|0i + |1i) and |−i := √1

2(|0i − |1i). (2.19)These are simply the equal superposition for a single qubit state For a multiple qubitsystem the equal superposition over all configurations is given as

2.3 Mapping MaxCut to an AQC Problem

2.3.2 Defining Problem Hamiltonian HP

Unlike for the initial Hamiltonian, the problem Hamiltonian is problem dependent.The problem Hamiltonian is chosen such its minimum encodes the solution to theproblem The objective function f (x) from the integer programming formulation ofthe MaxCut problem, equation (2.3), can be used as a basis for defining the problemHamiltonian The objective function was defined to be maximised, however, this can

be rephrased as a minimisation problem through multiplication by −1

max f (x) = 1

2X

1≤i<j≤n

(1 − xixj) ⇒ min f (x) = 1

2X

1≤i<j≤n

(xixj − 1) (2.22)From this formulation it is easy to define the Hamiltonian to be minimised

HP = 1

2X

(i,j)∈E(G)

(σizσzj − I), (2.23)where σz is the Pauli/matrix operator

HP = 1

2X

2.3 Mapping MaxCut to an AQC Problem

3

2 1

Figure 2.2 Simple n = 3 node graph, with m = 2 edges

The operators for the initial Hamiltonian and problem Hamiltonian have been chosensuch that they do not commute with one another

Hence a problem Hamiltonian has been defined such that the ground state of itencodes the solution to the problem The Hamiltonian has been suggested and used bymany such as Hamerly [22] in their experimental investigation of an adiabatic quantumcomputer compared to a coherent Ising model It has especially been well documented

in experimental research of discretised AQC known as the Quantum ApproximationOptimisation Algorithm (QAOA), a method also introduced by Farhi [15] This methodwas used to solve MaxCut by Crooks [9], Moussa [28], Google [2] and many more

Chapter 3

Methodology

3.1 Instance Space Analysis

For this project, a main driving force is investigating if there are any graph featuresthat drastically affect the performance of AQC In order to perform this sort of analysis,

we employ the technique of an Instance Space Analysis (ISA) using the tools oped by Smith-Miles and colleagues within the Melbourne Algorithm Test InstanceLibrary with Data Analytics (MATILDA) This tool allows the user to see the poten-tial strengths of an algorithm compared to others on a wide range of datasets throughthe visualisation of high dimensional data projected as single points on a 2D scatterplot We will give a brief introduction into the methodology used by MATILDA forISA However, we direct the reader to the paper “Instances spaces for machine learningclassification” [29] for a more in depth look into the current methodology

devel-The methodology used by MATILDA extends on Rice’s Algorithm Selection lem framework [33], which is detailed in the blue region of Figure 3.1 The basicpremise of the Algorithm Selection Problem is to choose an algorithm that is the mostappropriate algorithm for a given problem The Algorithm Selection Problem can bedefined formally as follows,

Prob-3.1 Instance Space Analysis

Definition 3.1 (Algorithm Selection Problem) For some given problem instance

x ∈ P, with features f (x) ∈ F , find the selection mapping S(f (x)) into the algorithmspace A, such that the selected algorithm α ∈ A maximizes the performance mappingy(α, x) ∈ Y

ISA extends on this by enabling visualisation of the instance space, instance difficultyand algorithm performance The aim of the extension is to give further insight thanallowed previously into why some algorithms may be well suited to specific instanceclasses

Figure 3.1 Instance Space Methodology as outlined in [29]

3.1 Instance Space AnalysisThe framework makes reference to a variety of different spaces

1 The problem space P is composed of all possible instances of a certain problem

2 The subspace of instances I ⊂ P is the space of problem instances for which wehave computational results

3 The feature space F contains measures characterising problems of the instances

in I

4 The algorithms space A contains selected algorithms to solve the problem

5 The performance space Y contains measures of the performance of algorithms in

A on instances in I

As described by Rice [33], for a given instance x ∈ I and algorithm α ∈ A a featurevector f (x) ∈ F and performance metric y(α, x) ∈ Y are measured This process is thenrepeated for all the algorithms in A on instances in I The meta-data {I, F , A, Y}

is then generated from this process The Rice framework then uses this data andregression models to find a relationship between features and the algorithm performancemetric

The ISA extension, as mentioned previously, allows for a more detailed analysis intoinstance classes and their difficulty The extended framework uses the meta-data tolearn some mapping g(f (x), y(α, x)) that projects the instances from a high dimensionalfeature space to a 2D space The 2D space is generated so that it is easy for the user tonotice linear trends of features and performance in the data The current methodologyfollows these main steps:

1 Construction of meta-data and set of features

2 Selection of subset of features

3 Justification of subset of features by performance

3.1 Instance Space Analysis

5 Measure algorithm footprints and gain insights into strengths and weaknesses.Once given the meta-data MATILDA performs a feature selection process to choosethe most significant features that affect the chosen algorithms Each instance is given alabel ‘Good’ or ‘Bad’ for each algorithm This label is determined by the performancemetric chosen to compare the algorithms The procedure works by first identifying fea-tures that correlate with the performance of each algorithm to choose a smaller subset

of features The similar features from this subset are clustered and one feature percluster is chosen to consider all combinations of features For each combination, ma-chine learning techniques are used to determine the accuracy of a classification problem

to classify an algorithm performance as ‘Good’ or ‘Bad’ The optimal feature subset

is chosen as the one with the best separability of ‘Good’ and ‘Bad’ performances.Once a relevant set of features is selected based on the performance of the algo-rithms, a 2D instance space is created This space is created so that the easy and hardinstances are separated and easy to visualise in a 2D plane Dimensionality reduc-tion techniques are used in order to visualise the high dimension feature space in R2.Previously MATILDA used Principal Component Analysis (PCA) for dimensionalityreduction [37] However, more recently the MATILDA methodology has altered [29]

to instead use a tailored dimensionality reduction technique to improve visualisation

of trends, where the aim is to minimize the following:

||F − ˆF|| + ||yT − ˆyT||2F (3.1)such that

Z = ArF, (3.2)ˆ

F = BrZ, (3.3)ˆ

yT = cTrZ (3.4)Here F is the feature data matrix, y is the performance vector and we want to find Ar,

3.2 Instances

Br and crto minimize the system given above The aim is to find two new axes, z1 and

z2, such that each instance is given a coordinate (z1, z2) in the plane The instanceswith similar features or located close to each other and the direction of increasing anddecreasing features are shown as clear trends in the plane The algorithm performance

is visible across the 2D plane with each instance clearly labelled as ‘Good’ or ‘Bad’ foreach algorithm

The footprints for the different algorithms are then determined An algorithmfootprint is defined as the region in the instance space where that algorithm is predicted

to perform well MATILDA uses a Support Vector Machine prediction (SVM) witheither a Gaussian or polynomial kernel The SVM is used to analyse the data andproduce a regression analysis The function of the kernel is to transform the data into

a higher dimensional space where the classes are more easily separable This is thenprojected onto the instance space to show visually where the algorithm is predicted toperform ‘Good’ or ‘Bad’ for each given instance

There is another step in the methodology that is evolving instances to fill the gaps

in the 2D instance space This generation of artificial problem instances is a verypowerful tool, however, it is beyond the scope of the current project

For the remainder of this chapter we will go through the set up of each of the spaces{I, F , A, Y} for this project in terms of AQC and MaxCut

3.2 Instances

The set of problem instances I is an important consideration for any form of algorithmtesting, especially when performing an ISA In terms of MaxCut, an instance is asingle simple graph

To complete this project we use Python’s NetworkX library to create a library ofrandom graphs We use the following 5 random graph generators:

• Uniformly random graphs - graph edges are chosen uniformly at random

An n-node graph corresponds to an n-qubit system For an n-qubit system there are

2n configurations To give some perspective of the greatness of this number a classicexample is; given n = 63 qubit system there are 263 configurations, which is roughlyequivalent to the number of grains of sand on earth For this project, all simulationsare done on a classical computer, so due to memory issues we are unable to performexperiments for anything larger than approximately 12 qubits

Whilst we have used a few different graph generators, a significant problem withusing randomly created instances is the possibility of losing specific structural graphproperties which are useful to analyse and compare However, all pre-existing reposi-tories of MaxCut instances contain graphs consisting of hundreds of nodes which arefar too big for running this algorithm classically So whilst it would be interesting toanalyse the algorithm on such graphs, unfortunately, we have been left with creatingand using randomised graphs

Specifically for this project, we use a graph library of 400 graphs from each tor, 2000 graphs in total Each graph is of 9 nodes and connected We choose to keepthe number of nodes constant as we do not want the number of qubits to affect thesystem In doing this, we aim to keep our focus on the structural graph properties

genera-It is also important to note that all graphs we use have a unique solution to Cut When solving MaxCut many graph instances can have more than one node

1 Can be computed in polynomial time.

2 Can potentially expose what makes an instance hard for a given algorithm

It is important to be able to compute these features in polynomial time, in order tofind features that affect the algorithm The aim of an ISA is to give some predictiveproperties of performance before actually running the algorithm If a feature is also anNP-Hard problem or takes exponential time to compute, it will not offer much insightinto the performance of the algorithm, as it is just as hard to solve as the problem

we are analysing We also endeavour to look at features that may offer these insightsinto what makes an instance hard for the algorithm, as this is what makes an ISA avaluable tool If a feature does not help in exposing the weaknesses or strengths of thealgorithm, it is just a waste of valuable computational power and will not be of use inthe analysis of the algorithm

As mentioned earlier, there has been research in the past into developing algorithms

to solve MaxCut for particular structures of graphs This has lead to some valuableresearch into quantum computing and specific graph sub-classes

In 2019, Hamerly [22] looked into solving MaxCut on a D-Wave Systems’ adiabaticquantum computer for dense graphs and 3-regular graphs However, their research did

3.3 Graph Features

algorithm performance

Whilst there has been research into solving MaxCut using AQC for specific graphsub-classes, there has been little to no research on how a range of different graphfeatures affect the performance of the algorithm

The graph features we choose to measure are ones that are easy to compute andgive us information about the structure of the graph Much inspiration for these graphfeatures have been taken from Smith-Miles [37] and their ISA investigation of the GraphColouring Problem The graph features chosen are given in Figure 3.2

Graph FeaturesFeature Type Feature

Nodes & Edges Number of edges

DensityMinimum, Maximum, Standard Deviation, Mean, HarmonicMean, Geometric Mean, Skewness and Kurtosis of node degreesCycles & Paths Number of triangles (3-cycles)

Average shortest pathAverage clusteringDiameter & RadiusSpectral Algebraic connectivity

Laplacian EnergyLog ratio of two largest eigenvalues of the normalised Laplacianmatrix

Log ratio of largest and smallest non-zero eigenvalue of the malised Laplacian matrix

Log ratio of the two smallest non-zero eigenvalues of the malised Laplacian matrix

nor-Figure 3.2 Table of graph features that are measured for each instance.See Appendix A for further details It should be noted that the number of nodes is not

a graph feature we are measuring, as it is kept constant at n = 9 for all instances

3.4 Simulating AQC

For each instance, we calculate a feature vector f (x) ∈ F , where f (x) is a highdimensional vector that contains all the features listed above for a single graph instance,and F is the high dimension feature space that contains all feature vectors for all graphinstances

3.4 Simulating AQC

For this project, we want to test a variety of different instances on the AQC solvingmethod Unfortunately, we have not been able to obtain access to an adiabatic quan-tum device, such as those made by D-Wave Systems In order to obtain results all AQCexperiments were done as simulations on a classical computer To allow for larger testinstances the code was run on the University of Melbourne High Performance Comput-ing Cluster, SPARTAN To provision and manage these experimental workloads theez-experimentr architecture by Katial [25] was used

As we are classically simulating the algorithm, we are unable to continuously evolve

in time as we would in a physical system Instead we choose some time step (tstep) andsome total time (T ), and evolve the system from 0 to T one tstep at a time The timestep is chosen to be relatively small in order to simulate a physical system as closely

as possible First an initial ground state is defined as in the previous explanation ofAQC in Chapter 2 At each time step we calculate two values for eH, one at the current

t

T and the next t+tstep

T We then take an average of these two eH values From this

we want to find an operator to act on the state If we look back to the Schrödingerequation, we can use the setup by van Dam [11] From this, the Schrödinger equationcan be described with reference to a unitary transformation as follows,

d

dtU (t) = −iH(t)U (t). (3.5)

3.4 Simulating AQCFrom this we can define the operator U to be given as

U = e−iHtstep (3.6)

This operator then acts on the current state to calculate the next state This process iscompleted iteratively and terminates at t = T , then the algorithm returns the currentfinal state vector as the output To perform these simulations we use an algorithm ofthe following form

Algorithm 1 Simulated AQC

Require: An initial Hamiltonian HB, a problem Hamiltonian HP, a total run-time Tand a time step tstep

1: t ← 0 Define start of evolution at time 0

2: |ψi ← |−i⊗n n is number of nodes in graph

3: while t < T do Algorithm terminates when t = T

4: H1 ← (1 − Tt)HB+TtHP

5: H2 ← (1 − t+tstep

T )HB+ t+tstep

T HP

6: H ← H1+H22 Average of the two Hamiltonians

7: U ← e−iHtstep Matrix exponential

8: |ψi ← U |ψi Apply operator to state vector

9: t ← t + tstep

10: return normalized |ψi

Given some T and some tstep there will be tT

step iterations The Hamiltonian operatorsthat we are working with are of dimension 2n× 2nand the state |ψi if of size 2n Hence,line 8 of the algorithm is the most computationally expensive to execute

The returned state |ψi at the end of the algorithm will ideally be the solution to theproblem at hand We class the “solution” as the configurations that have the highestprobability (amplitude squared) Each configuration is a sequence of 0s and 1s Wesay that each qubit corresponds to a particular node of the graph, and a qubit being

0 or 1 represents the subset containing the relevant graph node For the example in

3.4 Simulating AQC

Figure 3.3 the two subsets are S = {1, 3} and ¯S = {2}, hence the solutions in terms ofconfigurations will be |010i and |101i We can see the peaks in the probability densityfunction (PDF) are located at those two configurations This implies that the algorithmhas begun to find the correct solution It is important to note that for MaxCut inour simulations the PDF will always be symmetric, as both |010i and |101i correspond

to the same solution

Figure 3.3 Running AQC on 3 node graph for tstep= 0.1 and T = 5

The example in Figure 3.3 is for a very short run time As the graph instance isrelatively small we can still see fairly large peaks at the correct configurations, evenwith such a short run-time However, if we were to test the algorithm on larger graphinstances the algorithm run-time may need to be extended, as T = 5 may not be suf-ficient to exhibit peaks at the correct solutions This is an important consideration inthe experimental investigation for this project

One of the fundamental components when performing an ISA is applying a variety

of different algorithms to a single set of instances in order to compare their mance based on some metric Unfortunately, there are no classical algorithms that areappropriate to compare with AQC For this project, we instead choose our 5 differ-ent algorithms to be AQC but run for different total times We choose the 5 times