Machine Learning for Designing Fast Quantum Gates

Home , Andreas Wallraff, Quantum logic gate

University of Calgary PRISM: University of Calgary's Digital Repository

Graduate Studies The Vault: Electronic Theses and Dissertations

2016-01-26 Machine Learning for Designing Fast Quantum Gates

Zahedinejad, Ehsan

Zahedinejad, E. (2016). Machine Learning for Designing Fast Quantum Gates (Unpublished doctoral thesis). University of Calgary, Calgary, AB. doi:10.11575/PRISM/26805 http://hdl.handle.net/11023/2780 doctoral thesis

University of Calgary graduate students retain copyright ownership and moral rights for their thesis. You may use this material in any way that is permitted by the Copyright Act or through licensing that has been assigned to the document. For uses that are not allowable under copyright legislation or licensing, you are required to seek permission. Downloaded from PRISM: https://prism.ucalgary.ca UNIVERSITY OF CALGARY

Machine Learning for Designing Fast Quantum Gates

Ehsan Zahedinejad

A THESIS

SUBMITTED TO THE FACULTY OF GRADUATE STUDIES

IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE

DEGREE OF DOCTOR OF PHILOSOPHY

GRADUATE PROGRAM IN PHYSICS AND ASTRONOMY

CALGARY, ALBERTA

January, 2016

c Ehsan Zahedinejad 2016 Abstract

Fault-tolerant quantum computing requires encoding the quantum information into logical qubits and performing the quantum information processing in a code-space.

Quantum error correction codes, then, can be employed to diagnose and remove the possible errors in the quantum information, thereby avoiding the loss of information.

Although a series of single- and two-qubit gates can be employed to construct a quantum error correcting circuit, however this decomposition approach is not practically desirable because it leads to circuits with long operation times. An alternative approach to designing a fast quantum circuit is to design quantum gates that act on a multi-qubit gate. Here I devise quantum control schemes to design high-ﬁdelity single-shot multi-qubit (up to three) quantum gates.

Quantum control task is to steer quantum dynamics towards closely realizing specific quantum operation by varying the external control parameters (external field) such that the resultant evolution closely approximates the desired evolution. A set of instructions that determines the control parameters, and hence the e↵ectiveness of the control scheme, is called a policy. Machine learning algorithms can be employed to find successful policies for designing quantum gates. In particular, we employ supervised machine learning techniques to generate these successful policies.

Finding successful policies is a feasibility problem for which optimization algorithms can be employed. Greedy algorithms are at the heart of machine learning techniques. They converge faster onto a successful policy and require less-computational resource than non-greedy algorithms. However, there is no guarantee that greedy algorithms succeed to a feasible solution when there exist constraints on i) gate operation time ii) computational resources, and iii) experimental resources.

Our results show the failure of standard greedy machine learning algorithms and

ii the superiority of non-greedy machine learning algorithms over greedy ones for designing quantum logic gates, when there exist constraints on the quantum system.

We have also observed the failure of existing greedy and non-greedy techniques for designing high-ﬁdelity three-qubit gates. Hence, we devised our machine learning technique called Subspace-Selective Self-adaptive Di↵erential Evolution (SuSSADE).

Each three-qubit gate designed by SuSSADE operates as fast as an entangling two- qubit gate under the same experimental constraints. Preface

We have two published papers [1, 2], the content of which are used in the appropriate sections of my thesis. The main portion of the papers are used in Chapters 5 and

6eitherverbatimorwithsomerequiredmodiﬁcations.Inordertokeeptheﬂowof di↵erent subjects smooth in my thesis, I have used the background and introduction parts of the papers in the early chapters of my thesis. Here I list the two papers which are published based on this work:

1. Ehsan Zahedinejad, Sophie Schirmer, and Barry C. Sanders. Evo-

lutionary algorithms for hard quantum control. Physical Review A,

90:032310, Sep 2014. arXiv.org:1403.0943

2. Ehsan Zahedinejad, Joydip Ghosh, and Barry C. Sanders. High-ﬁdelity

single-shot To↵oli gate via quantum control. Physical Review Letters,

114:200502, May 2015. arXiv.org:1501.04676

In order to make the material taken from our publications and used in my thesis more informative, I have modiﬁed and introduced some changes into the context of previously published work. The changes that I made to those materials taken from our publications and used in the body of my thesis are listed as below:

Chapter 2: Section 2.4.3 contains some sentences verbatim (but not • explicitly marked) from the introduction sections of [1, 2].

Chapter 3: Sections 3.3 and 3.11 transcribed from [1]. • Chapter 5: Mostly contains material from [1]. The following changes • are made to the content to make the chapter more informative:

– Whenever found appropriate, a sentence is added to refer

to the introduction and background chapters. All ﬁgures

iv in this chapter are cited to the corresponding ﬁgures in

the paper.

– In Section 5.1 the ﬁrst paragraph is completely modiﬁed.

The gate operation time T is changed to ⇥ to be consis-

tent with the rest of the thesis. The rest of this section

is unchanged.

– Subsection 5.3.1 is modiﬁed to clarify our choice of ex-

ternal pulse. A sentence is added to refer to Section 3.5

for more clarity.

– In Subsection 5.3.2 we have removed the details of evo-

lutionary algorithms. A sentence is added to refer to

Secs. 3.11 and 3.10 in which we discussed the optimiza-

tion algorithms in detail.

– Subsection 5.3.3 is modiﬁed slightly by adding a sentence

which refers to the evolution equation 3.4.

Chapter 6 contains some of the material from [2]. All the result for the To↵oli gate are reproduced from [2] with proper citations to the original publication. Other ﬁgures are based on our new results which will be published in [3]. The following are the list of the changes made to the content to make the chapter more informative:

Section 6.1: The first paragraph includes the first paragraph of [2] with • some modifications to include two other three-qubit gates (i. e. CNOT-

NOT and Fredkin gates).

Section 6.1: The fourth paragraph copied from [2]. • Subsection 6.4.6 transcribed from [2] and modiﬁed extensively to be • more clear. We added a sentence to refer to original DE algorithm in Section 3.11.

Section 6.5 is copied verbatim from [2]. • Subsection 6.6.1: The second paragraph is transcribed from [2]. • Subection 6.8.3 discussion on distortion of control pulses is transcribed • from [2]. Acknowledgements

IwouldliketoexpressmyspecialappreciationtomyadvisorBarrySanders,forhis endless support, enthusiasm, and insight during my PhD studies. I would like to thank him for allowing me to follow my interest in research and to become an independent researcher. Your advice on both research and my career have been priceless. I also like to thank my co-supervisor Dennis Salahub for his subtle guidance on my research on molecular dynamics Simulation.

I am deeply indebted to Joydip Ghosh whose insight and valuable ideas helped me to complete this work. I am also grateful for the expertise of my recent scientiﬁc collaborators, Sophie Schirmer, Nathan Babcock. I specially thank Doug Phillips for helping me to become familiar with the world of supercomputers during the ﬁrst year of my PhD program. For insightful discussions and words of encouragement, I wish to thank Jonny Johannes, Pantita Palittapongarnpim, and Hamidreza Kaviani. I am grateful to Lucia Wang, Nancy Jing Lu, Tracy Korsgaard, and Gerri Zannet for their administration assistance during my PhD studies.

IacknowledgeWestgridComputeCanadaforprovidingcomputationalresources to enable this work. I acknowledge the Murray Fraser Memorial Graduate program and Eyes High International Doctoral Scholarship and support from Natural Sciences and Engineering Research Council of Canada.

I would not be here without the moral and physical support of my great parents

Ghorban Zahedinejad and Nosrat Zahedi. Words cannot express my feelings, nor my thanks for all your sacriﬁce in my life. I would like to thank my brothers and sister

Ali, Mohammad and Elahe. Just saying thank you will never repay your kindness.

Last but not the least I would like to thank my beautiful wife, Samira Hafezi for her support and care during the stressful time of my PhD studies. Your support and

vii encouragement was in the end what made this dissertation possible. I cannot imagine what would I do without you in my life! Table of Contents

Abstract ...... ii Preface ...... iv Acknowledgements ...... vii TableofContents...... ix List of Tables ...... xii ListofFigures...... xiii List of Symbols ...... xvii 1Introduction...... 1 1.1 Motivation ...... 1 1.2 Research problem ...... 3 1.3 Research objective ...... 4 1.4 Physical models ...... 4 1.5 Approach ...... 5 1.6 Summary of the research achievements ...... 9 1.7 Overview of chapters ...... 10 2QuantumInformationProcessing:APrelude...... 13 2.1 Quantum information theory ...... 13 2.2 Classical and quantum bits ...... 14 2.3 Classical logic gates ...... 16 2.4 Quantum logic gates ...... 17 2.4.1 Single-qubit gates: Pauli matrices and the Hadamard . . . . . 18 2.4.2 Controlled-NOT(CNOT)gate...... 19 2.4.3 Three-qubit gates: To↵oli and Fredkin ...... 20 2.5 Universalquantumgates ...... 22 2.6 Quantum error correction ...... 22 2.7 Fault-tolerant quantum computing and threshold theorem ...... 24 2.8 Quantum noise ...... 24 2.8.1 Decoherence-induced noise ...... 25 2.8.2 Quantum noise and quantum operation ...... 26 2.8.3 Quantumoperationsandenvironment ...... 27 2.8.4 Operator-sum representation ...... 27 3QuantumControl:Background...... 29 3.1 Optimal control theory: Application in quantum systems ...... 29 3.2 Control fields: Time- vs. frequency-domains ...... 31 3.3 Quantum control ...... 32 3.4 Machine learning: A quantum control tool ...... 33 3.5 Controlpulsesaslearningparameters ...... 35 3.6 Learning algorithm confidence: Intrinsic fidelity ...... 37 3.7 Averagestatefidelity ...... 38 3.8 O✏ine vs. online noise consideration ...... 38 3.9 Threshold-fidelity gate: A feasibility problem ...... 39 3.10 Greedyoptimizationalgorithms ...... 40

ix 3.10.1 Nelder-Meadtechnique ...... 40 3.10.2 Quasi-Newton...... 42 3.10.3 Krotov ...... 43 3.11 Evolutionary algorithms ...... 45 3.11.1 GeneticAlgorithm ...... 46 3.11.2 Particle Swarm Optimization ...... 47 3.11.3 Di↵erential Evolution ...... 48 4 Superconducting Artificial Atoms and Gate Design: Background . . . 50 4.1 Quantum computing with superconducting devices ...... 50 4.1.1 JosephsonJunction...... 51 4.1.2 Charge qubit ...... 53 4.1.3 Transmon ...... 54 4.2 Single-Qubit gate design for superconducting artificial atom . . . . . 56 4.3 Two-Qubit (CZ) gate design for superconducting artificial atoms . . . 56 5 HardQuantumControlProblems ...... 60 5.1 Introduction ...... 60 5.2 Criteriatoevaluatealgorithmperformance ...... 62 5.3 Methods ...... 64 5.3.1 Type of control function or hypothesis ...... 64 5.3.2 Optimizing the control function ...... 64 5.3.3 Evaluating the objective function ...... 66 5.4 Qutrit phase gate ...... 66 5.4.1 Qutrit phase gate: Physical Model ...... 67 5.4.2 Qutrit phase gate: Results ...... 69 5.4.3 Qutrit phase gate: Discussion ...... 70 5.5 Controlled-NOT(CNOT)gate...... 71 5.5.1 CNOTgate: PhysicalModel...... 72 5.5.2 CNOTgate:Results ...... 72 5.5.3 CNOTgate:Discussion ...... 75 5.6 Discussion on algorithms performance ...... 76 5.7 Conclusion ...... 78 6 Designing High-Fidelity Single-Shot Three-Qubit Gates ...... 79 6.1 Introduction ...... 79 6.2 Physical model ...... 82 6.2.1 ProjectedHamiltonian ...... 83 6.2.2 Unitaryevolution ...... 83 6.2.3 Phase compensation ...... 84 6.3 Three-Qubit gate design: An avoided-crossing level approach . . . . . 84 6.4 Quantum control ...... 86 6.4.1 Three-Qubit gate design: A quantum control approach . . . . 86 6.4.2 Supervised machine learning: A quantum control tool . . . . . 87 6.4.3 Controlpulsesaslearningparameters ...... 87 6.4.4 Confidence or fitness functional ...... 87 6.4.5 Machine Learning and optimization algorithms ...... 88 6.4.6 Subspace-Selective Self-Adaptive Di↵erential Evolution . . . . 89

x 6.5 Noisemodel...... 92 6.5.1 Amplitudedamping...... 92 6.5.2 Phase damping ...... 93 6.6 Three-Qubit logical gates ...... 93 6.6.1 To↵oli...... 94 6.6.2 Fredkin ...... 95 6.6.3 CNOTNOT ...... 96 6.7 Results ...... 97 6.7.1 To↵oli...... 99 6.7.2 Fredkin ...... 102 6.7.3 Controlled-NOT-NOT (CNOTNOT) ...... 105 6.8 Discussion ...... 109 6.8.1 Controlpulses...... 109 6.8.2 Intrinsicfidelity...... 110 6.8.3 Noise...... 111 6.9 Conclusion ...... 114 7ConcludingRemarks...... 116 7.1 Summary ...... 116 7.2 Hardquantumcontrolproblems ...... 116 7.3 Threshold-fidelity To↵oli gate ...... 117 7.4 Threshold-fidelity Fredkin and CNOTNOT gates ...... 118 7.5 Future work ...... 119 ASubspace-selectiveSelf-adaptiveDi↵erential Evolution (SuSSADE) source code in C++ ...... 143

xi List of Tables

3.1 The truth table representation of CZ gate. T and C denote the control (first) and target (second) qubits, respectively. A CZ gate applies a Pauli-Z operator on the target qubit if the state of the control qubit is 1 and leaves the state unchanged otherwise ...... 35 | i 5.1 Median, best-case, worst-case, and }t for logarithmic intrinsic infidelity L for the qutrit phase gate with ⇥ =2.5⇡, K =10,andR =80 (R =40)forgreedy(evolutionary)algorithms...... 70 5.2 Median, best-case, worst-case, and }t for logarithmic-infidelity L for the CNOT gate with ⇥ =3.2, K =4,andR =80(R =40)forgreedy (evolutionary) algorithms...... 74

6.1 The truth table representation of CCZ gate. C1 and C2 denote the control qubits and T represents the target qubit. The columns under the Output and Input columns show the states of the three qubits before and after applying CCZ ...... 95 6.2 The truth table representation of Fredkin gate. C1 and C2 denote the control qubits and T represents the target qubit. The column under the Output and Input columns show the state of the three qubits before and after applying the Fredkin gate...... 96 6.3 The truth table representation of CZZ gate. C1 denotes the control qubit and T1 and T2 represent the target qubits. The columns under the Output and Input show the states of the three qubits before and after applying CZZ ...... 98

xii List of Figures and Illustrations

2.1 Bloch sphere representation of a qubit. Each point on the surface of the sphere denotes a pure state and a rotation of the Bloch sphere about any of the axes represents a single-qubit Pauli X, Y , Z operation. 15

4.1 A schematical view of a inductor-capacitor (LC) circuit with L and C denote the inductance and capacitance of inductor and capacitor, respectively...... 51 4.2 (a) A schematic view of a Josephson Junction (JJ) with two superconducting (S) electrodes separated by a thin insulator (I). (b) Circuit model of a JJ, and (c) equivalent circuit representation which consists of a non-linear element and a capacitive element...... 52 4.3 (a) Circuit representation of a Charge qubit. The dotted red line denotes the isolated charge island. The bias-voltage Vg is used to tune the qubit frequency. (b) The circuit representation of a transmon which is a descendants of Charge qubit. Transmon overcomes the problem of o↵set charge noise by shunting the JJ by an external capacitance. The higher external capacitance in transmon is shown by bigger capacitor plates (red plates) ...... 53 4.4 (a) The energy (E) spectrum of the system Hamiltonian of two capacitively-coupled transmons. The frequency of the ﬁrst transmon is ﬁxed at 6.5 GHz. The frequency of the second qubit, "2(t)varies from 7.5to6.5GHz...... 58

5.1 Logarithmic intrinsic infidelity L vs iteration number ı for the qutrit gate using the quasi-Newton method with ⇥ =10⇡ (red, solid lines), ⇥ =4⇡ (blue lines with ’+’ markers), and ⇥ =3⇡ (green lines with ’ ’ markers) such that K = 50 in all cases. [reproduced from ref. [1], Fig.⇥ 1a] 69 5.2 (a) Median-run performance (b) Best-run performance for the qutrit phase gate (⇥ =2.5⇡ and K =10).LogarithmicintrinsicinfidelityL vs iteration number ı for (⇤)GA,( )DE,()CommonPSO, (I)PSO1,()PSO2,( )PSO3,( ⇥) quasi-Newton, (V)simplex ⇤ ⌃ B and (O)KrotovwithR =80(R =40)forgreedy(evolutionary) algorithms. [reproduced from ref. [1], Figs. 2a and 2b]...... 70 5.3 Logarithmic intrinsic infidelity L vs iteration number ı for the CNOT gate using the quasi-Newton method with T =30andK =30((red, solid lines), T =10andK =10(bluelineswith’+’markers)and T =4andK =4(greenlineswith’ ’ markers) [reproduced from ref.[1],Fig.1b]...... ⇥ 73

xiii 5.4 (a) Median-run performance (b) Best-run performance for the CNOT (⇥ =3.2andK =4).LogarithmicintrinsicinﬁdelityL vs iteration number ı for ( ) GA, ( )DE,()CommonPSO,(I) PSO1, ⇤ ⇥ ( )PSO2,(⌃)PSO3,(B) quasi-Newton, (V)simplexand(O)Krotov with⇤ R =80(R =40)forgreedy(evolutionary)algorithms[reproduced fromref.[1],Figs.2cand2d]...... 74

6.1 The energy (E)spectrumofthreenearest-neighbor-coupledtransmons. The ﬁrst and third transmon frequencies are ﬁxed at 4.8and6.8 GHz respectively. The frequency of the second transmon varies from 4.5to 7.5GHz ...... 86 6.2 The quantum circuit representation of the To↵oli (CCNOT) gate (left), which is equivalent to the CCZ gate up to a local transformation of two Hadamard gates (right). The horizontal solid black lines are

circuit wires, .418pt• shows the control qubits and denotes the Pauli-X operator acts on the target qubit. The boxes with Z and H denotethePauli-ZandHadamardgates...... L ...... 94 6.3 The quantum circuit representation of Fredkin (Controlled-Swap)

gate. The horizontal solid back line is the circuit wire, .418pt• denotes the control qubit and the big cross sign shows the SWAP gate which acts on the target qubits (second and third qubits)...... 96 6.4 The quantum circuit representation of the Controlled-NOT-NOT (CNOTNOT) gate (left), which is equivalent to the CZZ gate up to local Hadamard gates (right). The horizontal solid black lines are

circuit wires, .418pt• represents the control qubit and denotes the Pauli-X operator acting on the target qubit. The boxes with Z and H denote the Pauli-Z and Hadamard operations, respectively.L ...... 98 6.5 Optimal pulses for designing To↵oli gate with the resultant fidelity better than 0.999 and the gate operation time of 26 ns. Transmon frequencies, "i, are varied from -2.5 to 2.5 GHz, which are within the experimental constraint of transmon implementation. The black dots denote the learning parameter for SuSSADE. A) The piecewise- constant pulses for each transmon frequency. B) The piecewise- error-function pulses for each transmon frequency [reproduced from ref.[2],Fig.1]...... 100 6.6 A) The dependence of intrinsic fidelity for the To↵oli gate on the evolution time ⌧ for various values of g. The discretized values show the actual numerical data with ⌃, , ,and⇤ corresponding to the values of g to be 20, 30, 40, 504 MHz, respectively. A cubic interpolation fits the curves to the data. B) The relation between the inverse of the gate operation time and coupling strength between transmons, where the dots denote the actual numerical results for various values of g 20, 30, 40, 50 . A linear-fit interpolates the data points.[reproducedfromref.[2],Fig.2].2 { } ...... 101

xiv 6.7 The fidelity versus the coherence time for the To↵oli gate. The dots denote the actual numerical data and the blue solid line shows a cubic- fit interpolation on the actual data. [reproduced from ref. [2], Fig. 3]. 101 6.8 Intrinsic fidelity of the To↵oli gate as a function of " for CCZ gate. The vertical red dotted-line denotesF the threshold, such that > 0.9999 on the left of the dotted line...... 102 6.9 OptimalF pulses for designing Fredkin gate with the resultant fidelity better than 0.999 and the gate operation time of 26 ns. System frequencies, "i, are varied from -2.5 to 2.5 GHz, which are within the experimental requirements of transmon implementation. The black dots denote the learning parameters for SuSSADE. A) The piecewise-constant pulse for each transmon frequency. B) The piecewise-error-function pulses for each transmon frequency...... 103 6.10 A) The dependence of intrinsic fidelity of the Fredkin gate on the evolution time ⌧ of the system for various values of g. The discretized values show the actual numerical data with , ⇤, , ⌃ corresponding to the values of g to be 20, 30, 40, 50 MHz,4 respectively. A cubic interpolation fits the curves to the data. B) The relation between the inverse of the gate operation time and coupling strength between transmons where the dots denote the actual numerical results for various values of g 20, 30, 40, 50 . A linear fit interpolates the pointstotheactualdata.2 { . . . . .} ...... 104 6.11 The fidelity versus the coherence time for the Fredkin gate. The dots denote the actual numerical data and the red solid line shows a cubic-fit interpolation on the actual data...... 105 6.12 Intrinsic fidelity versus the random noise applied on the optimal pulse of the FredkinF gate. The vertical red dotted-line denotes the threshold, such that on the left side of the line > 0.9999...... 106 6.13 Optimal pulses for designing CZZ gate with the resultantF fidelity better than 0.999 and the gate operation time of 31 ns. System frequencies, "i, vary from -2.5 to 2.5 GHz which are within the experimental constraints of transmon implementation. The black dots denote the learning parameter for SuSSADE. A) The piecewise-constant pulses for each transmon frequency. B) The piecewise-error-function pulses foreachtransmonfrequency...... 107 6.14 A) The dependence of the intrinsic fidelity of the CZZ gate on the evolution time ⌧ of the system for various values of g. The discretized values show the actual numerical data with ⌃, , ,and⇤ corresponding to the values of g to be 20, 30, 40, 50 MHz, respectively.4 A cubic interpolation fits the curves to the data. B) The relation between the inverse of the gate operation time and coupling strength between transmons where the dots denote the actual numerical results for various values of g 20, 30, 40, 50 . A linear-fit interpolates the pointstotheactualdata.2 { ...... } ...... 108

xv 6.15 The fidelity versus the coherence time for the CZZ gate. The dots denote the actual numerical data and the red solid line shows a cubic-fit interpolation on the actual data...... 108 6.16 Intrinsic fidelity versus " for CZZ gate. The vertical red dotted-line denotes the threshold,F such that on the left side of this line > 0.9999.109 6.17 A schematic view of the Closed-Loop Learning Control (ClLC)F technique which uses SuSSADE as a quantum control scheme. Based on this control procedure, the optimal pulses which are generated using SuSSADE fed into a noisy quantum system. if the output met the target fidelity, the procedure aborts otherwise a new set of control pulses is chosen using SuSSADE, and the iteration continues until the target is met...... 114

xvi List of Symbols, Abbreviations and Nomenclature

Symbol Deﬁnition U Unitary operator

CNOT Controlled-NOT gate

CNOTNOT Controlled-NOT-NOT gate

K Number of control (learning) parameters

⇥ Gate operation time

GA Genetic Algorithm

PSO Particle Swarm Optimization

DE Di↵erential Evolution SuSSADE Subspace-selectiveSelf-adaptiveDi↵erential Evolution

CZ Controlled-Z gate

ClLC Closed-loop Learning Control

CCNOT Controlled-Controlled-NOT H Hadamard gate

CZZ Controlled-Z-Z gate

CCZ Controlled-Controlled-Z gate

T1 Relaxation time

T2 Dephasing time ⌧ Time evolution of a quantum system

"(t) Amplitudeoftime-dependentcontrolﬁeld

Hˆ dr Drift hamiltonian

Hˆ c Control hamiltonian t Timestep

Utarget Target unitary operator

xvii U[⇥, "(⌧)] Approximatedunitaryoperator

"i Control (learning) parameters Intrinsic ﬁdelity F ¯ Average state ﬁdelity F JJ Josephson Junction

L Logarithmic intrinsic inﬁdelity

CC Cooperative Coevolution

OCT Optimal Control Theory

CPB Cooper Pair Box

DRAG DerivativeRemovalbyAdiabaticGate

xviii Chapter 1

Introduction

“When we get to the very, very small world – say circuits of seven atoms

– we have a lot of new things that would happen that represent completely

new opportunities for design. Atoms on a small scale behave like nothing

on a large scale, for they satisfy the laws of quantum mechanics. So,

as we go down and ﬁddle around with the atoms down there, we are

working with di↵erent laws, and we can expect to do di↵erent things.

We can manufacture in di↵erent ways. We can use, not just circuits,

but some system involving the quantized energy levels, or the interactions

of quantized spins, etc.”

— Richard P. Feynman, 1960 [4]

1.1 Motivation

Quantum computing [5] enables ecient algorithms for problems that are intractable on non-quantum computers. The power of quantum computing [6] arises by representing and processing information in superpositioned states. Two of the most important quantum algorithms are the Shor factorization [7, 8] and the Grover search [9] algorithms with the former yielding an exponential and the latter yielding a quadratic speed-up over their classical counterparts. The extraordinary eciency of quantum algorithms motivates the e↵ort of building a universal quantum computer to leverage the parallelism power of the quantum algorithms.

One way to perform quantum computing is the circuit-based approach, which is proposed by David Deutsch [10]. A circuit-based quantum computer employs quantum logic gates [11] to process quantum information. Quantum logic gates are the

1 building block of a circuit-based quantum computer. They act on qubits (quantum bits) to process quantum information [12]. Designing fast and high ﬁdelity quantum gates is the key element to enable scalable quantum computing and quantum error correction. Fast quantum logic gates are also required to design fast quantum processor units [13, 14].

A quantum computing algorithm can be represented by a unitary matrix U of size 2n with n being the number of qubits (quantum bits). Designing a procedure for calculating the output by applying U on the input state involves decomposition into a concatenation [15] of a universal set of quantum gates [16]. The universal class of quantum gates eases the practical implementation of quantum algorithms. Pauli single-qubit gates and Controlled-NOT two-qubit gate comprise one class of universal quantum gates. Experimental progress towards a high-ﬁdelity universal set of gates comprising single- and two-qubit operations has been impressive, exceeding 99.9% for single-qubit [17] and 99% for an entangling two-qubit gates [11].

Quantum information is very fragile against external noise [18]. One way to protect the quantum information against gate imperfection or external noise is to employ quantum error corrections [19]. One can then perform quantum information processing in a code-space and use the quantum error correcting codes to diagnose and remove the errors, thereby avoiding the loss of information. Although error correcting codes can be decomposed into a sequence of single- and two-qubit gates [20], this decomposition approach is not preferable in practice because it leads to quantum circuits [21, 22] with long operation time. Designing quantum gates that act on more than two qubits leads to faster quantum processor units.

2 1.2 Research problem

There are two desirable criteria for any quantum gate design proposal. First, a proposed scheme has to enable the design of quantum gates with the shortest possible operation time. Second, it has to be experimentally implementable with less experimental resources. The former criterion enables processing of quantum information within timescales smaller than the decoherence time of qubits, thereby maintaining the quantum information. The latter eases the experimental realization of quantum gates with high-ﬁdelity. In the ﬁrst part of my PhD thesis, I show that, having two constraints of time and experimental resource on the schemes for designing quantum gates, will turn the gate design problems into hard problems. I propose algorithms to overcome this diculty and to enable fast quantum gates that can be implemented with less experimental resources.

Thus far most experimental e↵orts to build a circuit-based quantum computer have been limited to designing high-ﬁdelity single- and two-qubit gates and to performing the quantum information processing. However, fault-tolerant quantum computing requires encoding the quantum information into logical qubits and performing quantum computing in a code-space [19]. Quantum error correcting codes [23, 24] then must be employed to diagnose and remove the errors. Three-qubit gates are the building blocks of many quantum error correction codes [23, 24, 25, 26]. Designing fast high-ﬁdelity three-qubit gates enables the implementation of fast quantum error correcting circuits, thereby leading to fast quantum processor units.

Although a universal set of single- and two-qubit gates can be employed to decompose three-qubit gates into a series of single and two-qubit gates [27, 28], in practice, this decomposition-based approach is undesirable because it leads to quantum circuits with long operation time [21, 22] . In the second part of my thesis, I devise algorithms to design single-shot high-ﬁdelity three-qubit gates without resorting to

3 inecient decomposition approaches.

1.3 Research objective

In this thesis two objectives are pursued. First, we show that hard quantum gate design problems exist. In particular, we bring two examples of gate design problems including: CNOT [28] and qutrit phase gates [29], which are key elements of standard quantum computing instructions sets for qubits and for qutrits, respectively. It is well- known that, given no constraints on the quantum evolution process, either there is always an evolution path toward a target gate or there will be no path to the target gate [30]. Here our aim is to show that having time and experimental resources as the constraints on the evolution of the quantum system, there will be no guarantee of success for standard schemes to ﬁnd a successful evolution path. Hence, one should explore alternative approaches or devise novel schemes to designing fast quantum gates upon the failure of existing methods.

The second objective is to devise quantum gate schemes for designing three-qubit gates. The three-qubit gates that we consider here are the To↵oli, Fredkin and CNOT-

NOT, which are the typical three-qubit gates up to a local transformation. Here our aim is to ﬁrst show that the existing methods fail to design high-ﬁdelity three-qubit gates in the hand, then we propose a new technique to enable the design of fast three-qubit gates.

1.4 Physical models

Our goal to generate policies for designing CNOT and qutrit phase gates is to show the existence of hard quantum gate design problems. Thereby any physical system can be chosen to implement these gates. For the qutrit phase gate one can choose a spin-1 system or single atom with three pertinent electronic levels. For the CNOT

4 gate we have chosen the one-dimensional linear Ising-ZZ model [31]. Physically, the

Ising-ZZ model corresponds to a one-dimensional spin chain, which was originally studied in the context of explaining ferromagnetism.

We limit the design of high-fidelity single-shot three-qubit gates to a specific physical system, namely superconducting artificial atoms. Recent progress in superconducting artificial atoms [32, 33, 34] has made them appealing for quantum information processing, especially for gate-based quantum computing [35]. In particular our superconducting artificial atoms are working in the regime of a transmon [36], which is adescendantofachargequbit[37,38].Inordertodesignthree-qubitgates,weonly consider the first four energy levels of the transmons.

1.5 Approach

One approach to designing fast quantum gates is to formulate the task as a control problem and devise policies that successfully achieve the desired outcome. In the context of quantum gate design, the quantum control [39] task is to steer the quantum dynamics towards closely realizing speciﬁc unitary operations. Control is achieved by varying the external control parameters such that the resultant evolution closely approximates the desired evolution. A set of instructions that determine the control parameters, and hence, the e↵ectiveness of the control scheme, is called a policy. We use machine learning [40] techniques to generate policies for designing three-qubit gates.

The task of machine learning is to develop algorithms that can learn from system behaviour and predict the future behaviour of the system based on their past evolution. Machine learning algorithms have already been applied to various problems in quantum information science, such as phase estimation [41], asymptotic state estimation [42], discriminating quantum measurement trajectories and improving read-

5 out [43], and quantum gate design [44]. One can classify the machine learning algorithms in three distinct categories [40] namely; supervised learnings, unsupervised learnings and reinforcement learnings. Here we focus on supervised machine learning algorithms [45] as quantum control tools.

The supervised learning task is to infer a function (hypothesis) from the labelled data (training set). The training data comprises an input vector along with its corresponding output vector. The supervised learning algorithm trains the hypothesis on the training data to construct an inferred hypothesis. This inferred hypothesis can be further used to label novel data. The idea of supervised learning can be generalized to develop quantum control schemes that deliver successful policies for quantum gate design. In, particular, the learning problem for designing quantum logic gates are regression problems for those we don’t require to check the learnt hypothesis for novel data. We only construct the hypothesis to provide the maximum possible conﬁdence for our learning procedure.

A quantum logic gate is a map between an input and an output state. One can always represent the action of any quantum logical gate on the basis elements in terms of a truth table. There is a one-to-one correspondence between the input and output elements in this truth table, as the quantum logic gates are themselves reversible.

In the context of supervised learning problem, we consider this truth table as the training set and consider qubits frequencies to be the hypothesis. Loosely speaking, we train our hypothesis on the truth table data as the training set to generate a successful policy that determines the shape of the external pulses.

Although our machine learning technique can generate any type of external pulses, here we only consider two type of pulses including the piecewise-constant [1] and piecewise-error-function [46]. We chose the piecewise-constant function because it is computationally less-expensive as opposed to expensive realistic piecewise-error func-

6 tions. We use the piecewise-constant pulse when we analyze the e↵ectiveness of our quantum control schemes against the physical parameters of the system. We employ the piecewise-error function to provide a realistic implementation of the policy for designing three-qubit gates. We provide the numerical evidence that the performance of our quantum control schemes do not depend on the shape of the pulse but on the number of learning (control) parameters.

In the case of a piecewise-constant pulse, we discretize each control pulse (hypothesis) and express it as the sum of K orthogonal constant functions over the interval

[0,⇥]. In our machine learning approach, K denotes the number of learning parameters or experimental resources to shape the external pulse. We construct a smooth pulse (piecewise-error-function) by connecting each of the control parameters using an error function. We measure the performance of our learning algorithm by taking the distance between the target and approximated operators. Minimizing this distance will increase the conﬁdence of our learning procedure.

According to the threshold theorem [19], if the accuracy in designing quantum gates exceeds the threshold for fault-tolerant quantum computing, quantum error correction codes can be used to perform arbitrarily long quantum computation. The bounded error on the accuracy of designed quantum gates implies that the generated policies for designing quantum gates do not need to lead to a perfect target gate.

The generated policy only need to approximate the target gate within some error which is acceptable by fault-tolerant quantum computing. This bounded error turns the problem of finding a successful policy for designing high-fidelity quantum gates into a feasibility problem. Any policy that results in approximated unitary operation within threshold fidelity will be a successful (feasible) policy. Therefore, I use the term feasible policy and successful policy interchangeably throughout this thesis. One can employ optimization algorithms to find feasible policies for designing fast quantum

7 gates.

To search for a successful policy, we have used several optimization routines including the greedy and nongreedy (stochastic) algorithms. For greedy algorithms we employ three well-known optimization techniques, namely Simplex [47], quasi-

Newton [48] and Krotov [49, 50, 31]. We choose these three algorithms because of their superior performance over other greedy algorithms in many quantum control problems [51, 52, 48, 31, 53]. There is a large class of non-greedy algorithms but we choose to test just the three most common or promising evolutionary algorithms, namely the traditional Genetic Algorithm (GA) [54] (a commonly used algorithm) and the modern particle swarm optimization (PSO) [55] and Di↵erential Evolution

(DE) [56] algorithms (promising for this type of problem). The promising nature of

PSO and DE is based on many studies that have shown the superiority of DE and

PSO over other evolutionary algorithms [57, 58, 59].

For all the gate design problems in this thesis we first try the greedy algorithms for finding a successful policy. Greedy algorithms are fast in converging on a feasible policy when performing a local search. Greedy algorithms are not guaranteed to succeed (i) when the search domain is non-convex or (ii) when the computational resources (model dimensionality) or the time for performing the control task is constrained [60, 61, 1]. Upon the failure of greedy algorithms on specific quantum control tasks we try the three most promising evolutionary algorithms. Generally, evolutionary algorithms fail when the number of learning parameters increases, or decoherence and loss are included. We have devised a new optimization routine that succeeds to generate a successful policy when existing optimization algorithms fail.

For realistic implementation of quantum gates, we follow the standard practice of gate design by ﬁrst ignoring the noise and generating a successful policy to designing gates for closed quantum systems. We then evaluate the performance of the generated

8 policies under the random noise on the learning parameters. We also evaluate the performance of successful policies in the presence of decoherence-induced noise. In order to incorporate decoherence into our systems evolution, we model each qubit in the physical model as a harmonic oscillator su↵ering from an environmental e↵ect.

1.6 Summary of the research achievements

We have succeeded to generate successful policies to design CNOT and qutrit phase gates [1]. For these two problems, we have shown that if one evolves the quantum system over a long time with a large number of control parameters, the greedy machine learning algorithms can always find a successful policy to design threshold-fidelity gates. Reducing the control parameters and shortening the operation time turn the problem of designing CNOT and qutrit phase gates into hard quantum control problems. Under the constraints of operation time and experimental resources (i. e. control parameters), greedy machine learning techniques fail to generate a successful policy for designing high-fidelity quantum gates. We then used the non-greedy machine learning techniques as quantum control tools to search for an feasible policies. We have shown the superiority of evolutionary machine learning algorithms, in particular, the DE-based machine learning, in finding the successful policies even in the presence of constraints on operation time and experimental resources.

We have proposed a new machine learning algorithm, which is suited for high- dimensional learning problems [2]. Our machine learning algorithm is based on a variant of DE, which is called Subspace-Selective Self-Adaptive DE (SuSSADE). SuS-

SADE has been developed as a modular optimization engine, which takes the objective function and constraints on the learning parameters as input and searches for an optimal solution for the problem. SuSSADE is capable of solving non-convex optimization problems, because it globally searches for the optimal solution. We have developed

9 our machine learning algorithm such that it runs on single or multiple processors.

We have employed SuSSADE to generate policies for designing high-fidelity single- shot three-qubit gates for a linear chain of three capacitively coupled transmons. The three-qubit gates that we designed are To↵oli, Fredkin and CNOTNOT. Each of the three-qubit gate operates as fast as an entangling two-qubit CZ gate under the same experimental constraints. Here in order to design the high-fidelity three-qubit gates, we first test the standard machine learning algorithms. We have observed that existing machine learning techniques failed to achieve any fidelity better than

99%. We then proposed our evolutionary machine learning algorithm to overcome this challenge. The generated policies from SuSSADE led to the three-qubit gates with ﬁdelity better than 99.9%.

We have tested the generated policies for designing three-qubit gates in the presence of noise. Our analyses show that our policies are resilient against the random noise on the learning parameters within the experimentally prescribed random noise on the external pulse [62]. We have also tested our policies against decoherence- induced noise. The resultant ﬁdelity remains above the threshold even in the presence of decoherence-induced noise. Our policies to design threshold-ﬁdelity gates account for the leading order of noise that causes distortion on the learning parameters. We have proposed a Closed-loop Learning Control (ClLC) to suppress the higher order noise on the quantum system.

1.7 Overview of chapters

This chapter brieﬂy explained the objectives pursued in the course of my PhD studies. I have summarized the problem statement, the approach that I took to tackle the problems and the achievements of solving each problems. This thesis includes seven chapters. The interdisciplinary nature of my PhD research requires the knowledge in

10 four ﬁelds including quantum information, quantum control, superconducting artiﬁ- cial atoms, and machine learning. Therefore, the next three chapters establish some familiarities with these topics.

In order to establish the framework for quantum gate design, Chapter 2 gives an introductory on quantum information. I introduce qubits which are the basic unit of information in quantum computing. I discuss the action of quantum gates on qubits basis and explain the importance of designing fast quantum logic gates. I explain the importance of quantum error correction for fault-tolerant quantum computing. I conclude the chapter by giving the mathematical model for noise, which we used to incorporate decoherence into our quantum systems.

Chapter 3 includes the mathematical foundation of quantum control. In this chapter I explain how to formulate a gate design problem into a quantum control problem. Then I formulate a quantum control problem into a supervised machine learning problem. Improving the performance of a learning procedure is equivalent to

ﬁnding a feasible solution for a feasibility problem. Hence, I discuss the possible choice of optimization algorithms that can be employed to tackle the feasibility problem.

In Chapter 4, I introduce the superconducting artiﬁcial atoms, which are the physical system for designing three-qubit gates. I start with the earliest proposed superconducting qubit, the charge qubit, and then discuss the transmon, which is the improved version of charge qubit. I review the existing proposals for designing high-

ﬁdelity single- and two-qubit gates for the architecture of superconducting artiﬁcial atoms.

In Chapter 5, I present the results of our early work [1] on designing two important quantum control gates including CNOT and qutrit phase gates. I show that hard quantum control problems exist upon the existence of constraints on the quantum system. I show the performance of several machine learning techniques for generating

11 these two quantum gates.

Chapter 6 presents our results on generating successful policies for designing high-

ﬁdelity single-shot three-qubit gates including: To↵oli, Fredkin and CNOTNOT [2,

3]. We show the success of our machine learning technique in designing three-qubit gates, which are as fast as an entangling two-qubit gate under the same experimental constraints. We discuss the performance of our policies in the presence of di↵erent types of noise in Chapter 6.

In Chapter 7, I summarized the works that I have accomplished in this thesis. I suggest some of the further works that can branch out from this thesis.

12 Chapter 2

Quantum Information Processing: A Prelude

“The entire universe must, on a very accurate level, be regarded as a

single indivisible unit in which separate parts appear as idealisations

permissible only on a classical level of accuracy of description. This

means that the view of the world being analogous to a huge machine,

the predominant view from the sixteenth to nineteenth centuries, is now

shown to be only approximately correct. The underlying structure of

matter, however, is not mechanical. This means that the term ‘quan-

tum mechanics’ is very much a misnomer. It should, perhaps, be called

quantum “nonmechanics”.”

— David Bohm, 1951 [63]

2.1 Quantum information theory

The theory of quantum computing has been established initially by a number of pi- oneers in the field. Richard Feynman [64] was the first who proposed his concept of a Quantum Computer. A machine which can eciently simulates a quantum system as opposed to a classical Turing machine [65] which faces an exponential slow down. David Albert contributed to the field by showing how a quantum mechanical automaton remarkably outperforms a classical automaton [66]. However David

Deutsch [67, 10] was the one who made the key discovery by proving that “There exists or can be built a universal quantum computer that can be programmed to perform any computational task that can be performed by any physical object.”

The quantum computer proposed by David Deutsch [10] is a circuit-based quantum computer which is one of the approaches to performing the quantum comput-

13 ing. A circuit-based quantum computer employs quantum logic gates to process the quantum information. Quantum logic gates are the building blocks of a quantum computer. Designing fast quantum gates is the key factor to designing fast quantum processor units. The primary goal of my thesis is to devise quantum control schemes to design fast quantum logic gates. A prelude of quantum information comes in the following sections to establish some familiarity with the subject.

2.2 Classical and quantum bits

Data are the distinct pieces of information. In classical information theory, a bit is the smallest distinguishable unit of data. In practice, a classical bit is not a mathematical abstract of information but any binary physical device that can exist in two well- deﬁned, coherent, and mutually exclusive states – either 0 or 1. The state of the physical systems can be found by performing measurement on the device, without a↵ecting the current state of the system (Or the system can be fully initialized to its initial state upon a measurement on the system).

In the quantum information theory, a quantum bit which is usually refereed to as a qubit is the smallest distinguished unit of data. Just as a classical bit, a qubit has two states – 0 and 1 . In quantum mechanics ‘ ’ is called the Dirac notation that | i | i | i is the standard notation to represent the state of the quantum system. Qubits have privilege over the classical bits because they do not need to be in mutually exclusive states. In other words, it is possible to have a linear combinations of states, called superposition:

= ↵ 0 + 1 (2.1) | i | i | i with ↵ and being complex numbers. It is clear from 2.1 that the qubit is a vector in a two-dimensional complex vector space with states 0 and 1 known as computational | i | i basis states.

14 ˆz 0 | i

| i

✓

yˆ

xˆ

1 | i

Figure 2.1: Bloch sphere representation of a qubit. Each point on the surface of the sphere denotes a pure state and a rotation of the Bloch sphere about any of the axes represents a single-qubit Pauli X, Y , Z operation.

Unlike a classical bit that can be examined through a measurement with certainty, we cannot perform measurement on a qubit such that the output of the measurement gives us both ↵ and . This is because a measurement projects the qubit state into one of its basis with certain probabilities. Upon a measurement on a qubit we get either 0 with probability ↵ 2 or 1 with probability 2 with the sum of these | i | | | i | | probabilities equal to one.

Similar to a classical bit, a qubit is not a mathematical abstract but a quantum- mechanical system (physical device) that can exist in two well-deﬁned states. Many physical systems can be employed to realize qubits. For example, the vertical and horizontal polarization of a photon can represent a qubit [68]. Nuclear spin in a magnetic ﬁeld is another physical system that can be used to realize a qubit [69].

The quantum state of a two-level system (qubit) can mathematically be best represented by a Bloch sphere (Fig. 2.1) which is a unit 2-sphere. It is convenient to consider the north and south poles of the sphere to correspond to unit vectors 0 | i

15 and 1 , respectively. Then one can write the qubit state as: | i ✓ ✓ =cos 0 + eisin 1 (2.2) | i 2 | i 2 | i with 0 ✓ ⇡ and 0 2⇡ and    

1 0 0 = 2 3 , 1 = 2 3 (2.3) | i 0 | i 1 6 7 6 7 4 5 4 5 are two dimensional real vectors.

Qubits are very fragile against external noise. Usually in quantum computing, the time that a qubit maintains its initial information without being a↵ected by the environment is called the coherence time of that qubit. The coherence time for a qubit depends on the physical system implementation of that qubit. For example, superconducting qubits, in particular transmons, loose their information over a timescale of

60µs (See 4.1.3 for more detail). Decoherence places the time constraint on quantum computing devices to perform computational tasks in timescales much shorter than the coherence time of a qubit. Therefore, e↵orts are divided into two main domains to avoid information loss resulting from decoherence, a) Designing qubits with long decoherence times and b) designing fast quantum logic gates which operate in faster time than the qubit coherence time. The latter is the topic of the current thesis.

2.3 Classical logic gates

George Boole was a British mathematician who started to explore the concept of logic gates in his e↵orts to formalize the laws of thought [70]. His main interest was to establish the concept of reasoning in mathematics. He introduced the Boolean algebra in his book of ‘The Mathematical Analysis of Logic’ [71]. Boolean algebra is to perform algebra not in a quantitative method but in terms of variables that take only discrete binary values like ‘0’ or ‘1’.

16 The primary application of Boole’s algebra is in fabricating classical electronic devices called logic gates, which can perform Boolean logic on classical bits. A logic gate is a physical device, like a transistor, which takes one or more inputs as 0s and

1s and output the result as a single or more logical variables. The AND and OR are two examples of logical gates.

The AND, and OR gates are examples of irreversible logic gates. The term irreversible stands for those logical gates whose inputs cannot be retrieved from their corresponding output. This loss of information is one of the sources of heat generation in the current classical computers. On the other side there is a set of reversible classical gates that for those the initial information processed can be retrieved via the output of the reversible logic gates. The NOR gate and the To↵oli gate are examples of reversible logical gates [72].

In order to make the engineering design of a computational unit simpler, there exists a speciﬁc set of logic gates, “universal gates” for which the logic circuit of any computational task can be decomposed into a series of universal logic gates. The

NAND gate or (AND, OR, NOT) gates are examples of classical universal logic gates which means any classical logical function can be computed with a series of these gates.

2.4 Quantum logic gates

Given an introduction of what a logic gate does in a classical computer now we can have a better grasp of what a quantum logic gate does in a quantum computer! A quantum logic gate acts on qubits to process quantum information. They take the state of one or more qubits as input and return the output as the state of one or more qubits. For example, if the qubit information is encoded in an atomic or nuclear spin, the external magnetic ﬁeld is being used to manipulate the qubit information.

17 Another example would be the energy levels of a atom which can serve as a qubit system. One can manipulate the encoded information via emitting external pulses on the atomic system. Therefore, similarly to a classical logic gate, a quantum logic gate is a physical implementation of a quantum system which evolves based on quantum mechanical laws.

Since the quantum logical gate itself is a quantum system, we can provide a mathematical representation of its evolution based on the laws of quantum mechanics.

Schrödinger’s equation is the principal equation that governs the transformation of a quantum system from some initial to a final state. Converting the external | ii | if forces acting on the quantum system into energy quantities we can represent the total energy of a quantum system by Hˆ , the Hamiltonian of the system. Hence, we can write the time-dependen, Schrödinger equation as follow:

@ i~ | i = Hˆ (2.4) @t | i with ~ denoting the reduced Planck’s constant. Although there are many quantum gates in the context of quantum information processing, here I mostly focus on those gates that enable universal quantum computing and play a signiﬁcant role in quantum error correction. I discuss the physical action of each gate and show their mathematical representation in the qubit basis.

2.4.1 Single-qubit gates: Pauli matrices and the Hadamard

Single-qubit gates are those logical gates that act on one qubit. A special set of single- qubit gates is the set of Pauli matrices (1, X, Y , Z), which are unitary and Hermitian operators. Pauli matrices are special because any single-qubit Hamiltonian can be written as the weighted sum of these matrices. Pauli matrices can be represented in

18 the basis of a single qubit ( 0 , 1 )asfollows[19]: | i | i

10 01 0 i 10 1 = 0 1 ,X= 0 1 ,Y= 0 1 ,Z= 0 1 . (2.5) 01 10 i 0 0 1 B C B C B C B C @ A @ A @ A @ A The Hadamard gate is another single-qubit gate. It maps 0 1 ( 0 + 1 )and | i! p2 | i | i 1 1 ( 0 1 ). There is no classical counterpart for the Hadamard gate, because | i! p2 | i| i it generates a quantum state, which is a superposition of 0 and 1 upon its operation | i | i on these states. Based on the action of the Hadamard gate on a qubit basis one can write its mathematical representation as follows:

1 11 H= . (2.6) 2 0 1 1 1 B C @ A Here I only discussed those single-qubit gates that I will use in the following chapters.

An interested reader should refer to [19] for further discussion on other single-qubit gates.

2.4.2 Controlled-NOT (CNOT) gate

Controlled-NOT (CNOT) is an entangling two-qubit gate which operates on two qubits. A CNOT gate applies the Pauli-X operator on the second (target) qubit if the ﬁrst (control) qubit is at state 1 , otherwise leaves the state of the target | i qubit unchanged. A CNOT gate is equivalent to a Controlled-Z (CZ) gate under a

Hadamard transformation on the target qubit. A CZ gate applies a Paul-Z operator on the target qubit, if and only if the state of the control qubit is 1 . The mathemat- | i ical representation of CNOT and CZ gates in the computational basis of two qubits

19 ( 00 , 01 , 10 , 11 )canbewrittenasfollow: | i | i | i | i

1000 100 0 0 1 0 1 0100 010 0 CNOT = B C , CZ = B C . (2.7) B C B C B0001C B001 0C B C B C B C B C B0010C B000 1C B C B C @ A @ A 2.4.3 Three-qubit gates: To↵oli and Fredkin

AquantumTo↵oli gate is an essential element for (non-topological) quantum error correction [6, 7] and the key component for reversible quantum computing [2, 15].

The quantum To↵oli gate is to e↵ect a three-qubit controlled-controlled-NOT (CC-

NOT) gate, which means that the third (target) qubit is flipped only if the first two (control) qubits are in the 1 state and not flipped otherwise. Constructing the | i mathematical representation of the To↵oli is simple given the action of the gate on three qubits. One can write this mathematical representation in the computational basis ( 000 , 001 , 010 , 011 , 100 , 101 , 110 , 111 )ofthreequbitsasfollow: | i | i | i | i | i | i | i | i

10000000 0 1 01000000 B C B C B00100000C B C B C B00010000C B C CCNOT = B C (2.8) B C B00001000C B C B C B00000100C B C B C B C B00000001C B C B C B00000010C B C Similar to the equivalence relation@ between two-qubit CNOTA and CZ gates, the

CCNOT and CCZ operations are equivalent under the local transformation on the

20 target qubit:

CCNOT = [1 1 H] CCZ [1 1 H] (2.9) ⌦ ⌦ ⌦ ⌦ where H is the single-qubit Hadamard gate. A CCZ gate applies a Pauli-Z operator on a target qubit, if and only if the state of the control qubits is 11 and leaves the | i target state unaltered otherwise.

The Fredkin gate is another important three-qubit gate which enables reversible quantum computing [19]. The Fredkin gate is also called a controlled-swap operator, because it applies a swap gate on the quantum state of the second and third qubits if the state of the ﬁrst qubit is 1 , and leaves the quantum state unchanged otherwise. | i The Fredkin gate is an excitation-number-preserving operator which means the output state has the same number of excited states as the input state. It is also a self- inverse operation which means applying two consecutive Fredkin operations gives the same output as the input. The Fredkin gate can be conﬁgured to function as other single logical quantum qubits [73]. The logical action of the Fredkin gate can also be represented as a matrix in the computational basis of three qubits as follow:

10000000 0 1 01000000 B C B C B00100000C B C B C B00010000C B C Fredkin = B C (2.10) B C B00001000C B C B C B00000010C B C B C B C B00000100C B C B C B00000001C B C @ A

21 2.5 Universal quantum gates

As I explained earlier in 2.3, there is a small set of classical gates (AND, OR, NOT) that are universal for classical computation. A similar universality is true for quantum computation. A set of gates is universal for quantum computation if any unitary operation can be decomposed into a series of only those gates. In quantum computing there are a few sets of universal gates, with the three following are the most important ones [19]:

1. Controlled-phase (CZ), and single-qubit Pauli X, Y and Z spin–half

matrices.

2. To↵oli and Hadamard gates.

3. Fredkin and Hadamard gates.

In principle one set of universal gates such as single-qubit and CZ gates is sucient for quantum computing. However an outstanding problem is that many quantum algorithms [21, 22, 7] require a gate acting on at least three qubits. Although three- qubit gates can be constructed by a decomposition into a series of single- and two- qubit gates [27, 28], in practice, this approach is not desirable since it leads to quantum circuits with long operation times [21, 22]. Designing high-ﬁdelity single-shot three- qubit gates is one of the goals of this thesis.

2.6 Quantum error correction

Noise is a great challenge for quantum information processing. Ideally we want to build the quantum system such that noise can be avoided completely. In practice, this ideal situation fails to exist and one should devise methods to protect the system against the e↵ects of noise.

22 The basic idea of protecting information against noise is to encode the information by adding some redundant information to the initial information. Under the condition that some of the encoded information being corrupted by the noise, there exists enough redundancy in the encoded information that the initial information can be retrieved successfully. Protecting quantum information against noise is based on the same ideology.

The basic idea of quantum error correction is inspired by the ideas introduced by Shor [24]. In general, the procedure of error correction includes three distinct steps [19, 24]. First, one encodes the quantum information (initial information) into a quantum error-correcting code. This step is usually done by using the unitary operation deﬁned by the error correcting algorithm. The encoded information resides in a larger Hilbert space than the Hilbert space for the initial information to ensure enough redundancy for restoring the initial information. The space in which encoded information resides is called code-space and the eigenstates of the code-space are called logical states. Quantum information processing is being performed in the code-space on the logical states. In the second step, after logical states are subjected to noise, one should perform the syndrome measurement to diagnose the type of the error on logical states. In the last step we perform a recovery operation to retrieve the initial information and transform the quantum system into its original state of the code.

Two examples of well-known quantum error correcting codes are Calderbank–

Shor–Steane algorithm [19] and Laflamme et al. error-correcting code [23]. The former encodes each physical qubit (initial information) into a block of seven qubits, which are called logical qubits. The latter encodes each physical qubit into a block of five logical qubits. Both algorithms account for an arbitrary error on a single qubit, with the Laflamme et al. error-correcting code proposing the minimum number of logical qubits for performing error correction.

23 2.7 Fault-tolerant quantum computing and threshold theorem

Of course my discussion on quantum error correction codes in previous section is based on this assumption that encoding the quantum information into the code-space and decoding the information out of it can be done perfectly. In practice this simpliﬁed assumption can not be made, because quantum gates, which are the building blocks of quantum error correcting circuits can not be designed perfectly. However the theory of fault-tolerant quantum computing [24] comes to the rescue by removing the assumption of having perfect encoding and decoding for having fault-tolerant quantum computation.

As the quantum information dynamically undergoes computation in the code- space, quantum error correcting codes have to be recursively applied to protect the quantum information against decoherence. Given the fact that quantum logic gate are the building block of quantum algorithms and perfect design of quantum gate is challenging, the main question is how the quantum computation can be performed correctly (without the error accumulated over the computation) when the quantum error-correcting codes themselves are faulty? Remarkably there is a celebrated theory called “threshold theorem” which says provided only that the error probability per gate is below a certain constant threshold, quantum error correction can be employed to perform any arbitrarily long quantum computation [19].

2.8 Quantum noise

Closed quantum systems, are those quantum systems that do not su↵er from unwanted interactions with environment. Although studying closed quantum systems deepen our understanding of such ideal systems, in practice, a quantum system cannot be isolated from interaction with outside world. In fact, there is no closed quantum system except the universe itself. The unwanted interactions of the quantum system

24 with environment appears as noise in quantum information processing systems. In order to build practical and useful quantum processor unit, one needs to understand noise on the quantum system. There are several types of noise which can a↵ect the quantum system. Here we discuss the decoherence-induced noise and the existing approaches that can model this type of noise.

2.8.1 Decoherence-induced noise

The decoherence-induced noise comes from the fragility of quantum information against the interaction with the environment. In general if a qubit is initialized in a superposition of its eigenstates ( 0 , 1 ), there is no guarantee that it stays in | i | i this superposition forever because of external noise acting on the qubit system. This fragility of information to external noise is also present in classical information processing. This is the reason that several layers of classical error correction codes are applied on classical computing and storage devices like CDs, Hard Drive and RAMs to protect the loss of information against the external noise. Quantum information processing devices can also exploit error correcting codes to protect their information; however, a deep knowledge of various types of noise is essential for designing e↵ective quantum error correction schemes. Here I discuss the decoherence-induced noise and its e↵ect on quantum information.

In the quantum information processing the decoherence-induced processes are labelled by their e↵ective timescales. The Bloch sphere representation (Fig. 2.1) of qubit is the best picture to explain the e↵ects of these processes. In the Bloch representation, T1 processes that move the state of the qubit toward the poles are called relaxation time, and T2 processes that rotate the Bloch vector around the vertical axis (axis connecting the ground and excited levels) are called dephasing.

In the following we review some backgrounds on the noise model that we use to incorporate decoherence-induced into our quantum system.

25 2.8.2 Quantum noise and quantum operation

The quantum operations [19] provides a solid mathematical formalism to describe the dynamics of open quantum system. In the context of quantum operations one

ﬁrst describes the initial state of the quantum system in terms of a density operator

(density matrix), ⇢ and follow the system evolution according to the following map:

⇢0 = (⇢)(2.11) E

The map, , is a quantum operation and (⇢)istheﬁnalstateaftertheprocess E E occurs (up to some normalization factor).

There exist three distinct methods of understanding the quantum operations, all of which are equivalent [19]. In the first method we study the dynamics that caused by the interaction of a system with an environment. While this method is a physically sound approach to understand the dynamics of the system under noise, it is not mathematically convenient. Operator-sum representation is the second method that can be employed to study the quantum operation. In contrast to the first method, the operator-sum representation is an abstract method, however, it provides a solid mathematical framework for theoretical study of an open quantum system. The last and third method is based on a set of physically motivated principles under which a dynamic map in quantum mechanic evolves. I will not discuss the third method, as it lacks the mathematical strength of the second method and the physical concreteness of the first method.

In order to incorporate the e↵ect of noise in our simulation of quantum system,

I employ the operation-sum representation method. However before providing the detail of this method, an understanding of how the system and environment interact with each other in a open quantum system is required. Then, in the following, I ﬁrst explain the mathematical representation of this interaction and discuss the operation- sum representation afterward.

26 2.8.3 Quantum operations and environment

One way of considering noise in an open quantum system is to follow the evolution of the system as it interacts with environment as another system. Since we consider the environment as another system, for the sake of clarity, I call our system of interest as the principal system, which with environment comprises a closed quantum system.

We represent the evolution of this closed-system by U. Let assume that the principal system and the environment are initially at a product state ⇢ ⇢ . Thereby, after ⌦ env the unitary transformation U acting on the system, the principal system will no longer interact with environment. Thus, one can perform a partial trace (Trenv)overthe environment to obtain the state of the principal system as follow:

(⇢)=Tr U(⇢ ⇢ U † (2.12) E env ⌦ env ⇥ ⇤ Equation 2.12 represents the quantum operation in terms of the interaction of the system with an environment, thereby giving the ﬁrst of three equivalent deﬁnitions of quantum operation. One issue with using (2.12) as a representation of the quantum operation is how to specify U when the environment has many degrees of freedom. It seems the operation-sum representation can address this concern in an e↵ective way.

2.8.4 Operator-sum representation

One can represent the quantum operations in terms of the operator-sum representation [2]. In order to present the quantum operation in terms of operator-sum, let e be an orthonormal basis for the environment with an inﬁnite number of modes. | ii We consider U as the unitary operation of the environment and the principal system, which together forms a closed quantum system. Assuming the initial state of the environment is ⇢ = e e (if not we are free to introduce an extra system purifying env | 0ih 0| the environment), one can decompose (2.12) in terms of the operators (which act Qi

27 on the state space of the principal system) as follow:

(⇢)= †⇢ (2.13) E Qi Qi i X where e U e . Equation 2.13 is called the operator-sum representation of Qi ⌘hi| | 0i and are known as operation elements for the quantum operation . The E {Qk} E operation elements satisfy the completeness relation as follow:

† i = 1 (2.14) Qi Q i X with 1 representing the identity matrix. Equation 2.14 is satisﬁed by the quantum operations which are trace-preserving.

It can be shown that the operation-sum approach for considering noise is equivalent to the ﬁrst method that I explained in Subsec. 2.8.3 (See [19] for more details).

Therefore, I employ the operation-sum approach to perform numerical simulation of noise in our quantum system. Performing this numerical calculation is straightforward once we know the mathematical representation of the operation elements. In chapter 6, I give the explicit mathematical formulas of operation elements when I discuss decoherence-induced noise on three-qubit gate quantum systems.

28 Chapter 3

Quantum Control: Background

“People worry that computers will get too smart and take over the world,

but the real problem is that they’re too stupid and they’ve already taken

over the world.”

— Pedro Domingos, 2015 [74]

In this chapter I first start with the application of Optimal Control Theory (OCT) in quantum control. Then I clarify the choice of our control field to control the quantum system. I also discuss the quantum control in the context of gate design problems. Then I introduce the supervised machine learning approach as a quantum control tool. I explain how a gate design problem can be turned into the learning problem for finding a successful policy. The problem of finding a successful policy is afeasibilityproblemforwhichoptimizationalgorithmsmustbeusedtotacklethe problem. I discuss several optimization algorithms that I used in the latter chapters to generate the successful policies for designing fast quantum logical gates.

3.1 Optimal control theory: Application in quantum systems

The task of OCT is to redirect the control process by maximizing an objective functional via some external control ﬁelds, which are usually expressed as functions in time or frequency-domains [75]. OCT has been successfully applied in controlling many quantum systems including the selective breaking of chemical bonds [76], the creation of ultrafast semiconductor optical switches [77], electron transfer in biological systems [78], and quantum information processing [79].

Depending on the type of control problem, there is a variety of objective functional

29 choices that can be deﬁned for controlling a quantum system. However, in most cases studied so far [30], the objective is to maximize the transition probability of the system

2 Pi f = Uif , (3.1) ! | | with

U = f U i . (3.2) if h | | i Here, U = U("(t)) is a time-dependent evolution operator, which is a functional of the control function "(t). In (3.1), complete controllability of the control system implies that Pi f =1andPi f < 1denotesthatthesystemisonlypartiallycontrollable. ! ! Typically, an OCT problem involves an optimization over a large number of (from ten to a thousand) control parameters which result from the discretization of the control function over the time- or frequency-domain. Searching the optimal solution over such a large dimensional space of control parameters requires e↵ective optimization routines. Greedy (local) algorithms are largely used in the context of OCT, because they require less computational resources and converge faster towards a successful solution as opposed to non-greedy (global) algorithms, which usually require more computational resources with slower convergence rate.

In spite of the high dimensionality of the quantum control problems and the complexity of the map between the system evolution and the control function, greedy algorithms are remarkably e↵ective in delivering almost perfect control schemes for controlling the quantum system. This remarkable performance gives rise to this question: under what conditions can greedy algorithms be used reliably for solving the quantum control problem?

It is shown in [30] that greedy algorithms can easily yield excellent-quality control schemes for a quantum control problem under the absence of any constraint on the external control ﬁeld. Under this assumption “no suboptimal local extrema exist as

30 a trap when seeking optimal quantum control” [30]. Although there exist various classes of extrema in the quantum control landscape with distinct ease of discovery and robustness properties, they all have peaks with the same height, all resulting in excellent-quality control schemes (See for example Fig. 1 in [30]).

Naturally, a variety of issues, such as quantum noise, the precision of the control devises, random noise on the control field and physical constraints on the control parameters could all invalidate the assumption that all the quantum control problems can be solved using the local optimization routines. Inspired by the above discussion we aim to explore the performance of greedy algorithm on quantum gate design under the constraints on system evolution and control field [60, 61]. Upon the failure of standard greedy algorithms we propose state-of-the-art evolutionary algorithms to enable the design of fast high-fidelity quantum gates.

3.2 Control ﬁelds: Time- vs. frequency-domains

Application of OCT in quantum system was initially motivated by controlling chemical reactions [76, 78]. The initial idea was to control the output of a chemical reaction by tuning the magnitude of an external control function "(t). In terms of the type of the control function, there are two di↵erent but equivalent approaches, which are followed in the ﬁeld [80, 81]. The ﬁrst one is having the control function in the time-domain and the second one is in the frequency-domain.

Time- and frequency-domains are two ways of studying the same dynamic system.

They can be interchangeably used to control the quantum system. The interchange- ability means that no information will be lost upon transformation from one domain to another. In the time-domain we are interested to studying the evolution of a process element over time, whereas the frequency-domain we study how fast or slow a process occurs. Therefore these two di↵erent domains provide the tools to look at the

31 same physical phenomena di↵erently.

The control procedure in the time-domain was ﬁrst proposed by Tannor and

Rice in 1985 [80]. The control procedure can be explained based on a two-color pump/probe scheme, where the control is the time delay between the two produced pulses. This time delay between pulses designed such that the second (dump) pulse comes into resonance with the evolution of a pump-excited molecule and directs the whole system toward a target product Frank-Condon region. Experimental implementations of the Tannor-Rice pump-dump scheme have been successfully performed by several groups [82, 83, 84]

The control procedure in the frequency-domain was ﬁrst proposed by Shapiro and

Brumer in 1986 [81]. This scheme is mainly inspired by the coherent control of chemical reaction. It employs two laser pulses with known phase di↵erence and distinct frequencies to change the phases of interfering dynamical pathways in order to manipulate the dynamical processes [85]. There are several experimental demonstrations of the Shapiro-Brumer scheme such as coherent control of product distribution [86] and interference between ionization process [87].

In this thesis we employ the control ﬁeld in the time-domain, which is consistent with the current experimental implementations and theoretical proposals for designing quantum gates [11, 88, 46].

3.3 Quantum control

Quantum control aims to steer quantum dynamics towards closely realizing speciﬁc quantum states or operations [75] with applications to femtosecond lasers [89, 90], nuclear magnetic resonance and other resonators [91, 92, 93, 94, 95], laser-driven molecular reactions [96, 80], and to quantum-gate synthesis for quantum computing [97].

Control is achieved by varying the external control parameters such that the resultant

32 evolution closely approximates the desired evolution. The set of instructions that determine the control parameters, and hence, the e↵ectiveness of the control scheme, is called a policy. We employ the quantum control schemes to generate policies for designing quantum gates.

In any quantum control problem, the goal is to decompose the system’s Hamilto- nian into a controllable and an uncontrollable part, and steering the dynamics towards adesiredevolutionthroughvaryingthecontrollablepartofthesystem.Foraclosed system, the Hamiltonian

L Hˆ ["(⌧)] = Hˆ dr + "(⌧) Hˆ c = Hˆ dr + " (⌧)Hˆ c, (3.3) · ` ` X`=1 acts on Hilbert space H [98] with drift Hamiltonian Hˆ dr describing free (uncontrolled) evolution, which we treat as being time-independent here. The control Hamiltonians, represented by the vector operator Hˆ c(t)=(Hˆ c)(for ` the control ﬁeld labels) ` { } should steer the system towards the desired evolution with time-varying control am- plitudes contained in the vector "(⌧):= " (⌧) . { ` } The resultant unitary operation over the time interval, ⇥ writes as follow:

⇥ U[⇥,"(⌧)] = exp i Hˆ ("(⌧))d⌧ (3.4) T ⇢ Z0 with the time-ordering operator [99]. Machine learning techniques can be employed T to evolve (3.4) towards a target operation.

3.4 Machine learning: A quantum control tool

The task of machine learning [40] is to develop algorithms that can learn from system behaviour and predict the future behaviour of the system based on their past evolution. Machine learning algorithms have already been applied to various problems in quantum computing such as phase estimation [41], asymptotic state estimation [42], and discriminating quantum measurement trajectories and improving readout [43].

33 One can classify the machine learning algorithms into three distinct categories including, supervised and unsupervised learnings, and reinforcement learning.

The supervised learning task is to infer a function (hypothesis) from the labelled data (training set). The training data is comprised of the input vector along with their corresponding output vectors. The supervised learning algorithm trains the hypothesis on the training data to construct an inferred hypothesis. This inferred hypothesis can be further used to label novel data. Examples of supervised learning problems are regression or classiﬁcation problems [100, 101].

Here I ﬁrst explain our strategy to transform a gate design problem into a learning problem and discuss the speciﬁc learning problem we are dealing with. A quantum logic gate is a map between an input and an output state. One can always represent the action of any quantum logical gate on the basis elements in terms of a truth-table.

There is a one-to-one correspondence between the input and output elements in this truth-table, as the quantum logic gates are themselves reversible. The quantum gate design can be turned into a regression problem where the main task is to construct a hypothesis that maps the input state of qubits to its corresponding output state after the action of the desired gate.

Our strategy to transform a gate design problem into a learning problem leads to amulti-valuedregressionproblem.Typicalregressionproblemsinmachinelearning consist of ﬁnding a hypothesis that maps an n-dimensional input vector to a single- valued output parameter. A single-valued regression problem poses a much easier learning problem in contrast to our multi-valued regression problems. Novel machine learning techniques must be devised to tackle these multi-valued regression problems.

A simple example of quantum gate that can be transformed into a learning problem is a CZ gate. Given the action of the CZ quantum logic gate on the ﬁrst and second qubits, it is straightforward to construct a truth-table which corresponds to the action

34 Input Output T C T C 0 0 0 0 |0i |1i |0i |1i |1i |0i |1i |0i |1i |1i |1i -| 1i | i | i | i | i Table 3.1: The truth table representation of CZ gate. T and C denote the control (first) and target (second) qubits, respectively. A CZ gate applies a Pauli-Z operator on the target qubit if the state of the control qubit is 1 and leaves the state unchanged otherwise | i of a CZ gate (See Table 3.1). In Table 3.1 C and T denote the control (first) and target (second) qubits. In the context of supervised learning problem, we consider the truth-table as the training set. Loosely speaking, we train our hypothesis on the truth-table data as the training set such that the learnt hypothesis maps input states to the final states with high confidence.

Having clariﬁed that the truth-table represents the training set, we now discuss what the hypothesis is. In the context of quantum gate design, the hypothesis is represented by the external pulses. Therefore, we train the parameters of the external pulses on the truth table data to shape the external pulses such that the system evolution approximates the target gate. If the hypothesis is learnt successfully, it will generate a policy which determines the shape and strength of the external pulses.

Thus far, we have explained the training set and hypothesis in the context of quantum gate design. However, we still need to know how to measure the success of our learning procedure as well as the explicit form of the hypothesis (external ﬁeld), which we elaborate in the next two sections.

3.5 Control pulses as learning parameters

Our learning algorithm uses the external pulses as the hypothesis and a successful policy will determine the shape of the optimal pulse. Although our quantum control

35 approach can generate any type of pulses (hypothesis) for "(t), here we only consider two types of pulses: piecewise-constant and piecewise-error-function. In the case of piecewise-constant function, we discretize each control pulse, "(t), and express it as sum of K orthogonal constant functions over the interval [0,⇥]. A "(t)thencanbe shown as:

"1 0 1 "2 "(t):=B C (3.5) B . C B . C B C B C B"K C B C @ A Each "l in (3.5) is a constant number over the sequential and equally-spaced time steps:

t = ⇥/K (3.6)

Whereas, the pulse generators can generate the piecewise-constant functions, such rectangular-shaped pulses get distorted by the gaussian ﬁlters that bridge the control circuitry with the quantum system. More realistic pulse shapes that can take such distortions into account should therefore be considered.

In order to consider the distortion on the rectangular pulses, we connect each control parameter in (3.5) by the following error-function [46]

" + " " " t + t "(t)= l l+1 + l+1 l erf t l l+1 (3.7) 2 2 t 2  ✓ ◆ for t t t , t being the lth timestep and determine the switching rate of l   l+1 l the pulse from tl to tl+1. Here we use =5,howeveranyothervaluecanbeused for depending on experimental procedure and type of the pulse generator. The resultant smooth pulse expressed in (3.7) accounts for the first-order distortion caused by gaussian filters. In general, designing smooth pulses is computationally more expensive than for piecewise-constant function. This is because the latter evolves the system over the coarser time intervals but the former requires finer time intervals

36 to numerically evaluate the evolution of the system, We therefore choose the less expensive piecewise-constant functions to analyze the gate ﬁdelity against various parameters. We justify this choice by showing that the gate ﬁdelity does not depend on the type of pulse, but depends on the number of learning parameters.

3.6 Learning algorithm conﬁdence: Intrinsic ﬁdelity

The standard method to measure the performance of a supervised learning algorithm is to define a confidence for the learnt hypothesis. The confidence is the ratio of the number of training data that are learnt successfully to the total number of training data. If the learning task is to generate a policy for designing a quantum gate, one can define this confidence, , by the distance between target and approximated unitary F operators:

= U[⇥,"(⌧)] U (3.8) F k targetk with the operator norm and therefore is the trace distance [102] between the k • k F target and actual evolution operators.

Our machine learning algorithm uses an explicit form of (3.8), where

1 = Tr U † U[⇥, "(⌧)] . (3.9) F 8 target ⇣ ⌘ Note that =1ifU[⇥, "(⌧)] corresponds to the target gate U and 0 < 1 F target  F otherwise.

In the context of quantum gate design, the confidence functional is called the F intrinsic fidelity which refers to the fidelity between the unitary evolution of the closed quantum system and the target operation when decoherence noise is ignored. We call the confidence of our learnt hypothesis in the presence of noise the average state

ﬁdelity and denote it by ¯. In the next section I explain how the average state F ﬁdelity is related to the gate intrinsic or noise error.

37 3.7 Average state ﬁdelity

In the presence of decoherence, the ecacy of the non-unitary evolution compared to the target gate is quantified by the average state fidelity ¯, which is calculated as F n follows. For H ⌦ the set of computational basis states for n qubits, the non- {| ki2 2 } unitary extension of the unitary evolution (3.4) transforms a pure computational basis state into a mixed state ⇢final. As each basis state remains invariant | kih k| k | kih k| under an ideal CCZ gate, average state fidelity ¯ = 1 ⇢final quantifies F 8 k h k| k | ki P q the ecacy of a quantum gate in the presence of intrinsic as well as decoherence- induced noise for a given optimal pulse.

Here we follow the standard practice of gate design schemes [32, 17, 46, 31, 2]. We

ﬁrst employ our machine learning scheme to generate policies for designing threshold-

ﬁdelity quantum gates under the ideal condition of a closed quantum system. We then incorporate noise into our policies and simulate the system evolution under decoherence. I explain the reason behind this choice in the next section.

3.8 O✏ine vs. online noise consideration

Optimal control experiments are usually performed under noisy conditions. In an experimental set up for quantum gate design there exist several types of error caused by defects in superconducting materials, measurement devices, pulse generator devices imperfection and the presence of environmental decoherence. Logically, there are two approaches to consider noise into the control procedure. One is to introduce anoisemodelintothecontrolprocedureasweinvestigatethesystemevolutionunder the noise. I call this approach online noise consideration. The other approach is to perform the control task in the absence of any type of noise and ﬁnd the control procedure for the ideal system and investigate the e↵ect of noise on the control procedure afterward. I call this approach o✏ine noise consideration. Here the main question is

38 which approach we should follow for designing quantum gates.

In practice a gate design control procedure could su↵ers from many types of noise, however, most of the calculation in quantum gate design are performed under the ideal condition of closed quantum system [32, 17, 46, 31, 2]. It is a challenging task to construct theoretical models for all types of noise occuring in an experimental set up.

Even if such a task was possible, there is no guarantee that an online noise consideration in the control procedure will lead to the same experimental output. Therefore the standard approach in the OCT is to ﬁrst provide the evidence (usually via numerical simulation) that a solution exists under the ideal condition. Second incorporate the leading order of noise into the ideal optimal solution to explore the resilience of the control procedure against the leading order of noise. Then one employs the closed-loop learning control scheme [103, 104, 76] to ﬁnd the optimal solution in the presence of di↵erent types of noise.

In Chapter 6, we follow the above approach when the goal is to generate policies for designing high-ﬁdelity three-qubit gates . An example of closed-loop learning control is also given in Chapter 6, which accounts for higher order noise. We will not consider noise e↵ect on the problem that we consider in Chapter 5, because in that chapter the goal is to show the existence of hard quantum control problems. Clearly if aquantumcontrolproblemishardundertheidealcondition,itwillbeharderunder the e↵ect of noise.

3.9 Threshold-ﬁdelity gate: A feasibility problem

So far we have turned the gate design problem into a supervised learning problem.

Intrinsic ﬁdelity (6.8) quantiﬁes the performance of the learning algorithm. As the

ﬁdelity approaches unity, the performance of a learning algorithm reaches its maximum value. The threshold theorem guarantees fault-tolerant quantum computing

39 even if the designed gate does not have perfect fidelity ( =1),butanintrinsic F fidelity higher than some threshold ( > 0.9999) [11]. F Setting the fidelity to some fixed value, which is acceptable for fault-tolerant quantum computing, turns the problem of generating policies for designing threshold-

ﬁdelity gates into a feasibility problem. All policies which result in approximated operators within the threshold error are called feasible (successful) policies. Opti- mization algorithms are employed to tackle this feasibility problem. In the following,

I list several optimization algorithms that I employed to ﬁnd a successful policy for quantum gate design. I start with the greedy optimization algorithms and then discuss our choice of the non-greedy algorithms.

3.10 Greedy optimization algorithms

A greedy algorithm in general is a sequence of local optimal decisions in the search domain with the hope that the ﬁnal solution is a global optimum. In many cases, a greedy algorithm does not guarantee an optimal solution. However, in a feasibility problem a global solution is not required because any feasible solution can approximate a global optimal in a reasonable time. Greedy algorithms are widely used in the context of quantum control. Here I consider the three most used greedy algorithms in the ﬁeld of quantum control including: The Nelder-Mead [47], Krotov [49, 50, 31] and the quasi-Newton method, which employs the Broyden-Fletcher-Goldfarb-Shanno

(BFGS) approximation of the Hessian [105, 106, 107, 108, 109].

3.10.1 Nelder-Mead technique

The Nelder-Mead technique is designed as an algorithm for minimizing an uncon- strained, nonlinear, and real-valued function f(x)whenx is an n-dimensional vector over Rn. The Nelder-Mead algorithm includes four operations each with a distinct

40 coecient which can be chosen by the user. The operations (coecients) are Reﬂec- tion (), Expansion (⇣), Contraction (), and Shrinkage ($). For almost all cases

(including the Nelder-Mead algorithm in this thesis) these parameters are set to the following constant values:

=1, ⇣ =2,  =0.5, $ =0.5(3.10)

At each iteration i, the optimization starts with constructing a simplex, Si, from n+1 vertices. Each vertex corresponds to a point in Rn. Vertices are ordered and labelled

i i as x1, ... xn+1 according to the following constraint:

f(xi ) f(xi ) f(xi )(3.11) 1  2  ··· n+1

i i If the task is minimization, then x1 and xn+1 are called the best and worst vertices, respectively. Here to keep the algorithmic description simple I drop the index i and only explain how the algorithm updates the vertices in one iteration:

1. Order n+1 vertices such that f(x ) f(x ) f(x ), 1  2  ··· n+1 2. Compute the centroid, x¯, of ﬁrst n vertices,

3. Reﬂection: Calculate the reﬂection point x =(1+)x¯ x . r n+1 if f(x ) f(x )

4. Expansion:iff(xr)

xe and go to step 1.

else replace worst vertex with x and go to step 1. • r else go to step 5.

41 5. Contraction: Calculate the contracted point, x : x = x¯+(x x¯) c c n+1 if f(x )

else go to step 6. • 6. Shrinkage: Update all vertices except the best vertex as follow:

x = x + $(x x )(3.12) i 1 i 1 with i 2,...,n+1 . Go to step 1. 2 { } The Nelder-Mead algorithm is a fast convergence algorithm. Usually the ﬁrst few iterations (depending on the size of the optimization problem) lead to a considerable improvement on an objective function toward an optimal point. The iterative procedure stops when either the change in the objective function is small or the algorithm found a suciently optimal solution.

3.10.2 Quasi-Newton

Quasi-Newton methods are designed to ﬁnd the local maxima or minima of an uncon- strained, twice continuously di↵erentiable function f(x)whenx is a n-dimensional vector over Rn. quasi-Newton is similar to Newton methods in which it searches for the stationary points of f(x), where the gradient becomes zero. The Newton method approximates the objective function as a quadratic function (using the Taylor series expansion) around the local optima and employs the gradient ( f) and Hessian r (H = 2f)oftheobjectivefunctionwithrespecttox to ﬁnd the optima. There r are several variants of quasi-Newton optimization algorithms which all di↵er in the way that they update the Hessian matrix. Here I employ Broyden – Fletcher – Gold- farb – Shanno (BFGS) to update the Hessian matrix. The algorithmic description of quasi-Newton based on the BFGS method for Hessian update can be explained as follow:

42 Initialize both x(0) and Hessian matrix H at 0th iteration • (0) for i=1, 2, . . . , until a stopping criteria satisﬁed • 1 (i 1) 1. Compute the search direction x = H(i 1) f(x ) r (i 1) 2. Find the step size, ↵, by solving: min f(x + ↵x) ↵

k k 1 3. Update x =x + ↵x

4. Update the Hessian matrix using (BFGS) method as fol-

low:

T T PP H(i 1)yy H(i 1) Hi =H(i 1) + T T (3.13) P y y H(i 1)y where y and P can be computed using the following equa-

tions:

(i) (i 1) (i) (i 1) y = x x ,P= f(x ) f(x )(3.14) r r

The quasi-Newton algorithm convergence is usually fast and it improves the objective function in the few ﬁrst iterations depending on the dimension of the optimization problem. In the iterative algorithm explained above, the stopping criteria include:

1) Reaching a predeﬁned number of iteration, 2) Reaching to the suciently optimal solution, and 3) Small improvement over the objective function values over sequential iterations.

3.10.3 Krotov

The Krotov algorithm is an iterative algorithm which is widely used in the context of the optimal control theory. Here I give a review of the main feature of the Krotov algorithm, however, the explicit formulation of the Krotov algorithm can be found in [110, 111]. Lets assume %(t)deﬁnesthestateofacontrolsystem which evolves C according to the following equation of motion:

%˙ = f[%, ⌦](t) (3.15) | i | i 43 with ⌦(t)thecontrollableparameterofthesystem.Giventhesystemisallowedto evolve over a time ⇥ according to 3.15, the control problem would be to maximize a target quantity (%(⇥)) under the constraint (3.15). Usually there are some extra J constraints on the control parameters, hence, it is useful to add some extra cost function on the control parameters. One way to deﬁning this cost function is as follow [111]: ⇥ = (t)(⌦(t) #(t))dt (3.16) Jc Z0 with #(t) called the reference control and (t)canbeseenasaLagrangemultiplier.

Having the constraints (3.15) and (3.16) on the objective function and control parameter, one can use the Lagrange multiplier ⌥(t)towritethedualobjectivefunctional as follow:

¯ = + + + , (3.17a) J J J1 J2 Jc where

⇥ 1 = 2Re ⌥(t) %˙ dt, (3.17b) J 0 h | i ⇥ Z =2Re ⌥(t) f[%, ⌦] dt. (3.17c) J2 h | i Z0 The condition for an optimal control is that ¯ =0whichresultsinthefollowing rJ three equations [111]:

⌥˙ = J2 , (3.18a) % | i ⌥(˙⇥)= J , (3.18b) %(⇥) | i f[%, ⌦] Re ⌥ = (⌦⇤ #)(3.18c) ⌦ |⌦=⌦⇤ ⌧ with ⌦⇤ being the optimal control function. The common approach in ﬁnding (or at least approaching) ⌦⇤ is to use an iterative and self-consistent method.

44 The Krotov method provides an iterative procedure to update the control ﬁeld while monotonically maximizing the dual objective functional ¯. This iterative pro- J cedure takes the following form for updating ⌦ at the kth iteration:

(k) (k) 1 (k 1) f[% , ⌦] ⌦ = # + Re ⌥ (3.19) ⌦ ⌧ In summary the algorithmic steps of Krotov at each ieration k can be given as follow:

(k 1) k k 1. Using ⌥ and % , Eq. 3.19 can be used to update ⌦ . The new

control is used to propagate %k according to the equation of motion 3.15

2. At time ⇥, ¯ can be calculated via Eqs. 3.16 and 3.17a J 3. The ﬁnal condition of the Lagrange multiplier can be obtained via

Eq. 3.18b

4. ⌥k is propagated and calculated for all times via Eq. 3.18a

The above iterative procedure stops when either a convergence criteria met or a certain predetermined number of iteration is reached. One usually initializes the

Krotov algorithm with a guessed value of ⌦(0) and uses it to propagate %(0) over the time ⇥ via Eq. 3.15. The algorithm uses this initial information and continues the iterative process till one of the convergence criteria met.

3.11 Evolutionary algorithms

As an alternative to greedy algorithms, we consider evolutionary algorithms for quantum control. Evolutionary algorithms are stochastic optimization algorithms, inspired by the process whereby biological organisms adapt and survive [112]. These algorithms only require the ﬁtness functional and not its gradient or Hessian.

The large class of evolutionary algorithms includes simulated annealing [113], ant- colony systems [114], memetic algorithms [115], DE [56], and particle swarm optimization (PSO) [55], GA [54] inter alia [112], but we choose to test just the three most

45 common or promising evolutionary algorithms, namely traditional GA (a commonly used algorithm) and the modern PSO and DE algorithms (promising for this type of problem). The promising nature of PSO and DE is based on many studies [57, 58, 59] that have shown the superiority of DE and PSO over other evolutionary algorithms.

All PSO, DE and GA employ the initial condition of multiple guesses, called particles in PSO and chromosomes in DE and GA. In what follows I discuss the detail of each of these evolutionary algorithms. I start with the earliest evolutionary algorithm which is GA.

3.11.1 Genetic Algorithm

Genetic algorithms (GAs) [116] are well known for global optimization. A candidate solution is ﬁrst coded in a binary representation, called a parent vector. These parents evolve through several algorithmic steps, namely selection, crossover, and mutation.

These steps lead to the generation of new candidates, known as children or o↵spring, for subsequent generations. These children become parents for the next generation.

Several variants of algorithmic steps exist for GA [54]. These steps evolve the

ﬁtness function towards its optimal state. We choose the following GA variant that leads to the best performance for our problem.

1. Selection:– This step speciﬁes how the GA chooses the next-generation

parent for subsequent breeding. We use the Roulette Wheel method,

which assigns a selection probability to each individual parent vector

according to

fi pi = N (3.20) i=1 fi

for N the total population numberP and fi the ﬁtness level of each individual parent vector. This probability distribution is used to select

parent vectors for the crossover step.

46 2. Crossover:– This step, which is considered to be the heart of GA,

speciﬁes how the two parents unite to generate the new o↵spring. We

use the two-point selection method to choose two random integers m

and n between one and the number of variables in each parent vector.

O↵spring elements are constructed from the element of the ﬁrst parent

vector P1, whose indices are less than n or greater than m, and those

elements of the second parent P2, whose elements share equal indices or are between n and m.

3. Mutation:– The purpose of mutation is to introduce small changes in

an individual selected from the population, which leads to the creation

of mutant o↵spring. We mutate uniformly on each individual o↵spring.

The mutation algorithm thus, selects vector elements that are be mu-

tated according to a small rate of 0.001. Then those selected elements

are replaced by a random number selected uniformly from the set of all

elements of the corresponding o↵spring vector.

3.11.2 Particle Swarm Optimization

PSO optimizes a function f(x)(withx an n-dimensional vector over Rn)byenabling exploration of the search domain using a swarm of particles with position-velocity pairs (x , v ) with v also an n-dimensional vector. These pairs are updated in each { i i } i iteration of the algorithm based on the PSO’s rules:

vi+1 = (wvi + c1r1(xi, xi)+c2r2(x xi)), (3.21a) ⇤ ⇤

xi+1 = xi + vi (3.21b)

th where xi, is the i particle’s previous personal best and x the global best position ⇤ ⇤ so far. We employ as a constriction factor, and w is an inertial weight. The

47 coecients c1 and c2 are deterministic weights, and r1 and r2 are uniformly distributed random numbers in [ 1, 1]. For the common PSO algorithm, the inertial weight decreases linearly starting from w =0.9tow =0.4overN iterations according to w = w (n max min n max 1)(w w )/N and the standard parameters are c = c =2and =1.Clerc’s max min 1 2 and Trelea’s variants use constant inertial weights and di↵erent parameter values.

Clerc uses w =1(PSO1)whereasTreleausesw =0.6(PSO2)andc1 = c2 =1.7

(PSO3) and w =0.729 and c1 = c2 =1.492 (variant 2).

3.11.3 Di↵erential Evolution

Individuals in DE are represented by a D-dimensional vector (X ), i 1,...,N , i 2 { P} where D is the number of control parameters and NP is the population size. The classical DE algorithm can be summarized as follow [56]:

1. Mutation:– The update step is

V = X + µ (X X )(3.22) i i1 i2 i3

with i, i , i , i [1,N ]beingintegersandmutuallydi↵erent. Here µ is 1 2 3 2 P the mutation factor controlling the di↵erential variation d := X X . i i2 i3 2. Crossover:–

Vi(j)ifCj(0, 1) < ⇠ Ci(j)=8 (3.23) > <>Xi(j)otherwise > with Cj(0, 1) representing a:> uniform random number between 0 and 1, and ⇠ (0, 1) is the crossover rate. 2 3. Selection:– The ﬁnal step is the assignment

Ci if f(Ci) <>Xi otherwise

> :48 with Xi0 the o↵spring of Xi for the next generation and f(Xi)theob- jective function, which, in our case, is the measured ﬁdelity.

49 Chapter 4

Superconducting Artiﬁcial Atoms and Gate

Design: Background

“I think I can safely say that nobody understands quantum mechanics.”

— Richard P. Feynman, 1964 [117] In this chapter I give the theoretical background for superconducting artiﬁcial atoms [32, 33, 34] as a physical system for quantum computing and quantum gate design. I review the current theoretical approaches for designing single- and two-qubit

(CZ ) gates [17, 88, 46] for an architecture of superconducting artiﬁcial atoms.

4.1 Quantum computing with superconducting devices

The appearance of superconducting computing devices resulted from the e↵orts to satisfy the DiVincenzo criteria [118] for a physical system to implement a quantum computer. DiVincenzo’s criteria include scalability, ability to initialize the qubits, long coherence time, ability to carry out a universal set of gates, and ability to perform measurements on each qubit. Superconducting quantum devices are shown to be an excellent candidate to meet these criteria [119, 34].

The simplest form of a superconducting artiﬁcial atom can be built from a superconducting inductance and capacitance which is well-known as the LC oscillator

(Fig. 4.1) [32]. Solving Kirchho↵’s equations for the LC oscillator system, one can realize a sinusoidally varying in time voltage on the capacitor (or current on con- ductor). Solving for energy levels of this physical device when the system is cooled down to an energy level less than one quasiparticle at the plasma frequency, the LC

50 L

Figure 4.1: A schematical view of a inductor-capacitor (LC) circuit with L and C denote the inductance and capacitance of inductor and capacitor, respectively. oscillator behaves like a harmonic oscillator with evenly-spaced discrete energy levels.

This harmonicity is the main problem of this structure to be used as an artificial superconducting atom. If the first two levels of the LC oscillator are used as a qubit, then it is experimentally challenging to populate the first excited level without interfering with many other excited levels. Anharmonicity then is the main requirement for a controllable superconducting artificial atom.

Thus far, many superconducting artiﬁcial atoms [37, 38, 120, 121, 122] are implemented with energy level anharmonicity and long coherence time. At the time of writing this thesis, transmons [36, 123] are one of the most popular superconducting qubits with a long coherence time of 60 µs. In chapter 6, we employ an architecture of transmons as the physical system to design three-qubit gates. Transmon is an improved version of a charge qubit [37, 38].

In the next three Subsections, I ﬁrst explain the fundamental element of superconducting artiﬁcial atom circuits, which is a Josephson Junction (JJ). I then explain the physical structure of a charge qubit and a transmon.

4.1.1 Josephson Junction

Superconducting artiﬁcial atoms must have energy level anharmonocity to enable e↵ective manipulation of speciﬁc energy levels. To have this anharmonocity, the

51 S I

(a) (b) (c)

Figure 4.2: (a) A schematic view of a Josephson Junction (JJ) with two superconducting (S) electrodes separated by a thin insulator (I). (b) Circuit model of a JJ, and (c) equivalent circuit representation which consists of a non-linear element and acapacitiveelement. linear electrical element used in the LC oscillator (Fig. 4.1) must be replaced with a nonlinear electronic element. Because the quantum information is so fragile against thermal energy, the non-linear element should be non-dissipative to avoid the loss of information within the superconducting circuit. The Josephson junction (JJ) is one of the non-dissipative nonlinear circuit elements which is widely used in the structure of superconducting artiﬁcial atoms. A JJ is built of two superconductor plates which are separated by a thin layer of insulator. Figure 4.2 shows a JJ which has a similar structure as a linear capacitor with a nonlinear inductance, responsible for the nonlinear response of JJ.

A JJ can be characterized by two energy scales. These are the JJ coupling energy

~I0 E , (4.1) J ⌘ 2e and the Cooper-charging energy

(2e)2 E (4.2) C ⌘ 2C with e denoting the magnitude of the electron charge and I0 in (4.1) being the critical current. C in (4.2) denotes the junction capacitance, which accounts for junction charging. It is the relative size of these energy scales EJ and EC that determine the

52 Vg Vg (a) (b)

Figure 4.3: (a) Circuit representation of a Charge qubit. The dotted red line denotes the isolated charge island. The bias-voltage Vg is used to tune the qubit frequency. (b) The circuit representation of a transmon which is a descendants of Charge qubit. Transmon overcomes the problem of o↵set charge noise by shunting the JJ by an external capacitance. The higher external capacitance in transmon is shown by bigger capacitor plates (red plates) speciﬁc type of superconducting artiﬁcial atom. I write about this more in the next

Subsection.

4.1.2 Charge qubit

A JJ by itself represents a superconductor anharmonic oscillator. The only thing that we need to turn a JJ into a superconducting artiﬁcial atom is to add control elements to tune the energy level of this anharmonic oscillator. In practice this controllability can be achieved, by changing the current across the JJ through a bias-voltage which is capacitively connected to the JJ. Therefore, a JJ element in serial connection with an external capacitor and bias-voltage led to the ﬁrst practical implementation of a charge qubit. Figure 4.3a shows a schematic representation of charge qubit which consists of a Cooper Pair Box (CPB) (the dotted-region) as an isolated charge island.

One can write the Hamiltonian of a charge qubit in terms of the Cooper pairs transferred between the island,n ˆ and the gauge-invariant phase di↵erence between

53 the superconductors ˆ as follow [36]:

Hˆ =4E (ˆn nˆ )2 E cosˆ, (4.3) C g J wheren ˆg denotes the e↵ective o↵set charge. A charge qubit works in a regime where JJ coupling energy is much smaller than

Cooper-charging energy (E E ). The sensitivity of a the charge qubit to charge J ⌧ C ﬂuctuations can be greatly reduced if the system works in a certain parameter space of

1 nˆg [124]. For instance biasing the system to the charge-degeneracy pointn ˆg = 2 will reduce the sensitivity to the charge noise [36]; these points are called sweet spots [124]

. The slope of the energy spectrum of the ﬁrst three energy levels with respect to the e↵ective o↵set charge is zero at the sweet spots, where the linear contributing noise does not vary the qubit frequency.

Unfortunately, large ﬂuctuations exist in the local electrostatic potential at the superconducting island. These ﬂuctuations limit the long-time stability of the charge qubit at the sweet spots and drive the system out of these stationary points. Therefore the major practical limitation of charge qubits is still their high sensitivity to the o↵set charge.

4.1.3 Transmon

There are two important quantities for the operation of CPB including the anharmonicity and the charge dispersion of the energy levels. As mentioned earlier a large enough anharmonicity guarantees fast energy level manipulation of the qubit without disturbing other energy levels of the system. The charge dispersion determines how the energy levels vary against the gate voltage or the ﬂuctuation of o↵set charge which is caused by the environment. A small charge dispersion leads to qubit frequencies that vary slowly in response to the gate charge ﬂuctuation.

It is the ratio of JJ coupling energy to the charging energy that determines the

54 magnitude of charge dispersion and anharmonicity. Increasing this ratio results in one drawback and one advantage for CPB operation. The advantage is the reduction of overall charge dispersion and thereby the decrease in the sensitivity of the box to the charge noise. The drawback is to increase the harmonicity of the box thereby lowering the speed of qubit operation. The idea of the transmon is to ﬁnd an optimal ratio of

EJ and EC such that we gain simultaneously a suciently large anharmonicity and alowchargenoisesensitivity.

Although increasing the ratio EJ /EC increases the harmonicity of CPB and decrease its sensitivity to noise, but these changes do not occur with the same rate.

Explicitly, in terms of the ratio of EJ /EC , the reduction in charge dispersion is exponential whereas, the reduction in anharmonicity occurs with a slow power law [125].

By exploiting this remarkable fact, a transmon works in a regime in which the ratio of EJ /EC is much larger than the one for a charge qubit. In practice, this large ratio can be achieved by increasing the size of the island, thus, shunting the JJ by a large external capacitor (See Fig. 4.3b).

As a result of working at a much larger EJ /EC than the charge qubit, the transmon considerably reduces the charge fluctuation sensitivity, while slightly sacrifices anharmonicity. In practice the charge dispersion can be suppressed such that the transmon frequency becomes insensitive to the charge fluctuation. This remarkable feature eliminates the need for tuning to the charge sweet spots and eases the practical implementation of transmon by eliminating the individual electrostatic gates to control the o↵set charge. Transmons can be coupled to each other by the means of linear electronic elements such as a capacitors or inductor to make one- or two-dimensional networks. The networks of transmons can be utilized to design quantum logic gates which act on multi-qubits.

55 4.2 Single-Qubit gate design for superconducting artiﬁcial atom

There are a few proposals for designing high-fidelity single-qubit gates for the architecture of superconducting qubits [126, 127]. However, Motzoi et al. [17] were the first to propose a design for threshold-fidelity ( > 0.9999) single-qubit gate operating in F timescale no longer than 10 ns under the experimental constraint of a transmon. The physical model in [17] for designing single-qubit is a three-modal transmon, with energy level coupled by microwave frequencies with the first two levels of the transmon representing a qubit. If the leakage to the third level is small, it is straightforward to shape the external pulses such that the system’s Hamiltonian and its evolution reduce to that of a qubit.

In the more general case where the leakage is large, the imperfection in the pulse shape can lead to unwanted leakage to a third level, therefore a↵ecting the decoherence time of the qubit. Motzoi et al. proposed to solve this problem using two quadrature controls for e↵ective phase modulation, thereby reducing the leakage outside the qubit subspace by an approach called Derivative Removal by Adiabatic Gate (DRAG) [17].

4.3 Two-Qubit (CZ) gate design for superconducting artiﬁcial atoms

An avoided-crossing-based CZ gate [46] has already been achieved for an architecture of superconducting artificial atoms. The idea of an avoided-crossing-based gate is to vary the energy level of artificial atoms such that energy levels approach each other, but avoid degeneracies. These avoided crossings mix population and dynamical phases at the corresponding levels such that the final evolution of the system gives the required phase and population for the target gates.

An avoided-crossing-based CZ gate was ﬁrst proposed by Strauch et al. for an architecture of two phase qubits [88]. Ghosh et al. adapted the technique for an architecture where a superconducting qubit (phase qubit or transmon) is coupled

56 with a bus resonator that is also coupled with other superconducting resonators [46].

Here I elaborate on the avoided-crossing-based CZ gate for the physical model of two capacitatively-coupled frequency-tunable transmons.

Each transmon k is capacitatively coupled to its nearest neighbour where the location of each transmon is labeled by k =1, 2. The transmon frequency "k(t) can be tuned via superconducting control electronics. The anharmonicity of the second energy level is represented by ⌘. The transmons are coupled capacitatively to yield YY interactions between adjacent transmons with a coupling strength g. The

Hamiltonian for two capacitatively-coupled transmons is thus [46]

00 0 2 Hˆ (t) 0 1 = 0 "(t)0 + gY1 Y2 (4.4) h ⌦ k=1 B C X B C B002"(t) ⌘C B Ck @ A where 0 i 0 0 1 Y = i 0 p2i (4.5) B C B C B0 p2i 0 C B C @ A is the generalized Pauli operator [46].

The energy levels of two capacitatively coupled transmons are shown in Fig. 4.4, where we ﬁx the frequency of the ﬁrst transmon at "1 =6.5 GHz and allow the frequency of the second transmon "2(t)tovaryfrom!o↵ =7.5 GHz (detuned frequency) to !on = "1 + ⌘ =6.7 GHz. We vary the frequency of the second transmon using atime-dependentgaussian-errorfunction,witharisingtimeoftramp and the gate operation time of tgate, which can be represented as [46]

! ! 4t 2t " (t)=! + on o↵ erf ramp 2 o↵ 2 t  ✓ ramp ◆ 4t 4t +2t erf gate ramp (4.6) t ✓ ramp ◆

57 15 20 14 | i 11 13 | i 7.5 02 | i 10 | i

(GHz) 7 01 | i

E/h 6.5

0.25 00 0 | i 6.6 6.8 7 7.2 7.4 "2(t) (GHz)

Figure 4.4: (a) The energy (E) spectrum of the system Hamiltonian of two capacitively-coupled transmons. The frequency of the ﬁrst transmon is ﬁxed at 6.5 GHz. The frequency of the second qubit, "2(t)variesfrom7.5to6.5 GHz

The idea of an avoided-crossing-based CZ gate works as follows: Initially, we detune the transmon frequencies from each other by setting the frequency of the second transmon equal to "2 = !o↵. This makes all the eigenstates of the system non-degenerate. Then we turn on the frequency of the second transmon to !on for atimet = t 2t , and ﬁnally detune the second transmon again to the on gate ramp frequency !o↵. During the time ton there will be mixing between the computational basis 11 with the two auxiliary levels ( 02 , 20 )whilealltheothereigenstatesin | i | i | i the computational basis ( 00 , 01 , 10 )aredetunedfromtheothereigenstateof | i | i | i the system. The parameters of the control pulse are determined such that the mixing among 11 , 02 and 20 states over the time interval t ensures the phase factors | i | i | i on required for the CZ gate.

Depending on the timescale ton, there exists two regimes under which a CZ gate can operate: the sudden-approximation regime and the adiabatic regime. In the

58 sudden-approximation regime we vary the second qubit frequency fast enough, such that the switching time can be made sudden with respect to the coupling g (but still adiabatic with respect to the anharmonicity ⌘). For the sudden-approximation regime, the switching time has an inverse relation with the coupling factor as

⇡ ton = . (4.7) p2g

Under the sudden approximation, there are two parameters of the pulse, !on and ton that must be optimized to obtain a high-ﬁdelity CZ gate.

On the other hand, in the adiabatic regime, the switching is adiabatic with respect to the coupling g (and therefore with respect to ⌘ as well). In this regime, one requires astrongercouplingbetweentransmonstomakethegateoperateasfastasthegates in the sudden approximation regime. This increase in g leads to residual errors in a multiqubit device, whereas the advantage of operating the transmon in the adiabatic regime is that it suces to optimize only one parameter. This is because the adiabatic regime ensures that the population of each energy level is preserved. A CZ gate in the adiabatic regime is demonstrated in [128].

In chapter 6 we will use the idea of avoided-crossing-level gates to generate policies for designing three-qubit gates. I we will show that designing such three-qubit gates are hard quantum control problems. Therefore before going into the details of designing three-qubit gates, in chapter 5, we discuss the algorithms which can overcome the hardness of gate design problems. These algorithms inspire us to devise new machine learning techniques which enable the design of realistic three-qubit gates.

59 Chapter 5

Hard Quantum Control Problems

“It is often stated that of all the theories proposed in this century, the

silliest is quantum theory. In fact, some say that the only thing that

quantum theory has going for it is that it is unquestionably correct.”

— Michio Kaku, 1995 [129]

5.1 Introduction

As it was explained earlier in Chapter 3, a gate design problem can be transformed into a quantum control problem in which the task is to steer the system’s Hamiltonian toward some specific unitary operation. Supervised machine learning techniques can be employed to generate successful policies for designing quantum gates. The performance of the learning procedure can be enhanced by maximizing a confidence function called the intrinsic fidelity. When the error in intrinsic fidelity is fixed to some value accepted for fault-tolerant quantum computing, designing threshold-fidelity quantum gates becomes a feasibility problem. Optimization algorithms can be used to tackle this feasibility problem. In this chapter we show the performance of several greedy and non-greedy optimization algorithms to generate policies for designing quantum gate design.

A key goal in quantum control is to reach the ﬁttest procedure possible within the target time ⇥ subject to certain resource limitations such as a limited number of independent control parameters K and therefore the time resolution ⇥/K for time-domain quantum control. Practical considerations usually tightly constrain the maximum allowable values for ⇥,andlowerboundsfor⇥ are central to questions

60 about fundamental “quantum speed limits” to operations in quantum computing, quantum metrology and quantum chemistry [130, 131, 132, 133]

Early quantum control employed non-greedy approaches, e.g., the genetic algorithm (GA) [104, 54]. Today, greedy algorithms dominate the methodology as local optimization strategies usually have lower computational cost than global search algorithms and the ﬁtness landscape (plot of ﬁtness vs. control parameters) typically appears to be tractable [30]. Unfortunately, greedy algorithms can fail even for low- dimensional quantum control with simple Hamiltonians if ⇥ must be short. This seemingly innocuous constraint eliminates any guarantee of global optimality for local extrema.

Although it is tempting to attribute the failure to ﬁnd a satisfactory control procedure to infeasibility of the constrained problem, we show that this failure can instead be due to restricting strategies to greedy algorithms. To make our case, we present examples of control problems involving simple systems for which greedy algorithms overwhelmingly fail. These two control problems are especially contrived to be hard to solve using common quantum-control techniques, but the problems are physically meaningful as discussed in Subsecs. 5.4.1 and 5.5.1, respectively. We use the term

‘hard’ to refer to problems that defy existing methods in the sense that the probability that they produce a satisfactory solution is small. A key element of these problems are that the time required for the unitary operation is short, which could make many quantum control problems hard. We show that these hard quantum control problems can be solved using global optimization techniques based on the di↵erential evolution (DE) algorithm [56], which succeeds in ﬁnding e↵ective controls up to the computational-power limits (machine error) even for very short ⇥ and very few controls.

We compare greedy vs non-greedy algorithms for realizing two di↵erent quan-

61 tum computing gates: the original qutrit phase gate [134, 135] and the two-qubit controlled-not (CNOT) gate [28], which are key elements of standard quantum computing instruction sets for qutrits and for qubits, respectively. We show that, for each gate and given our selected drift and control Hamiltonians, the greedy algorithm fails to find a high-fitness quantum control procedure for short target time ⇥ while our non-greedy DE algorithm succeeds. Moreover, for larger ⇥ where greedy algorithms work, DE is able to find solutions requiring fewer independent control parameters K than the greedy algorithms tested. Interestingly, the common non-greedy GA also strongly fails for our test problems.

5.2 Criteria to evaluate algorithm performance

Evaluating and comparing algorithms for optimization should be conducted fairly and clearly. Using run-time directly as a cost criterion obscures fundamental issues in comparing the intrinsic di↵erences. Therefore, we evaluate and compare algorithms based on whether the algorithm yields a suciently optimal solution over many at- tempts, here called “runs”. Each run is allowed to iterate until it succeeds or fails in which case the run aborts.

The iteration number of run r is ı, and the total number of iterations for run r is denoted Ir with IR the maximum iteration number over all R runs. For R runs, we determine and tabulate the best and worst ﬁtness value obtained over these runs, and we characterize the statistics of error values according to the median error and the probability }, or percentage, of runs whose error is less than some threshold value.

We compare the performance of the optimization algorithms based on the bounds and statistics of the statistics of runs, and these statistics are analyzed in plots that depict the Real( )vsı for each of the many runs. A plot of vs ı is overly crowded F F to reveal key features clearly. Therefore, we stretch the plots by presenting the

62 monotonically-related “logarithmic intrinsic inﬁdelity”

L := log (1 Real ( )) (5.1) 10 F vs. ı for each run. Logarithmic intrinsic inﬁdelity is zero for perfect inﬁdelity

=0, (5.2) F hence, approximately bounded by L = 16 for double precision, and ideally for 1 perfect fidelity ( =1). F The algorithm for run r is deemed successful if the final exceeds a minimum Fr threshold Lt, which we set to L = 4commensuratewiththewidelyacceptedgate t fidelity required for scalable quantum computing [136]. Our algorithm aborts a run after I iterations only if the change in is within machine error or an infidelity within r Fr machine precision is reached. The percentage of runs that beat Lt is denoted }t.

A fair comparison of greedy vs evolutionary algorithms would consider an equal number of trials in each case. In order to make a stronger case that our evolutionary algorithm is superior, we are giving the greedy algorithms an advantage by allowing them twice as many runs as for the evolutionary case. This allowance is feasible because greedy algorithms typically run much quicker so allotting additional time to double the number of greedy runs is not onerous in terms of computational time. Speciﬁcally we run the greedy algorithms over 80 trials and the evolutionary algorithms over 40 trials. Our choice of 80 and 40 trials, respectively, comes from our experience in testing these di↵erent algorithms, and these numbers correspond to balancing achieving sucient success probability against excessive computational cost.

63 5.3 Methods

We begin this section by explaining the choice of control function that we use for the purpose of optimizing the external ﬁeld. We then discuss the details of how we use the external ﬁeld to numerically approximate the unitary operation in (3.4). The last part of this section discusses the optimization routines that we have tested on two quantum control cases. We discuss two classes of optimization routines namely: local

(greedy) and global (evolutionary) algorithms with our focus on the latter.

5.3.1 Type of control function or hypothesis

Here we use a piecewise-constant function as the control pulse (See Sec. 3.5). This type of function is commonly used and justiﬁed by the fact that control pulses on experimental hardware are often limited to this form although there are alternatives such as decomposition into K monochromatic functions to be solved in the frequency domain. The rectangular time bins also have computational advantages in that the time-ordered integral (3.4) is straightforward to evaluate. However we show in the next chapter that the performance of a quantum control scheme does not depend on the type of control pulse but rather on the number of control parameters K.

5.3.2 Optimizing the control function

For any optimization problem, greedy algorithms are the primary choice if they can provide a satisfactory result. Greedy algorithms locally explore the landscape so their convergence rate toward a local optimum is much faster than for global optimization algorithms. If the landscape includes many traps, most trials striving to ﬁnd global optima become ensconced within local traps in which case greedy algorithms fail to

ﬁnd the best solution. Evolutionary algorithms are speciﬁcally designed for non- convex optimization problems, which typically arise when the landscape includes

64 many traps and a global optimum is the goal. Here we ﬁnd that greedy algorithms are preferred when there is enough time to approximate the unitary operation and enough control parameters to search the landscape. Otherwise evolutionary algorithms are the choice to solve the problems. We discuss these two class of optimization algorithms here.

As greedy algorithms we employ the Nelder-Mead technique [47], Krotov [49, 50,

31], the quasi-Newton method, which employs the Broyden-Fletcher-Goldfarb-Shanno

(BFGS) approximation of the Hessian [105, 106, 107, 108, 109]. Greedy algorithms are especially successful if both ⇥ and K are suciently large. For constrained ⇥, second-order traps such that the Hessian is negative semideﬁnite arise [137, 138, 139] and numerical evidence arguably exists for the presence of other traps [140, 29, 141].

As an alternative to greedy algorithms, we consider evolutionary algorithms for quantum control including GA [54], PSO [55] and DE [56].

In GA, “parent” chromosomes go through three steps: selection, crossover and mutation to generate a new generation (“o↵spring”) of chromosomes. We test all

Matlabr (version R12118) GA options and found that the Wheel-Roulette, Two-

Point and Uniform methods perform best. We test GA fairly by optimizing population number N independently for each GA variant and ﬁx the run time to equal those for

PSO and DE runs.

In PSO the particle evolves according to a Langevin equation that includes a random kick, an attractive force to its previous best fitness and a force pulling the particle to the fittest particle in its neighborhood (where the size of the neighborhood is logarithmic in the number of particles). Neighborhoods overlap such that they do not partition into distinct sets. Specifically we employ three PSO variants labeled here as PSO1, PSO2 [142] and PSO3 [143].

In DE each chromosome breeds with three other randomly chosen chromosomes

65 from the same generation to produce a “daughter”, and the ﬁttest of the original vs the bred “daughter” survives to the next generation. We use a DE variant that incorporates mutation scaling factor µ [0, 2] and cross-over rate ⇠ [56]. In each 2 generation the di↵erence between two randomly chosen target vectors is weighted by µ then added to a third randomly selected target vector to generate the new set of vectors called donors. This quantity µ determines the DE step size for exploring the control landscape. Donor vector elements are incorporated into target vectors with probability ⇠ to generate trial vectors, and the ﬁttest of the target and trial vectors survive to the next generation.

Details of DE, PSO and GA and a comparison between these three algorithm can be found in Chapter 3.

5.3.3 Evaluating the objective function

In order to simulate the evolution of quantum system according to (3.4), we use the following decomposition approach:

U["(⌧ ); ⇥]=UK UK 1UK 2 ...U3U2U1 (5.3) with UK =exp(iH("l)⌧)and⇥ the ﬁxed target time for the unitary operation. The next step is to optimize over "(t)withintargettime⇥ keeping the number K of F time bins small.

5.4 Qutrit phase gate

Now we proceed to the specific example of generating a policy for designing a qutrit phase gate. We first test conventional greedy algorithms. For suciently large ⇥ for e↵ecting the unitary operation, we show that greedy algorithms can rapidly converge to a local optimum, but not necessarily a global optimum, which we characterize here as a local optimum that meets the intrinsic infidelity condition L := 4. We also show 66 that reducing the time and the number of control parameters transforms the problem into a hard optimization problem for which we employ evolutionary algorithms as an alternative approach.

5.4.1 Qutrit phase gate: Physical Model

For a qutrit phase gate the Hilbert space is H =span 0 , 1 , 2 , and the target {| i | i | i} gate is:

i⇥Hˆ dr -i -i i U =e (e 0 0 ie 1 1 ie 2 2 )(5.4) | ih | | ih | | ih | with objective parameters corresponding to the phases and and Hˆ dr is the drift

Hamiltonian deﬁned in (3.3). As our interest is in hard quantum control problems, we choose a challenging ⇥-dependent drift Hamiltonian and a single control given by [29] ⇡ 1+ ⇥ 00 a 10 0 1 0 1 Hˆ dr = 010, Hˆ c = 1 b 1 , (5.5) B C B C B C B C B 002C B01cC B C B C respectively. @ A @ A

This choice of control and drift Hamiltonian (5.5) provides a rich lode for studying hard quantum control because, for any target time ⇥, many choices of a, b, c, , and lead to "(t) 0beingacriticalpoint.Theresultantcriticalityresultsin ⌘ Re[ ["(⌧)] < 1 for which the Hessian becomes strictly negative deﬁnite. We consider F the speciﬁc choice

a =2,b=2,c=1. (5.6)

Then the phase choices

5⇡ b + c = , sin = cos (5.7) 3 a ensure that

"(t) 0(5.8) ⌘ 67 is a critical point i.e. a point in which

("(⌧)) = 0, 2 ("(⌧)) < 0. (5.9) rF r F

Therefore, a strong trap in the ﬁtness landscape is deliberately set [29]. The resultant

Hamiltonian is obtained by inserting (5.5) into (3.3). The external ﬁeld, or control parameters, are adjusted to realize (5.4) according to expression (3.4). In this way, we can realize the qutrit phase gate by quantum control using the control and drift

Hamitlonians (5.5).

While this problem is deliberately contrived to illustrate the existence of traps, the drift Hamiltonian (5.5), for a ﬁxed value of ⇥,e↵ectively describes the free evolution of a three-level system such as encountered in a spin-one system or in a single atom with three pertinent electronic levels. The diagonal terms correspond to the electronic energy levels of the atom.

The ﬁrst and second energy levels are non-degenerate in the absence of the driving

ﬁeld, but the states approach degeneracy in the limit of long time ⇥. A system whose energy levels depend on the control time ⇥ does not appear in nature but is a legitimate system for mathematically exploring the limitations of greedy algorithms and the power of evolutionary algorithms. Therefore, we employ this model in the qutrit case to compare these di↵erent optimization strategies.

The control Hamiltonian (5.5) can represent the interaction of an atom with a driving field. The diagonal terms of the control Hamiltonian represent level shifts due to the e↵ect of the field. The o↵-diagonal terms are the Rabi frequencies between the corresponding pairs of levels, in this case between the first and second levels and between the second and third levels. Here we have scaled the Rabi frequencies to unity.

68 0

−5 (a) r L −10

−15 50 100 150 200 ı

Figure 5.1: Logarithmic intrinsic inﬁdelity L vs iteration number ı for the qutrit gate using the quasi-Newton method with ⇥ =10⇡ (red, solid lines), ⇥ =4⇡ (blue lines with ’+’ markers), and ⇥ =3⇡ (green lines with ’ ’ markers) such that K = 50 in all cases. [reproduced from ref. [1], Fig. 1a] ⇥

5.4.2 Qutrit phase gate: Results

In this section we give the result for generating policies to design a Qutrit phase gate where there is enough time for unitary operation or a sucient number of control parameters. Then we numerically show that reducing the time ⇥ and control parameters K transform the problem into a hard optimization problem and results in runs of the greedy algorithms getting trapped. In the next part of this section we evaluate the performance of evolutionary algorithms when the time is shortened and K is reduced and compare the performance of di↵erent algorithms in terms of their median and best plots and ﬁnally tabulate the resultant data.

We choose to begin with a plot of the fast-convergent quasi-Newton method because this approach should be the preferred choice for when it succeeds to deliver a satisfactory results. Figure 5.1 depicts the logarithmic intrinsic inﬁdelity L as a { r} function of ı for the qutrit phase gate using the quasi-Newton method.

In Fig. 5.2, we compare the greedy simplex, Krotov and quasi-Newton methods against GA, DE, Common PSO, PSO1, PSO2, and PSO3 algorithms when the operation time ⇥ and number of learning parameters K are reduced. Speciﬁcally we

69 0 0 (a) (b)

−4 −4

−8 −8 L L

−12 −12

−16 −16 250 500 750 250 500 750 ı ı

Figure 5.2: (a) Median-run performance (b) Best-run performance for the qutrit phase gate (⇥ =2.5⇡ and K =10).LogarithmicintrinsicinﬁdelityL vs iteration number ı for ( ) GA, ( )DE,( )CommonPSO,(I)PSO1,( )PSO2,( )PSO3, ⇤ ⇥ ⇤ ⌃ (B) quasi-Newton, (V)simplexand(O)KrotovwithR =80(R =40)forgreedy (evolutionary) algorithms. [reproduced from ref. [1], Figs. 2a and 2b].

L GA DE PSO PSO1 PSO2 PSO3 Newton simplex Krotov median -0.6 -15.9 -1.7 -2.5 -2.4 -1.1 -0.7 -0.7 -0.6 best-case -1.2 -15.9 -2.4 -4.4 -4.1 -1.5 -1.4 -1.3 -1.16 worst-case -0.4 -2.2 -1.3 -1.6 -1.4 -0.9 -0.4 -0.4 -0.4 }t 072.50 12.57.50 0 0 0

Table 5.1: Median, best-case, worst-case, and }t for logarithmic intrinsic inﬁ- delity L for the qutrit phase gate with ⇥ =2.5⇡, K =10,andR =80(R =40)for greedy (evolutionary) algorithms. depict best-run performance and median-run performance in terms of ﬁnal L.

These plots are indicative only. Careful comparisons are summarized in Table 5.1 for median, best-case, and worst-case performance as well as for the percentage of runs }t that exceed Lt over R =40runsforevolutionaryalgorithmsandoverR =80 runs for greedy algorithms.

5.4.3 Qutrit phase gate: Discussion

As we explained in earlier sections, greedy algorithms converge faster than evolutionary algorithms and they should be the ﬁrst choice for quantum control optimization if they can provide satisfactory results. We show the greedy-algorithm performance

70 in Fig. 5.1 where most quasi-Newton runs converge rapidly within machine precision

(L = 15.65) to the target gate for large ⇥ and for small time resolution ⇥/K.For small ⇥ and K, a majority of runs becoming trapped at low ﬁtness (high L)values.

Evidently the quasi-Newton method fails (green plots in Fig. 5.1) for short-time and

ﬁne–time-resolution constraints.

Our results show that greedy algorithms perform poorly for the highly-constrained-

⇥,low-K problems as do PSO and GA. Figure 5.2 compares the performance of di↵erent algorithms for two cases by providing the median and best plots for each algorithm. For the qutrit phase gate, optimization performance is shown in Fig. 5.2.

Evidently, all quasi-Newton, Krotov and simplex runs become trapped at very low

fidelity. On the other hand, DE and PSO1 and PSO2 are the only algorithms that successfully achieve the infidelity target of L = 472.5%,12.5%and7.5%ofthe time, respectively (c.f., Table 5.1) and DE achieves the best performance in terms of the best and median infidelity among all algorithms.

In the qutrit-phase-gate example we are searching the landscape around a critical point "(t)=0bysamplingeachtrial"(t)randomlyfrom[ 1, 1] and evolving them toward their optimal values. As there are other studies that numerically provide the proof of local traps in the quantum control landscape [140, 29, 141], here our results show many local traps in the landscape as many runs from greedy algorithms get trapped at low ﬁdelities. Using an ecient global-optimization routine like DE is necessary to avoid these local traps and to ﬁnd a global optimum.

5.5 Controlled-NOT (CNOT) gate

Now we proceed to the second example which is a CNOT gate. We ﬁrst give the physical model that we employ to design the gate. We then test conventional greedy algorithms to generate a policy for designing a CNOT gate when ⇥ is suciently

71 large. We show that greedy algorithms can rapidly ﬁnd a successful policy when there is enough time to evolve the system. We also show that reducing the time and the number of control parameters transforms the problem into a hard optimization problem for which we employ evolutionary algorithms as an alternative approach.

5.5.1 CNOT gate: Physical Model

The second example concerns the two-qubit CNOT gate [28]. Inspired by the one- dimensional linear Ising-ZZ model [31], the drift and control Hamiltonians are

X 1 ⌦ 0 1 J 1 X ˆ dr ˆ c ⌦ H = Z Z, H = B C , (5.10) 2 ⌦ B C BY 1C B ⌦ C B C B1 Y C B ⌦ C @ A respectively, in which the X, Y , Z are the Pauli matrices and 1 the 2 2identity ⇥ matrix. We normalize time by setting J 1. The time-dependent four-dimensional ⌘ control vector "(⌧)inEq.(3.3)isoptimizedsothattheresultantevolution(3.4) approximates CNOT with high . F Physically the Ising-ZZ model corresponds to a one-dimensional spin chain, which was originally studied in the context of explaining ferromagnetism. The weak interaction is described by a tensor product of Pauli Z operators for nearest neighbours.

The spin chain interacts with an external ﬁeld, for example a magnetic ﬁeld, and this interaction involves only single non-identity Pauli operators as seen in the control

Hamiltonian (5.10).

5.5.2 CNOT gate: Results

We follow the same approach for CNOT gate as the qutrit phase gate. We ﬁrst discuss the performance of the quasi-Newton method for generating policies for designing

CNOT gate where there is enough time for unitary operation or a sucient number of

72 0

−5 (b) r L −10

−15 50 100 150 ı

Figure 5.3: Logarithmic intrinsic inﬁdelity L vs iteration number ı for the CNOT gate using the quasi-Newton method with T =30andK =30((red,solidlines), T =10andK =10(bluelineswith’+’markers)andT =4andK =4(greenlines with ’ ’ markers) [reproduced from ref. [1], Fig. 1b]. ⇥ control parameters. Then we numerically show that reducing the time ⇥ and control parameters K transform the problem into a hard optimization problem and results in runs of the greedy algorithms getting trapped. We then evaluate the performance of evolutionary algorithms when the time is shortened and K is reduced and compare the performance of di↵erent algorithms in terms of their median and best plots and

ﬁnally tabulate the resultant data.

We begin by giving the performance of the fast-convergent quasi-Newton method.

This is a reasonable start since this approach should be the preferred choice when it succeeds to deliver a satisfactory results. Figure 5.3 shows the logarithmic intrinsic inﬁdelity L as a function of ı for the CNOT gate using the quasi-Newton method. { r} Fig. 5.4 depicts the performance of greedy simplex, Krotov and quasi-Newton methods against GA, DE, Common PSO, PSO1, PSO2, and PSO3 algorithms. In particular, we depict best-run performance and median-run performance in terms of ﬁnal L.

These plots are indicative only. A quantitative comparison is summarized in Table 5.2 for median, best-case, and worst-case performance as well as for the percentage of runs }t that exceed Lt over R =40runsforevolutionaryalgorithmsandoverR =80

73 0 (c) 0 (a) (b)(d)

−1 −2 L L −2 −4

−3 −6 0 1000 2000 3000 0 1000 2000 3000 ı ı

Figure 5.4: (a) Median-run performance (b) Best-run performance for the CNOT (⇥ =3.2andK = 4). Logarithmic intrinsic inﬁdelity L vs iteration number ı for ( ) GA, ( )DE,( )CommonPSO,(I)PSO1,( )PSO2,( )PSO3, ⇤ ⇥ ⇤ ⌃ (B) quasi-Newton, (V)simplexand(O)KrotovwithR =80(R =40)forgreedy (evolutionary) algorithms [reproduced from ref. [1], Figs. 2c and 2d].

L GA DE PSO PSO1 PSO2 PSO3 Newton simplex Krotov median -1.2 -2.9 -1.8 -2.4 -2.3 -0.7 -2.4 -1.45 -2.6 best -1.8 -5.5 -2.9 -4.2 -4.7 -1.0 -3.9 -2.4 -3.2 worst -0.7 -2.0 -1.3 -1.9 -1.3 -0.6 -2.0 -0.8 -1.9 }t 015.00 2.510.00 0 0 0

Table 5.2: Median, best-case, worst-case, and }t for logarithmic-inﬁdelity L for the CNOT gate with ⇥ =3.2, K =4,andR =80(R =40)forgreedy(evolutionary) algorithms.

74 runs for greedy algorithms.

5.5.3 CNOT gate: Discussion

Greedy algorithms are the primary choice for generating policy for designing quantum gate because they converge faster than evolutionary algorithms. We show the greedy- algorithm performance in Fig. 5.3 where most quasi-Newton runs converge rapidly within machine precision (L = 15.65) to the target gate for large ⇥ and for small time resolution ⇥/K. For small ⇥ and K, a majority of runs becoming trapped at low ﬁtness (high L) values. Evidently the quasi-Newton method fails (green plots in

Fig. 5.3) for short-time and ﬁne–time-resolution constraints.

For the CNOT gate, whose performance is shown in Figs. 5.4(a, b), all runs become trapped at poor ﬁdelities for the greedy algorithm case, and the GA and various PSO algorithms are also poor. In contrast the DE performance is vastly superior for the

CNOT gate under the extreme conditions of ⇥ =3.2andK = 4. Naturally the greedy and PSO algorithms can be improved by increasing K, and this strategy is common in the quantum control literature, but our aim is to constrain ⇥ and limit the number of control parameters K, and DE is the superior tool for doing so in that it works when the greedy and GA algorithms fail.

In the CNOT case, DE succeeds in providing a satisfactory result (See Table 5.2)

15% of the time whereas this success rate is 2.5% and 10% for the PSO1 and PSO2 cases and zero for other cases. Therefore, this result shows that for short ⇥ and small K there are many local traps in the landscape causing the greedy algorithms to fail.

75 5.6 Discussion on algorithms performance

In all evolutionary algorithms discussed here, DE always outperforms its algorithmic ancestor GA. One might ask why DE performs better than GA [57] on these two spe- ciﬁc quantum control problems and the answer lies in the mechanism of generating the new population from the old population. In GA, parents are selected based on probabilities that lead to individuals with better ﬁtness. The crossover operation combines partial parts of two parents to generate a new o↵spring. As the new o↵spring comes from a combination of two parents, in this sense GA explores the optimal solution around some good solution candidates. GA must perform the mutation operation on the individual with a low mutation probability constant; otherwise it turns into asearchingalgorithmandbecomesinecient. This low mutation probability limits the GA’s ability in searching the whole domain of landscape and thus, might cause

GA to fail with locating the global optimum.

Unlike GA, which converts candidate solutions into a binary format, DE constructs candidate solutions that are represented by real numbers. The crossover operation in

DE generates o↵spring individuals from the entire set of populations so that newly generated o↵spring are always di↵erent from parent individuals. The higher mutation probability in DE, compared to GA, enables DE to explore the search space more eciently while reducing the chance of getting trapped in local minima hence, outperforms GA in term of the quality of the results (See Fig 5.4 and 5.2)

Optimization strategies can be compared in various ways. The most important criterion is whether the optimization approach delivers a satisfactory result. A sec- ondary consideration is the rate of convergence, which is relevant to the run-time.

Of course use of computational space is another consideration. In our case we are most concerned with the primary consideration of whether the optimization works, as determined by whether the threshold inﬁdelity reaches L = 4.

76 As shown in Fig 5.4 and 5.2, the quasi-Newton method converges faster than all other approaches but fails to achieve L = 4. Our message is that the most ecient, fastest optimization strategy should be used as long as it delivers a satisfactory result. If the fastest routine failed, then our analysis of two tightly time-constrained control problems is that di↵erential evolution is an excellent alternative that appears to deliver a satisfactory result even when the other approaches fail.

The fast convergence of quasi-Newton runs in Fig 5.4 and 5.2 raises the tantalizing possibility of whether increasing the number of quasi-Newton runs would result in a small but non-zero success probability }t. A fast algorithm like quasi-Newton with a low probability of success could make it superior to the slow DE approach with ahighsuccessprobability.Totestthishypothesis,wedid500repetitionsof100 quasi-Newton iterations applied to the (CNOT) gate control problem. We chose 100 iterations of quasi-Newton runs as the average “wall time” (the true run time on the given computer) for 100 iterations approximates the average wall time for 40 iterations of the DE method. Our numerical study showed that the quasi-Newton runs never reached L 4. In principle the quasi-Newton method would work with  asucient number of trials simply because the global search would be achieved by a huge number of local searches, but replacing a good global search by extremely many local searches is not feasible in practice.

Finally we emphasize that, when greedy algorithms work, the quantum control strategy should be to employ current practice and use the best available greedy algorithm. When greedy algorithms fail, though, evolutionary algorithms could work and di↵erential evolution is the best amongst these according to our investigation.

This is particularly relevant when exploring quantum speed limits numerically. In view of our results, quantum speed limits found using greedy algorithms reﬂect the limitations of these algorithms rather than intrinsic speed limits for quantum control.

77 5.7 Conclusion

In conclusion we have shown that evolutionary algorithms such as DE and PSO are essential alternatives to greedy algorithms for hard quantum control problems with strong constraints. Greedy algorithms are often used because ﬁtness landscapes are assumed to be well-behaved [30], and traps presumed to be negligible if ⇥ can be long and K can be increased without paying a signiﬁcant price. In such cases greedy algorithms work because most local optima are globally optimal or close enough.

However, when resources are limited, even straightforward control problems for simple systems can become hard due to a proliferation of traps in the landscape and non- convexity, thereby causing greedy algorithms to fail.

We have considered two quantum gates relevant to quantum information and used drift and control Hamiltonians that illustrate our point. These examples show that di↵erential evolution is e↵ective for hard quantum control problems. The superiority of di↵erential evolution over greedy algorithms is unsurprising because the ﬁtness landscape is no longer well behaved for hard quantum control. On the other hand, the superiority of di↵erential evolution over GA and PSO and its variants is due to the greater ecacy of DE for optimization over higher-dimensional search spaces, which is the case for hard quantum control.

78 Chapter 6

Designing High-Fidelity Single-Shot Three-Qubit

Gates

“Design is a funny word. Some people think design means how it looks.

But of course, if you dig deeper, it’s really how it works.”

— Steve Jobs, 1996

6.1 Introduction

Quantum computing requires a universal set of high ﬁdelity quantum gates to enable fault-tolerant quantum computing [144, 19]. A universal set of single- [17] and two- qubit [11] gates can be employed to decompose [20] multi-qubit gates into a series of single and two-qubit gates. In practice, this decomposition-based approach is undesirable because it leads to quantum circuits [21, 22] with long operation times. Here we employ our machine learning technique, named Subspace-Selective Self-Adaptive

Di↵erential Evolution or SuSSADE [2], to generate policies for designing single-shot high-ﬁdelity three-qubit gates without any need to resort to a decomposition. We test our policy in the presence of decoherence-induced noise and demonstrates its robustness under the e↵ect of random control noise. The three-qubit gates that we consider here are To↵oli [145, 146, 147], Fredkin [148, 149] and Controlled-NOT-

NOT (CNOTNOT) [150], which are typical three-qubit gates up to a local unitary transformation.

The three-qubit gates that we consider in this study are essential elements for quantum information processing. A quantum To↵oli gate is an essential element for (non-topological) quantum error correction [21, 22] and a key component for re-

79 versible quantum computing [151, 19]. The To↵oli gate together with the single-qubit

Hadamard gate comprise a universal set of quantum gates [152, 153]. The Fredkin gate enables reversible quantum computing [151, 19], and also forms a universal set along with the Hadamard gate [154]. The CNOTNOT gate appears in the syndrome operator measurement circuit [155] for quantum error correction algorithms like Steane code [26] and surface code [150]. Although the Fredkin and CNOTNOT gates can be decomposed into three and two CNOT gates respectively [11], we want to avoid the decomposition-based approach and generate a policy to design single-shot three-qubit gates which operate in a shorter time.

Thus far, To↵oli and Fredkin gates are achieved by decomposition into single- and two-qubit gates [156, 157, 158] in various physical systems, and yet none of these e↵orts have achieved the threshold ﬁdelity [11]. Hence, here we propose a quantum control scheme (called SuSSADE) for designing single-shot high-ﬁdelity

(> 99.9%) three-qubit (To↵oli, Fredkin and CNOTNOT) gates for an architecture of three nearest-neighbor-coupled superconducting artiﬁcial atoms [11]. For all the three-qubit gates considered in this work we show that our gates operate as fast as atwo-qubitentanglingControlled-Z(CZ)gateunderthesameexperimentalcon- straints.

Recent progress in superconducting artificial atoms [32, 33, 34] has made them appealing for quantum information processing, especially for gate-based quantum computing [35]. An avoided-crossing-based CZ gate [46] has already been achieved for an architecture of superconducting artificial atoms. The idea of avoided-crossing- based gates is to vary the energy levels of artificial atoms such that they approach each other, but avoid degeneracies. These avoided crossings mix population and dynamical phases at the corresponding levels such that the final evolution of the system gives the required phase and population for the target gates.

80 Our strategy to design the three-qubit gates is also based on the avoided-crossing- based gate. We employ the quantum control approach to generate optimal external pulses for the frequencies of the superconducting artiﬁcial atoms. We employ machine learning as a quantum control tool to generate successful policies. We show that our policy can also be implemented in an open quantum system where external noise is also acting on the system.

There exist other approaches to design quantum gates from a network of superconducting transmon systems, where one can couple each transmon with a microwave generator or couple the transmons via tunable couplers and control these external circuit elements to evolve the system toward a speciﬁc unitary operation. These approaches require more resources (additional circuit elements) and longer operation time compared to our approach [2], where we only control the transmon frequency via a quantum control scheme [159, 75] and evolve the system’s dynamics toward the target gate.

The rest of this chapter is organized as follows. In Section 6.2 we explain the physical model that we use to design the three-qubit gates. In Section 6.3 we discuss the avoided-crossing-based gates for two- and three-qubit gates. In particular, we review the current theoretical framework for designing an avoided-crossing-based CZ gates and also discuss why taking the same theoretical approach is challenging for avoided-crossing-based three-qubit gates. In Section 6.4 we discuss our quantum control scheme and show how we translate the problem of designing a three-qubit gate into a learning algorithm. In Section 6.5 we discuss our noise model. In Section 6.6 we discuss each individual three-qubit gate and their e↵ect on a quantum state.

Section 6.7 presents the results. The signiﬁcance of our results come in Section 6.8 and we conclude our work in Section 6.9.

81 6.2 Physical model

Here we consider an architecture of three nearest-neighbor-coupled superconducting artiﬁcial atoms [11] with parameters appropriate for a transmon system [36, 160].

Each transmon k is capacitively coupled to its nearest neighbor where the location of each transmon is labeled by k =1, 2, 3. The shifted frequency "k(t), in the rotating- frame, can be tuned via superconducting control electronics. The anharmonicity of the second and third energy levels are represented by ⌘ and ⌘0. Here we approximate

⌘0 =3⌘ which is valid for qubic anharmonicity [46]. The transmons are coupled capacitively which yields an XY interaction between adjacent transmons (in the rotating frame) with a coupling strength g. The Hamiltonian for three capacitively- coupled transmons is thus [46]

00 0 0

3 0 1 Hˆ (t) 0 "k(t)0 0 = B C h B C k=1 B002"k(t) ⌘ 0 C X B C B C B00 0 3"k(t) ⌘0C B Ck @ A g 2 + (X X + Y Y )(6.1) 2 k k+1 k k+1 Xk=1 where 0 10 0 01 0 0 0 1 0 1 Y 10 p20 10p20 k = B C ,Xk = B C (6.2) i B C B C B0 p20 p3C B0 p20p3C B C B C B C B C B00 p30C B00p30C B Ck B Ck @ A @ A are the generalized Pauli operators [46].

The experimental constrains for the transmons require speciﬁc values for each physical parameter in (6.1). The transmon frequencies are varied between 2.5and

2.5 GHz. We consider ⌘ = 200 MHz and g = 30 MHz. Although the physical

82 system considered for this work consists of superconducting circuits, our quantum control scheme is, however, not limited to a speciﬁc system.

6.2.1 Projected Hamiltonian

The Hamiltonian (6.1) that generates our three-qubit gates act on 43-dimensional

3 Hilbert space H4⌦ . Under the rotating-wave approximation, this Hamiltonian will be a block-diagonal matrix with each block corresponding to a ﬁxed number of excitations. This allows us to reduce the 43-dimensional Hamiltonian to a subspace where at most 3 excitations are present, which is the relevant subspace for three- qubit gates. We deﬁne an operator Om that truncates the Hamiltonian (6.1) up to the mth excitation subspace, and is given by

ˆ ˆ Hp(t)=O3H(t)O3†. (6.3)

We observe that the unitary evolution of the system is una↵ected by this truncation, which is what we expect from a block-diagonal Hamiltonian as mentioned earlier.

6.2.2 Unitary evolution

Here we evolve Hˆp(t)suchthattheresultantunitaryoperatoris ⇥ U(⇥)= exp i Hˆ (⌧)d⌧ (6.4) T p ⇢ Z0 with the time-ordering operator [99]. One should note that U(⇥)isa20 20 T ⇥ unitary operator while the three-qubit gates reside in a 23-dimensional computational subspace. We therefore deﬁne the projection operator P, which projects U(⇥)into the computational subspace of the three-transmon system

Ucb(⇥)=PU(⇥)P†, (6.5) where Ucb is the projected unitary operator. Our goal here is to achieve the speciﬁc three-qubit unitary operation (To↵oli, Fredkin or CNOTNOT) over the duration ⇥, such that the distance between Ucb(⇥)andthetargetthree-qubitgateisminimum.

83 6.2.3 Phase compensation

We evolve the system Hamiltonian (6.4) such that the ﬁnal time evolution operator approaches to the target three-qubit gate modulo some phases that can be compen- sated by local z-rotations on each transmon. This Phase Compensation [161, 46] is performed via the excursions of transmon frequencies and is trivial for superconducting circuits.

To steer the system dynamics towards a speciﬁc entangling gate operation, we deﬁne the equivalence class of a given three-qubit gate Utarget under local z-rotations as U U 0 ,ifU 0 = U U U [46], where target ⌘ target target post target pre

U ( , , ) R ( ) R ( ) R ( ) pre,post 1 2 3 ⌘ z 1 ⌦ z 2 ⌦ z 3

i3 i2 i(2+3) i1 i(1+3) i(1+2) =diag(e ,e ,e ,e ,e ,e

i(1+2+3) e )(6.6)

th with j are the local phases acquired by the j transmon and Rz denotes a unitary single-qubit rotation about the z-axis.

6.3 Three-Qubit gate design: An avoided-crossing level approach

In chapter 4 Sec. 4.3, I have already discussed the theoretical approach in designing a

CZ avoided-crossing level gate. In what follows I explain why providing a theoretical framework for designing three-qubit avoided-crossing-based gates is challenging which is our motivation to devise machine learning techniques to overcome this challenge.

Either in the sudden or in the adiabatic regime, the idea of engineering a pulse for the avoided-crossing-based CZ gate in a superconducting architecture remains the same: Designing a control pulse for the qubit frequency, such that the 11 state mixes | i with the other states in the second excitation subspace, while the states in zero- and single-excitation subspaces remain detuned from each other. However, for practical

84 implementations both sudden and adiabatic regimes are unsuitable for obtaining the threshold ﬁdelity required for the fault-tolerance, and one needs to resort to advanced machine-learning-based techniques to engineer the optimal pulse, which is the primary motivation for our work.

One idea to design three-qubit gates is to couple three transmons via a superconducting cavity, usually referred to as the circuit-QED architecture [162], and tune the transmon frequencies in the dispersive regime such that the time-evolution operator gives rise to the target three-qubit at the end of the operation. Whereas such an approach has already been used to demonstrate a To↵oli gate [22], we do not consider the circuit-QED hardware here as the architecture can only contain a few transmons inside a superconducting cavity, and therefore is not scalable. Instead, we consider aone-dimensionalchainofthreetransmonswithnearest-neighborcoupling.Tosee if such an approach is suitable for avoided-crossing-based three-qubit gates, we first plot the energy spectrum of such a three-transmon system in Fig. 6.1, where we fix the frequencies of the first and third transmons to 4.8 and 6.8 GHz, respectively, and vary the frequency of the second one from 4.5 to 7.5 GHz. We also set g = 30MHz and ⌘ = 200 MHz.

In contrast to the two-qubit case, the energy spectrum of a three-transmon system is crowded with many level-crossings (or anticrossings in the presence of interactions).

For this system, therefore, ﬁnding optimal pulses theoretically for the transmon frequencies, such that the 111 state mixes strongly with the other states in the third | i excitation subspace, while all the other states are detuned from each other is a challenging task, which is why we employ our quantum control scheme and in particular our machine learning technique to devise a policy for designing such three-qubit gates [2].

85 40

24 (GHz) 16 E/h

0 4.5 5.5 6.5 7.5 "3(t) (GHz)

Figure 6.1: The energy (E)spectrumofthreenearest-neighbor-coupledtransmons. The ﬁrst and third transmon frequencies are ﬁxed at 4.8and6.8 GHz respectively. The frequency of the second transmon varies from 4.5to7.5 GHz

6.4 Quantum control

In this section we quickly review how to turn a three-qubit gate design problem into a quantum control problem. We then discuss the supervised machine learning technique and clarify our choice of training set and hypothesis. We explain our choice of conﬁdence function for the supervised learning at hand. We explain how improving conﬁdence is a feasibility problem and discuss our choice of optimization algorithms to tackle this feasibility problem.

6.4.1 Three-Qubit gate design: A quantum control approach

As we explained earlier, a chain of three capacitively-coupled transmons constitute our physical model for the three-qubit gates. This physical system evolves according to (6.4) and our goal is to steer the evolution toward the target three-qubit gate operation. In order to turn the problem into a quantum control problem, we need to

86 clarify what are the control parameters. Here the control parameters are the qubit frequencies which can be tuned via external pulses. The task of ﬁnding the optimal shape for the external pulses can be performed via quantum control schemes. Machine learning can be employed as a quantum control tool to perform this task.

6.4.2 Supervised machine learning: A quantum control tool

Chapter 3 gives a comprehensive description of how a quantum control problem can be transformed into a supervised learning problem. Given the training set and the choice of the hypothesis, the task of the supervised machine learning is to generate policies for designing high-ﬁdelity three-qubit quantum gates. Here the training set is the truth-table data for each three-qubit gate. We give the mathematical representation of the truth-table for each three-qubit gate in Sec. 6.6 where we present the circuit model of each gate as well. The next two parts discuss our choice of hypotheses and our learning algorithm conﬁdence criteria.

6.4.3 Control pulses as learning parameters

Here we consider two types of pulses: piecewise-constant and piecewise-error-function as the hypothesis for our machine learning algorithm (See chapter 3, Subsec. 3.5). In general, designing smooth pulses are computationally more expensive than piecewise- constant functions. We therefore choose the less expensive piecewise-constant functions to analyze the gate ﬁdelity against various parameters. We justify this choice by showing that the gate ﬁdelity does not depend on the type of pulse, but depends on the number of learning parameters.

6.4.4 Conﬁdence or ﬁtness functional

The standard method to measure the performance of a supervised learning algorithm is to define a confidence for the learnt hypothesis. The confidence is the ratio of the

87 number of training data that are learnt successfully to the total number of training data. If the learning task is to generate a policy for designing a quantum gate, one can deﬁne this conﬁdence, , by the distance between target and approximated unitary F operators:

= PU(⇥)P† U (6.7) F || target|| with the operator norm and therefore is the trace distance [102] between the k • k F target and actual evolution operators projected to the computational subspace.

Our machine learning algorithm uses an explicit form of (6.7), where

1 = Tr U † U (⇥) . (6.8) F 8 target cb ⇣ ⌘ Note that =1ifU (⇥)correspondstothetargetthree-qubitgate U (To↵oli, F cb target Fredkin or CNOTNOT) and 0 < 1otherwise.  F In the context of quantum gate design, the confidence functional is called the F intrinsic fidelity which refers to the fidelity between the unitary evolution of the closed quantum system of (6.1) and the target operation when the decoherence noise is ignored. Here we follow the standard practice of gate design by first considering a closed quantum system and generating a successful policy for the learning task, and then evaluate the performance of generated policy in the presence of noise. We call the confidence of our learnt hypothesis in the presence of noise the average state fidelity and denote it by ¯. We will elaborate on the average state fidelity in Section 6.8.3, F where the noise model is discussed in detail.

6.4.5 Machine Learning and optimization algorithms

For a gate design problem, one can turn the problem of finding a successful policy into afeasibilityproblembysettingthefidelitybetweentheobtainedunitaryoperation and the target gate to a fixed value that is acceptable by fault-tolerant quantum computing. All policies that result in an error within the threshold value are called

88 feasible (successful) policies. Various optimization algorithms can be employed to tackle this feasibility problem.

Greedy algorithms [163, 31, 164] are at the heart of the machine learning techniques. Given a quantum control system with no physical constraints, ﬁnding a feasible policy is a trivial task for greedy-algorithms [30]. However we have already shown in [1] that reducing either gate operation time ⇥ or number of control parameters harden the quantum control problem. In order to design high-ﬁdelity three-qubit gates, we have examined the existing quantum control schemes including the quasi-

Newton [105, 106, 107, 108, 109] and Nelder-Mead [47] algorithms (greedy) as well as DE [56] and Particle Swarm Optimization [143] algorithms (non-greedy). We observed that all these schemes fail to generate a ﬁdelity better than 99% with the best ﬁdelity related to DE for designing the CNOTNOT gate. Therefore we enhance

DE by introducing modiﬁcations into its standard version to enable feasible policies that lead to intrinsic ﬁdelity beyond 99.99%. In the next part, I discuss our machine learning approach, which is called the Subspace-Selective Self-Adaptive Di↵erential

Evolution (SUSSADE).

6.4.6 Subspace-Selective Self-Adaptive Di↵erential Evolution

There are two approaches to ﬁnding the optimal algorithmic-parameters (µ, ⇠)for

DE (See chapter 3). One can run DE with many initial guesses to ﬁnd the optimal parameters. This method is computationally expensive as it needs many trial runs of

DE. This method also does not propose a general solution to the problem of ﬁnding the algorithmic-parameters because a new set of trail runs are needed if the learning problem is changed. An alternative approach is to self-adaptively [165] change the

89 parameters at each generation G as follows:

µl + r1.µu if r2 < 1 µi,G+1 = 8 (6.9) > <>µi,G otherwise > and :>

r3 if r4 < 2 ⇠i,G+1 = 8 (6.10) > <>⇠i,G otherwise, where rj, j 1, 2, 3, 4 are random numbers> uniformly sampled from (0,1], and µl, 2{ } :

µu, 1 and 2 are assigned to ﬁxed values of 0.1, 0.1, 0.1and0.9, respectively. While using a self-adaptive version of DE improved the obtained ﬁdelity up to 0.993, the result is still sub-threshold because of the high dimensionality of the learning problem.

Therefore the next step is to enhance the self-adaptive DE using the cooperative coevolution (CC) approach [166].

CC decomposes a high-dimensional problem into problems over several subspaces and evolves each sub-component of the original high-dimensional problems using a choice of EA. CC then cooperatively combines the solution of each sub-component to form the ﬁnal solution. There are several methods to decompose the high-dimensional problem into smaller sub-components [166, 167, 168, 169]. The easiest method is to decompose a K-dimensional problem into K one-dimensional problems and evolve each component using EA. This approach has its own drawbacks originating from ignoring the interdependencies between variables. One alternative method is to split the problem dimension in two halves and evolve each half over the course of the learning process. However should K be high, K/2isalsohigh,andthereforetheproblem of high dimension is not addressed properly. Here we take a di↵erent approach in decomposing the high-dimensional problem. Our approach is inspired by Di↵erential

Evolution with Cooperative Coevolution (DECC-II) [170]. Here we ﬁrst give a short description on DECC-II and then explain our enhanced version of DE.

90 DECC-II decomposes a K-dimensional problem into m-dimensional subspaces and run the learning algorithm on a subspace for a fixed number of cycles s while keeping the other subspaces unchanged. DECC-II combines the CC with Self-Adaptive DE with Neighborhood Search (NSDE) to address two issues: the slow-convergence of DE and finding the optimal algorithmic parameters. Using DECC-II in its original form did not improve the fidelity and the run-time and convergence of DE still remained slow for our case, as evaluating the fitness function is computationally expensive. We also found our result to be influenced by the choice of s and m and finding the optimal values of these parameters needed additional computational resources and trial runs, and even with this overhead the threshold fidelity was not achieved.

Inspired by the DECC-II algorithms, we set s =1andchoosethedimensionof subspace based on a random projection over the m-dimensional subspace with m 1, 2{ 2, 3, 4, 5 . Now, there is no need to look for the optimal values of s and m to perform } the optimization. This new strategy, however, makes the convergence slower, as in each generation, only a small part of the candidate solutions are being selected for the optimization. In order to enhance the convergence, our algorithm randomly switches breeding between the subspace and the whole space according to the value of an input switch parameter S [0, 1], such that a uniformly distributed random number 2 r [0, 1] at generation j restricts breeding to the subspace, if r

91 6.5 Noise model

In order to incorporate decoherence into our system’s evolution, we model each transmon as a harmonic oscillator su↵ering from environmental e↵ects [171]. The decoherence of each harmonic oscillator is represented by two damping rates: amplitude and phase damping with the corresponding amplitude relaxation time T1 and dephasing time T2. In order to make the noise model simpler, we assume T =T1=T2, which is a valid assumption for transmons with tunable frequency [46]. Equation (6.4) expresses the system evolution in the absence of decoherence. In the presence of noise we model the system evolution by the time-dependent density matrix which is decomposed in terms of the sum of Kraus matrices as [19] Qk n ⇢(t)= (t)⇢(0) † (t), (6.11) Qk Qk Xk=0 with Kraus matrices being the operation elements (E)forthequantumoperation⇢(t)

(See chapter 2 Sec. 2.8).

We ﬁrst discuss the construction of the Kraus matrices for each transmon. Con- structing the Kraus matrix representation for a system of three capacitively coupled transmons, will then be straitforward by performing all the possible tensor products of three transmons. Here we also assume that the decoherence only a↵ects each individual transmon separately.

6.5.1 Amplitude damping

In [171], Liu et al. formulate the Kraus matrix representation of amplitude damping of a single qubit (treated as a truncated harmonic oscillator) coupled to the environment, which is modeled as multimode oscillators. One can easily generalize this approach to represent the Kraus representation of amplitude damping of a single transmon

(modeled as a four-modal harmonic oscillator) coupled to the environment modeled

92 as multimode oscillators, where

3 j l l j t 2 t 2 T T Ql(t)= e 1 1 e 1 j l j (6.12) s l | ih | Xj=l ✓ ◆ ⇣ ⌘ ⇣ ⌘ with l 0, 1, 2, 3 denotes the Karus matrices and exp( t/T )representstheampli- 2{ } tude damping factor, which decays exponentially with the timescale T1.

6.5.2 Phase damping

We represent the Kraus matrix representation of the phase damping of a single transmon (with four energy levels) coupled to the environment [171] as

3 2 2 l j t (j t/T2) Ql(t)= exp j j , (6.13) 2T l! | ih | j=0 2 r X ⇢ with l 1, 2, 3, 4 . Ql denotes the Kraus matrices and T2 indicates the timescale 2 { } for dephasing. In both equations (6.12) and (6.13), we need to put an upper bound on the Kraus-Matrix index l to enable numerical simulation of decoherence. Such an upper bound would violate the completeness relation (2.14). However, if the evolution time of the quantum system t is much smaller than the coherence time T , the higher order terms in (6.12) and (6.13) will damp exponentially with respect to the t/T .

As in our case t T , we only consider l up to three for both amplitude and phase ⌧ damping, and discard the higher order terms in our numerical calculation as they have negligible e↵ects.

6.6 Three-Qubit logical gates

In this section we give the details of the To↵oli, Fredkin and CNOTNOT gates. We give the circuit model of each gate as well as the truth tables showing how the basis states transform under the actions of these gates.

93 H# Z H#

Figure 6.2: The quantum circuit representation of the To↵oli (CCNOT) gate (left), which is equivalent to the CCZ gate up to a local transformation of two Hadamard gates (right). The horizontal solid black lines are circuit wires, shows the control qubits and denotes the Pauli-X operator acts on the target qubit.• The boxes with Z and H denote the Pauli-Z and Hadamard gates. L 6.6.1 To↵oli

Fig. 6.2 demonstrates the circuit representation of the To↵oli gate and its equivalent

CCZ gate (See Sec. 2.4.3 for more details on To↵oli gate). In order to design the

To↵oli gate, here we only show how to implement the CCZ gate, since the Hadamard gates can be performed fast in superconducting circuits as presented in [172, 17]. In our supervised learning, the truth table of the CCZ gate represents the training set.

One can deﬁne the truth table of the CCZ gate based on its action on the three-qubit basis states (See Table 6.1). In this table C1 and C2 represent the states of the ﬁrst two (control) qubits and T denotes the target qubit. The columns under the Input and Output show the state of the three qubits before and after applying the CCZ operation.

So far, the design of a high ﬁdelity To↵oli gate has been investigated in several physical systems with the achieved ﬁdelities limited to 81% in a post-selected pho- tonics circuit [173], 71% in an ion trap system [145], 68.5% in a three-qubit circuit

QED [146] and 78% in a four-qubit circuit QED [22]. We recently proposed a quantum control approach to design a high ﬁdelity (>99.9%) To↵oli gate for an architecture of three nearest-neighbor-coupled transmons [2]. In this work we ﬁrst review our

94 Input Output C1 C2 T C1 C2 T 0 0 0 0 0 0 |0i |0i |1i |0i |0i |1i |0i |1i |0i |0i |1i |0i |0i |1i |1i |0i |1i |1i |1i |0i |0i |1i |0i |0i |1i |0i |1i |1i |0i |1i |1i |1i |0i |1i |1i |0i |1i |1i |1i |1i |1i -| 1i | i | i | i | i | i | i Table 6.1: The truth table representation of CCZ gate. C1 and C2 denote the control qubits and T represents the target qubit. The columns under the Output and Input columns show the states of the three qubits before and after applying CCZ approach to designing a high-ﬁdelity To↵oli gate and then discuss the performance of our quantum control scheme on designing other three-qubit gates such as the Fredkin and the CNOTNOT gates.

6.6.2 Fredkin

The Fredkin gate (See Fig. 6.3) is an excitation-number-preserving operation, where the output state has the same number of excitations as that for the input states. It is also a self-inverse operation, which means applying two consecutive Fredkin gates generates the Identity operation. Fredkin gate is universal for reversible classical computation, as it can be used to construct any other reversible classical logic gates [73].

For quantum computing, however, the Fredkin along with the Hadamard gate forms a universality class (See Sec. 2.4.3 for more details on Fredkin gate).

We can represent the truth table of the Fredkin gate, as shown in Table 6.2. In this representation the C denotes the control qubit and T1 and T2 represent the target qubits. This truth table provides the training set for the Fredkin gate for supervised learning. The columns under the Output and Input show the states of the three qubits before and after applying the Fredkin gate.

Proposals to implement the Fredkin gate are mainly restricted within the linear

95 Figure 6.3: The quantum circuit representation of Fredkin (Controlled-Swap) gate. The horizontal solid back line is the circuit wire, denotes the control qubit and the big cross sign shows the SWAP gate which acts• on the target qubits (second and third qubits).

Input Output C1 C2 T C1 C2 T 0 0 0 0 0 0 |0i |0i |1i |0i |0i |1i |0i |1i |0i |0i |1i |0i |0i |1i |1i |0i |1i |1i |1i |0i |0i |1i |0i |0i |1i |0i |1i |1i |1i |0i |1i |1i |0i |1i |0i |1i |1i |1i |1i |1i |1i |1i | i | i | i | i | i | i Table 6.2: The truth table representation of Fredkin gate. C1 and C2 denote the control qubits and T represents the target qubit. The column under the Output and Input columns show the state of the three qubits before and after applying the Fredkin gate. and non-linear optical systems, and there has been no proposals yet for a single-shot

Fredkin gate with superconducting circuits. Here we employ our quantum control scheme to design a fast single-shot high-ﬁdelity Fredkin gate for an architecture of three nearest-neighbor-coupled superconducting transmon systems.

6.6.3 CNOTNOT

The CNOTNOT gate is a three-qubit gate which applies Pauli-X operations on the second and third qubits when the ﬁrst qubit is at state 1 , and otherwise leaves the | i

96 state of the qubits unaltered. CNOTNOT gate is equivalent to the Controlled-Z-Z

(CZZ) gate up to local Hadamard operations on both the second and the third qubits:

CNOTNOT = [1 H H] CZZ [1 H H](6.14) ⌦ ⌦ ⌦ ⌦ The CZZ gate is a three-qubit gate which applies a Pauli-Z operation on the second and the third qubits, if and only if, the ﬁrst qubit is 1 . In order to design the | i CNOTNOT gate, here we also assume that the implementation of fast and high-

ﬁdelity Hadamard gates are trivial for superconducting circuits [172, 17], hence, we employ our quantum control scheme to design the high ﬁdelity CZZ gate.

CZZ gate can easily be constructed by consecutive operations of two CZ gates.

A high ﬁdelity CZ gate has already been realized with a gate time of about 26 ns.

Therefore, a high ﬁdelity CZZ gate decomposed into two consecutive CZ gates can be readily designed with a gate operation time no longer than 52 ns. However, a CZZ gate with a shorter operation time is more interesting for quantum computing or quantum error correction, which motivates us to employ our quantum control scheme for this problem.

The truth table representation of a CZZ gate is shown in Table 6.3. In this table,

C1 denotes the control qubit and T1 and T2 represent the target qubits. We use the truth table data as the training set to train the qubit frequencies (our hypothesis).

The columns under the Input and Output show the states of the qubits before and after applying the CZZ gate.

6.7 Results

Here we give the results for designing single-shot high-ﬁdelity three-qubit gates: Tof- foli, Fredkin and CNOTNOT. For each gate we ﬁrst give the optimal piecewise- constant and piecewise-error-function pulses which guide the system evolution to-

97 Input Output C1 T1 T2 C1 T1 T2 0 0 0 0 0 0 |0i |0i |1i |0i |0i |1i |0i |1i |0i |0i |1i |0i |0i |1i |1i |0i |1i |1i |1i |0i |0i |1i |0i |0i |1i |0i |1i |1i |0i -| 1i |1i |1i |0i |1i -| 1i |0 i |1i |1i |1i |1i |1 i |1i | i | i | i | i | i | i Table 6.3: The truth table representation of CZZ gate. C1 denotes the control qubit and T1 and T2 represent the target qubits. The columns under the Output and In- put show the states of the three qubits before and after applying CZZ

H# Z H#

Figure 6.4: The quantum circuit representation of the Controlled-NOT-NOT (CNOTNOT) gate (left), which is equivalent to the CZZ gate up to local Hadamard gates (right). The horizontal solid black lines are circuit wires, represents the control qubit and denotes the Pauli-X operator acting on the• target qubit. The boxes with Z and H denote the Pauli-Z and Hadamard operations, respectively. L wards the threshold-ﬁdelity gates. We then investigate the dependence of intrinsic

fidelities on the coupling strength between transmons. We test the robustness of our optimal pulses by applying uniformly distributed random noise on each of the learning parameters and then calculating the intrinsic fidelity in the presence of such noises. Finally, we give the results for the average state fidelities in the presence of decoherence-induced noises.

98 6.7.1 To↵oli

In Fig. 6.5 we give a set of optimal pulses that guide the system evolution (6.4) towards a high-ﬁdelity To↵oli gate. Fig. 6.5A shows the optimal transmon frequencies for piecewise-constant pulses. The time resolution for each piecewise-constant pulse is set to 1 ns. Connecting the black dots via the error function (3.7) and running the

SuSSADE for the smooth control pulses, we come up with the shaped smooth pulses that are depicted in Fig. 6.5B. We used the same number of learning parameters to design the piecewise-constant pulses or piecewise-error-function pulses. The To↵oli gate which is obtained under the control pulse in Fig. 6.5 has a ﬁdelity higher than

0.999 and an operation time of 26 ns.

We explore the dependency of the intrinsic ﬁdelity over the time of the system evolution by ﬁxing the coupling strength, g, to various values and running the SuS-

SADE for the less-computationally expensive piecewise-constant pulses. The control pulses are discretized into equally-spaced time intervals of 1 ns which give rise to learning problems with di↵erent learning parameters. For each curve in Fig. 6.6A the discretized points show the actual numerical data and the curves depict the cubic interpolation through the actual data. Fig. 6.6B shows the relation between the coupling strength and the inverse of the gate operation time for the intrinsic ﬁdelity

ﬁxed at 0.999.

Fig. 6.7 shows the change in the ﬁdelity against the coherence time, T (assuming

T1 = T2 = T as noted earlier). Here we first employ the piecewise-constant pulses profile to calculate the intrinsic fidelity. The resulted intrinsic fidelity under the piecewise-constant pulse is better than 0.9999. The optimal pulse then evolves the system in the presence of decoherence under the amplitude- and phase-damping for each transmon. The actual numerical data is represented by the dots and the resultant curve is the cubic interpolation of the actual data.

99 A 2.5 ε 1 ε 2 ε 3

(GHz) 0 3 , 2 , 1 "

−2.5 0 5 10 15 20 26 ⌧ (ns) B

2.5 ε 1 ε 2 ε 3 (GHz)

3 0 , 2 , 1 "

−2.5 0 5 10 15 20 26 ⌧ (ns)

Figure 6.5: Optimal pulses for designing To↵oli gate with the resultant ﬁdelity better than 0.999 and the gate operation time of 26 ns. Transmon frequencies, "i, are varied from -2.5 to 2.5 GHz, which are within the experimental constraint of transmon implementation. The black dots denote the learning parameter for SuSSADE. A) The piecewise-constant pulses for each transmon frequency. B) The piecewise-error-function pulses for each transmon frequency [reproduced from ref. [2], Fig. 1].

100 A B 0.9999 0.044 0.99

0.97 0.042 0.95 (ns) F g=20MHz 0.93 g=30MHz

1/ 0.04 g=40MHz g=50MHz

0.89 0.038 20 22 24 26 28 20 30 40 50 (ns) g (MHz)

Figure 6.6: A) The dependence of intrinsic fidelity for the To↵oli gate on the evolution time ⌧ for various values of g. The discretized values show the actual numerical data with ⌃, , ,and⇤ corresponding to the values of g to be 20, 30, 40, 50 MHz, respectively.4 A cubic interpolation fits the curves to the data. B) The relation between the inverse of the gate operation time and coupling strength between transmons, where the dots denote the actual numerical results for various values of g 20, 30, 40, 50 . A linear-fit interpolates the data points. [reproduced from ref. [2],2 Fig.{ 2]. }

0.9998

0.9996 ¯

F 0.9994

0.9992

0.999 20 30 40 50 60 T (µs)

Figure 6.7: The ﬁdelity versus the coherence time for the To↵oli gate. The dots denote the actual numerical data and the blue solid line shows a cubic-ﬁt interpolation on the actual data. [reproduced from ref. [2], Fig. 3].

101 1 0.9999

0.9997 F

0.9995

0.9992 0 1 2 3 x 10−3 "1,2,3 (GHz)

Figure 6.8: Intrinsic ﬁdelity of the To↵oli gate as a function of " for CCZ gate. The vertical red dotted-line denotes the threshold,F such that > 0.9999 on the left of the dotted line. F

We also study the robustness of the designed pulse against the random noise on the learning parameters. In order to test the robustness we choose a sample optimal pulse (for example Fig.6.5) and add random values (" rand(-1,1)) to the learning ⇥ parameters at each time-bin, with " varying from 0 to 3000 KHz. We then use the distorted pulse to calculate the intrinsic ﬁdelity for each value of ". Figure 6.8 shows the change in the intrinsic ﬁdelity originating from such random noise on learning parameters.

6.7.2 Fredkin

We employ our quantum control scheme, SuSSADE, to design a high-ﬁdelity Fredkin gate for an architecture of three nearest-neighbor-coupled superconducting transmons. The system Hamiltonian evolves over 26 ns under the piecewise-constant pulse

(See Fig. 6.9A), where the ﬁnal evolution approximates a Fredkin gate with an intrinsic ﬁdelity of =0.9999. We also show a more realistic piecewise-error-function pulse F in Fig. 6.9B. Our learning algorithm uses the same number of learning parameters to shape the transmon frequencies through the learning procedure.

102 A

2.5 ε 1 ε 2 ε 3

(GHz) 0 3 , 2 , 1 "

−2.5 0 5 10 15 20 26 ⌧ (ns) B 2.5 ε 1 ε 2 ε 3

(GHz) 0 3 , 2 , 1 "

−2.5 0 5 10 15 20 26 ⌧ (ns)

Figure 6.9: Optimal pulses for designing Fredkin gate with the resultant ﬁdelity better than 0.999 and the gate operation time of 26 ns. System frequencies, "i, are varied from -2.5 to 2.5 GHz, which are within the experimental requirements of transmon implementation. The black dots denote the learning parameters for SuSSADE. A) The piecewise-constant pulse for each transmon frequency. B) The piecewise-error-function pulses for each transmon frequency.

103 B A 0.044 0.9999

0.97 0.042 0.95 (ns)

F 0.93 g=20MHz

=30MHz 1/ 0.04 0.91 g g=40MHz =50MHz 0.89 g

0.87 0.038 20 22 24 26 28 20 30 40 50 (ns) g (MHz)

Figure 6.10: A) The dependence of intrinsic fidelity of the Fredkin gate on the evolution time ⌧ of the system for various values of g. The discretized values show the actual numerical data with , ⇤, , ⌃ corresponding to the values of g to be 20, 30, 40, 50 MHz, respectively.4 A cubic interpolation fits the curves to the data. B) The relation between the inverse of the gate operation time and coupling strength between transmons where the dots denote the actual numerical results for various values of g 20, 30, 40, 50 . A linear fit interpolates the points to the actual data. 2 { }

In order to show that the ecacy of our quantum control approach does not depend on the type of the gate, we conduct the same analyses on the Fredkin gate as we did for To↵oli. In Fig. 6.10A we analyze the change in intrinsic fidelity with the gate operation time for di↵erent values of the coupling strength. In Fig. 6.10B we fix the intrinsic fidelity at =0.999 and compute the relation between coupling F strength and the inverse of the gate operation time, where the points on the curve show the actual numerical data, and the solid line is the cubic-fitted interpolation plot.

Figure 6.11 shows the evolution of the system under the decoherence. We set g = 30 MHz and evolve the system towards the Fredkin gate with an intrinsic ﬁdelity higher than =0.9999. Then we apply our noise model on each transmon to analyze F how the ﬁdelity changes over the coherence time, T , of each transmon. Under our noise model each transmon goes under amplitude- and phase-damping, and we assume

T = T1 = T2 for tunable transmons.

104 0.9998

0.9994 ¯ F

0.999

0.9986 20 30 40 50 60 T (µs)

Figure 6.11: The ﬁdelity versus the coherence time for the Fredkin gate. The dots denote the actual numerical data and the red solid line shows a cubic-ﬁt interpolation on the actual data.

Figure 6.12 shows the e↵ect of random noise on the learning parameters of the

Fredkin gate. Here we choose the optimal pulse shown in Fig.6.9 and apply random noise up to 3000 KHz on the learning parameters. We then use the distorted pulse to investigate the change in the intrinsic ﬁdelity as a function of the applied random noise.

6.7.3 Controlled-NOT-NOT (CNOTNOT)

Fig. 6.13A shows the piecewise-constant pulse generating a high-fidelity CZZ gate in 31 ns with an intrinsic fidelity higher than 0.9999. Here we have 31 learning parameters for each pulse (93 in total) to design the pulse shapes for the transmon frequencies. Under the piecewise-error-function pulse (shown in Fig. 6.13B), the system evolution approximate CZZ gate with a fidelity higher than 0.9999 in the same gate operation time as the piecewise-constant pulse. In designing the optimal pulses in Fig. 6.13 we set g = 30 MHz.

We perform the same analysis on the dependence of intrinsic ﬁdelity on the gate operation time, as we did for To↵oli and Fredkin gates. The analysis is performed for

105 1 0.9999

0.9997 F

0.9996

0.9994 0 1 2 3 x 10−3 "1,2,3 (GHz)

Figure 6.12: Intrinsic fidelity versus the random noise applied on the optimal pulse of the Fredkin gate. TheF vertical red dotted-line denotes the threshold, such that on the left side of the line > 0.9999. F various values of coupling strengths and is shown in Fig. 6.14A. The discrete points on the plot show the actual data and the curves are the cubic-fit to the data. Fig. 6.14B represents the relation between the inverse of the gate operation time and coupling strength. The discrete points on the plot show the actual numerical data and the solid line is the liner fit to data.

Figure 6.15 shows the decoherence-induced noise for the CZZ gate. We plot the

ﬁdelity versus the transmon coherence time. The actual discrete points are connected via a linear interpolation. Similar to the To↵oli and Fredkin gates, the decoherence appears in terms of the amplitude- and phase-damping of the transmons. Here the coupling strength is g = 30MHz.

We follow the same procedure as for the To↵oli and Fredkin gates to test the robustness of our designed pulse for the CZZ gate. Here we employ the optimal pulse in Fig. 6.13 and apply random noise on each learning parameter. Figure 6.16 shows the e↵ect of such random noises on the intrinsic ﬁdelity of the CZZ gate which operates in 31 ns.

106 A 2.5 ε 1 ε 2 ε 3

0 (GHz) 3 , 2 , 1 "

−2.5 0 5 10 15 20 25 31 ⌧ (ns)

B 2.5 ε 1 ε 2 ε 3

(GHz) 0 3 , 2 , 1 "

−2.5 0 5 10 15 20 25 31 ⌧ (ns)

Figure 6.13: Optimal pulses for designing CZZ gate with the resultant ﬁdelity better than 0.999 and the gate operation time of 31 ns. System frequencies, "i,vary from -2.5 to 2.5 GHz which are within the experimental constraints of transmon implementation. The black dots denote the learning parameter for SuSSADE. A) The piecewise-constant pulses for each transmon frequency. B) The piecewise-error– function pulses for each transmon frequency.

107 A B 1 0.044

0.95 0.042 g=20MHz

=30MHz (ns) F 0.9 g

g=40MHz =50MHz g 1/ 0.04 0.85

0.8 0.038 26 28 30 32 20 30 40 50 (ns) g (MHz)

Figure 6.14: A) The dependence of the intrinsic fidelity of the CZZ gate on the evolution time ⌧ of the system for various values of g. The discretized values show the actual numerical data with ⌃, , ,and⇤ corresponding to the values of g to be 20, 30, 40, 50 MHz, respectively.4 A cubic interpolation fits the curves to the data. B) The relation between the inverse of the gate operation time and coupling strength between transmons where the dots denote the actual numerical results for various values of g 20, 30, 40, 50 . A linear-fit interpolates the points to the actual data. 2 { }

0.9996

0.9992 ¯ F

0.9988

0.9984 20 30 40 50 60 T (µs)

Figure 6.15: The ﬁdelity versus the coherence time for the CZZ gate. The dots denote the actual numerical data and the red solid line shows a cubic-ﬁt interpolation on the actual data.

108 1

0.9998 F

0.9996

0.9994 0 1 2 3 x 10−3 "1,2,3 (GHz)

Figure 6.16: Intrinsic ﬁdelity versus " for CZZ gate. The vertical red dotted-line denotes the threshold, such thatF on the left side of this line > 0.9999. F 6.8 Discussion

We employed a linear architecture of three superconducting artiﬁcial atoms to design single-shot high-ﬁdelity three-qubit gates, such as To↵oli, Fredkin and CNONTNOT.

Our results include the optimal pulses for each three-qubit gate, analysis of the dependence of the intrinsic fidelity on the physical model parameters, and analysis of performance of these gates under decoherence-induced noises. In this section, we discuss the results for all three gates. We first elaborate on our choice of the control pulses. Then we discuss the dependence of fidelities for three-qubit gates on the physical model parameters, and finally we discuss the noise.

6.8.1 Control pulses

Here to formulate the problem of designing the high ﬁdelity quantum gates into a learning algorithm. We represent the qubit frequency in terms of external control functions. The choice of the control function is ubiquitous and here we choose two pulse proﬁles, piecewise-constant and error-piecewise-constant, which are relevant for superconducting control electronics. Our learning algorithm shapes the external

109 pulses to obtain high-ﬁdelity quantum gates. Each of these control pulses has its own advantage and drawback in terms of the computational resources and practical implementation.

The piecewise-constant control functions are computationally less expensive, and on average, a single run of our learning procedure using the square pulse takes an order of magnitude less run-time in contrast to the piecewise-error-function pulses.

Piecewise-constant pulses are easy to generate using the current superconducting control electronics. However, the gaussian ﬁlters connecting the control electronics and the physical qubits cause distortion on the square pulses. Transmons thus, receive a distorted pulse. A smooth pulse must, therefore, be generated to account for the

ﬁrst order of distortion numerically.

The piecewise-error-function connects the control parameters smoothly such that it approximates the realistic control pulses for a transmon system. In this way we overcome the problem of infinite bandwidth of the square pulses as well as the first order distortion. We have numerically shown that (See Figs. 6.5, 6.9 and 6.13) the learning procedure does not depend on the shape of the control pulse, but, depends on the number of learning parameters. For designing each high-fidelity three-qubit gate, we used the same number of learning parameters either for the piecewise-constant or piecewise-error-function pulses. For To↵oli and Fredkin gate, we used 3 26 pa- ⇥ rameters to design the gates, which operate on 26 ns using either piecewise-constant or piecewise-error-function pulses (See Figs. 6.5, 6.9). The number of learning parameters to design a CZZ gate (6.13), which operates over 31 ns, is 31 3forboth ⇥ piecewise-constant and piecewise-error-function pulses.

6.8.2 Intrinsic ﬁdelity

In Figs. 6.6A, 6.10A, and 6.14A, we plot the fidelity as a function of the gate operation time for various values of g 20, 30, 40, 50 MHz. Keeping the value of g 2 { } 110 fixed, the fidelity is a monotonically increasing function of the gate operation time.

This is consistent with the notion that increasing the evolution time of the system increases the ﬁdelity between the unitary evolution and the target gate that has also been obtained for the two-qubit gates [2]. As the coupling strengths become stronger, the gate operation time to reach to a threshold ﬁdelity becomes shorter.

This is consistent with the idea of avoided-crossing-based gates (See 4.7). For smaller values of g, the gate operation time becomes longer, and ﬁxing the time-bin to 1 ns, the number of learning parameters increases. Our learning algorithm still delivers high-ﬁdelity gates despite the increase in the number of the learning parameters.

In Figs. 6.6B, 6.10B, and 6.14B, we have shown that there exists a linear relation between the inverse of the gate operation time and coupling strength. Providing a theoretical framework to explain this relation is a challenging task for three-qubit gates. However, from our discussion for avoided-crossing-based CZ gates (Sec. 4.3), one can intuitively expect a linear relation between the coupling strength and the gate operation time for a ﬁxed intrinsic ﬁdelity, even for three-qubit avoided-crossing-based gates. This linear relation also emphasizes the ecacy of our learning algorithm to discover the correct relation between the coupling strength and gate operation time.

6.8.3 Noise

In this section, we explain the e↵ects of noise on the system evolution of each three- qubit gate in three parts. In the ﬁrst part, we discuss the e↵ect of random noise on the system and discuss the robustness of our policy. In the second part, we explain the e↵ects of decoherence-induced noises, which are caused by the environment. In the last part of this section, we discuss how the higher orders of noise on the generated policy can be suppressed.

111 Robustness

We test the robustness of our policy for designing the three-qubit gates by applying random noise on the learning parameters. Our analysis shows that the devised policies to design To↵oli, Fredkin and CZZ gates are robust against external random noise, if the magnitude of the random noise is lower than 800, 600 and 1500 KHz respectively, which are within the limits of current state-of-the-art superconducting control-electronics [62].

Decoherence-induced noise

1 1 Here the amplitude-damping and dephasing rates (T1 and T2 )determinethede- coherence rate of our three-transmon system. Assuming T = T1 = T2 for all the tunable transmon devices, we can plot ¯ versus the coherence time of the transmons F (See Figs. 6.7, 6.11, 6.15). For a gate operation time much faster than the coherence time of the transmons, i.e., T ⇥, if the intrinsic ﬁdelity is much smaller than the ﬁdelity caused by decoherence-induced errors, we can approximate ¯ as F ⇥ ¯ =1 (6.15) F T

Equation (6.15) matches our numerical simulation of decoherence in Figs. 6.7, 6.11, 6.15.

When the coherence time of the transmon is significantly higher than the gate operation time i.e., T ⇥,theerrorfromtheintrinsicfidelityisthemainsourceof noise. Under this condition, the intrinsic fidelity must be so high, such that the resultant gate fidelity meets the threshold fidelity for fault-tolerant quantum computing.

With the long coherence time (20 60µs) of the state-or-the-art superconducting ⇠ artiﬁcial atoms accompanied with our machine learning approach that delivers gates with ¯ > 0.999, our proposal enables the implementation of high-ﬁdelity three-qubit F gates under current experimental conditions.

112 Distortion of control pulses

In this section we discuss the calibration procedure to suppress the e↵ect of residual noise in an experiment, where a fast and high-ﬁdelity To↵oli gate is demonstrated. In aquantumcontrolprocedure,thee↵ect of noise is to distort the external pulses e.g. time-dependent qubit frequencies, which are designed optimally through a control procedure. In an ideal experiment with no noise acting on the quantum system,

Figs. 6.5(a), 6.9(a), and 6.13(a) show our optimal pulses in the absence of distortion.

However this idealized assumption is not valid in a real experimental procedure when noise distorts the designed pulses. Therefore a calibration procedure must take the distortions into account for optimally designed square pulses.

Up to first order, distortion occurs in an experiment whenever a square pulse is generated and passed through the superconducting control electronics. Therefore, by the time that the square pulse reaches the artificial atom, the pulse becomes smoothed. Mathematically, we model first-order distortion by convolving the square pulse with a Gaussian function, which yields an error-function (erf) pulse [46, 161].

Leading-order distortion has already been taken into account in designing our optimal pulses as shown in Figs. 6.5, 6.9 and 6.13.

Calibration is required for higher orders and can be achieved through the well-known

Closed-Loop Learning Control (ClLC) technique [174, 103]. ClLC has been successfully applied to tasks such as discriminating similar molecules [175], ionization [176], molecular isomerization [177], and coherent quantum control of two-photon transitions [90].

ClLC is an iterative technique for searching the optimal solution in a quantum control landscape. The idea is to start with a quantum control scheme (SuSSADE for our case) to solve an ideal, physically realistic model of the quantum system and then test the obtained optimal solution experimentally. If the experimentally measured

113 Noise

Input Quantum System Output

Control Scheme (SuSSADE)

Figure 6.17: A schematic view of the Closed-Loop Learning Control (ClLC) technique which uses SuSSADE as a quantum control scheme. Based on this control procedure, the optimal pulses which are generated using SuSSADE fed into a noisy quantum system. if the output met the target ﬁdelity, the procedure aborts otherwise a new set of control pulses is chosen using SuSSADE, and the iteration continues until the target is met. objective function (ﬁdelity in our case) does not satisfy the target, the control pulse should be calibrated again with the same quantum control algorithm (SuSSADE for our case) in order to obtain a new set of optimal solutions, and this process continues until the target is met. A schematic view of ClLC is depicted in Fig. 6.17.

6.9 Conclusion

In conclusion, we have transformed a problem of designing three-qubit gates into a quantum control problem. The control problem then mapped into a supervised machine learning algorithm. In the context of supervised machine learning, we used the truth-table data for each quantum gate as the training data. The transmon frequencies represent the hypothesis. Our supervised learning algorithm then trains the qubit frequencies on the truth table data to generate policies for designing high-ﬁdelity three-qubit gates. Our approach to deﬁning a gate design problem as a supervised machine learning can inspire the application of other supervised machine learning

114 methods, such as Support Vector Machine [178] and Neural Network [179] for designing quantum gates which act on more than three qubits.

We have employed our machine learning algorithm, Subspace-Selective Self-adaptive

Di↵erential Evolution (SuSSADE), as a quantum control scheme to generate policies for designing high-ﬁdelity single-shot three-qubit gates. The generated policies enable the design of threshold ﬁdelity three-qubit gates, such as To↵oli, Fredkin and

CNOTNOT gates. Our three-qubit gates operate as fast as the two-qubit entangling

CZ gate under the same experimental constraints that reveals the advantage of our approach in contrast to inecient decomposition-based approaches. Our architecture of three nearest-neighbor-coupled transmons can serve as a module for any 1D or 2D architecture, and in fact our three-qubit gates can be realized in multi-qubit systems if the undesired couplings are switched o↵.

115 Chapter 7

Concluding Remarks

“There is no end to education. It is not that you read a book, pass

an examination, and ﬁnish with education. The whole of life, from the

moment you are born to the moment you die, is a process of learning.”

— Jiddu Krishnamurti, 2003 [180]

7.1 Summary

In this thesis we devise quantum control schemes for designing single-shot high-ﬁdelity quantum gates. We pursued two main objectives in this thesis. First we showed the existence of local traps in the quantum control landscape for two contrived but physically meaningful quantum systems. Second we showed that even state-of-the- art evolutionary algorithms fail to generate policies for realistic implementations of quantum gates. Therefore, we devise a quantum control scheme called Subspace-

Selective Self-adaptive Di↵erential Evolution to avoid the traps within the quantum control landscape. Our technique enabled the design of threshold-ﬁdelity three-qubit gates while existing techniques failed.

7.2 Hard quantum control problems

Given a quantum control procedure with no constraint on the system’s evolution, there is always a perfect or no solution for the control problem [30]. There has a long debate in the quantum control community regarding the existence of local traps in the quantum control landscape. This debate inspired my PhD studies to explore the question of whether having constraints on the quantum system evolution can make

116 the quantum control problems hard?

In my ﬁrst publication on the quantum control problem [1], I have shown that two constraints of i) system evolution time and ii) experimental resources (number of control parameters) on the quantum system can make the control problem hard. My main contribution was to develop programs for DE and PSO. Formulating the control problems and comparing the performance of greedy and non-greedy algorithms on the quantum control problems at hand. I have produced all the results and discussed the performance of di↵erent control schemes. Our collaborator, Sophie Schirmer provided us with a Matlab implementation of the Krotov algorithm.

The results of our ﬁrst work on the quantum control problem [1] convinced us that not all the quantum control problems can be solved using greedy machine learning algorithm. Therefore, one should look for alternative non-greedy algorithms, which globally search for a feasible policy within the quantum landscape. We employed state-of-the-art evolutionary algorithms to avoid the trap in the quantum landscape and design threshold-ﬁdelity CNOT and qutrit phase gates.

7.3 Threshold-ﬁdelity To↵oli gate

In the second part of my PhD studies, I focused on designing quantum gates for a linear chain of superconducting artificial atoms (transmons). Starting with To↵oli [2], we realized that generating policies for designing threshold-fidelity the To↵oli gate is ahardquantumcontroltask.Wehaveobservedthefailureofthegreedyalgorithms in reaching a high-fidelity To↵oli gate. Even standard versions of evolutionary algorithms were unsuccessful to proceed to a threshold-fidelity To↵oli gate. Upon the failure of existing machine learning techniques, we proposed our non-greedy machine learning technique, which is called SuSSADE.

My contribution in [2] was to formulate the problem of designing threshold-ﬁdelity

117 To↵oli gate into a supervised machine learning. I developed SuSSADE which is suited for high dimensional learning algorithms. I initially programmed SuSSADE to run on a single processor. To reduce the run-time of the algorithm, I reprogrammed

SuSSADE to run on multiprocessor, thereby increasing the run-time proportionally with the number of processors. SuSSADE is programmed as a modular optimization routine that takes the objective function and constraints on a control scheme as inputs and globally searches for a feasible solution. Our collaborator Joydip Ghosh was responsible for proposing the suitable physical system (transmon) for designing the To↵oli gate.

SuSSADE enabled the design of a fast high-ﬁdelity To↵oli gate operating as fast as an entangling two-qubit gate under the same experimental constraints. The successful performance of SuSSADE for designing To↵oli, gave rise to this question that, whether it can be used for designing other three-qubit gates. This was the topic of my third contribution into the quantum control ﬁeld.

7.4 Threshold-ﬁdelity Fredkin and CNOTNOT gates

To show the capability of SuSSADE in designing other three-qubit gates, I have chosen two important three-qubit gates including Fredkin and CNOTNOT gate. Our initial expectation was that greedy algorithms would fail to ﬁnd successful policies for designing these two gates. Our prediction was correct as all policies generated by greedy machine learning algorithms led to a gate with under-threshold ﬁdelities. The standard non-greedy techniques also failed to generate a feasible policy. The modular feature of SuSSADE enabled us to feed the quantum control problem of designing

Fredkin and CNOTNOT into our machine learning program. Our result showed the capability of SuSSADE in generating policies for designing high-ﬁdelity Fredkin and

CNOTNOT gates.

118 My contribution in designing high-ﬁdelity single-shot Fredkin and CNOTNOT gates [3] was to formulate the problem of gate design into a supervised machine learning algorithm. I have also tested existing machine learning techniques to show the failure of the available techniques. I have produced all the results. I have constructed a framework to transform a quantum control problem into a machine learning algorithm. Our collaborator Joydip Ghosh contributed mainly on constructing a suitable physical system for designing quantum gates. For all the three-qubit gates that are designed in this work, we have employed an architecture of three linearly coupled transmons. Our results show that the designed Fredkin and CNOTNOT gate, each, operates as fast as an entangling two-qubit gate under the same experimental condition.

7.5 Future work

Our e↵orts to employ machine learning techniques to generate policies for designing quantum gates inspires further research in the ﬁeld of quantum control and machine learning. In the following, I suggest some of the future work that can branch from the objectives summarized above:

1. We have employed SuSSADE for designing multi-qubit quantum gates

acting on up to three qubits. While SuSSADE can be employed to

design other quantum gates acting on more than three qubits, this

requires some knowledge about the optimal values of the algorithmic-

parameters (s, m) of SuSSADE. If the goal is to employ SuSSADE for

designing multi-qubit gates acting on more than three qubits, a study

that shows the performance of SuSSADE against these algorithmic val-

ues is inevitable.

2. Non-greedy machine learning techniques are well-known to be com-

119 putationally expensive. For example, a single run of our SuSSADE

algorithm to generate a successful policy for designing the To↵oli gate

takes 30 min over 200 cores. One approach to reduce the run-time

for non-greedy algorithms is to combine them with greedy algorithm.

Several studies showed superiority of hybrid optimization techniques

for solving high dimensional optimization problems. Combining SuS-

SADE with other greedy algorithms might enhance its ecacy and its

convergence rate towards a successful policy.

3. Supervised machine learning framework is a vast subject in machine

learning and data analysis ﬁelds. There exist many supervised machine

learning algorithms with two most important ones are Neural Network

(NN) [178] and Support Vector Machine (SVM) [179] that can also be

used in the context of quantum control. In this thesis we have made

the framework of how to transform the quantum control problems into

a machine learning framework. Further work can be accomplished to

adapt well-known supervised techniques such as SVM and NN to solve

quantum control problems.

120 Bibliography

[1] Ehsan Zahedinejad, Sophie Schirmer, and Barry C. Sanders. Evolutionary al-

gorithms for hard quantum control. Phys. Rev. A,90:032310,Sep2014.

[2] Ehsan Zahedinejad, Joydip Ghosh, and Barry C. Sanders. High-ﬁdelity single-

shot to↵oli gate via quantum control. Phys. Rev. Lett., 114:200502, May 2015.

[3] Ehsan Zahedinejad, Joydip Ghosh, and Barry C. Sanders. Designing high-

ﬁdelity single-shot three-qubit gates: A machine learning approach. arXiv

preprint quant-ph/1511.08862v1,2015.

[4] Richard P Feynman. There’s plenty of room at the bottom. Eng. Sci.,23(5):22–

36, 1960.

[5] Andrew Steane. Quantum computing. Reports on Progress in Physics,

61(2):117, 1998.

[6] Daniel R. Simon. On the power of quantum computation. SIAM Journal on

Computing,26(5):1474–1483,1997.

[7] Lieven M. K. Vandersypen, Matthias Ste↵en, Gregory Breyta, Costantino S.

Yannoni, Mark H. Sherwood, and Isaac L. Chuang. Experimental realization of

shor’s quantum factoring algorithm using nuclear magnetic resonance. Nature,

414(6866):883–887, December 2001.

[8] Peter W. Shor. Polynomial-time algorithms for prime factorization and discrete

logarithms on a quantum computer. SIAM J. Comput.,26(5):1484–1509,1997.

[9] Lov K. Grover. A fast quantum mechanical algorithm for database search.

In Proceedings of the Twenty-eighth Annual ACM Symposium on Theory of

Computing, STOC ’96, pages 212–219, New York, NY, USA, 1996. ACM.

121 [10] D. Deutsch. Quantum computational networks. Proc. R. Soc. A: Mathematical,

Physical and Engineering Sciences,425(1868):73–90,1989.

[11] R. Barends, J. Kelly, A. Megrant, A. Veitia, D. Sank, E. Je↵rey, T. C.

White, J. Mutus, A. G. Fowler, B. Campbell, Y. Chen, Z. Chen, B. Chiaro,

A. Dunsworth, C. Neill, P. O/’Malley, P. Roushan, A. Vainsencher, J. Wen-

ner, A. N. Korotkov, A. N. Cleland, and John M. Martinis. Superconducting

quantum circuits at the surface code threshold for fault tolerance. Nature,

508(7497):500–503, April 2014.

[12] David P. DiVincenzo and Peter W. Shor. Fault-tolerant error correction with

ecient quantum codes. Phys. Rev. Lett., 77:3260–3263, Oct 1996.

[13] A. Steane. The ion trap quantum information processor. Applied Physics B,

64(6):623–643, 1997.

[14] C. Monroe. Quantum information processing with atoms and photons. Nature,

416(6877):238–246, 03 2002.

[15] Tomas Jochym-O’Connor and Raymond Laﬂamme. Using concatenated quan-

tum codes for universal fault-tolerant quantum gates. Phys. Rev. Lett.,

112:010505, Jan 2014.

[16] Jean-Luc Brylinski and Ranee Brylinski. Universal quantum gates. Mathematics

of Quantum Computation,79,2002.

[17] F. Motzoi, J. M. Gambetta, P. Rebentrost, and F. K. Wilhelm. Simple pulses for

elimination of leakage in weakly nonlinear qubits. Phys. Rev. Lett.,103:110501,

Sep 2009.

[18] Melvin Lax. Quantum noise. iv. quantum theory of noise sources. Phys. Rev.,

145:110–129, May 1966.

122 [19] M. A. Nielsen and I. L. Chuang. Quantum Computation and Quantum Infor-

mation. Cambridge University Press, Cambridge, 2005.

[20] Mikko M¨ott¨onen, Juha J. Vartiainen, Ville Bergholm, and Martti M. Salomaa.

Quantum circuits for general multiqubit gates. Phys. Rev. Lett., 93:130502, Sep

2004.

[21] D. G. Cory, M. D. Price, W. Maas, E. Knill, R. Laﬂamme, W. H. Zurek, T. F.

Havel, and S. S. Somaroo. Experimental quantum error correction. Phys. Rev.

Lett., 81:2152–2155, Sep 1998.

[22] M. D. Reed, L. DiCarlo, S. E. Nigg, L. Sun, L. Frunzio, S. M. Girvin, and

R. J. Schoelkopf. Realization of three-qubit quantum error correction with

superconducting circuits. Nature, 482(7385):382–385, February 2012.

[23] Raymond Laﬂamme, Cesar Miquel, Juan Pablo Paz, and Wojciech Hubert

Zurek. Perfect quantum error correcting code. Phys. Rev. Lett.,77:198–201,

Jul 1996.

[24] P.W. Shor. Fault-tolerant quantum computation. In Foundations of Computer

Science, 1996. Proceedings., 37th Annual Symposium on, pages 56–65, Oct 1996.

[25] A. R. Calderbank and Peter W. Shor. Good quantum error-correcting codes

exist. Phys. Rev. A, 54:1098–1105, Aug 1996.

[26] A. M. Steane. Error correcting codes in quantum theory. Phys. Rev. Lett.,

77:793–797, Jul 1996.

[27] T. C. Ralph, K. J. Resch, and A. Gilchrist. Ecient to↵oli gates using qudits.

Phys. Rev. A, 75:022313, Feb 2007.

123 [28] Adriano Barenco, Charles H. Bennett, Richard Cleve, David P. DiVincenzo,

Norman Margolus, Peter Shor, Tycho Sleator, John A. Smolin, and Harald

Weinfurter. Elementary gates for quantum computation. Phys. Rev. A,52:3457–

3467, Nov 1995.

[29] Pierre De Fouquieres and Sophie G. Schirmer. A closer look at quantum control

landscapes and their implication for control optimization. Inﬁn. Dimens. Anal.

Quantum. Probab. Relat. Top.,16(3):1350021,2013.

[30] Herschel A Rabitz, Michael M Hsieh, and Carey M Rosenthal. Quantum op-

timally controlled transition landscapes. Science, 303(5666):1998–2001, Mar

2004.

[31] S. Machnes, U. Sander, S. J. Glaser, P. de Fouqui`eres, A. Gruslys, S. Schirmer,

and T. Schulte-Herbr¨uggen. Comparing, optimizing, and benchmarking

quantum-control algorithms in a unifying programming framework. Phys. Rev.

A, 84:022305, Aug 2011.

[32] M.R. Geller, E.J. Pritchett, A.T. Sornborger, and F.K. Wilhelm. Quantum

computing with superconductors i: Architectures. In MichaelE. Flatt and I. if-

rea, editors, Manipulating Quantum Coherence in Solid State Systems, volume

244 of NATO Science Series II: Mathematics, Physics and Chemistry, pages

171–194. Springer Netherlands, 2007.

[33] Michel H Devoret, A Wallra↵, and JM Martinis. Superconducting qubits: A

short review. arXiv preprint cond-mat/0411174,2004.

[34] John Clarke and Frank K. Wilhelm. Superconducting quantum bits. Nature,

453(7198):1031–1042, 06 2008.

124 [35] Chad Tyler Rigetti. Quantum Gates for Superconducting Qubits. BiblioBazaar,

Charleston, South Carolina, 2011.

[36] Jens Koch, Terri M. Yu, Jay Gambetta, A. A. Houck, D. I. Schuster, J. Majer,

Alexandre Blais, M. H. Devoret, S. M. Girvin, and R. J. Schoelkopf. Charge-

insensitive qubit design derived from the cooper pair box. Phys. Rev. A,

76:042319, Oct 2007.

[37] V Bouchiat, D Vion, P Joyez, D Esteve, and M H Devoret. Quantum coherence

with a single cooper pair. Phys. Scripta, 1998(T76):165, 1998.

[38] Y. Nakamura, Yu. A. Pashkin, and J. S. Tsai. Coherent control of macroscopic

quantum states in a single-cooper-pair box. Nature,398(6730):786–788,041999.

[39] Lszl Ndai and Jzsef Bokor. Quantum control systems. In ImreJ. Rudas, Jnos

Fodor, and Janusz Kacprzyk, editors, Towards Intelligent Engineering and In-

formation Technology,volume243ofStudies in Computational Intelligence,

pages 93–102. Springer Berlin Heidelberg, 2009.

[40] Christopher M Bishop. Pattern recognition and machine learning. springer,

Singapore, 2006.

[41] Alexander Hentschel and Barry C. Sanders. Machine learning for precise quan-

tum measurement. Phys. Rev. Lett., 104:063603, Feb 2010.

[42] Mdlin Gu and Wojciech Kotowski. Quantum learning: asymptotically optimal

classiﬁcation of qubit states. New J. Phys.,12(12):123032,2010.

[43] Easwar Magesan, Jay M. Gambetta, A. D. C´orcoles, and Jerry M. Chow. Ma-

chine learning for discriminating quantum measurement trajectories and im-

proving readout. Phys. Rev. Lett., 114:200501, May 2015.

125 [44] Leonardo Banchi, Nicola Pancotti, and Sougato Bose. Quantum gate learning

in engineered qubit networks: To↵oli gate with always-on interactions. arXiv

preprint arXiv:1509.04298,2015.

[45] S. B. Kotsiantis. Supervised machine learning: A review of classiﬁcation tech-

niques. In Proceedings of the 2007 Conference on Emerging Artiﬁcial Intelli-

gence Applications in Computer Engineering: Real Word AI Systems with Ap-

plications in eHealth, HCI, Information Retrieval and Pervasive Technologies,

pages 3–24, Amsterdam, The Netherlands, The Netherlands, 2007. IOS Press.

[46] J. Ghosh, A. Galiautdinov, Z. Zhou, A. N. Korotkov, J. M. Martinis, and M. R.

Geller. High-ﬁdelity controlled-z gate for resonator-based superconducting

quantum computers. Phys. Rev. A, 87:022309, Feb 2013.

[47] Donald M. Olsson and Lloyd S. Nelson. The nelder-mead simplex procedure

for function minimization. Technometrics,17(1):45–51,1975.

[48] Jr. J. E. Dennis and Jorge J. Mor. Quasi-newton methods, motivation and

theory. SIAM Review, 19(1):46–89, 1977.

[49] AI Konnov and VF Krotov. On global methods of successive improvement of

controlled processes. Autom. Remote Control,60(10):1427–1436,1999.

[50] Shlomo E. Sklarz and David J. Tannor. Loading a bose-einstein condensate onto

an optical lattice: An application of optimal control theory to the nonlinear

schr¨odinger equation. Phys. Rev. A, 66:053619, Nov 2002.

[51] Yvon Maday and Gabriel Turinici. New formulations of monotonically con-

vergent quantum control algorithms. The Journal of Chemical Physics,

118(18):8191–8196, 2003.

126 [52] Ivan I. Maximov, Julien Salomon, Gabriel Turinici, and Niels Chr. Nielsen.

A smoothing monotonic convergent optimal control algorithm for nuclear mag-

netic resonance pulse sequence design. The Journal of Chemical Physics,132(8),

2010.

[53] Michael J. Biercuk, Hermann Uys, Aaron P. VanDevender, Nobuyasu Shiga,

Wayne M. Itano, and John J. Bollinger. Optimized dynamical decoupling in a

model quantum memory. Nature,458(7241):996–1000,042009.

[54] David E. Goldberg. Genetic Algorithms in Search, Optimization and Machine

Learning. Addison-Wesley Longman, Boston, 1st edition, 1989.

[55] James Kennedy. Particle swarm optimization. In Encyclopedia of Machine

Learning, pages 760–766. Springer, 2010.

[56] Rainer Storn and Kenneth Price. Di↵erential evolution–a simple and ecient

heuristic for global optimization over continuous spaces. J. Global Optim.,

11(4):341–359, 1997.

[57] Marco A Panduro, Carlos A Brizuela, Luz I Balderas, and Diana A Acosta.

A comparison of genetic algorithms, particle swarm optimization and the dif-

ferential evolution method for the design of scannable circular antenna arrays.

Prog. Electromagn. Res. B, 13:171–186, 2009.

[58] Emad Elbeltagi, Tarek Hegazy, and Donald Grierson. Comparison among ﬁve

evolutionary-based optimization algorithms. Adv. Eng. Inform.,19(1):43–53,

2005.

[59] S. A Ethni, B. Zahawi, D. Giaouris, and P.P. Acarnley. Comparison of particle

swarm and simulated annealing algorithms for induction motor fault identiﬁ-

127 cation. In Conference on Industrial Informatics, 2009. INDIN 2009. 7th IEEE

International, pages 470–474, June 2009.

[60] D. Zeidler, S. Frey, K.-L. Kompa, and M. Motzkus. Evolutionary algorithms

and their application to optimal control studies. Phys. Rev. A, 64:023420, Jul

2001.

[61] A. M. Weiner. Femtosecond pulse shaping using spatial light modulators. Re-

view of Scientiﬁc Instruments,71(5):1929–1960,2000.

[62] Private communication with Pedram Roushan.

[63] David Bohm. Quantum theory. Courier Corporation, Mineola, NY, 2012.

[64] Richard P Feynman. Simulating physics with computers. Int. J. Theor. Phys.,

21(6/7):467–488, 1982.

[65] A. M. Turing. On computable numbers, with an application to the entschei-

dungsproblem. Proc. London Math. Soc., s2-42(1):230–265, 1937.

[66] David Z. Albert. On quantum-mechanical automata. Phys. Lett. A, 98(56):249–

252, 1983.

[67] David Deutsch. Quantum theory, the church-turing principle and the universal

quantum computer. In Proc. R. Soc. A: Mathematical, Physical and Engineering

Sciences, volume 400, pages 97–117. The Royal Society, 1985.

[68] Nicholas A. Peters, Julio T. Barreiro, Michael E. Goggin, Tzu-Chieh Wei, and

Paul G. Kwiat. Remote state preparation: Arbitrary remote control of photon

polarization. Phys. Rev. Lett., 94:150502, Apr 2005.

[69] Warren S. Warren. The usefulness of nmr quantum computing. Science,

277(5332):1688–1690, 1997.

128 [70] G. Boole. An Investigation of the Laws of Thought: On which are Founded

the Mathematical Theories of Logic and Probabilities. George Boole’s collected

logical works. Walton and Maberly, Cambridge, 1854.

[71] George Boole. The mathematical analysis of logic. Philosophical Library, 1847.

[72] ColinP. Williams. Quantum gates. In Explorations in Quantum Computing,

Texts in Computer Science, pages 51–122. Springer London, 2011.

[73] Edward Fredkin and Tommaso To↵oli. Conservative logic. Int. J. Theor. Phys.,

21(3-4):219–253, 1982.

[74] P. Domingos. The Master Algorithm: How the Quest for the Ultimate Learning

Machine Will Remake Our World. Basic Books. Perseus Distribution, New

York, NY, 2015.

[75] Daoyi Dong and Ian R Petersen. Quantum control theory and applications: A

survey. IET, Contr. Theor. Ap.,4(12):2651–2671,2010.

[76] Robert J. Levis, Getahun M. Menkir, and Herschel Rabitz. Selective bond

dissociation and rearrangement with optimally tailored, strong-ﬁeld laser pulses.

Science,292(5517):709–713,2001.

[77] Jens Kunde, Benedict Baumann, Sebastian Arlt, Fran¸cois Morier-Genoud, Uwe

Siegner, and Ursula Keller. Optimization of adaptive feedback control for ul-

trafast semiconductor spectroscopy. J. Opt. Soc. Am. B, 18(6):872–881, Jun

2001.

[78] T. Brixner, N. H. Damrauer, P. Niklaus, and G. Gerber. Photoselective adaptive

femtosecond quantum control in the liquid phase. Nature,414(6859):57–60,11

2001.

129 [79] DJ Wineland, D Leibfried, MD Barrett, A Ben-Kish, JC Bergquist,

RB Blakestad, JJ Bollinger, J Britton, J Chiaverini, B DeMarco, et al. Quan-

tum control, quantum information processing, and quantum-limited metrology

with trapped ions. In Laser Spectroscopy, volume 1, pages 393–402. World

Scientiﬁc, 2005.

[80] David J Tannor and Stuart A Rice. Control of selectivity of chemical reaction

via control of wave packet evolution. J. Chem. Phys., 83:5013, 1985.

[81] Moshe Shapiro and Paul Brumer. Laser control of product quantum state popu-

lations in unimolecular reactions. The Journal of Chemical Physics, 84(7):4103–

4104, 1986.

[82] Thomas Baumert and Gustav Gerber. Fundamental interactions of molecules

(na2, na3) with intense femtosecond laser pulses. Israel Journal of Chemistry,

34(1):103–114, 1994.

[83] T. Baumert, B. Buehler, M. Grosser, R. Thalweiser, V. Weiss, E. Wiedenmann,

and G. Gerber. Femtosecond time-resolved wave packet motion in molecular

multiphoton ionization and fragmentation. The Journal of Physical Chemistry,

95(21):8103–8110, 1991.

[84] E. D. Potter, J. L. Herek, S. Pedersen, Q. Liu, and A. H. Zewail. Femtosecond

laser control of a chemical reaction. Nature,355(6355):66–68,011992.

[85] Luis G.C. Rego, Lea F. Santos, and Victor S. Batista. Coherent control of

quantum dynamics with sequences of unitary phase-kick pulses. Annual Review

of Physical Chemistry, 60(1):293–320, 2009. PMID: 18999992.

[86] Ce Chen, Yi-Yian Yin, and D. S. Elliott. Interference between optical transi-

tions. Phys. Rev. Lett., 64:507–510, Jan 1990.

130 [87] Langchi Zhu, Valeria Kleiman, Xiaonong Li, Shao Ping Lu, Karen Trentelman,

and Robert J. Gordon. Coherent laser control of the product distribution ob-

tained in the photoexcitation of hi. Science,270(5233):77–80,1995.

[88] Frederick W. Strauch, Philip R. Johnson, Alex J. Dragt, C. J. Lobb, J. R. An-

derson, and F. C. Wellstood. Quantum logic gates for coupled superconducting

phase qubits. Phys. Rev. Lett., 91:167005, Oct 2003.

[89] Andreas Assion, T Baumert, M Bergt, T Brixner, B Kiefer, V Seyfried,

MStrehle,andGGerber.Controlofchemicalreactionsbyfeedback-optimized

phase-shaped femtosecond laser pulses. Science,282(5390):919–922,1998.

[90] Doron Meshulach and Yaron Silberberg. Coherent quantum control of two-

photon transitions by a femtosecond laser pulse. Nature,396(6708):239–242,

1998.

[91] C. A. Ryan, Martin Laforest, J. C. Boileau, and Raymond Laﬂamme. Exper-

imental implementation of a discrete-time quantum random walk on an nmr

quantum-information processor. Phys. Rev. A,72(6):062317,2005.

[92] Navin Khaneja, Timo Reiss, Cindie Kehlet, Thomas Schulte-Herbr¨uggen, and

Ste↵en J Glaser. Optimal control of coupled spin dynamics: design of nmr pulse

sequences by gradient ascent algorithms. J. Magn. Reson, 172(2):296–305, 2005.

[93] Rusko Ruskov, Keith Schwab, and Alexander N Korotkov. Squeezing of a

nanomechanical resonator by quantum nondemolition measurement and feed-

back. Phys. Rev. B,71(23):235407,2005.

[94] Stefano Mancini, David Vitali, and Paolo Tombesi. Optomechanical cool-

ing of a macroscopic oscillator by homodyne feedback. arXiv preprint quant-

ph/9802034,1998.

131 [95] Asa Hopkins, Kurt Jacobs, Salman Habib, and Keith Schwab. Feedback cooling

of a nanomechanical resonator. Phys. Rev. B,68(23):235328,2003.

[96] Paul Brumer and Moshe Shapiro. Laser control of molecular processes. Annu.

Rev. Phys. Chem.,43(1):257–282,1992.

[97] T. Schulte-Herbr¨uggen, A. Sp¨orl, N. Khaneja, and S. J. Glaser. Optimal control-

based ecient synthesis of building blocks of quantum algorithms: A perspec-

tive from network complexity towards time complexity. Phys. Rev. A,72:042331,

Oct 2005.

[98] Domenico d’Alessandro. Introduction to Quantum Control and Dynamics.

Chapman & Hall/CRC Applied Mathematics & Nonlinear Science. CRC, New

York, Boca Raton, FL, 2007.

[99] G. Dattoli, J. Gallardo, and A. Torre. Timeordering techniques and solution of

di↵erential di↵erence equation appearing in quantum optics. J. Math. Phys.,

27(3):772–780, Aug 1986.

[100] Rich Caruana and Alexandru Niculescu-Mizil. An empirical comparison of su-

pervised learning algorithms. In Proceedings of the 23rd International Confer-

ence on Machine Learning, ICML ’06, pages 161–168, New York, NY, USA,

2006. ACM.

[101] Leonardo Banchi, Nicola Pancotti, and Sougato Bose. Quantum gate learning

in engineered qubit networks: To↵oli gate with always-on interactions. arXiv

preprint arXiv:1509.04298,2015.

[102] Gene H Golub and Charles F Van Loan. Matrix Computations,volume4of

Johns Hopkins Studies in the Mathematical Sciences (Book 3). JHU Press,

Baltimore, 2012.

132 [103] Richard S. Judson and Herschel Rabitz. Teaching lasers to control molecules.

Phys. Rev. Lett., 68:1500–1503, Mar 1992.

[104] Christopher J Bardeen, Vladislav V Yakovlev, Kent R Wilson, Scott D Car-

penter, Peter M Weber, and Warren S Warren. Feedback quantum control of

molecular electronic population transfer. Chem. Phys. Lett., 280(1-2):151–158,

1997.

[105] Charles George Broyden. The convergence of a class of double-rank minimiza-

tion algorithms 1. general considerations. IMA J. Appl. Math.,6(1):76–90,

1970.

[106] Roger Fletcher. A new approach to variable metric algorithms. Comput. J.,

13(3):317–322, 1970.

[107] Roger Fletcher. Practical Methods of Optimization, volume 2. Wiley, Padstow,

2013.

[108] Donald Goldfarb. A family of variable-metric methods derived by variational

means. Math. Comput.,24(109):23–26,1970.

[109] David F. Shanno. Conditioning of quasi-newton methods for function mini-

mization. Math. Comput.,24(111):647–656,1970.

[110] Daniel M. Reich, Mamadou Ndong, and Christiane P. Koch. Monotonically

convergent optimization in quantum control using krotov’s method. The Journal

of Chemical Physics,136(10),2012.

[111] Reuven Eitan, Michael Mundt, and David J. Tannor. Optimal control with

accelerated convergence: Combining the krotov and quasi-newton methods.

Phys. Rev. A, 83:053426, May 2011.

133 [112] Kenneth A De Jong. Evolutionary Computation: A Uniﬁed Approach,volume

262041944 of Bradford Book. MIT press Cambridge, Cambridge, 2006.

[113] S. Kirkpatrick, C. D. Gelatt, and M. P. Vecchi. Optimization by simulated

annealing. Science,220(4598):671–680,1983.

[114] M. Dorigo, M. Birattari, and T. Stutzle. Ant colony optimization. IEEE Com-

put. Intell. Mag., IEEE, 1(4):28–39, Nov 2006.

[115] Pablo Moscato et al. On evolution, search, optimization, genetic algorithms

and martial arts: Towards memetic algorithms. Caltech concurrent computation

program, C3P Report, 826:1989, 1989.

[116] John H. Holland. Adaptation in Natural and Artiﬁcial Systems: An Introduc-

tory Analysis with Applications to Biology, Control, and Artiﬁcial Intelligence.

University of Michigan Press, Ann Arbor, MI, 1975.

[117] R.P. Feynman. The Character of Physical Law. Messenger lectures on the

evolution of civilization. Modern Library, United Kingdom, 1994.

[118] David P. DiVincenzo. The physical implementation of quantum computation.

Fortschritte der Physik, 48(9-11):771–783, 2000.

[119] R. J. Schoelkopf and S. M. Girvin. Wiring up quantum systems. Nature,

451(7179):664–669, 02 2008.

[120] Caspar H. van der Wal, A. C. J. ter Haar, F. K. Wilhelm, R. N. Schouten,

C. J. P. M. Harmans, T. P. Orlando, Seth Lloyd, and J. E. Mooij. Quantum

superposition of macroscopic persistent-current states. Science,290(5492):773–

777, 2000.

134 [121] J. E. Mooij, T. P. Orlando, L. Levitov, Lin Tian, Caspar H. van der Wal, and

Seth Lloyd. Josephson persistent-current qubit. Science,285(5430):1036–1039,

1999.

[122] John M. Martinis, S. Nam, J. Aumentado, and C. Urbina. Rabi oscillations in

a large josephson-junction qubit. Phys. Rev. Lett., 89:117901, Aug 2002.

[123] A. A. Houck, J. A. Schreier, B. R. Johnson, J. M. Chow, Jens Koch, J. M.

Gambetta, D. I. Schuster, L. Frunzio, M. H. Devoret, S. M. Girvin, and R. J.

Schoelkopf. Controlling the spontaneous emission of a superconducting trans-

mon qubit. Phys. Rev. Lett., 101:080502, Aug 2008.

[124] D. Vion, A. Aassime, A. Cottet, P. Joyez, H. Pothier, C. Urbina, D. Esteve,

and M. H. Devoret. Manipulating the quantum state of an electrical circuit.

Science,296(5569):886–889,2002.

[125] Audrey Cottet. Implementation of a quantum bit in a superconducting circuit.

PhD thesisUniversit´eParis VI,14,2002.

[126] J. M. Chow, J. M. Gambetta, L. Tornberg, Jens Koch, Lev S. Bishop, A. A.

Houck, B. R. Johnson, L. Frunzio, S. M. Girvin, and R. J. Schoelkopf. Ran-

domized benchmarking and process tomography for gate errors in a solid-state

qubit. Phys. Rev. Lett., 102:090502, Mar 2009.

[127] Erik Lucero, M. Hofheinz, M. Ansmann, Radoslaw C. Bialczak, N. Katz,

Matthew Neeley, A. D. O’Connell, H. Wang, A. N. Cleland, and John M. Marti-

nis. High-ﬁdelity gates in a single josephson qubit. Phys. Rev. Lett., 100:247001,

Jun 2008.

[128] L DiCarlo, JM Chow, JM Gambetta, Lev S Bishop, BR Johnson, DI Schuster,

J Majer, A Blais, L Frunzio, SM Girvin, et al. Demonstration of two-qubit

135 algorithms with a superconducting quantum processor. Nature, 460(7252):240–

244, 2009.

[129] Michio Kaku. Hyperspace: a scientiﬁc odyssey through parallel universes, time

warps, and the tenth dimension. Oxford Paperbacks, Oxford, 1995.

[130] Lev B. Levitin and Tommaso To↵oli. Fundamental limit on the rate of quantum

dynamics: The uniﬁed bound is tight. Phys. Rev. Lett., 103:160502, Oct 2009.

[131] M. M. Taddei, B. M. Escher, L. Davidovich, and R. L. de Matos Filho. Quantum

speed limit for physical processes. Phys. Rev. Lett., 110:050402, Jan 2013.

[132] A. del Campo, I. L. Egusquiza, M. B. Plenio, and S. F. Huelga. Quantum speed

limits in open system dynamics. Phys. Rev. Lett., 110:050403, Jan 2013.

[133] Gerhard C. Hegerfeldt. Driving at the quantum speed limit: Optimal control

of a two-level system. Phys. Rev. Lett., 111:260501, Dec 2013.

[134] Daniel Gottesman, Alexei Kitaev, and John Preskill. Encoding a qubit in an

oscillator. Phys. Rev. A, 64:012310, Jun 2001.

[135] Stephen D. Bartlett, Hubert de Guise, and Barry C. Sanders. Quantum encod-

ings in spin systems and harmonic oscillators. Phys. Rev. A, 65:052316, May

2002.

[136] Andrew M. Steane. Overhead and noise threshold of fault-tolerant quantum

error correction. Phys. Rev. A, 68:042322, Oct 2003.

[137] Alexander N. Pechen and David J. Tannor. Are there traps in quantum control

landscapes? Phys. Rev. Lett., 106:120402, Mar 2011.

136 [138] Herschel Rabitz, Tak-San Ho, Ruixing Long, Rebing Wu, and Constantin Brif.

Comment on “are there traps in quantum control landscapes?”. Phys. Rev.

Lett.,108:198901,May2012.

[139] Alexander N. Pechen and David J. Tannor. Publisher’s note: Pechen and tannor

reply [phys. rev. lett. 108, 198902 (2012)]. Phys. Rev. Lett., 108:229901, May

2012.

[140] Alexander N. Pechen and David J. Tannor. Quantum control landscape for a

-atom in the vicinity of second-order traps. Isr. J. Chem., 52:467–472, May

2012.

[141] Alexander N. Pechen and David J. Tannor. Pechen and tannor reply:. Phys.

Rev. Lett., 108:198902, May 2012.

[142] Ioan Cristian Trelea. The particle swarm optimization algorithm: convergence

analysis and parameter selection. Inf. Proc. Lett.,85(6):317–325,2003.

[143] Maurice Clerc and James Kennedy. The particle swarm-explosion, stability,

and convergence in a multidimensional complex space. Evol. Comput., IEEE

Trans. on, 6(1):58–73, 2002.

[144] D. Gottesman. Theory of fault-tolerant quantum computation. Phys. Rev. A,

57:127–137, Jan 1998.

[145] T. Monz, K. Kim, W. H¨ansel, M. Riebe, A. S. Villar, P. Schindler, M. Chwalla,

M. Hennrich, and R. Blatt. Realization of the quantum To↵oli gate with trapped

ions. Phys. Rev. Lett., 102:040501, Jan 2009.

[146] A. Fedorov, L. Ste↵en, M. Baur, M. P. da Silva, and Andreas Wallra↵.

Implementation of a To↵oli gate with superconducting circuits. Nature,

481(7380):170–172, January 2012.

137 [147] V. M. Stojanovi´c, A. Fedorov, A. Wallra↵,andC.Bruder.Quantum-control

approach to realizing a To↵oli gate in circuit qed. Phys. Rev. B, 85:054504, Feb

2012.

[148] G. J. Milburn. Quantum optical fredkin gate. Phys. Rev. Lett., 62:2124–2127,

May 1989.

[149] Joseph Shamir, H. John Caulﬁeld, William Micelli, and Robert J. Seymour.

Optical computing and the fredkin gates. Appl. Opt., 25(10):1604–1607, May

1986.

[150] Joydip Ghosh, Austin G. Fowler, and Michael R. Geller. Surface code with

decoherence: An analysis of three superconducting architectures. Phys. Rev.

A, 86:062318, Dec 2012.

[151] Asher Peres. Reversible logic and quantum computers. Phys. Rev. A, 32:3266–

3276, Dec 1985.

[152] Dorit Aharonov. A simple proof that to↵oli and hadamard are quantum uni-

versal. In IN QUANT-PH/0301040,2003.

[153] Y. Shi. Both To↵oli and controlled-NOT need little help to do universal quan-

tum computing. Quantum Info. Comput., 3(1):84–92, January 2003.

[154] Tycho Sleator and Harald Weinfurter. Realizable universal quantum logic gates.

Phys. Rev. Lett., 74:4087–4090, May 1995.

[155] Yaakov S Weinstein. Syndrome measurement strategies for the [[7,1,3]] code.

Quantum Information Processing,14(6):1841–1854,2015.

[156] H. F. Chau and F. Wilczek. Simple realization of the fredkin gate using a series

of two-body operators. Phys. Rev. Lett., 75:748–750, Jul 1995.

138 [157] John A. Smolin and David P. DiVincenzo. Five two-bit quantum gates are

sucient to implement the quantum fredkin gate. Phys. Rev. A,53:2855–2856,

Apr 1996.

[158] Vivek V. Shende and Igor L. Markov. On the cnot-cost of to↵oli gates. Quantum

Info. Comput., 9(5):461–486, May 2009.

[159] Moshe Shapiro and Paul Brumer. Principles of the quantum control of molecular

processes. Principles of the Quantum Control of Molecular Processes, by Moshe

Shapiro, Paul Brumer, pp. 250. ISBN 0-471-24184-9. Wiley-VCH, February

2003.,1,2003.

[160] A.A. Houck, Jens Koch, M.H. Devoret, S.M. Girvin, and R.J. Schoelkopf. Life

after charge noise: recent results with transmon qubits. Quantum Information

Processing, 8(2-3):105–115, 2009.

[161] Andrei Galiautdinov, Alexander N. Korotkov, and John M. Martinis.

Resonator˘zero-qubit architecture for superconducting qubits. Phys. Rev. A,

85:042321, Apr 2012.

[162] A. Wallra↵, D. I. Schuster, A. Blais, L. Frunzio, R. S. Huang, J. Majer, S. Ku-

mar, S. M. Girvin, and R. J. Schoelkopf. Strong coupling of a single photon

to a superconducting qubit using circuit quantum electrodynamics. Nature,

431(7005):162–167, 09 2004.

[163] Sophie G Schirmer and Pierre de Fouquieres. Ecient algorithms for optimal

control of quantum dynamics: the krotov method unencumbered. New J. Phys.,

13(7):073029, 2011.

[164] Patrick Doria, Tommaso Calarco, and Simone Montangero. Optimal control

139 technique for many-body quantum dynamics. Phys. Rev. Lett.,106:190501,

May 2011.

[165] J. Brest, V. Zumer, and M. S. Maucec. Self-adaptive di↵erential evolution algo-

rithm in constrained real-parameter optimization. In IEEE C. Evol. Computat.,

2006. CEC 2006, pages 215–222. IEEE, 2006.

[166] Mitchell A. Potter and Kenneth A. De Jong. A cooperative coevolutionary

approach to function optimization. In Proceedings of the International Confer-

ence on Evolutionary Computation. The Third Conference on Parallel Problem

Solving from Nature: Parallel Problem Solving from Nature, PPSN III, pages

249–257, London, UK, UK, 1994. Springer-Verlag.

[167] Yong Liu, Xin Yao, Qiangfu Zhao, and T. Higuchi. Scaling up fast evolutionary

programming with cooperative coevolution. In Proceedings of the 2001 Congress

on Evolutionary Computation, 2001., volume 2, pages 1101–1108 vol. 2, 2001.

[168] Yan-jun Shi, Hong-fei Teng, and Zi-qiang Li. Cooperative co-evolutionary dif-

ferential evolution for function optimization. In Lipo Wang, Ke Chen, and

YewSoon Ong, editors, Advances in Natural Computation,volume3611ofLec-

ture Notes in Computer Science, pages 1080–1088. Springer Berlin Heidelberg,

2005.

[169] D. Sofge, K. De Jong, and A. Schultz. A blended population approach to

cooperative coevolution for decomposition of complex problems. In Evolutionary

Computation, 2002. CEC ’02. Proceedings of the 2002 Congress on,volume1,

pages 413–418, May 2002.

[170] Z. Yang, K. Tang, and X. Yao. Di↵erential evolution for high-dimensional

function optimization. In IEEE C. Evol. Computat., 2007. CEC 2007, pages

3523–3530. IEEE, Sept 2007.

140 [171] Yu-xi Liu, Sahin K. Ozdemir,¨ Adam Miranowicz, and Nobuyuki Imoto. Kraus

representation of a damped harmonic oscillator and its application. Phys. Rev.

A, 70(4):042308, October 2004.

[172] J. Kelly, R. Barends, B. Campbell, Y. Chen, Z. Chen, B. Chiaro, A. Dunsworth,

A. G. Fowler, I. C. Hoi, E. Je↵rey, A. Megrant, J. Mutus, C. Neill, P. J. J.

O’Malley, C. Quintana, P. Roushan, D. Sank, A. Vainsencher, J. Wenner, T. C.

White, A. N. Cleland, and J. M. Martinis. Optimal quantum control using

randomized benchmarking. Phys. Rev. Lett., 112:240504, Jun 2014.

[173] Ben P. Lanyon, M. Barbieri, M. P. Almeida, Thomas Jennewein, Timothy C.

Ralph, Kevin J. Resch, G. J. Pryde, Jeremy L. O/’Brien, Alexei Gilchrist, and

Andrew G. White. Simplifying quantum logic using higher-dimensional Hilbert

spaces. Nat. Phys., 5(2):134–140, February 2009.

[174] Herschel Rabitz, Regina de Vivie-Riedle, Marcus Motzkus, and Karl

Kompa. Whither the future of controlling quantum phenomena? Science,

288(5467):824–828, 2000.

[175] Baiqing Li, Gabriel Turinici, Viswanath Ramakrishna, and Herschel Rabitz.

Optimal dynamic discrimination of similar molecules through quantum learning

control. J. Phys. Chem. B,106(33):8125–8131,2002.

[176] Boris Schfer-Bung, Roland Mitri, Vlasta Bonai-Kouteck, Andreas Bartelt, Cos-

min Lupulescu, Albrecht Lindinger, Stefan Vajda, Stefan M. Weber, and Ludger

Wste. Optimal control of ionization processes in nak: comparison between the-

ory and experiment. J. Phys. Chem. Lett. A,108(19):4175–4179,2004.

[177] Marija Kotur, Thomas Weinacht, Brett J. Pearson, and Spiridoula Matsika.

141 Closed-loop learning control of isomerization using shaped ultrafast laser pulses

in the deep ultraviolet. J. Chem. Phys,130(13),2009.

[178] Simon Haykin. Neural Networks: A Comprehensive Foundation. Prentice Hall

PTR, Upper Saddle River, NJ, USA, 2nd edition, 1998.

[179] Corinna Cortes and Vladimir Vapnik. Support-vector networks. Mach. Learn.,

20(3):273–297, September 1995.

[180] J. Krishnamurti. Krishnamurti on Education. Krishnamurti Foundation India,

India, 2003.

142 Appendix A

Subspace-selective Self-adaptive Di↵erential

Evolution (SuSSADE) source code in C++

ﬁlename:main.cpp

#i n c l u d e ”cmatrix.h”

#i n c l u d e ”kron.h”

#i n c l u d e

#i n c l u d e ”utilities.h”

#i n c l u d e

#i n c l u d e ”DE. h”

#i n c l u d e ”problem.h”

#i n c l u d e ”EvalUT.h”

#i n c l u d e ”printi.h”

#i n c l u d e

int main ()

{ //======I n i t i a l i z i n g MPI Gloabl Variable======

int totalnode ,mynode;

MPI : : I n i t ( ) ;

MPI Comm size(MPICOMM WORLD, & t o t a l n o d e ) ;

MPI Comm rank(MPI COMM WORLD, & my n o d e ) ;

MPI Status status ;

//======I n i t i a l i z i n g Variables for DE======

unsigned int Generation=200000;

float Crossover CR=0.5;

float Mutation F=0.9;

double NPDim p=5.78;

double ctrpar=27;

//defining system paremeters

unsigned int D=4; //Dimension of each qubits

unsigned int Computational D=20;

143 unsigned int Hamitonian M=3; //numner of control Hamiltonain float g=0.03; // coupling factor double eta= 0.2; //anharmonocity double Time=27; double dt=2 M PI Time/( ctrpar ) ; ⇤ ⇤ int mesh=10;

//======Declaring qubits ’ individual Hamiltonains ( Real )======matrix etamat(D,D) ,X(D,D) ,eye(D,D) ,eye2 (2 ,2) ; matrix HXtot(pow(D,D) ,pow(D,D)) ,H1(D,D) ,EtaH(pow(D,D) ,pow(D,D)) ; matrix Hw1(pow(D,D) ,pow(D,D)) ,Hw2(pow(D,D) ,pow(D,D)) ,Hw3(pow(D,D) ,pow(D,D)) ; matrix CNot(8 ,8) ,CNot vec (1 ,8) , Utarget (8 ,8) ,HYtot(pow(D,D) ,pow(D,D) ) ,H(pow(D,D) ,

pow(D,D) ) ;

etamat (0 ,0)=0;etamat (0 ,1)=0;etamat (0 ,2)=0;etamat (0 ,3)=0; etamat (1 ,0)=0;etamat (1 ,1)=0;etamat (1 ,2)=0;etamat (1 ,3)=0; etamat (2 ,0)=0;etamat (2 ,1)=0;etamat (2 ,2)=eta ; etamat (2 ,3)=0; etamat (3 ,0)=0;etamat (3 ,1)=0;etamat (3 ,2)=0;etamat (3 ,3)=3 eta ; ⇤

X(0 ,0) =0;X(0 ,1) =1;X(0 ,2) =0;X(0 ,3) =0;

X(1 ,0)=1;X(1 ,1)=0;X(1 ,2)=sqrt (2) ;X(1 ,3)=0;

X(2,0)=0;X(2,1)=sqrt(2) ;X(2,2)=0;X(2,3)=sqrt(3) ;

X(3 ,0)=0;X(3 ,1)=0;X(3 ,2)=sqrt (3) ;X(3 ,3)=0;

H1 ( 0 , 0 ) =0;H1 ( 0 , 1 ) =0;H1 ( 0 , 2 ) =0;H1 ( 0 , 3 ) =0;

H1 ( 1 , 0 ) =0;H1 ( 1 , 1 ) =1;H1 ( 1 , 2 ) =0;H1 ( 1 , 3 ) =0;

H1 ( 2 , 0 ) =0;H1 ( 2 , 1 ) =0;H1 ( 2 , 2 ) =2;H1 ( 2 , 3 ) =0;

H1 ( 3 , 0 ) =0;H1 ( 3 , 1 ) =0;H1 ( 3 , 2 ) =0;H1 ( 3 , 3 ) =3;

eye (0 ,0)=1;eye (0 ,1)=0;eye (0 ,2)=0;eye (0 ,3)=0; eye (1 ,0)=0;eye (1 ,1)=1;eye (1 ,2)=0;eye (1 ,3)=0; eye (2 ,0)=0;eye (2 ,1)=0;eye (2 ,2)=1;eye (2 ,3)=0; eye (3 ,0)=0;eye (3 ,1)=0;eye (3 ,2)=0;eye (3 ,3)=1; eye2 (0 ,0)=1;eye2 (0 ,1)=0;eye2 (1 ,0)=0;eye2 (1 ,1)=1;

//======Target Gate (CZ gate )======

CNot vec . array1d [0]=1; CNot vec . array1d [1]=1; CNot vec . array1d [2]=1; CNot vec .

array1d [3]=1;

CNot vec . array1d [4]=1; CNot vec . array1d [5]=1; CNot vec . array1d [6]=1; CNot vec .

array1d[7]= 1; CNot=diagmat ( CNot vec) ;

144 //======Declaring qubits ’ indovidual Hamiltonains (Complex)

======

cmatrix Y(D,D) ;

Y(0 ,0)=Complex(0) ;Y(0 ,1)=Complex(0, 1) ;Y(0 ,2)=Complex(0) ;Y(0 ,3)=Complex(0) ; Y(1 ,0)=Complex(0 ,1) ;Y(1 ,1)=Complex(0) ;Y(1 ,2)=Complex(0, sqrt (2)) ;Y(1 ,3)=Complex (0) ;

Y(2 ,0)=Complex(0) ;Y(2 ,1)=Complex(0 , sqrt (2) ) ;Y(2 ,2)=Complex(0) ;Y(2 ,3)=Complex(0, sqrt (3)) ;

Y(3 ,0)=Complex(0) ;Y(3 ,1)=Complex(0) ;Y(3 ,2)=Complex(0 , sqrt (3) ) ;Y(3 ,3)=Complex(0) ;

//======Define the total Hamiltonian along X,Y,Z of the system

======

HYtot=g/2 (kron(kron(Y,Y),eye)+kron(eye,kron(Y,Y))).cmatrix to matrix () ; ⇤ HXtot=g/2 (kron(kron(X,X),eye)+kron(eye,kron(X,X))); ⇤ EtaH=kron(etamat ,kron(eye ,eye))+kron(kron(eye ,eye) ,etamat)+kron(kron(eye ,etamat) ,

eye) ;

H=H X t o t+H Y t o t+E t a H ;

Hw1=kron(H1,kron(eye ,eye)) ;

Hw2=kron(eye ,kron(H1,eye)) ;

Hw3=kron(eye ,kron(eye ,H1)) ;

Utarget=CNot;

mVector Htot (4 , matrix (20 ,20) ) ; Htot [0]= projection (H) ;

mVector Htot[1]=projection(Hw1);Htot[2]=projection(Hw2);Htot[3]=projection(Hw3);

mVector U(1 , matrix (8 ,8) ) ; U[0]= Utarget ;

//======Define the problem to be sent to DE function , Pre initialization of DE optimization=====

problem Problem(Hamitonian M,Crossover CR , Mutation F,Computational D,NPDimp,

ctrpar , Generation ,Htot ,U,dt ,mesh) ;

int dist1=1;

int dist2=2;

unsigned int NPDIM=( P r o b l e m . NPDim ) (Problem.K); ⇤ unsigned int each popsize=Problem.K Problem .M; ⇤ int seed [4]; if (fmod((double)mynode,2)==0) { seed[0]=mynode+451;seed[1]=mynode+3425;seed[2]=mynode+2501;seed[3]=mynode

+3217;

else } { seed[0]=mynode+1078;seed[1]=mynode+3960;seed[2]=mynode+1601;seed[3]=mynode

+1202;

}

145 matrix pop(NPDIM, each popsize) , Fidelity (1,NPDIM) ,single pop (1,each popsize) ,

Fidelity itr (1,Generation); rand matrix( dist2 , seed , single pop) ;

double err=EvalUT(single pop ,Problem) ;

if (mynode==0) { Fidelity .array1d[0]=err ;

for ( int j=0; j

pop(mynode, j )=single pop .array1d[ j ];

} //======DE rates definition======double tau1=.1;double tau2=.1;double Fl=.1;double Fu=.9; matrix rates (1 ,2) ; rand matrix( dist1 , seed , rates ) ; rates .array1d[0]=rates .array1d [0] Fu+Fl ; ⇤ //======MPI part

of the program======

//1 1transferringdatafromsalvestomaster Initialization if (mynode!=0) { MPI Send( single pop .array1d , each popsize ,MPI DOUBLE, 0 , 0 ,MPI COMM WORLD) ;

MPI Send(&err ,1 ,MPI DOUBLE, 0 , 1 ,MPI COMM WORLD) ;

else } { for ( int j=1; j

MPI COMM WORLD, & s t a t u s ) ;

for ( int k=0; k

pop( status .MPI SOURCE, k )=s i n g l e pop . array1d [k];

//4 3recievingthefidelitydata,objectivefunctionoutput MPI Recv(&err ,1 , MPI DOUBLE, MPI ANY SOURCE, 1 , MPI COMM WORLD, & s t a t u s ) ;

Fidelity .array1d[ status .MPISOURCE]= e r r ;

}

} int Gen=0;

//======Iterative part of DE======

while (Gen

146 if (mynode==0) { for( int j=1; j

MPI Send( Fidelity . array1d ,NPDIM,MPI DOUBLE, j , 0 ,MPI COMM WORLD) ;

} //2 2recieving”allpop”andFidelityfromslaves

else } { MPI Recv( pop . array1d ,NPDIM each popsize , MPI DOUBLE, 0 , 0 , ⇤ MPI COMM WORLD, & s t a t u s ) ;

MPI Recv( Fidelity .array1d ,NPDIM, MPI DOUBLE, 0 , 0 , MPI COMM WORLD, & s t a t u s

);

} err=DE(Problem, pop , single pop ,mynode, seed , Fidelity , rates ,Gen) ;

//3 1runningDEoneachnodeandreturningtheresults //updating master node information

//saving data from node zero on global variable on node zero if (mynode==0) { Fidelity .array1d[0]=err ;

for( int j=0; j

pop (0 , j )=single pop . array1d [ j ];

} //4 Updating allpop contents by single pop from slaves if (mynode!=0) { MPI Send(&err ,1 ,MPI DOUBLE, 0 , 1 ,MPI COMM WORLD) ;

MPI Send( single pop .array1d , each popsize ,MPI DOUBLE, 0 , 0 ,MPI COMM WORLD)

;

else } { for ( int j=1; j

status) ;

Fidelity .array1d[ status .MPISOURCE]= e r r ;

//6 2recievingthepopulationdata

147 MPI Recv( single pop .array1d , each popsize , MPI DOUBLE, MPI ANY SOURCE,

0, MPICOMM WORLD, & s t a t u s ) ;

for ( int k=0; k

pop( status .MPI SOURCE, k )=s i n g l e pop .array1d [k];

}

//printing out the results from node zero Fidelity itr .array1d[Gen]=(Fidelity .min()).array1d[0];

} Gen++;

} if (mynode==0) { printi(Fidelity itr ,”Fidelity itr .dat”);

printi( pop . rowi (( int)(Fidelity.min()).array1d[1]) ,”Optimal solution .dat”) ;

printi( pop , ”Population . dat”) ;

}

MPI : : F i n a l i z e ( ) ;

return 0;

}

ﬁlenames:matrix.cpp

#i n c l u d e ”matrix.h”

#i n c l u d e

/ ⇤ version 0.00 Date=Sep 25 2014 Written by Ehsan Zahedinejad. PhD at U of Calgary. Department of Physics...

This is the matrix class implementation. A short explanation is given for each

function

in the matrix .h file . Note that I am treating 1d aray as 2d array in my program in a

column major routine .

The main reason is that you can not pass 2d array in MPI library between nodes so

this could be a good reason to have 1d and deal as 2d arrays.

/ ⇤ //======//

matrix :: matrix(unsigned int t1 , unsigned int t2)

{ rows=t1 ;

148 cols=t2;

array1d= new double [rows cols ]; ⇤

} //======// matrix :: matrix(const matrix &t)

{ rows=t . rows ;

cols=t. cols ;

int size=rows cols ; ⇤ int one=1;

array1d= new double [size];

dcopy(&size ,t.array1d,&one ,array1d,&one);

} //======// matrix ::˜ matrix ()

{ delete [] this >array1d ;

} //======// matrix& matrix :: operator=(const matrix& t)

{ if ( this!=&t ) //be aware of self assignement { this >˜matrix () ; this >rows=t . rows ; this >cols=t. cols ; int size=rows cols ; ⇤ int one=1;

this >array1d= new double [size]; dcopy(&size , t . array1d ,&one , this >array1d ,&one) ;

// std ::copy(t.array1d ,t.array1d+(t.rows t.cols),this >array1d) ; ⇤

} return this ; ⇤

} //======//

// I am chaning this to a column major one double&matrix::operator ()(unsigned int t1 , unsigned int t2) { unsigned int r=this >rows ; return( this >array1d [ r t2+t1 ]) ; ⇤

149 / return(this >array1d [ t1 c+t 2 ] ) ; ROW MAJOR / ⇤ ⇤ ⇤

} //======// matrix operator+(const matrix& m1, const matrix& m2)

{ unsigned int size=m1.rows m1 . c o l s ; ⇤ matrix temp(m1. rows ,m1. cols ) ;

for ( int i=0; i

} return temp ;

} //======// matrix operator ( const matrix& t1 , const matrix& t2) ⇤

{ int m=t1 . rows ,n=m,k=m, lda=m,ka=m, ldc=m, ldb=m;

double alpha=1.00,beta=0; //C< alpha A B beta C ⇤ ⇤ ⇤ matrix product(m,m);

/ ⇤ Since we have row major array and blas does the product in column major we f i r s t tranpose each matrix and then

pass them to the dgemm function . TSD and TSA with having the fist letter ”T”

sending this message to the dgemm. The other

letters ”S” and ”A” do not matter / ⇤ dgemm(”NSA” ,”NSA”,&m,&n,&k,&alpha , t1 . array1d,&lda , t2 . array1d,&ldb,&beta , product .

array1d ,&ldc ) ;

return product ;

} //======// matrix operator ( const double c,const matrix& m) ⇤

{ matrix product(m. rows ,m. cols ) ;

for ( int i=0; i

return product ;

} //======// matrix operator ( const matrix& m, const double c) ⇤

{

150 return (c m) ; ⇤

} //======// matrix matrix :: rowi(unsigned int i)

{ int c=this >cols ; int r=this >rows ; matrix tmp(1 ,c) ;

for ( int j=0; jarray1d [ r j+i ] ; ⇤

}

return tmp ;

} //======// void matrix :: eye ()

{ int r=this >rows ; int c=this >cols ;

for ( int i=0 ; iarray1d [ i ]=0;

}

for ( int j=0; jarray1d [ c j+j ]=1.0; ⇤

}

} //======// void eig(matrix& eigevalue ,matrix& eigenvector ,matrix& t1)

{ int n=t 1 . r o w s ;

int lda=n;

double vl=0,vu=0;

int il=1, iu=n;

double abstol=1e 14; int ldz=n;

151 int lwork=40 n; ⇤ int liwork=20 n; ⇤ int iwork=new i n t [liwork]; ⇤ double work=new double [lwork]; ⇤ int m;

int info ;

int isuppz=new i n t [2 n]; ⇤ ⇤

dsyevr(”VECTOR”,”ALL”,”LOWER”,&n, t1 . array1d ,&lda ,&vl ,&vu,&il ,&iu ,&abstol ,&m,

eigevalue .array1d , eigenvector .array1d,&ldz ,isuppz ,work,&lwork ,iwork,&

liwork ,&info ) ;

delete [] iwork;

delete [] work;

delete [] isuppz;

} //======// matrix conjugate (const matrix& t1) {

//first making the identity matrix

int rows=t1 . rows ;

int cols=t1. cols ;

matrix eye(rows , cols ) ;

for ( int i=0 ; i

}

for ( int j=0; j

}

matrix product(t1 . rows , t1 . cols ) ;

int m=t1 . rows ,n=m,k=m, lda=m,ka=m, ldc=m, ldb=m;

double alpha=1,beta=0; //C< alpha A B beta C ⇤ ⇤ ⇤ dgemm(”CSA” ,”NSA”,&m,&n,&k,&alpha , t1 . array1d,&lda , eye . array1d,&ldb,&beta , product .

array1d ,&ldc ) ;

return product ;

} //======//

152 matrix transpose (const matrix& t1) {

//first making the identity matrix

int rows=t1 . rows ;

int cols=t1. cols ;

matrix eye(rows , cols ) ;

for ( int i=0 ; i

}

for ( int j=0; j

}

matrix product(t1 . rows , t1 . cols ) ;

int m=t1 . rows ,n=m,k=m, lda=m,ka=m, ldc=m, ldb=m;

double alpha=1,beta=0; //C< alpha A B beta C ⇤ ⇤ ⇤ dgemm(”TSA” ,”NSA”,&m,&n,&k,&alpha , t1 . array1d,&lda , eye . array1d,&ldb,&beta , product .

array1d ,&ldc ) ;

return product ;

} //======// matrix matrix :: min()

{ int c=this >cols ; int r=this >rows ;

matrix id min (1 ,2) ;

id min . array1d[0]=this >array1d [0]; id min . array1d [1]=0;

for ( int i=0; iarray1d [ i]< id min . array1d [0]) { id min . array1d[0]=this >array1d [ i ]; id min . array1d[1]= i ;

}

return id min ;

}

153 //======//

matrix matrix :: operator+(double a) {

int c=this >cols ; int r=this >rows ;

matrix tmp(c , r) ;

for ( int i=0; iarray1d [ i]+a;

return tmp ;

} //======//

matrix operator+(double a,matrix& t1) {

return(t1+a);

} //======//

matrix diagmat(matrix& t1) {

int cols=t1. cols ;

matrix tmp( cols , cols ) ;

for ( int i=0 ; i

}

for ( int j=0; j

} return tmp ;

}

ﬁlenames:matrix.h

#i f n d e f MATRIX

#d e f i n e MATRIX

#i n c l u d e // std : : copy

#i n c l u d e

154 #d e f i n e MKL Complex16 std : : complex

#i n c l u d e ”mkl.h”

/ Function for Matric Matrix multiplication ”Blas routine” / ⇤ ⇤ ⇤ //extern ”C” void dgemm(char TransA , char TransB , int m, i n t n, int k,double alpha , ⇤ ⇤ ⇤ ⇤ ⇤ ⇤ double a,int lda , double b,int ldb , double beta , double c,int ldc); ⇤ ⇤ ⇤ ⇤ ⇤ ⇤ ⇤ class matrix

{ public :

unsigned int rows , cols ;

double array1d ; ⇤ matrix(unsigned int t1 , unsigned int t2) ; //Constructor

matrix(const matrix &t) ; //Matrix copy constructor

matrix& operator=(const matrix& t) ; //Matrix copy assignment

// matrix reshape(unsigned int t1,unsigned int t2); //Reshape Matrix

˜matrix() ; // deallocate memroy

double& operator ()(unsigned int t1 , unsigned int t2) ; //Forming Mat( i , j )

instead of Mat.array[ i ][ j ]

matrix rowi(unsigned int i); //return the ith row of

matrix

void eye () ; //Making Identity

Matrices

matrix min() ;

matrix operator+(double a);

; } matrix operator+(double a,matrix& t1);

matrix operator+(const matrix& m1, const matrix& m2) ; //Matrix+ overload

matrix operator ( const matrix& t1 , const matrix& t2) ; //Matrix overload ⇤ ⇤ matrix operator ( const double c,const matrix& m); //Matrix overload ⇤ ⇤ matrix operator ( const matrix& m, const double c); //Matrix overload ⇤ ⇤ void eig(matrix& eigevalue ,matrix& eigenvector ,matrix& t1) ; // Calculate the

eigenvalue and eigenvector of a symetric matrix

matrix transpose (const matrix& t1) ;

matrix conjugate (const matrix& t1) ;

matrix diagmat(matrix& t1) ;

#e n d i f

ﬁlenames:cmatrix.cpp

#i n c l u d e ”cmatrix.h”

155 / ⇤ version 0.00 Date=Sep 25 2014 Written by Ehsan Zahedinejad. PhD at U of Calgary. Department of Physics...

This is the std :: complex matrix class implementation . A short explanation is

given for each function

in the matrix .h file . Note that I am treating 1d aray as 2d array in my program.

This is just to increase the cashe waste and memory miss and to spped up the

algorithms

performance. The other reason is that you can not pass 2d array in MPI library

between nodes se this could be a good reason to have 1d and deal as 2d arrays.

/ ⇤ //======// cmatrix :: cmatrix(unsigned int t1 , unsigned int t2) { rows=t1 ;

cols=t2;

array1d=new std :: complex[rows cols ]; ⇤

} //======//

cmatrix ::˜ cmatrix ()

{ delete [] array1d;

} //======// cmatrix :: cmatrix(const cmatrix &t)

{ rows=t . rows ;

cols=t. cols ;

int size=rows cols ; ⇤ int one=1;

array1d= new std :: complex[size ];

zcopy(&size ,t.array1d,&one ,array1d,&one);

} //======// cmatrix& cmatrix :: operator=(const cmatrix& t) { if ( this!=&t ) { this >˜cmatrix () ; rows=t . rows ;

cols=t. cols ;

156 int size=rows cols ; ⇤ int one=1;

array1d= new std :: complex[rows cols ]; ⇤ zcopy(&size ,t.array1d,&one ,array1d,&one); } return this ; ⇤ } //======// cmatrix operator+(const cmatrix& m1,const cmatrix& m2) { int r=m1. rows ;

int c=m1 . c o l s ;

cmatrix sum(r , c) ;

for ( int i=0; i

return sum ;

} //======// cmatrix operator+(const matrix& m1, const cmatrix& m2)

{ int r=m1. rows ;

int c=m1 . c o l s ;

cmatrix sum(r , c) ;

for ( int i=0; i(m1.array1d[ i ])+m2.array1d[ i ];

return sum ; } //======// cmatrix operator+(const cmatrix& m1,const matrix& m2) { return(m2+m1) ; } //======// cmatrix operator ( const cmatrix& t1 ,const cmatrix& t2) ⇤ { cmatrix product(t1 . rows , t2 . cols ) ;

int m=t1 . rows ,n=m,k=m, lda=m,ka=m, ldc=m, ldb=m;

Complex alpha=Complex (1.0) , beta=Complex(0) ; //C< alpha A B beta C ⇤ ⇤ ⇤ zgemm(”NSA” ,”NSA”,&m,&n,&k,&alpha , t1 . array1d,&lda , t2 . array1d,&ldb,&beta , product .

array1d ,&ldc ) ;

return product ; } //======// cmatrix operator ( const matrix& t1 , const cmatrix& t2) ⇤ {

int rows=t1 . rows ;

int cols=t1. cols ;

int lda=rows ;

157 int ldc=rows;

int ldb=rows ;

cmatrix product(rows , cols ) ;

double rwork=new double [2 rows cols ]; ⇤ ⇤ ⇤ zlarcm(&rows,&cols , t1 . array1d ,&lda , t2 . array1d ,&ldb , product . array1d ,&ldc , rwork) ;

delete [] rwork;

return product ; }

//======// cmatrix operator ( const cmatrix& t1 ,const matrix& t2) ⇤ { int rows=t1 . rows ;

int cols=t1. cols ;

int lda=rows ;

int ldc=rows;

int ldb=rows ;

cmatrix product(rows , cols ) ;

double rwork=new double [2 rows cols ]; ⇤ ⇤ ⇤ zlacrm(&rows,&cols , t1 . array1d ,&lda , t2 . array1d ,&ldb , product . array1d ,&ldc , rwork) ;

delete [] rwork;

return product ;

} //======// cmatrix operator ( const double c,const cmatrix& m) ⇤ { cmatrix product(m. rows ,m. cols ) ;

for ( int i=0; i(c) m. array1d [ i ] ; ⇤

} return product ;

} //======// cmatrix operator ( const cmatrix& m,const double c) ⇤

{ return(c m) ; ⇤

} //======// std :: complex&cmatrix::operator ()(unsigned int t1 , unsigned int t2)

{ unsigned int r=this >rows ; return( this >array1d [ r t2+t1 ]) ; ⇤

158 } //======// matrix cmatrix :: cmatrix to matrix ()

{ int r=this >rows ; int c=this >cols ; matrix tmp(r , c) ;

for ( int i=0; iarray1d [ i ]) ; return tmp ; } //======// void cmatrix :: eye ()

{ int r=this >rows ; for ( int i=0 ; iarray1d [ i]=Complex(0) ;

} for ( int j=0; jarray1d [ cols j+j ]=Complex (1.0) ; ⇤

}

} //======// cmatrix diagmat(cmatrix& t1) { int cols=t1. cols ;

cmatrix tmp( cols , cols ) ;

for ( int i=0 ; i

} for ( int j=0; j

} return tmp ;

} //======// cmatrix transpose (const cmatrix& t1) { //first making the identity matrix

int rows=t1 . rows ;

int cols=t1. cols ;

cmatrix eyec(rows , cols ) ;

for ( int i=0 ; i

159 eyec . array1d [ i]=Complex(0) ;

} for ( int j=0; j

} cmatrix product( cols , rows) ;

int n=rows ,k=rows , lda=rows ,ka=rows , ldc=rows , ldb=rows;

Complex alpha=Complex (1.0) , beta=Complex(0) ; //C< alpha A B beta C ⇤ ⇤ ⇤ zgemm(”TSA” ,”NSA”,&rows,&n,&k,&alpha , t1 . array1d,&lda , eyec . array1d,&ldb,&beta ,

product . array1d ,&ldc ) ;

return product ;

} //======// std :: complex sum mat( cmatrix t1 ) { std :: complex tmp ( 0 , 0 ) ;

int r=t1 . rows ;

int c=t1 . c o l s ;

for ( int i=0; i

} //======// cmatrix operator (Complex beta ,cmatrix t2) ⇤ { cmatrix product=t2 ;

int m=t2 .rows ,n=m,k=m, lda=m,ka=m, ldc=m, ldb=m;

Complex alpha=Complex(0) ; //C< alpha A B beta C ⇤ ⇤ ⇤ zgemm(”NSA” ,”NSA”,&m,&n,&k,&alpha , product . array1d,&lda , product . array1d,&ldb,&beta

,product.array1d,&ldc);

return product ;

}

//======// cmatrix innerproduct (cmatrix t1 , matrix t2) {

int r=t1 . rows ;

int c=t1 . c o l s ;

cmatrix tmp(r , c) ;

for ( int i=0; i

160 tmp( i , j )=t1 ( i , j ) Complex( t2 ( i , j ) ) ; ⇤

}

} return tmp ;

}

ﬁlenames:cmatrix.h

#i f n d e f COMPLEX MATRIX

#d e f i n e COMPLEX MATRIX

#i n c l u d e

#i n c l u d e ”matrix.h”

#i n c l u d e

typedef std :: complex Complex ;

class cmatrix

{ public :

unsigned int rows , cols ;

std :: complex array1d ; ⇤

cmatrix(unsigned int t1 , unsigned int t2) ; //Complex matrix

constructor

˜cmatrix() ; //array destructor

cmatrix(const cmatrix &t) ; //Complex copy

constructor

cmatrix& operator=(const cmatrix& t) ; //Complex copy assignment

// double norm1() ;

std :: complex& operator ()(unsigned int t1 , unsigned int t2) ;

matrix cmatrix to matrix () ;

void eye () ;

; } cmatrix operator+(const cmatrix& m1,const cmatrix& m2) ; //Matrix+ overload

cmatrix operator+(const matrix& m1, const cmatrix& m2) ; //Matrix+ overload

cmatrix operator+(const cmatrix& m1,const matrix& m2) ; //Matrix+ overload

cmatrix operator (Complex beta ,const cmatrix t2) ; ⇤

cmatrix operator ( const cmatrix& t1 ,const cmatrix& t2) ; //Matrix overload ⇤ ⇤ cmatrix operator ( const cmatrix& t1 ,const matrix& t2) ; //Matrix overload ⇤ ⇤ cmatrix operator ( const matrix& t1 , const cmatrix& t2) ; //Matrix overload ⇤ ⇤

161 cmatrix operator ( const double c,const cmatrix& m); //Matrix overload ⇤ ⇤ cmatrix operator ( const cmatrix& m,const double c); //Matrix overload ⇤ ⇤ //double max( double p,int i); ⇤ cmatrix diagmat(cmatrix& t1) ; //

Making matrix diagonal

cmatrix transpose (const cmatrix& t1) ; //Transpose of a Matrix

std :: complex sum mat( cmatrix t1 ) ;

cmatrix innerproduct (cmatrix t1 , matrix t2) ;

#e n d i f //#COMPLEX MATRIX

ﬁlenames:utilities.cpp

#i n c l u d e ”utilities.h”

//======

void rand matrix(int a,int seed , matrix& t1) ⇤

{

int rows=t1 . rows ;

int cols=t1. cols ;

int size=rows cols ; ⇤ dlarnv (&a, seed , &size , t1 . array1d) ;

} //======

void random shuffle1(int mat , int size ,int mynode) ⇤

{ srand (unsigned(time(0) mynode) ) ; ⇤ std :: random shuffle( &mat[0] , &mat[ size ]) ;

/ for (int i=0; i

} //======

void constrain(matrix& pop,double min , double max)

{ int rows=pop . rows ;

int cols=pop. cols ;

int size=cols rows ; ⇤ for ( int i=0; imax) { pop . array1d [ i ]=max;

else if (pop.array1d[ i]

162 pop . array1d [ i ]=min ;

}

} //======matrix projection (matrix& t1)

{ int G[20]= 0,1,2,3,4,5,6,8,9,12,16,17,18,20,21,24,32,33,36, { 48 ; } matrix tmp(20 ,20) ;

for ( int k=0; k<20; k++)

for ( int j=0; j<20; j++)

tmp( k , j )=t1 (G[ k ] ,G[ j ] ) ;

return tmp ;

} //======matrix erfun (problem& Problem , matrix& f )

{ int K= P r o b l e m . K ;

int M= P r o b l e m . M ;

int mesh=Problem . mesh ;

int dim=(K 1) mesh ; ⇤ double Pdt=Problem . dt ;

double width=5;

matrix pulse1(1,K) ,pulse2(1,K) ,pulse3(1,K);

matrix sp1(1 ,dim) ,sp2(1 ,dim) ,sp3(1 ,dim) ;

matrix out(1 ,3 dim) ; ⇤

for ( int main=0; main

}

double dt=(double)1/mesh 2 M PI ; ⇤ ⇤ int num=0;

double X,Y1p1 ,Y1p2 ,Y1p3 ,Y2p1 ,Y2p2 ,Y2p3;

for ( int i=0; i

163 X=((double)(i+0.5) Pdt)+(dt /2) ; ⇤ Y1p1=0.5 (pulse1.array1d[i]+pulse1.array1d[i+1]);Y2p1=0.5 (pulse1.array1d[i ⇤ ⇤ +1] pulse1 . array1d [ i ]) ; Y1p2=0.5 (pulse2.array1d[i]+pulse2.array1d[i+1]);Y2p2=0.5 (pulse2.array1d[i ⇤ ⇤ +1] pulse2 . array1d [ i ]) ; Y1p3=0.5 (pulse3.array1d[i]+pulse3.array1d[i+1]);Y2p3=0.5 (pulse3.array1d[i ⇤ ⇤ +1] pulse3 . array1d [ i ]) ;

for ( int j=0; j

X+= d t ;

}

} num=0;

for ( int k=0; k

out . array1d [num+1]=sp2. array1d [k ];

out . array1d [num+2]=sp3. array1d [k ];

num+=3;

}

return out ;

//End of function }

ﬁlenames:utilities.h

#i f n d e f UTILITIES H

#d e f i n e UTILITIES H

#i n c l u d e ”cmatrix.h”

#i n c l u d e // std::rand, std::srand

#i n c l u d e

#i n c l u d e ”problem.h”

#i n c l u d e

#i n c l u d e ”printi.h”

164 / rand matrix function explanation This matrix generate random numbers according to ⇤ the following definitions:

a=t y p e o f d i s t r i b u t i o n

a=1: uniform (0 ,1)

a=2: uniform ( 1,1) a= 3 : normal ( 0 , 1 )

seed initial seed. its getting updated after each time we call this function matrix t1 : matrix includes tha final results

/ ⇤ void rand matrix(int a,int seed , matrix& t1) ; ⇤ // random generator functions for index of the matrices:

void random shuffle1(int mat , int size ,int mynode) ; ⇤ //constraining the elements of a matrix between a min and max value

void constrain(matrix& pop,double min , double max) ;

//Projecting from Hilbert space to Computational space

cmatrix project null(cmatrix& t1);

matrix projection (matrix& t1) ;

matrix erfun (problem& Problem , matrix& f ) ;

#e n d i f

ﬁlenames:problem.cpp

#i n c l u d e ”problem.h”

#i n c l u d e

using namespace std ;

problem : : problem(unsigned int h1 , float h2 , float h3 , unsigned int h4 , double h5 , double

h6 , unsigned int h7 , mVector h8 , mVector h9 , double h10 , int h11) { M= h 1 ;

CR=h 2 ;

F=h 3 ;

dimension=h4;

NPDim=h5 ;

K= h 6 ;

G= h 7 ;

H. push back(h8 [0]) ;

H. push back(h8 [1]) ;

H. push back(h8 [2]) ;

H. push back(h8 [3]) ;

U. push back(h9 [0]) ;

165 dt=h10 ;

mesh=h11 ;

//U=h9 ;

} //[h1,h2,h3,h4,h5,h6,h7,h8,h9]=[M,CR,F,dimesnion ,NPDim,K,G,H,U]

//Remember: I have to define the destructore for this class in the future.

//Although it is not needed at this time since We only generate One problem for one

run and it

//willbe destryed at the end of the run.

ﬁlenames:problem.h

#i f n d e f PROBLEM H

#d e f i n e PROBLEM H

#i n c l u d e

#i n c l u d e ”cmatrix.h”

#i n c l u d e ”matrix.h”

#i n c l u d e

typedef std :: vector mVector ;

typedef std :: vector cmVector ;

class problem { public :

//M defines the number of control Hamitonian

// Crossover rate

// F mutation rate

//dimension: is the Hilbert space dimension //NPDim is the number that if multiply with K gives us the number of population

//G Number of Generation

//K number of control parameter

unsigned int M; //h1

float CR ; //h2

float F; //h3

unsigned int dimension ; //h4

unsigned int NPDim ; //h5

int K; //h6

unsigned int G; //h7

double dt ;

//Having Hamiltonian defined Here. Their number may vary as the number of control

166 Hamiltonian changes

mVector H; //h8

//matrix H1, H2, H3, U; ⇤ ⇤ ⇤ ⇤ //Target Matrix

mVector U; //h9

int mesh ;

public :

//Constructor: Here we construct all the element of problem [h1,h2,h3,h4,h5,h6,h7

,h8,h9,h10,h11]=[M,CR,F,dimesnion,NPDim,K,G,H,U,dt,mesh]

problem(unsigned int h1 , float h2 , float h3 , unsigned int h4 , double h5 , double h6 ,

unsigned int h7 , mVector h8 , mVector h9 , double h10 , int h11) ;

//void kronker(complex h9 , complex h10) ; ⇤⇤ ⇤⇤ ; }

#e n d i f //PROBLEM H

ﬁlenames:EvalUT.cpp

#i n c l u d e ”EvalUT.h”

#i n c l u d e ”iostream”

//======Evolution part

double EvalUT( matrix m, problem& Problem )

{ int N= P r o b l e m . d i m e n s i o n ;

int M= P r o b l e m . M ;

int K= P r o b l e m . K ;

int mesh=Problem . mesh ;

matrix m1=erfun (Problem ,m);

cmatrix Utot(N,N) ; Utot . eye () ;

matrix V(N,N) ,Er(1 ,N) ;

cmatrix Ec(1 ,N) ;

double INTEGDT=(double)1/mesh 2 M PI ; ⇤ ⇤ for ( int main=0; main<(K 1) mesh ; main++) ⇤ {

matrix X=Problem .H[0];

for ( int i=0; i

}

167 eig(Er,V,X);

for ( int j=0; j

} Utot=(V diagmat(Ec) transpose(V)) Utot ; ⇤ ⇤ ⇤

} double val = abs(sum mat(innerproduct(project null(Utot) ,(Problem.U[0]) )));

double err= 1 val /8; return err ;

} //======Phase Nullification

cmatrix project null(cmatrix& t1)

{ int N=8;

int G[]= 0,1,4,5,10,11,13,14 ; { } cmatrix UTp(N,N) ;

for ( int i=0; i

}

} Complex g(0 , 1) ; double teta1=arg(UTp(4 ,4)) ;

double teta2=arg(UTp(2 ,2)) ;

double teta3=arg(UTp(1 ,1)) ;

double teta4=arg(UTp(0 ,0)) ;

cmatrix V tmp(N,N) ; V tmp . eye () ;

V tmp (0 ,0)=Complex (1 ,0) ;

V tmp (1 ,1)=exp ( g teta3) ; ⇤ V tmp (2 ,2)=exp ( g teta2) ; ⇤ V tmp (3 ,3)=exp ( g (teta2+teta3)); ⇤ V tmp (4 ,4)=exp ( g teta1) ; ⇤ V tmp (5 ,5)=exp ( g (teta1+teta3)); ⇤ V tmp (6 ,6)=exp ( g (teta1+teta2)); ⇤ V tmp (7 ,7)=exp ( g (teta1+teta2+teta3)); ⇤ V tmp=exp ( g teta4) V tmp ; ⇤ ⇤ UTp=UTp V tmp ; ⇤

168 return UTp ;

}

ﬁlenames:EvalUT.h

#i n c l u d e

#i n c l u d e ”cmatrix.h”

#i n c l u d e ”problem.h”

#i n c l u d e ”printi.h”

#i n c l u d e ”utilities.h”

double EvalUT( matrix m, problem& Problem ) ;

cmatrix project null(cmatrix& t1);

ﬁlenames:kron.cpp

#i n c l u d e ”kron.h”

======//

cmatrix kron(cmatrix k1 , cmatrix k2)

{ unsigned int r1=k1. rows ;

unsigned int c1=k1 . cols ;

unsigned int r2=k2. rows ;

unsigned int c2=k2 . rows ;

cmatrix K(r1 r2 , r1 r2) ; ⇤ ⇤ for ( int i=0; i

for ( int j=0; j

for ( int k=0; k

for ( int l=0; l

K( k+i c2 , l+j c2)=k1( i , j ) k2(k , l ) ; ⇤ ⇤ ⇤ return K;

} //

======//

cmatrix kron(matrix k1 , cmatrix k2)

{ unsigned int r1=k1. rows ;

unsigned int c1=k1 . cols ;

unsigned int r2=k2. rows ;

169 unsigned int c2=k2 . rows ;

cmatrix K(r1 r2 , r1 r2) ; ⇤ ⇤ for ( int i=0; i

for ( int j=0; j

for ( int k=0; k

for ( int l=0; l

K( k+i c2 , l+j c2)=Complex(k1( i , j ) ) k2(k , l ) ; ⇤ ⇤ ⇤

return K;

} //

======//

cmatrix kron(cmatrix k1 , matrix k2)

{ unsigned int r1=k1. rows ;

unsigned int c1=k1 . cols ;

unsigned int r2=k2. rows ;

unsigned int c2=k2 . rows ;

cmatrix K(r1 r2 , r1 r2) ; ⇤ ⇤

for ( int i=0; i

for ( int j=0; j

for ( int k=0; k

for ( int l=0; l

K( k+i c2 , l+j c2)=k1( i , j ) Complex(k2(k , l ) ) ; ⇤ ⇤ ⇤

return K;

} //

======//

matrix kron(matrix k1 , matrix k2)

{ unsigned int r1=k1. rows ;

unsigned int c1=k1 . cols ;

unsigned int r2=k2. rows ;

unsigned int c2=k2 . rows ;

matrix K(r1 r2 , r1 r2) ; ⇤ ⇤

170 for ( int i=0; i

for ( int j=0; j

for ( int k=0; k

for ( int l=0; l

K( k+i c2 , l+j c2)=k1( i , j ) k2(k , l ) ; ⇤ ⇤ ⇤

return K;

} //

======//

ﬁlenames:kron.h

#i f n d e f KRONKER

#d e f i n e KRONKER

#i n c l u d e ”cmatrix.h”

#i n c l u d e ”matrix.h”

cmatrix kron(cmatrix k1 , cmatrix k2) ;

cmatrix kron(matrix k1 , cmatrix k2) ;

cmatrix kron(cmatrix k1 , matrix k2) ;

matrix kron(matrix k1 , matrix k2) ;

#e n d i f

ﬁlenames:DE.cpp

#i n c l u d e ”DE. h”

double DE(problem& Problem ,matrix& pop , matrix& single pop , int mynode , int seed , ⇤ matrix& Fidelity , matrix& rates , int Gen) { //======I n i t i a l i z i n g DE parameters

======

//Population size NPDIM

unsigned int NPDIM=( P r o b l e m . NPDim ) (Problem.K); ⇤ unsigned int each popsize=Problem.K Problem .M; ⇤ //mutatted population

matrix mpop (1 , each popsize) ;

mpop=single pop ;

//Crossed over elements

matrix cpop (1 , each popsize) ;

171 matrix index (1 , each popsize) ;

//======Random number for Crossover and

Mutation evolution======int dist1=1; int dist2=2; matrix temprand(1 ,4) ; rand matrix( dist1 , seed ,temprand) ;

//======Step One Randomly Initialize the population ( pop)======int indexid [NPDIM] , idrand [ each popsize ]; for ( int i=0; i

} for ( int i=0; i

} //======Define the Self adaptive constants and and self adaptive array containing the crossover rate and mutation rate double tau1=.1;double tau2=.1;double Fl=.1;double Fu=.9;

//======decide whether we wanna do the single element or all elements

optimization======

random shuffle1(idrand , each popsize ,(mynode+1) seed [0]) ; ⇤ int S=1;

if (fmod(double(Gen) ,7)==0) { S=e a c h popsize ;

} //======mutation part using mutation rate , F

======

random shuffle1(indexid ,NPDIM,mynode seed [2]) ; ⇤ if (( indexid[0]==mynode) (indexid[1]==mynode) (indexid[2]==mynode)) | | { int tmp1=indexid [ 0 ] ; int tmp2=indexid [ 1 ] ; int tmp3=indexid [ 2 ] ;

indexid[0]=indexid [3]; indexid[1]=indexid [4]; indexid[2]=indexid [5];

indexid[3]=tmp1; indexid[4]=tmp2; indexid[5]=tmp3;

} for ( int j=0; j

mpop.array1d[idrand[idrand[ j ]]]= pop(indexid[0] ,idrand[idrand[j ]])+

rates .array1d [0] ( pop(indexid[1] ,idrand[idrand[j ]]) pop( indexid ⇤ [2] ,idrand[idrand[ j ]]) );

172 //======i f this is a constrained problem run this part , Lets

write the function======

constrain( mpop , 2.5 ,2.5) ; //======Crossover part of the DE using

Cross over rate , G ======

cpop= mpop ;

rand matrix(dist1 , seed , index) ;

for ( int j=0; j

[j]]];

}

} //======Selection part of

the DE======

double err=Fidelity .array1d[mynode];

double tmp=EvalUT( cpop , Problem) ;

if (tmp

single pop= cpop ; } //======Updating the DE

constants rates======

rates .array1d[0]=(temprand.array1d[0]< tau1) ? (Fl+temprand . array1d [1] Fu) : r a t e s ⇤ .array1d[0];

rates .array1d[1]=(temprand.array1d[2]< tau2) ? (temprand.array1d[3]) : rates.

array1d [1];

return err ;

}

ﬁlenames:DE.h

#i f n d e f DE P

#d e f i n e DE P

//DE takes the problem as the input.

//problem include all the information that DE needs for optimization

#i n c l u d e ”problem.h”

#i n c l u d e ”algorithm”

#i n c l u d e ”utilities.h”

173 #i n c l u d e ”EvalUT.h”

#i n c l u d e ”printi.h”

#i n c l u d e

//void constrain(matrix pop,float min,float max,unsigned int popsize ,unsigned int ⇤ vecsize);

//unsigned int uniquerand(trng ::yarn2 R, unsigned int i1,unsigned int i2); ⇤ void DE( p r o b l e m& P r o b l e m , int mynode) ;

double DE(problem& Problem ,matrix& pop , matrix& single pop , int mynode , int seed , ⇤ matrix& Fidelity , matrix& rates , int Gen) ;

#e n d i f

ﬁlenames:printi.cpp

#i n c l u d e ”printi.h”

void printi(matrix t , string cfilename) {

const char filename = cfilename . c str () ; ⇤ std :: ofstream file ;

int r=t . rows ;

int c=t . c o l s ;

if (!( file .is open ())) { file .open (filename , ios ::out ios :: trunc); |

} // f i l e <<”rows ”<< t.rows<<”columns”<< t.cols<<’ n’; \ // file

<< ”======”<<’ n’; \ for ( int i=0; i

} file<< ’ n’; \

}

file .close();

}

void printi(cmatrix t , string cfilename) {

const char filename = cfilename . c str () ; ⇤

174 std :: ofstream file ;

int r=t . rows ;

int c=t . c o l s ;

if (!( file .is open ())) { file .open (filename , ios ::out ios :: trunc); |

} // f i l e <<”rows ”<< t.rows<<”columns”<< t.cols<<’ n’; \ // file

<< ”======”<<’ \ n’;

for ( int i=0; i

} file<< ’ n’; \

} file .close();

} void prints(matrix t)

{

for ( int i=0; i

} std :: cout<< ’ n’; \

}

} void printcs(cmatrix t)

{

for ( int i=0; i

175 std :: cout<< t(i ,j)<<” ”;

} std :: cout<< ’ n’; \

}

ﬁlenames:printi.h

#i n c l u d e

#i n c l u d e ”cmatrix.h”

using namespace std ;

void printi(matrix t , string cfilename);

void prints(matrix t);

void printcs(cmatrix t);

void printi(cmatrix t , string cfilename);

176 177