examples/hybrid_quantum_algorithms/QAOA/QAOA_braket.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n",
    "from braket.tracking import Tracker\n",
    "t = Tracker().start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QUANTUM APPROXIMATE OPTIMIZATION ALGORITHM (QAOA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial we show how to (approximately) solve binary combinatorial optimization problems, using the __Quantum Approximate Optimization Algorithm (QAOA)__, as introduced in Ref.[1]. \n",
    "The QAOA algorithm belongs to the class of __hybrid quantum algorithms__ (leveraging both classical as well as quantum compute), that are widely believed to be the working horse for the current __NISQ (noisy intermediate-scale quantum) era__.\n",
    "In this NISQ era QAOA is also an emerging approach for benchmarking quantum devices and is a prime candidate for demonstrating a practical quantum speed-up on near-term NISQ device [1,4]. \n",
    "To validate our approach we benchmark our results with exact results as obtained from classical QUBO solvers. \n",
    "\n",
    "We provide a step-by-step walkthrough explaining the QAOA quantum algorithm and show how to build the corresponding parametrized quantum circuit ansatz using the ```Braket``` SDK, with simple modular building blocks (that can be re-used for other purposes). \n",
    "We use open-source off-the-shelf ```scipy``` optimizers for classical numerical optimization. \n",
    "While we demonstrate our proof-of-concept approach using classical simulators for circuit execution, our code could in principle be run on actual quantum hardware by simply changing the definition of the ```device``` object (provided that the gate set used in the ansatz is supported by the device, as is the case here for IonQ; for Rigetti we need to apply one more extra trick as shown below). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BACKGROUND: HYBRID QUANTUM ALGORITHMS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quantum computers hold the promise to outperform even the most-powerful classical computers on a range of computational problems in (for example) optimization, chemistry, material science and cryptography.\n",
    "The canonical set of quantum algorithms (such as Shor's or Grover's quantum algorithms), however, comes with hardware requirements (such as a large number of quantum gates) that are currently not available with state-of-the-art technology. \n",
    "Specifically, these algorithms are typically believed to be feasible only with fault-tolerance as provided by quantum error correction. \n",
    "In the current __noisy intermediate-scale (NISQ) era__, near-term quantum computers do not have a large enough number of physical qubits for the implementation of error correction protocols, making this canonical set of quantum algorithms unsuitable for near-term devices. Against this background, the near-term focus has widely shifted to the class of __hybrid quantum algorithms__ that do not require quantum error correction. \n",
    "In these hybrid quantum algorithms, the noisy __near-term quantum computers are used as co-processors__ only, within a larger classical optimization loop, as sketched in the schematic figure below. \n",
    "Here, the undesired effects of noise are suppressed by deliberately limiting the quantum circuits on the quantum processing unit (QPU) to short bursts of the calculation, and the need for long coherence times (as required for the standard set of quantum algorithms) is traded for a classical overhead due to (possibly many) measurement repetitions and (essentially error-free) classical processing. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\"><img src=\"hybrid_quantum.png\"/></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Variational Quantum Algorithms__: Specifically, variational quantum algorithms such as the Quantum Approximate Optimization Algorithm (QAOA) [1] belong to this emerging class of hybrid quantum algorithms. \n",
    "These are widely believed to be promising candidates for the demonstration of a __quantum advantage__, already with near-term (NISQ) devices in areas such as quantum chemistry [2], condensed matter simulations [3], and discrete optimization tasks [4].\n",
    "\n",
    "__Variational Quantum Computing vs. Deep Learning__: The working principle of variational quantum computing is very much reminiscent of training deep neural networks: \n",
    "when you train a neural network, you have an objective function that you want to minimize, typically characterized by the error on your training set. \n",
    "To minimize that error, typically you start out with an initial guess for the weights in your network. \n",
    "The coprocessor, in that case a GPU, takes these weights which define the exact operation to execute and the output of the neural network is computed. \n",
    "This output is then used to calculate the value of your objective function, which in turn is used by the CPU to make an educated guess to update the weights and the cycle continues. \n",
    "Variational quantum algorithms, a specific form of hybrid algorithms, work in the very same way, using parametrized quantum circuits rather than parametrized neural networks and replacing the GPU with a QPU. \n",
    "Here, you start with an initial guess for the parameters that define your circuit, have the QPU execute that circuit, perform measurements to calculate an objective function, pass this value (together with the current values of the parameters) back to the CPU and have this *classical* CPU update the parameters based on that information. \n",
    "\n",
    "Of course, coordinating that workflow for quantum computers is much more challenging than in the previous case. Quantum computers are located in specialized laboratory facilities, are typically single threaded, and have special latency requirements. \n",
    "This is exactly the undifferentiated heavy-lifting that Amazon Braket handles for us, such that we can focus on our scientific problem. \n",
    "For the sake of this introductory tutorial, we simply use a classical circuit simulator (that mimic the behavior of a quantum machine) as the device to execute our quantum circuits.\n",
    "Within Amazon Braket, the workflow, however, is exactly the same. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BACKGROUND: QUADRATIC BINARY OPTIMIZATION PROBLEMS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Combinatorial optimization__: \n",
    "Combinatorial optimization problems are ubiquitous across many areas of science and application areas. \n",
    "Applications can be found (for example) in logistics, scheduling, planning, and portfolio optimization.\n",
    "In a nutshell combinatorial optimization problems are problems involving a large number of yes/no decisions with each set of decisions yielding a corresponding objective function value, like a cost or profit value. \n",
    "Because of the combinatorial explosion of the solution space with the number of variables, finding good solutions is a daunting task and extremely difficult.  \n",
    "\n",
    "__QUBO problems__: The QUBO ([Quadratic Unconstrained Binary Optimization](https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization)) model unifies a rich variety of NP-hard combinatorial optimization problems: \n",
    "Famous examples include Quadratic Assignment Problems, Capital Budgeting Problems, Task Allocation Problems and Maximum-Cut Problems. \n",
    "For more details we refer to the excellent review and tutorial on QUBO problems presented in Ref.[5].\n",
    "\n",
    "__Maximum Cut__: Among the class of QUBO problems, Maximum Cut (MaxCut) is paradigm combinatorial optimization problem. \n",
    "Given a graph $G=(V,E)$ with vertex set $V$ and edge set $E$, we seek partition of $V$ into two subsets with maximum cut. \n",
    "In short, we have to color every node either blue or red and we score a point whenever an edge connects two nodes with different colors. \n",
    "We then would like to find the solution with the highest score. \n",
    "Applications thereof can be found in, for example, (i) clustering for marketing purposes (segment your customer base into different clusters for targeted marketing) or (ii) portfolio optimization in finance (vertex corresponds to asset, with color referring to sell or buy decisions. \n",
    "Again, the problem in this specific graph coloring problem is that there are $2^𝑁$ possible solutions for $N$ nodes (an exponential explosion in possibilities), making it impossible to enumerate all possible candidates for relevant system sizes. \n",
    "\n",
    "__Ising Hamiltonian__: Importantly, there is a fundamental correspondence between QUBO problems and Ising problems in physics. \n",
    "Specifically, we can encode the Maximum Cut problem as a __minimization problem__ of an Ising Hamiltonian, where the (classical) cost function reads \n",
    "\n",
    "$$H_{C}=\\sum_{i>j} J_{i,j} z_{i} z_{j},$$\n",
    "\n",
    "with Ising variables $z_{i}=-1,1$ and the Ising matrix $J$ encoding the weights of the edges. \n",
    "For the sake of this discussion, we ignore potential linear terms and constant offsets (that do not affect the optimal solution $z$ anyway). \n",
    "In short, the cost Hamiltonian $H_{C}$ assigns a number to every bitstring $z=(z_{1},z_{2},\\dots)$, and we would like to find the lowest number possible. \n",
    "This will be the optimal assignment and solution to our problem. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BACKGROUND: THE QUANTUM APPROXIMATE OPTIMIZATION ALGORITHM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial we will try to solve for the optimal _classical_ bitstring $z$ using the Quantum Approximate Optimization Algorithm (QAOA). \n",
    "To this end, we first promote the classical spin variables $z_{i}=-1,1$ to quantum-mechanical variables $\\sigma_{i}^{z}$ (with the Pauli matrix $\\sigma_{i}^{z}$ representing the observable corresponding to spin along the $z$ coordinate axis in three-dimensional Euclidean space $\\mathbb{R}^{3}$). \n",
    "This leads to the following quantum mechanical cost Hamiltonian encoding the optimization problem\n",
    "\n",
    "$$\\hat{H}_{C}=\\sum_{i>j} J_{i,j} \\sigma_{i}^{z} \\sigma_{j}^{z},$$\n",
    "\n",
    "which can be written as a matrix of size $(2^{N}, 2^{N})$ with diagonal elements only corresponding to all possible classical values for the cost function $H_{C}$. \n",
    "The ground state of $\\hat{H}_{C}$ corresponds to the optimal solution of the classical combinatorial problem.\n",
    "\n",
    "__QAOA ansatz__: Finding this ground state is generically hard. \n",
    "To approximate this groundstate, QAOA prepares a parametrized ansatz state (corresponding to a parameterized  gate  sequence),  whose  parameters  are iteratively updated by a classical optimizer in a closed loop. \n",
    "Specifically, QAOA involves a specific ansatz wavefunction parametrized by a parameter family $(\\vec{\\beta}, \\vec{\\gamma})$, embedded into a larger classical optimization loop to find the optimal values for these parameters. \n",
    "As shown in Ref.[1], good approximate solutions to the problem class considered here can be found by preparing the variational state \n",
    "\n",
    "$$|\\gamma, \\beta \\rangle = U_{x}(\\beta_{p})U_{zz}(\\gamma_{p}) \\cdots U_{x}(\\beta_{1})U_{zz}(\\gamma_{1}) |s\\rangle$$\n",
    "\n",
    "with single qubit rotations induced by $U_{x}(\\beta) = \\exp(-i\\beta \\sum_{i}\\sigma_{i}^{x})$, \n",
    "and interactions described by $U_{zz}(\\gamma) = \\exp(-i\\gamma H_{C})$,\n",
    "starting initially from a product of $\\sigma^{x}$ eigenstates, i.e.,\n",
    "$|s\\rangle =|-,-,\\dots\\rangle$, with $|-\\rangle = (|0\\rangle -|1\\rangle  )/\\sqrt{2}$. \n",
    "The family of states $|\\gamma, \\beta \\rangle$ is prepared by alternating single-qubit operations $U_{x}(\\beta_{p})$ with targeted spin-spin interactions generated by the cost Hamiltonian $H_{C}$. \n",
    "The depth $p$ can be interpreted as a hyperparameter. \n",
    "For $p$ layers of QAOA blocks, there are $2p$ classical parameters to optimize over, \n",
    "since each layer $k$ is characterized by just two variational parameters, $\\gamma_{k}$ and $\\beta_{k}$. \n",
    "The preparation step outlined above is followed by a measurement in the computational basis, giving a classical string $z$, with which one can evaluate the objective function $H_{C}$ of the underlying combinatorial problem at hand. \n",
    "Taking several measurements shots one can build the expectation value $E(\\beta, \\gamma) = \\langle H_{C} \\rangle$ that we report as the objective function to the classical minimizer (while other choices could be possible as well). \n",
    "Repeating this procedure will provide an optimized string $z$, with the quality of the result improving as the depth of the quantum circuit $\\sim 2p$ is increased [1]. \n",
    "In fact, in principle (in the absence of noise and other imperfections), QAOA can reach the global optimum of any cost function in the limit $p \\rightarrow \\infty$ [1], approaching the adiabatic protocol. \n",
    "Thus, in theory the computational power of QAOA increases with $p$, but in practice the number of layers that can be executed without errors on NISQ devices is limited due noise and imperfections. \n",
    "\n",
    "__Optimization__: Since we are primarily interested in solving the classical optimization problem, within this routine it is sufficient to keep track of the best classical bitstring. \n",
    "This means that the wavefunction prepared by the quantum circuit $|\\gamma, \\beta \\rangle$ has to have some overlap with the optimal solution $|z^{*} \\rangle$ that we can read out as bitstring $z^{*}$ in the measurement shots. \n",
    "To this end, in principle (i.e., without any training), we could just sample from a completely uniform state that is prepared in a superposition of all computational basis states, as prepared by applying Hadamard gates to all qubits: $|\\mathrm{uniform}\\rangle = 1/\\sqrt{2^{N}}\\sum_{i}|z_{i}\\rangle$. \n",
    "In that case (assuming a single optimal solution) the success probability per shot amounts to $p_{\\mathrm{success}}=1/2^{N}$. \n",
    "We can then amplify our success chances by just taking many measurement shots. \n",
    "For large systems, however, this approach is not scalable as we would need to take an exponentially increasing number of measurements. \n",
    "That is why we train our circuits, update the parameters, with the goal to increase our success chances to find the optimal bitstring. \n",
    "We can quantify our success chances as follows [6]. \n",
    "For a given wavefunction $|\\gamma, \\beta \\rangle$ the probability to find the optimal solution in a single shot is given by \n",
    "\n",
    "$$ p_{\\mathrm{success}}(\\gamma, \\beta) = |\\langle z^{*}|\\gamma, \\beta \\rangle |^{2},$$\n",
    "\n",
    "where $z^{*}$ denotes the optimal bitstring. \n",
    "If we perform $M$ repeated measurements, the overall probability $P$ for observing this solution at least once is given by \n",
    "\n",
    "$$ P = 1 - (1-p_{\\mathrm{success}}(\\gamma, \\beta))^{M}, $$ \n",
    "\n",
    "since the term $(1-p_{\\mathrm{success}}(\\gamma, \\beta))^{M}$ gives the probability of _not_ obtaining $z^{*}$ in repeated $M$ trials. \n",
    "Therefore, to have an overall success chance up to $\\epsilon$ close to 100%, i.e., $P \\geq 1-\\epsilon$, the number of required shots has to be \n",
    "\n",
    "$$ M \\geq \\frac{\\log(\\epsilon)}{\\log(1-p_{\\mathrm{success}}(\\gamma, \\beta))}.$$\n",
    "\n",
    "Let us illustrate this results as follows: \n",
    "If we do not know anything and just resort to a uniform superposition $|\\mathrm{uniform}\\rangle$, for a small system with $N=10$ qubits we can find the optimal solutions with 80% success probability by taking at least $\\sim 1650$ shots. \n",
    "For just $N=20$ qubits, however, this number amounts to $\\sim 1.7 \\times 10^{6}$, making this naive approach unfeasible. \n",
    "Conversely, if we can train the quantum circuit to obtain $p_{\\mathrm{success}}(\\gamma, \\beta) \\sim 0.1$, we only need $\\sim 15$ shots to have $P\\geq 80\\%$. \n",
    "Below we will track and illustrate the best classical optimum as our algorithm proceeds towards a local or (ideally) global optimum.  \n",
    "\n",
    "__Objective function__: Finally, some more details on the definition of the cost function are in order. \n",
    "Following the standard approach [1, 4], QAOA tries to minimize the expectation value $\\langle \\hat{H}_{C} \\rangle$, but does _not_ explicitly maximize the success probability [6]. \n",
    "However, a low expectation value for $\\langle \\hat{H}_{C} \\rangle$ does not necessarily translate to a high success probability $p_{\\mathrm{success}}(\\gamma, \\beta)$, as can be understood from the following example:\n",
    "Consider (for example) a variational state that is a linear combination of low energy excited eigenstates of the cost Hamiltonian $\\hat{H}_{C}$ other than the ground state $|z^{*}\\rangle$. \n",
    "By definition, this state will have a relatively low expectation value $\\langle \\hat{H}_{C} \\rangle$ while the success probability is zero (as this low energy state does not have any overlap with the ground state). \n",
    "Similarly, a variational state that is a linear combination of the ground state with very high energy eigenstates could have a high success probability $p_{\\mathrm{success}}(\\gamma, \\beta)$, while (at the same time) reporting a high cost value to the classical optimizer.\n",
    "To address this issue, alternative methods for the optimization of the variational parameters have recently been proposed. \n",
    "While for simplicity we follow the majority of the literature and take $\\langle \\hat{H}_{C} \\rangle$ as cost value that we report to the classical optimizer, here we do mention a potential alternative for future research: \n",
    "One approach is to use the Gibbs objective function, defined as $\\mathrm{cost}=-\\mathrm{log} \\langle \\exp(-\\eta \\hat{H}_{C})\\rangle$, with the hyperparameter $\\eta>0$ [7]. \n",
    "As compared to the simple expectation value $\\langle \\hat{H}_{C} \\rangle$, this definition of the cost value shows stronger rewards for low energy states, thereby increasing the success probability. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IMPORTS and SETUP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For classical benchmarking we will be using the python library ```pyqubo```, as used in our helper script ```utils_classical```. If not already present in your virtual environment, you can install this library simply with ```pip install pyqubo```. Similarly, as ```seaborn``` are not expected to be present in the virtual environment by default, we will install them via ```pip install seaborn```. Note the ```-q``` to suppress install updates from ```pip```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If these have already been installed, this cell can be commented out.\n",
    "!pip install pyqubo -q\n",
    "!pip install seaborn -q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# general imports\n",
    "import numpy as np\n",
    "from scipy.optimize import minimize\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import seaborn as sns\n",
    "import time\n",
    "from datetime import datetime\n",
    "import pickle\n",
    "import random\n",
    "\n",
    "# magic line for producing visualizations in notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fix random seed for reproducibility\n",
    "seed = 42\n",
    "np.random.seed(seed)\n",
    "random.seed(a=seed)\n",
    "\n",
    "# switch to trigger writing training results to disk\n",
    "store_results = False\n",
    "# switch to trigger printing results of each optimization cycle\n",
    "verbose = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# AWS imports: Import Braket SDK modules\n",
    "from braket.circuits import Circuit, Observable, FreeParameter\n",
    "from braket.aws import AwsSession, AwsDevice\n",
    "from braket.devices import LocalSimulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils_classical import plot_colored_graph, plot_colored_graph_simple, solve_classical_ising\n",
    "# auto reload external files, so that we can edit the external .py file and immediately see the changes here\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up device: Local Simulator\n",
    "device = LocalSimulator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## example code for other backends\n",
    "## choose the on-demand simulator to run your circuit\n",
    "# device = AwsDevice(\"arn:aws:braket:::device/quantum-simulator/amazon/sv1\")\n",
    "## choose the Rigetti device to run your circuit\n",
    "# device = AwsDevice(\"arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-2\")\n",
    "## choose the Ionq device to run your circuit\n",
    "# device = AwsDevice(\"arn:aws:braket:::device/qpu/ionq/ionQdevice\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PROBLEM SETUP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We consider a graph coloring problem.\n",
    "Given a graph $G=(V,E)$, made of a set vertices (also called nodes) $V$ and edges $E$, our goal is to color each node red or blue, then score a point for each node that is next to a node of different color. \n",
    "We strive to find the optimal coloring that scores the largest number of points.\n",
    "To this end, we will address the dual problem of finding the minimum energy of the corresponding Ising Hamiltonian. \n",
    "To get started, we first use the open-source ```networkx``` library to visualize the problem graph. \n",
    "Feel free to play with the parameters $n$ (for the number of nodes) and $m$ (for the number of edges) below to consider other graphs of your choice. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# setup Erdos Renyi graph\n",
    "n = 10  # number of nodes/vertices\n",
    "m = 20  # number of edges\n",
    "\n",
    "# define graph object\n",
    "G = nx.gnm_random_graph(n, m, seed=seed)\n",
    "# positions for all nodes\n",
    "pos = nx.spring_layout(G)\n",
    "\n",
    "# choose random weights\n",
    "for (u, v) in G.edges():\n",
    "    G.edges[u,v]['weight'] = random.uniform(0, 1)\n",
    "\n",
    "# draw graph\n",
    "nx.draw(G, pos)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set Ising matrix \n",
    "Jfull = nx.adjacency_matrix(G).todense()\n",
    "Jfull = np.array(Jfull)\n",
    "\n",
    "# get off-diagonal upper triangular matrix\n",
    "J = np.triu(Jfull, k=1).astype(np.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot Ising matrix\n",
    "plt.figure(1, figsize=[7, 5])\n",
    "sns.heatmap(J, annot=True,  linewidths=.5, cmap=\"YlGnBu\", annot_kws = {'alpha': 1})\n",
    "plt.title('Ising distance matrix');\n",
    "plt.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IMPLEMENTATION OF QAOA WITH BRAKET "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we load a set of useful helper functions that we will explain in detail below. \n",
    "Specifically in ```utils_qaoa.py``` we provide simple building blocks for the core modules of our QAOA algorithm, that is (i) a function called ```circuit``` that defines the parametrized ansatz, (ii) a function called ```objective_function``` that takes a list of variational parameters as input, and returns the cost associated with those parameters and finally (iii) a function ```train``` to run the entire QAOA algorithm for given ansatz. \n",
    "This way we can solve the problem in a clean and modular approach.\n",
    "Here, we show in markdown the definition of the parametrized QAOA circuit. \n",
    "For more details, see the corresponding file ```utils_qaoa.py```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "from utils_qaoa import circuit, train \n",
    "# auto reload external files, so that we can edit the external .py file and immediately see the changes here\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "# function to implement evolution with driver Hamiltonian\n",
    "def driver(beta, n_qubits):\n",
    "    \"\"\"\n",
    "    Returns circuit for driver Hamiltonian U(Hb, beta)\n",
    "    \"\"\"\n",
    "    # instantiate circuit object\n",
    "    circ = Circuit()\n",
    "    \n",
    "    for qubit in range(n_qubits):\n",
    "        gate = Circuit().rx(qubit, 2*beta)\n",
    "        circ.add(gate)\n",
    "    \n",
    "    return circ\n",
    "\n",
    "\n",
    "# helper function for evolution with cost Hamiltonian\n",
    "def cost_circuit(gamma, n_qubits, ising):\n",
    "    \"\"\"\n",
    "    returns circuit for evolution with cost Hamiltonian\n",
    "    \"\"\"\n",
    "    # instantiate circuit object\n",
    "    circ = Circuit()\n",
    "\n",
    "    # get all non-zero entries (edges) from Ising matrix \n",
    "    idx = ising.nonzero()\n",
    "    edges = list(zip(idx[0], idx[1]))\n",
    "    \n",
    "    for qubit_pair in edges:\n",
    "        # get interaction strength\n",
    "        int_strength = ising[qubit_pair[0], qubit_pair[1]]\n",
    "        # for Rigetti we decompose ZZ using CNOT gates\n",
    "        if device.name == 'Rigetti':\n",
    "            gate = ZZgate(qubit_pair[0], qubit_pair[1], gamma*int_strength)\n",
    "            circ.add(gate)\n",
    "        # classical simulators and IonQ support ZZ gate\n",
    "        else:\n",
    "            gate = Circuit().zz(qubit_pair[0], qubit_pair[1], angle=2*gamma*int_strength)\n",
    "            circ.add(gate)\n",
    "\n",
    "    return circ\n",
    "\n",
    "\n",
    "# function to build the QAOA circuit with depth p\n",
    "def circuit(params, n_qubits, ising):\n",
    "    \"\"\"\n",
    "    function to return full QAOA circuit\n",
    "    \"\"\"\n",
    "\n",
    "    # initialize qaoa circuit with first Hadamard layer: for minimization start in |->\n",
    "    circ = Circuit()\n",
    "    X_on_all = Circuit().x(range(0, n_qubits))\n",
    "    circ.add(X_on_all)\n",
    "    H_on_all = Circuit().h(range(0, n_qubits))\n",
    "    circ.add(H_on_all)\n",
    "\n",
    "    # setup two parameter families\n",
    "    circuit_length = int(len(params) / 2)\n",
    "    gammas = params[:circuit_length]\n",
    "    betas = params[circuit_length:]\n",
    "\n",
    "    # add circuit layers\n",
    "    for mm in range(circuit_length):\n",
    "        circ.add(cost_circuit(gammas[mm], n_qubits, ising))\n",
    "        circ.add(driver(betas[mm], n_qubits))\n",
    "\n",
    "    return circ\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VISUALIZATION OF THE QAOA ANSATZ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first visualize our parametrized QAOA ansatz for a small number of qubits and fixed (i.e., not optimized) parameters. \n",
    "For convenience, the parameters are displayed in the circuit (up to a factor of $2$ we have added in our ansatz definition). \n",
    "First we prepare the state $|0,0,\\dots\\rangle \\rightarrow |-,-,\\dots\\rangle$, with the superposition state $|-\\rangle = (|0\\rangle -|1\\rangle  )/\\sqrt{2}$. \n",
    "Following the discussion above, we choose to start out with this state as it is the minimal energy state of the simple driver Hamiltonian $H_{B}$. \n",
    "This state preparation is followed by one layer of the QAOA ansatz, consisting of evolution with the cost Hamiltonian by $\\exp(-i\\gamma H_{C})= \\prod_{j,l}\\exp(-i\\gamma J_{j,l}\\sigma_{j}^{z}\\sigma_{l}^{z}) = \\prod_{j,l} ZZ_{j,l}(2\\gamma J_{j,l})$, followed by the single-qubit driving term, $\\exp(-i\\beta H_{B})= \\prod_{j} \\exp(-i\\beta \\sigma_{j}^{x})= \\prod_{j} R_{j}^{(x)}(2\\beta)$.\n",
    "Note that the circuit definition depends on the ```device``` object, as the implementation of the ZZ gate depends on the specific gate set supported by the device.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing test circuit:\n",
      "T  : |0|1|     2     |    3     |\n",
      "                                 \n",
      "q0 : -X-H-ZZ(2*gamma)-Rx(2*beta)-\n",
      "          |                      \n",
      "q1 : -X-H-ZZ(2*gamma)-Rx(2*beta)-\n",
      "\n",
      "T  : |0|1|     2     |    3     |\n",
      "\n",
      "Unassigned parameters: [beta, gamma].\n"
     ]
    }
   ],
   "source": [
    "# create parameters\n",
    "gammas = [FreeParameter('gamma')]\n",
    "betas = [FreeParameter('beta')]\n",
    "params = gammas + betas\n",
    "\n",
    "# for demonstration purposes use small Ising matrix\n",
    "J_sub = np.array([[0, 1], [0, 0]])\n",
    "N = J_sub.shape[0]\n",
    "\n",
    "# get circuit ansatz\n",
    "my_simple_circuit = circuit(params, device, N, J_sub)\n",
    "\n",
    "# print test ansatz circuit\n",
    "print('Printing test circuit:')\n",
    "print(my_simple_circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that our ansatz produces the expected result for shallow QAOA with $p=1$. \n",
    "We run one more sanity check for $p=2$ below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing test circuit:\n",
      "T  : |0|1|      2      |     3      |      4      |     5      |\n",
      "                                                                \n",
      "q0 : -X-H-ZZ(2*gamma_1)-Rx(2*beta_1)-ZZ(2*gamma_2)-Rx(2*beta_2)-\n",
      "          |                          |                          \n",
      "q1 : -X-H-ZZ(2*gamma_1)-Rx(2*beta_1)-ZZ(2*gamma_2)-Rx(2*beta_2)-\n",
      "\n",
      "T  : |0|1|      2      |     3      |      4      |     5      |\n",
      "\n",
      "Unassigned parameters: [beta_1, beta_2, gamma_1, gamma_2].\n"
     ]
    }
   ],
   "source": [
    "# set number of qubits and fix parameters\n",
    "gammas = [FreeParameter('gamma_1'), FreeParameter('gamma_2')]\n",
    "betas = [FreeParameter('beta_1'), FreeParameter('beta_2')]\n",
    "params = gammas + betas\n",
    "\n",
    "# for demonstration purposes use small Ising matrix\n",
    "J_sub = np.array([[0, 1], [0, 0]])\n",
    "N = J_sub.shape[0]\n",
    "\n",
    "# get circuit ansatz\n",
    "my_simple_circuit = circuit(params, device, N, J_sub)\n",
    "\n",
    "# print test ansatz circuit\n",
    "print('Printing test circuit:')\n",
    "print(my_simple_circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QAOA SIMULATION ON LOCAL SCHROEDINGER SIMULATOR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now all set to run some QAOA simulation experiments. \n",
    "First of all, you can play and experiment yourself with the number of qubits $N$. \n",
    "Secondly, you may also experiment with the classical optimizer. \n",
    "Since we are using an off-the-shelf, black-box ```scipy``` minimizer (as described in more detail [here](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html)), you can simply swap between different optimizers by setting the ```OPT_METHOD``` parameter below. \n",
    "Some popular options readily available within this library include *Nelder-Mead*, *BFGS* and *COBYLA*. \n",
    "As a precautionary warning, note that the classical optimization step may get stuck in a local optimum, rather than finding the global minimum for our parametrized QAOA ansatz wavefunction. \n",
    "To address this issue, we may run several optimization loops, starting from different random parameter seeds. \n",
    "While this brute-force approach does not provide any guarantee to find the global optimum, from a pragmatic point of view at least it does increase the odds of finding an acceptable solution, at the expense of potentially having to run many more circuits on the simulator or QPU, respectively.\n",
    "Finally, the optimization loop may require the execution of many individual quantum tasks (i.e., single circuit executions for fixed parameters). \n",
    "For example, when choosing the classical [Powell](https://docs.scipy.org/doc/scipy/reference/optimize.minimize-powell.html#optimize-minimize-powell) optimizer for the graph considered here, we find $\\sim 270$ cycles in the for loop. \n",
    "For the local simulator device chosen here by default this is not an issue, but if you run this algorithm on any QPU you may want to adjust the ```maxfev``` parameter to control the maximum allowed number function evaluations (compare comment in the next code block below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################################################\n",
    "# set up hyperparameters\n",
    "##################################################################################\n",
    "\n",
    "# User-defined hypers\n",
    "DEPTH = 3  # circuit depth for QAOA\n",
    "SHOTS = 1000  # number measurements to make on circuit\n",
    "OPT_METHOD = 'Powell'  # SLSQP, COBYLA, Nelder-Mead, BFGS, Powell, ...\n",
    "\n",
    "# set up the problem\n",
    "n_qubits = J.shape[0]\n",
    "\n",
    "# initialize reference solution (simple guess)\n",
    "bitstring_init = -1 * np.ones([n_qubits])\n",
    "energy_init = np.dot(bitstring_init, np.dot(J, bitstring_init))\n",
    "\n",
    "# set tracker to keep track of results\n",
    "tracker = {\n",
    "    'count': 1,                           # Elapsed optimization steps\n",
    "    'optimal_energy': energy_init,        # Global optimal energy\n",
    "    'opt_energies': [],                   # Optimal energy at each step\n",
    "    'global_energies': [],                # Global optimal energy at each step\n",
    "    'optimal_bitstring': bitstring_init,  # Global optimal bitstring\n",
    "    'opt_bitstrings': [],                 # Optimal bitstring at each step\n",
    "    'costs': [],                          # Cost (average energy) at each step\n",
    "    'res': None,                          # Quantum result object\n",
    "    'params': []                          # Track parameters\n",
    "}\n",
    "\n",
    "# set options for classical optimization\n",
    "options = {'disp': True, 'maxiter': 500}\n",
    "# options = {'disp': True, 'ftol': 1e-08, 'maxiter': 100, 'maxfev': 50}  # example options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circuit depth hyperparameter: 3\n",
      "Problem size: 10\n",
      "Starting the training.\n",
      "====================================================================\n",
      "OPTIMIZATION for circuit depth p=3\n",
      "Param \"verbose\" set to False. Will not print intermediate steps.\n",
      "====================================================================\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: -0.528222\n",
      "         Iterations: 2\n",
      "         Function evaluations: 242\n",
      "Final average energy (cost): -0.5282224514612025\n",
      "Final angles: [3.80351695 1.4014099  1.39004847 1.16778289 2.18602397 1.93468655]\n",
      "Training complete.\n",
      "Code execution time [sec]: 37.18410015106201\n",
      "Optimal energy: -6.486032631497276\n",
      "Optimal classical bitstring: [ 1 -1  1  1 -1  1 -1 -1  1  1]\n"
     ]
    }
   ],
   "source": [
    "##################################################################################\n",
    "# run QAOA optimization on graph \n",
    "##################################################################################\n",
    "\n",
    "print('Circuit depth hyperparameter:', DEPTH)\n",
    "print('Problem size:', n_qubits)\n",
    "\n",
    "# kick off training\n",
    "start = time.time()\n",
    "result_energy, result_angle, tracker = train(\n",
    "    device = device, options=options, p=DEPTH, ising=J, n_qubits=n_qubits, n_shots=SHOTS, \n",
    "    opt_method=OPT_METHOD, tracker=tracker, verbose=verbose)\n",
    "end = time.time()\n",
    "\n",
    "# print execution time\n",
    "print('Code execution time [sec]:', end - start)\n",
    "\n",
    "# print optimized results\n",
    "print('Optimal energy:', tracker['optimal_energy'])\n",
    "print('Optimal classical bitstring:', tracker['optimal_bitstring'])\n",
    "\n",
    "##################################################################################\n",
    "# Compute output and dump to pickle\n",
    "##################################################################################\n",
    "\n",
    "if store_results:\n",
    "    out = {'p': DEPTH, 'N': n_qubits,\n",
    "           'ENERGY_OPTIMAL': tracker['optimal_energy'], 'BITSTRING': tracker['optimal_bitstring'],\n",
    "           'result_energy': result_energy, 'result_angle': result_angle}\n",
    "\n",
    "    # store results: dump output to pickle with timestamp in filename\n",
    "    time_now = datetime.strftime(datetime.now(), '%Y%m%d%H%M%S')\n",
    "    results_file = 'results-'+time_now+'.pkl'\n",
    "    print(f'Writing results to file: {results_file}')\n",
    "    pickle.dump(out, open(results_file, \"wb\"))\n",
    "    \n",
    "    # you can load results as follows\n",
    "    # out = pickle.load(open(results_file, \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## POSTPROCESSING AND COMPARISON OF OUR QAOA RESULTS WITH CLASSICAL RESULTS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we visualize the results we have found with QAOA. \n",
    "Specifically, we display the results found for the variational parameters $\\beta$ and $\\gamma$ for every layer in our QAOA ansatz. \n",
    "Moreover, we show the solution to our graph coloring problem with every node colored either red or blue (recall that there are just two colors since we solve a _binary_ optimization problem).\n",
    "Finally, we compare these results to results found classically using the open-source ```pyqubo``` package. \n",
    "Ideally, the two results should agree with each other but this is not necessarily the case for several reasons: \n",
    "First of all, for the original small toy problem we have set up there are several degenerate classical solutions with the same optimal quality. \n",
    "The classical and the QAOA approach may find solutions with different coloring configurations but the same quality (that is energy). \n",
    "Secondly, with QAOA we are not guaranteed to find the optimal solutions. \n",
    "Specifically, the deeper the circuit, the harder the classical optimization problem, and we may get stuck in a local rather than global optimum. \n",
    "One brute-force approach is then to just re-run QAOA with different random initial seeds for the parameters $(\\beta, \\gamma)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization on graph with n=10 vertices, m=20 edges, optimized with Powell and 1000 shots per call; seed=42.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize the optimization process\n",
    "cycles = np.arange(1, tracker['count'])\n",
    "optim_classical = tracker['global_energies']\n",
    "\n",
    "# print information\n",
    "info = 'Optimization on graph with n={} vertices, m={} edges, optimized with {} and {} shots per call; seed={}.'\n",
    "print(info.format(n, m, OPT_METHOD, SHOTS, seed))\n",
    "\n",
    "plt.plot(cycles, optim_classical)\n",
    "plt.xlabel('optimization cycle')\n",
    "plt.ylabel('best classical minimum')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal energy found with QAOA: -6.486032631497276\n",
      "Optimal bit-string found with QAOA: [ 1 -1  1  1 -1  1 -1 -1  1  1]\n"
     ]
    }
   ],
   "source": [
    "# print the optimal energy found with QAOA \n",
    "print('Optimal energy found with QAOA:', tracker['optimal_energy'])\n",
    "# print the corresponding bitstring\n",
    "print('Optimal bit-string found with QAOA:', tracker['optimal_bitstring'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3hUZdrH8e896SQBhISe0HsggSSAYgFXF6y4L+qKiKAUG4q6sqjrKqvurnXXXgBdwIKurCAoK2tBbKAkSAepoSshkIQ00p73jzMJkzBJBsjkJDP357rOlZkzp9wzhPzmnOc5zxFjDEoppfyXw+4ClFJK2UuDQCml/JwGgVJK+TkNAqWU8nMaBEop5ecC7S7gVEVFRZkOHTrYXYZSSjUoqamph40x0e5ea3BB0KFDB1JSUuwuQymlGhQR2V3Va3pqSCml/JwGgVJK+TkNAqWU8nMNro3AnaKiIvbt20dBQYHdpah6IDQ0lHbt2hEUFGR3KUo1CD4RBPv27SMyMpIOHTogInaXo2xkjCEjI4N9+/bRsWNHu8tRqkHwiSAoKCioNgSO5hXya1YBhSWlBAc4aNkklLMaBddxlaouiAjNmzcnPT3d7lKUajB8IgiAakNg/9F8Sp2jrBaWlLL/aD6AhoGP0qNCpU6NzzcW/5pVUB4CZUqN4dcsbU9QSinwYhCIyJsickhENlTx+mgRWSci60XkexGJr619Dx06lKVLlwLWEQDA27Ne5fEH7i1fpmx+VR5++GE+//zzapeZPXs2Bw4cKH8+YcIENm3adLplV7mPyZMnu31t4cKF9O3blx49ehAXF8f8+fMrvF5cXEx0dDT3339/hflZWVnceOONdOnShc6dO3PjjTeSlZVVYZm7776btm3bUlpa/edUG6p7j0op7/PmEcFsYHg1r+8CLjDG9AEeA2bU1o5HjRrFe++9B0BwgPUWP130IZeMGFm+TNl8d0pKSnj00Ue56KKLqt1P5SCYNWsWvXr1OpPSPbZ27Vruu+8+PvroI7Zs2cLixYuZNm0aqamp5ct89tlndOvWjQ8++ADXGxCNHz+eTp06sX37dnbs2EHHjh2ZMGFC+eulpaUsWLCAmJgYli9fXifvRyllH68FgTHma+BINa9/b4w56ny6EmhXW/u++uqr+eSTTygsLKRlk1AO7ttD+q8H6T/wHB5/4F5GXTqUERcO4pFHHilfp0OHDkybNo3+/fvzwQcfMG7cuPJv2I8++ijJycnExcUxadIkjDHMnz+flJQURo8eTUJCAvn5+QwZMqR8+It58+bRp08f4uLimDZtWvl+IiIi+NOf/kR8fDyDBg3i119/BWDx4sUMHDiQfv36cdFFF5XPr8ozzzzDgw8+WN4zpmPHjjz44IM8++yz5cvMmzePKVOmEBsby4oVKwDYvn07qamp/PnPfy5f7uGHHyYlJYUdO3YA8NVXX9G7d29uu+025s2b53b/aWlpnHfeefTv35/+/fvz/fffl687ZMgQrr76anr06MHo0aPLQ2jJkiX06NGDxMRE7rrrLi6//PKTtpuens7IkSNJTk4mOTmZ7777DoDly5eTkJBAQkIC/fr149ixY9V+PkqpU2CM8doEdAA2eLDcfcCsal6fBKQAKbGxsaayTZs2nTTvsssuMwsXLjTGGPPwXx43N90y2azde9R8v3GX2Xwwy6zZnWHOO/98s3btWmOMMe3btzdPPvlk+fpjx441H3zwgTHGmIyMjPL5N9xwg1m0aJExxpgLLrjArFq1qvy1suf79+83MTEx5tChQ6aoqMgMHTrULFiwwBjrzZSvP3XqVPPYY48ZY4w5cuSIKS0tNcYYM3PmTHPvvfcaY4z517/+Ze64446T3l+/fv3MmjVrKsxbs2aNiY+PN8YYk5+fb1q3bm3y8vLM66+/biZPnmyMMeajjz4yV1111Unbu+qqq8xHH31kjDFmwoQJZu7cuSYrK8u0adPGFBYWnrR8bm6uyc/PN8YYs3XrVpOYmGiMMWbZsmWmcePGZu/evaakpMQMGjTIfPPNNyY/P9+0a9fO7Ny50xhjzHXXXWcuu+yyk97jqFGjzDfffGOMMWb37t2mR48exhhjLr/8cvPtt98aY4w5duyYKSoqMsaY8vdbmbvfCaX8GZBiqvgba3tjsYgMBcYD06paxhgzwxiTZIxJio52O3jeSVxPD3304QfcMXEcfds1Ze3XnzLq0iFcO/x8NmzYyLr1J5owfv/737vd1rJlyxg4cCB9+vThyy+/ZOPGjdXue9WqVQwZMoTo6GgCAwMZPXo0X3/9NQDBwcHl34QTExNJS0sDrGshhg0bRp8+fXj66adr3EdNPv74Y4YOHUpYWBgjR45k4cKFlJSU1LheYWEhS5Ys4aqrrqJx48YMHDiwvL3FVVFRERMnTqRPnz5cc801FdpGBgwYQLt27XA4HCQkJJCWlsaWLVvo1KlT+RHMqFGj3O7/888/Z/LkySQkJHDllVeSnZ1NTk4OgwcP5t577+WFF14gMzOTwECrw9uaNWtO5+NRSrmwtfuoiPQFZgGXGGMyanPbI0aM4J577mH16tXk5eWRmJjIrl27eOaZZ1i1ahWh4Y257oYx7D+cTUmpdeoiPDz8pO0UFBRw++23k5KSQkxMDNOnTz+jK5iDgoLKuzcGBARQXFwMwJ133sm9997LlVdeyVdffcX06dOr3U6vXr1ITU0lPv5EG3tqaipJSUmAdVro22+/pWzI7oyMDL788kt69erFmjVrKC0txeGwvgeUlpayZs0aevXqxdKlS8nMzKRPnz4A5OXlERYWdtJpnH/+85+0bNmStWvXUlpaSmhoaPlrISEh5Y9d36MnSktLWblyZYXtAdx///1cdtllLFmyhMGDB7N06VJ69Ojh8XaVUlWz7YhARGKBD4Exxpittb39iIgIhg4dys0331z+7TM7O5vw8HCaNGlC9tHDrFj+BUUlpew7mlfldsr+6EdFRZGTk1OhZ05kZKTbc9UDBgxg+fLlHD58mJKSEubNm8cFF1xQbb1ZWVm0bdsWgDlz5tT4/u677z7+/ve/lx9RpKWl8dxzzzF16lSys7P55ptv2LNnD2lpaaSlpfHyyy8zb948unTpQr9+/Xj88cfLt/X444/Tv39/unTpwrx585g1a1b5ert27eKzzz4jL6/iZ5SVlUXr1q1xOBy89dZbNR5tdO/enZ07d5bX+/7777td7re//S0vvvhi+fOyb/w7duygT58+TJs2jeTkZLZs2VLjZ6SU8ow3u4/OA1YA3UVkn4iMF5FbReRW5yIPA82BV0RkjYjU+k0GRo0axdq1a8uDID4+nn79+tGjRw+uv/56zh08mCaNgsjKLyo/KqisadOmTJw4kbi4OIYNG0ZycnL5a+PGjePWW28tbywu07p1a5544gmGDh1KfHw8iYmJjBgxotpap0+fzjXXXENiYiJRUVE1vreEhASefPJJrrjiCrp160a3bt149dVX6d69OwsWLODCCy+s8M18xIgRLF68mOPHj/PGG2+wdetWOnfuTOfOndm6dStvvPEGeXl5fPrpp1x22WXl64WHh3PuueeyePHiCvu//fbbmTNnDvHx8WzZssXt0ZSrsLAwXnnlFYYPH05iYiKRkZE0adLkpOVeeOEFUlJS6Nu3L7169eK1114D4LnnniMuLo6+ffsSFBTEJZdcUv45KKXOjBjj/g9gfZWUlGQq35hm8+bN9OzZ87S2Z4xhf2Y+R3ILaXdWI5qFN8yrje+//35++OEHli5dSnBw/XwPOTk5REREYIzhjjvuoGvXrtxzzz1e2deZ/E4o5YtEJNUYk+TuNZ8ZYuJ0iQhtmoZRWFzK/sx8ggMdRIQ0vI/liSeesLuEGs2cOZM5c+ZQWFhIv379uOWWW+wuSSmFBgEADhFimzViR3ouuzNy6RIdQUhQgN1l+Zx77rnHa0cASqnTZ3v30foiMMBBh6hGCJCWkUdxDUNQKKWUr9AgcBESGEBs83AKS0rZcyTvpMHqlFLKF2kQVBIREkjbpmHkHC/mQGY+Da0xXSmlTpW2EbjRLDyY48UlpB87TkhgANGRITWvpJRSDZQGQRVaNQ6lsLiUg1n5hAQ6aBym979VSvkmDYIqiAjtzmpEYXEOe47k0Tk6grDgM+tJtPCn/Ty99GcOZObTpmkYU4d156p+bWupYqWUOj3aRlCNAIfQISqcAIeQlpFL0Rn0JFr4034e+HA9+zPzMcD+zHwe+HA9C3/af0Y1PvbYY3Tv3p1zzz2XUaNG8cwzzzBz5kySk5OJj49n5MiR5cNDjBs3jttuu41BgwbRqVMnvvrqK26++WZ69uzJuHHjyrcZERHB1KlT6d27NxdddBE//vgjQ4YMoVOnTixatAioehhqpVTD4/dXFnsiv7CYHem5hAY56BQVgcNx8j1x/7J4I5sOZFe5jZ/2ZLq9K1pwgIN+sU3drtOrTWMeuaJ3ldtctWoVEydOZOXKlRQVFdG/f39uueUWbrrpJpo3bw7AQw89RMuWLbnzzjsZN24cBQUFzJs3j0WLFjFmzBi+++47evfuTXJyMm+88QYJCQmICEuWLOGSSy7hd7/7Hbm5uXzyySds2rSJsWPHsmbNGvLy8nA4HISGhrJt2zZGjRpF5X8XO+mVxUpVpFcWn6Gw4EBimjVid0Yue4/mEdus0SnfIL2qW2PWdMvM6nz33XeMGDGC0NBQQkNDueKKKwDYsGEDDz30EJmZmeTk5DBs2LDyda644gpEhD59+tCyZcvyUUZ79+5NWloaCQkJBAcHM3y4dXO5Pn36EBISQlBQEH369CkfNK6oqIjJkyezZs0aAgIC2Lq11scNVErVEQ0CDzUJC6J1k1AOZhXwa/ZxWjWpOExydd/cAQY/8SX7M/NPmt+2aRjv33J2rdY6btw4Fi5cSHx8PLNnz+arr74qf61sIDqHw1FhUDqHw1E+XLTrUNmuy7kuU90w1EqphkXbCE5BVEQIzRoFc+hYAUfzCk9p3anDuhNWadiKsKAApg7rftr1DB48mMWLF1NQUEBOTg4ff/wxAMeOHaN169YUFRXxzjvvnPb2q3Oqw1ArpeovPSI4BSJCm7PCOF5Syr6j+QQHOAj3cIC6st5BtdlrKDk5mSuvvJK+ffuWn+Zp0qQJjz32GAMHDiQ6OpqBAwd65f6+t99+OyNHjmTu3LkMHz68xmGolVL1lzYWn4biklJ2pOdSUmro3CKckED7BqgrG9o5Ly+P888/nxkzZtC/f3/b6qkvtLFYqYqqayzWU0OnITDAQYfmjTAYdh/Oo6TUvgHqJk2aREJCAv3792fkyJEaAkqpU6anhk5TSFAA7Zs1YtfhPHZn5NExKvyUexLVhnfffbfO96mU8i16RHAGIkKDaHtWqDVAXdbp39BeKaXspEcEZ6hZeAjHi0udA9Q5iIrQAeqUUg2LBkEtaNU4lONFpRx03uqycagOUKeUajj01FAtEBFimjUiJCiAvRl5FBRpn3qlVMOhQVBLAhxCh+bhOBxC2uEzG6DuVKSlpREXF+fx8rNnz+bAgQNerEgp1dDoqaFaFBzooH3zRuxMz2V3Rh6dosJPDFD3dFfIPXTySuEtYOq2Oqtx9uzZxMXF0aZNmzrbp1KqftMjglrWKDiQmLPCyCssZt9Rl1tduguB6uafguLiYkaPHk3Pnj25+uqrycvLIzU1lQsuuIDExESGDRvGwYMHmT9/PikpKYwePZqEhATy8/N59NFHSU5OJi4ujkmTJumtOZXyQ3plcW357/3wy/ryp4UlpRQWlxIc6CA4wAG7v6163fbnup/fqg9c8kS1u01LS6Njx458++23DB48uPz+AgsWLOCjjz4iOjqa999/n6VLl/Lmm28yZMgQnnnmGZKSrAsMjxw5QrNmzQAYM2YM1157bfkopg1ZvfidUKoe0WGobRAUIJQaobC4FId494OOiYlh8ODBANxwww387W9/Y8OGDVx88cUAlJSU0Lp1a7frLlu2jKeeeoq8vDyOHDlC7969fSIIlFKe0yCoLZW+uQsQbAz703PJKyqhz8zYqte96ZMz2nXlK5ojIyPp3bs3K1asqHa9goICbr/9dlJSUoiJiWH69OkUFOiFcUr5G20j8CKHCO2bNyIowLtDT+zZs6f8j/67777LoEGDSE9PL59XVFTExo0bASskykYjLfujHxUVRU5ODvPnz/dqnUqp+kmDwMusAerCKQqLdr9AeIsz3kf37t15+eWX6dmzJ0ePHuXOO+9k/vz5TJs2jfj4eBISEsrvKTxu3DhuvfVWEhISCAkJYeLEicTFxTFs2DCSk5PPuBalVMOjjcV15FhBEWmH84gIDaRD81O/1aU6NQ3hd0KpuqTDUNcDkaFBtGkayrGCIg7qAHVKqXpEG4vrUPMIa4C6wznWAHXNdYA6pVQ94DNHBA3lFFfrJqFEhgZxILOAYwVFdpfjkxrK74JS9YVPBEFoaCgZGRkN4g+AiBDbrBEhQQ72HNEB6mqbMYaMjAxCQ0PtLkWpBsMnTg21a9eOffv2kZ6ebncpHisute5hcGiP0CIy5MSYROqMhYaG0q5dO7vLUKrB8IkgCAoKomPHjnaXccpW7znKdTNWEt+uCW9PGEhIYIDdJSml/JBPnBpqqPrHnsUz18SzKu0oD3y4vkGc2lJK+R6fOCJoyK6Mb8Ou9Fz++flWOkdHcMfQLnaXpJTyM147IhCRN0XkkIhsqOJ1EZEXRGS7iKwTkf7eqqW+u+s3Xbgyvg1PL/2Z/64/aHc5Sik/481TQ7OB4dW8fgnQ1TlNAl71Yi31mojw1NV96R/blHv+vYZ1+zLtLkkp5Ue8FgTGmK+BI9UsMgKYaywrgaYi4n6sZD8QGhTA62OSaB4ewvg5KRzIzLe7JKWUn7CzsbgtsNfl+T7nvJOIyCQRSRGRlIbURfRURUeG8Oa4ZPILS5gwJ4Xc48V2l6SU8gMNoteQMWaGMSbJGJMUHV3FKJ4+onurSF68vh9bfslmyntrKCnVnkRKKe+yMwj2AzEuz9s55/m9od1b8PDlvfh88688+ekWu8tRSvk4O4NgEXCjs/fQICDLGKNdZpzGntOBMYPaM+Prnbz34x67y1FK+bAqryPwsDtnkTFmvbsXRGQeMASIEpF9wCNAEIAx5jVgCXApsB3IA246pcp9nIjwyBW9SMvI5aGFG4ht3ohzOkfZXZZSygdVeWMaETkGrMK6/W5VOhpjOnihriq5uzGNL8suKGLkK99z6NhxFtx+Dp2iI+wuSSnVAJ3ujWlWGWMuNMYMrWoCdnqnZFWmcWgQb4xNJsAhjJ+TQmZeod0lKaV8TJVBYIy5sKaVPVlGnbnY5o2YMSaR/UfzufXtVAqLS+0uSSnlQ6oMAhHp4fzZ391UdyUqgKQOzXjy6j6s3HmEhxbqAHVKqdpT3aBz92IN/fCsm9cMoEcDdex3/dqxMz2XF7/cTpcWEUw6v7PdJSmlfECVQWCMmeT8ObTuylE1ueeibuxMz+Xv/91C++bhDOvdyu6SlFINXI3XEYhIqIjcKyIfish/RORuEdH7ANrE4RCevTaevu2acvd7a9iwP8vukpRSDZwnF5TNBXoDLwIvOR+/5c2iVPVCgwKYeWMiZzUKYsKcFH7NLrC7JKVUA+ZJEMQZY8YbY5Y5p4lYYaBs1CIylFljk8kuKGLCnBTyC0vsLkkp1UB5EgSrnUNAACAiAwH/uaKrHuvVpjEvXNePDQeyuOf9NZTqAHVKqdPgSRAkAt+LSJqIpAErgGQRWS8i67xanarRRb1a8qdLe/Lpxl945n8/212OUqoB8uSexdXdZUzVA+PP7ciO9Fxe+WoHnaIjuDqxnd0lKaUakBqDwBizuy4KUadPRHh0RG92Z+TywIfriG3WiAEdm9ldllKqgajuyuLVNa3syTKqbgQFOHh1dCIxzRpxy1sppB3OtbskpVQDUV0bQU8RWVfNtB7QcZHrkSaNgnhzbDIGuHnOKrLyiuwuSSnVAFR3aqiHB+trn8V6pkNUOK/dkMiYN37gjndX86+bkgkKaBB3JFVK2aS60Ud3ezDtq8tilWcGdWrOX3/Xh2+3H+aRRRt1gDqlVLU86TWkGqBrk2LYmZ7La8t30Dk6gvHndrS7JKVUPaVB4MP+OKw7uw7n8Pgnm+jQvBG/6dnS7pKUUvWQJ4POhYuIw/m4m4hcKSJB3i9NnSmHQ/jn7xPo3aYxd837ic0Hs+0uSSlVD3nSivg1ECoibYH/AWOA2d4sStWeRsGBzLoxmYjQQCbMSeHQMR2gTilVkSdBIMaYPOD/gFeMMdegg841KK2ahPLG2GSO5BYyaW4qBUXa2UspdYJHQSAiZwOjgU+c8wK8V5Lyhri2TXjuugTW7svkDx+s1QHqlFLlPAmCu4EHgAXGmI0i0glY5t2ylDcM692KacN78Mm6gzz3xTa7y1FK1ROejDW0HFguIo2cz3cCd3m7MOUdt5zfiR2Hcnjhi210igrnqn5t7S5JKWUzT3oNnS0im4AtzufxIvKK1ytTXiEi/PV3fRjYsRl/nL+O1N1H7C5JKWUzT04NPQcMAzIAjDFrgfO9WZTyruBAB6/dkEibpqFMmpvK3iN5dpeklLKRR4PQGGP2Vpql3U4auLPCg3ljXDJFJaXcPHsV2QU6QJ1S/sqTINgrIucARkSCROQ+YLOX61J1oHN0BK/dkMiuw7nc+e5PFJeU2l2SUsoGngTBrcAdQFtgP5DgfK58wDldonj8qjiWb03nsY832V2OUsoGnvQaOox1DYHyUdcNiGVHeg4zv9lFp+gIxp7Twe6SlFJ1qMogEJEXgSqvOjLGaBdSH3L/JT3ZdTiXvyzeSPvmjRjSvYXdJSml6kh1p4ZSgNRqJuVDAhzC89f1o3urxtz57k9s/fWY3SUppeqINLSbliQlJZmUlBS7y/BZBzLzGfHyd4QEOlh4x2CiIkLsLkkpVQtEJNUYk+TuNU8uKFssIosqTW+JyBQRCa39cpWd2jQNY9aNSaQfO84tb+kAdUr5A096De0EcoCZzikbOAZ0cz5XPiY+pin/uDaB1N1Huf8/6/RWl0r5OE/uUHaOMSbZ5fliEVlljEkWkY3eKkzZ67K+rdl1uBvP/G8rnaMjuPM3Xe0uSSnlJZ4cEUSISGzZE+fjCOfTQq9UpeqFO4Z24f/6teXZz7by8boDdpejlPIST44I/gB8KyI7AAE6AreLSDgwx5vFKXuJCH8f2Yc9R/L4w7/X0rZpGP1iz7K7LKVULavxiMAYswToinVfgilAd2PMJ8aYXGPMc9WtKyLDReRnEdkuIve7eT1WRJaJyE8isk5ELj3dN6K8IyQwgNfHJNKicQgT56ayPzPf7pKUUrXMo0HngESs21PGA9eKyI01rSAiAcDLwCVAL2CUiPSqtNhDwL+NMf2A6wAd3roeah4RwptjkzleVML42avIOV5sd0lKqVrkSffRt4BngHOBZOfkti9qJQOA7caYncaYQuA9YESlZQzQ2Pm4CaAnouupri0jeXl0f7YdyuGueT9Rore6VMpneNJGkAT0Mqfeh7At4Dp89T5gYKVlpgP/E5E7gXDgIncbEpFJwCSA2NhYd4uoOnB+t2imX9mbPy/cwN+WbObPl1c+wFNKNUSenBraALTy0v5HAbONMe2AS4G3ROSkmowxM4wxScaYpOjoaC+VojwxZlB7xp3TgTe+3cU7P+y2uxylVC3w5IggCtgkIj8Cx8tmGmOurGG9/UCMy/N2znmuxgPDndtb4bxSOQo45EFdyiYPXdaTtIxcHv5oI+2bhXNu1yi7S1JKnQFPjgimA1cBfwOedZlqsgroKiIdRSQYqzF4UaVl9gC/ARCRnkAokO5R5co2gQEOXhzVjy7REdz2TirbD+XYXZJS6gx40n10ubvJg/WKgcnAUqw7mv3bGLNRRB4VkbKjiT8AE0VkLTAPGHcabRHKBpGhQcwam0RIoIPxc1ZxJFevLVSqoapx9FERGQS8CPQEgoEAINcY07jaFb1ERx+tX1J3H2XUzJUktGvKWxMGEBIYYHdJSik3zmj0UeAlrEbdbUAYMAHr+gClSGx/Fk9f3Zcf047w4IcbdIA6pRogjy4oM8ZsBwKMMSXGmH/hbOBVCmBEQlvuvqgr/1m9j1eX77C7HKXUKfKk11Ces7F3jYg8BRzE8yuSlZ+Y8puu7EzP5alPf6ZTVDjD41rbXZJSykOe/EEf41xuMpCL1SV0pDeLUg2PiPDU1X3pF9uUu99fw/p9WXaXpJTykCe9hnYbYwqMMdnGmL8YY+51nipSqoLQoABmjEmieXgIE+au4pesArtLUkp5QE/xqFoVHRnCm+OSyT1ewvg5q8jVAeqUqvc0CFSt694qkhdH9WPzwWzufn8NpTpAnVL1mgaB8oqhPVrw58t78dmmX3ly6Ra7y1FKVaPKXkMishhrmGi3PBhrSPm5ced0YGd6Lq8v30nnqAiuTY6peSWlVJ2rrvvoM3VWhfJJIsIjV/QiLSOXBxesJ6ZZI87u3NzuspRSldQ4xER9o0NMNDxZ+UWMfPV70o8dZ+Edg+kYFW53SUr5nTMaYkJEuorIfBHZJCI7y6baL1P5qiZhQbw5NpkAhzB+9ioy83SAOqXqE08ai/8FvAoUA0OBucDb3ixK+Z7Y5o14fUwi+47mc9vbqykqKbW7JKWUkydBEGaM+QLrNNJuY8x04DLvlqV8UXKHZjwxsg8rdmbw54U6QJ1S9YUnYw0dd94+cpuITMa6y1iEd8tSvur/+rdjZ3ouLy3bTufoCCae38nukpTye54cEUwBGgF3AYlYYw+N9WZRyrfde3E3Lu3Tir/9dzOfbfrV7nKU8nvaa0jZIr+whOtmrGDboRw+uPVserdpYndJp+/prpDr5jbb4S1g6ra6r0cpN86011CSiCwQkdUisq5sqv0ylT8JCw5g5o1JNAkLYsKcFA5lN+AB6tyFQHXzlapnPDk19A5Wz6GRwBUuk1JnpEXjUGaNTSIrv4gJc1PILyyxu6Tat3gKfPMsrPsA9vwA2QehVHtMqfrFk8bidGPMIq9XovxS7zZNeOG6fkx8K4U/fLCGl0b1x59TCAIAABp3SURBVOEQu8vyzO7v4au/V7/M5o8h73DFeQHB0KQdNI21piaxJx43jYHI1uDQez+ruuNJEDwiIrOAL4DjZTONMR96rSrlVy7q1ZI/XdqTxz/ZzD+itnLfsO52l1S93SusANi1HMKjq1/2jzugMBey9kHmHsjcDZl7nY/3wNalkFOpwdwRaAVFkxho2r5iSDSNhcg2EODJf12lPOPJb9NNQA8gCCg7pjWABoGqNePP7ciO9BxeWradjlHhjExsZ3dJJ9uz0gqAnV9ZAfDbv0LSzfC3Gm7LGRwO0d2tyZ2ifGdQVAqJrL2w4ws4drDi8hIAjdu6BIRLSDSNtV4LCKqVt6z8gydBkGyMqedf0VRDJyI8OiKO3Rl53P/hOmKaNWJAx2Z2l2XZ84MzAJZBoyj47eNWAAQ7x0wKb1F1ryFPBIVBVFdrcqf4uMsRhUtIZO6xjkqyD1BhoGBxWEcN7kKiSYx1tBEYckofgfJtNXYfFZF/AU8bYzbVTUnV0+6jvi0rr4jfvfIdR/MKWXjHYNo3t3GAur0/WgGw40srAAZPgeTxJwKgviguhOz9J4dE2ZS9H4xrA7VY7RDuQqJpeysogkJtezvKO6rrPupJEGwGOgO7sNoIBDDGmL61XagnNAh8367Dufzule+IigjhP7edQ5OwOj7NsXeVMwC+gEbNnQEwof4FgKdKiqyjBnchkbnHOtowlXpsRbSseOqpQntFjHUUoxqUMw2C9u7mG2N210Jtp0yDwD+s3JnBmDd+YFCn5rw5LpmggDq4md6+FCsAtn9uBcA5d1kBEOLjI6qUFFvtEO5CoiwoSosqrhMeXSkkYp1BEWM99/XPrAE6rSAQkcbGmGwRcXui1hhzpBZr9JgGgf/4d8pe/jh/HaMHxvL4VXGIeKlb6b4U+OoJ2P4ZhDWDwXdB8kT9Y1amtMTq2eQuJMqCouR4xXUaNXcJCJeQKAuO0Mb2vBc/Vl0QVNdY/C5wOZCK1RLl+r/QADpamPKqa5Ni2JGew+vLd9KlRQQ3De5YuzvYl+o8AnAGwG8egQETISSydvfT0DkCoHEba4oddPLrpaVWY7m7kEjfAtv+B8WVrhwPbeo+JMqCIqxp3bw3BVQTBMaYy50/a/l/n1KemzasB7vSc3ns4010aB7O0B4e9sSpzv5U6whg2/8g7Cz4zcMwYJIGwOlyOCCylTXFDDj5dWMgN93ZNXZ3xUbtjO1WY3xRXsV1QppU3eupaaz17+atI0Q/5EkbwRfGmN/UNK+u6Kkh/5NXWMw1r61gd0Ye8287mx6tTvO0wv7VzgBYav0hOXsyDLxFA8BuxkDekRMh4a6tojCn4jrBkVWHRNP20KiZBkUlp9tGEIo1/PQyYAgnTg01Bj41xvSo/VJrpkHgn37JKmDEy98S6HCw8I7BREeeQj/4Az9ZAbD1U+uUxDmTYcAtep66oTAG8o9WERLOo4zj2RXXCWrkpteTy2mo8Gi/C4rTDYIpwN1AG+CAy0vZwExjzEu1XagnNAj81/p9WVz7+gp6tI5k3sRBhAbVMB7PgTXOAPgvhDaBs++0jgA0AHxPfmbVvZ4y90BBZsXlA8MqNl5XuEo71roY0FEHPdXq0Jl2H73TGPOiVyo7DRoE/u3TDb9w69upXBHfhheuS3Dfk+jAGlj+JPy8xCUAJlmPlX8qyK6me+xeyMuouHxASMWBAStPEa0aXFCcbq+hMrNE5F7gXKzeQt8ArxljGvAA8qqhGh7XimnDe/Dkp1voFBXOPRd3O/HiwbXw1ZPw8yfWH/2hf3IeAWgA+L3QxhDaG1r2dv/68RxnULhp0P55idXY7coRVHVQNImxelg1oBFkPQmCOcAxoOyo4HrgLeAabxWlVHVuvaATO9NzeP6LbXSKDmdEywzrCGDLx1ZvkyEPWgGgXRCVp0IioEVPa3KnMK/SCLIu7RXb/ud+BNmTBgZ0OQ3VuK3nI8jWwR3wPKkkzhjTy+X5MhGpF+MOKf8kIvz1d33g1w2EfTgWHKucAfAADLxVA0DVvuBGEN3NmtwpKjgxgmzlU1A7ljlHkHUdGNB5bYbbBm1nUAQGW8vWwR3wPAmC1SIyyBizEkBEBgJ6kl7Z55cNBC9/gqcPLybH0YgZcg2XjnuMdq1rGA5aKW8JCoWoLtbkjusIshWCYi/s+gaOHTh5YMCyoKgDngRBIvC9iOxxPo8FfhaR9dg4+JzyQ79ssE4BbV4EIY3hgmkc6nwjL725kf+8t435t0URGarj8Kt6KDAEmne2JndKiiqOIFveNXaP++VruzwPlhl+uhsXkeHA80AAMMsY84SbZa4FpmMdN601xlx/uvtTPurXjVYAbPrIupDo/D/CoNugUTM6Aa/eEMrYN3/kznk/MevGJALrYoA6pWpTQBCc1cGaKpvu/c4ONQaBMWa3iMQD5zlnfWOMWVvTeiISALwMXAzsA1aJyCLX+xqISFfgAWCwMeaoiNTC+AHKZ/y6yRkAC50BMBUG3W5dNepicJcoHrsqjgc+XM/jn2xm+pVV9AxRSrlVYxA4LyybyIlbU74tIjM8uLZgALDdGLPTuZ33gBGAa0PzROBlY8xRAGNM7bV+qIbr0GbrQrBNCyE4As67D86+46QAcDVqQCw7DuUw69tddI4OZ8zZHequXqW86UzvgOcBT04NjQcGGmNyAUTkSWAFJ7qTVqUtsNfl+T5gYKVlujm3+R3W6aPpxphPK29IRCYBkwBiY+um8UTZ4NBm6whg40LrJjDn/cEaD6iaAHD1wKU92XU4l+mLNxHbPJwLutVwY3mlGoJa6iJaHU9OpgrgevuiEioOSX0mAoGuWGMZjQJmishJff+MMTOMMUnGmKToaP3P7XMObYEPboJXzoZtn8G598Dd661RQT0MAYAAh/D8qH50bRHB5HdWs+3XY14sWinf4UkQ/Av4QUSmi8h0YCXwhgfr7QdiXJ63c85ztQ9YZIwpMsbsArZiBYPyB+k/w/yb4ZVBsHUpnHs3TFkHFz1ySgHgKiIkkDfHJRMaHMDNc1aRkXO85pWU8nM1BoEx5h/ATcAR53STMeY5D7a9CugqIh1FJBi4DlhUaZmFWEcDiEgU1qminR5Xrxqm9K0wfzy8PBB+/tQKgLvXw0XTIbz5GW++TdMwZt6YxKHs49zyVirHi0tqXkkpP+bRNc7GmNXA6lPZsDGmWEQmA0uxzv+/aYzZKCKPAinGmEXO137rvFK5BJhqjMmoequqQTu8zWoDWD/fGiZ48BQ4504Ij6r1XSXENOXZa+OZ/O5P3P+f9fzj2njv3epSqQbOw8EuTo8xZgmwpNK8h10eG+Be56R81eFtsPwp2DAfAkOtewKfc5dXAsDV5X3bsCs9l2c/20rn6HAmX6hnHZVyx6tBoPzc4e3w9VOw/gMrAM6ebAVARN01+E++sAs7D+fyzP+20jEqgsv66jAUSlWmQaBq3+Ht8PXTsP7f1rjuZ98B50yp0wAoIyI8MbIPe4/kce+/19DurDDiY3RQOqVc6bX4qvZk7IAFt8LLydZwEINuh7vXwW8ftyUEyoQEBvD6mERaNA5hwtwU9mfm21aLUvWRBoE6cxk7YMFt8FKydTHYoNthyloY9leIqB+jhjSPCOHNsckUFJYwfvYqco4X212SUvWGBoE6fUd2wsLbnQHwoXUvgLIAiGxpd3Un6doykpdG92fboRzufu8nSkqrv02rUv5Cg0CduiM7YeEd8GISbPiPdTewKetg+N/qZQC4uqBbNNOv6MXnmw/xxH83212OUvWCNhYrzx3ZBd88A2vmWbfiGzDJuhgsspXdlZ2SMWd3YEd6LjO/2UWn6AhGDdDxq5R/0yBQNTuaZvUCKg+AiTD4bmjccLtiPnRZT9Iycvnzwg3ENmvE4C7evaZBqfpMTw2pqh1Ng48mw4uJsO4DSJ5gtQFc8mSDDgGAwAAHL47qR6focG57O5Ud6Tl2l6SUbTQI1MmO7oZFdzoD4N+QNB6mrIFLn2rwAeAqMjSIN8YmExTgYPzsVRzNLbS7JKVsoUGgTsjcA4vughf7w9r3IOlmlwBoY3d1XhHTrBEzbkzkQFYBt76dSmFxac0rKeVjNAiUFQCLp8AL/WHtPEi8Ce5aA5c+7bMB4CqxfTOevrovP+w6wp8WrMcaAksp/6GNxf4scy988yz89DaIQOJY66YwTdrZXVmdG5HQlp3puTz/xTY6t4jg1gs6212SUnVGg8AfZe6Fb/8Bq9+ynve/Ec671y8DwNXdF3Vl5+Fcnvx0Cx2ahzM8rmF1i1XqdGkQ+JOsffDNP2D1XOt5/zFw7r3QNKb69fyEiPD01X3ZdzSPe95fQ7uzziaubRO7y1LK67SNwB9k7YdP/gAv9LNCoN8NcNdPcPk/NQQqCQ0KYMaYJJqFBzN+zip+ySqwuySlvE6DwJdl7YdP7oMXEiB1NiRcD3ethiue0wCoRnRkCG+MSyKnoJgJc1eRV6gD1CnfpkHgi7IPwJKpzgD4F8SPgjtXwxXPQ1MdTsETPVo15sXr+7HpQDZ3v7eGUh2gTvkwbSPwJdkH4dt/Wt/+TYl1BHDefXBWe7sra5Au7NGShy7rxaMfb+KppT9z/yU97C5JKa/QIPAF2Qfhu+cg5V9QWmwFwPn3wVkd7K6swbtpcAd2Hs7hteU76BQdzrVJekpN+R4Ngobs2C/WEYBrAJz3B2jW0e7KfIaI8MgVvdmdkcefFqwntlkjBnVqbndZStUqbSNoiI79Av+9H56Phx9nQt9r4M5UGPGShoAXBAU4eOn6/sQ2a8Stb6ey63Cu3SUpVas0CBqSY7/Cpw84A2AGxF0Nd6bAiJc1ALysSVgQb45LRoDxs1eRlVdkd0lK1RoNgobg2K/w6YPwfF/44XWIGwmTV8FVL0OzTnZX5zfaNw9nxo1J7Duaz23vpFJUogPUKd+gQVCf5RyCpX+yjgB+eBV6/58zAF6B5joWjh2SOzTj7//Xh+93ZPDwRxt1gDrlE7SxuD7KSbd6Aa16A0qOQ9/fw/lT9Y9/PTEysR07D+fw8rIddI4OZ8J5elSmGjYNgvokJx2+f94KgOIC6HOtFQBRXeyuTFXyh4u7s+twLn9dspkOzcO5qFdLu0tS6rRpENQHOenw/QuwapYzAK6B8/+oAVCPORzCs9cksO/oCu567yfuGNqFd3/Yw4HMfNo0DWPqsO5c1a+t3WUq5RFpaOc4k5KSTEpKit1l1I7cw1YA/DjTCoC4q+GCP0JUV7srUx46lF3Axf9cTnZ+Ma7/k8KCAvj7//XRMFC1YuFP+3l66c9n9EVDRFKNMUnuXtMjAjvkZpwIgKI86HO1dQQQ3c3uytQpatE4lODAAAwVB6bLLyrhL4s3EhzoQLAuTBMBARzOxw7nDIeIcxnXxyeWKVuvwjyX7VBpm9ZPAPfLW5ObeQiOSq/h3JaI8zXcL1/2U9W+hT/t54EP15NfVALA/sx8HvhwPUCtfdHQIKhLuRmw4kX4YYYVAHEjrSOA6O52V6bOwOFjx93OP5pXxO3vrK7jauznSXCUh6LjRPCVhZdD3Idi5VDDXbBSMdzcBivuw7DKYKVSzacU5K6fQcV5ruHpGuAn9mX9fGvF7vIQKJNfVMLTS3/WIGhQ8o7A9y9aF4EV5kLc/8EF0zQAfESbpmHsz8w/aX6LyBDeGj8Qg6G0FAwGY7AmDKUGjLF+Uv78xDzX5UuNwWC9Vr5+KRicr1XaRk3L47JMafkyJ5YvdfkJFbdZvrzLehXmVdpmhf0ZKr23isuXfxYun1fl5Usr1er6+Za9/xOfRc3Ll5SaCp9X5eWr/HzcfJYVlq/p8wVKS62fbv89nLUWlbg/fX/Aze/c6dIg8Ka8I7DiJesisLIAOP+P0EJHsfQlU4d1r3DoDlYbwYOX9qR7q0gbK1O+YPATX7r9otGmaVit7UODwBvyjsCKl50BkAO9f2edAmrR0+7KlBeUHZ6faWOeUu5U9UVj6rDaO6OgQVCbKgTAMSsAzv8jtOxld2XKy67q11b/8CuvqIsvGhoEtSH/qBUAK1+zAqDXVVYbgAaAUqoWePuLhgbBmcg/CitegR9eg+PZ0GuEMwB6212ZUkp5TIPgdORnwspXYOWrVgD0vNIKgFZxdlemlFKnzKtBICLDgeeBAGCWMeaJKpYbCcwHko0x9fey4fxM64//ylfheBb0vMIZAH3srkwppU6b14JARAKAl4GLgX3AKhFZZIzZVGm5SGAK8IO3ajlj+ZnW6Z8Vr1gB0ONyGHK/BoBSyid484hgALDdGLMTQETeA0YAmyot9xjwJDDVi7WcnoIsqwF45cvW4x6XW0cArfvaXZlSStUabwZBW2Cvy/N9wEDXBUSkPxBjjPlERKoMAhGZBEwCiI2N9UKplRRkWV1AV7xkPe5+GQyZBq3jvb9vpZSqY7Y1FouIA/gHMK6mZY0xM4AZYI0+6rWiCrJdAiATul9qHQG0SfDaLpVSym7eDIL9QIzL83bOeWUigTjgK+fAS62ARSJyZZ03GBdkw4+vw/fOAOh2iXUE0KZfnZahlFJ28GYQrAK6ikhHrAC4Dri+7EVjTBYQVfZcRL4C7qvTEDh+7MQRQP5RDQCllF/yWhAYY4pFZDKwFKv76JvGmI0i8iiQYoxZ5K19V/B0V8g9dPL84HAICHYGwHDrFFDb/nVSklJK1SdebSMwxiwBllSa93AVyw7xShHuQgCs0UC7nmsdAbRN9MqulVKqIfDvK4tH/9vuCpRSynYOuwtQSillLw0CpZTycxoESinl53w/CMJbnNp8pZTyM77fWDx1m90VKKVUveb7RwRKKaWqpUGglFJ+ToNAKaX8nAaBUkr5OQ0CpZTyc2KM94b39wYRSQd2n+bqUcDhWixHqcr0d0x505n8frU3xkS7e6HBBcGZEJEUY0yS3XUo36W/Y8qbvPX7paeGlFLKz2kQKKWUn/O3IJhhdwHK5+nvmPImr/x++VUbgVJKqZP52xGBUkqpSjQIlFLKz/lFEIjImyJySEQ22F2L8j0iEiMiy0Rkk4hsFJEpdtekfIeIhIrIjyKy1vn79Zda34c/tBGIyPlADjDXGBNndz3Kt4hIa6C1MWa1iEQCqcBVxphNNpemfICICBBujMkRkSDgW2CKMWZlbe3DL44IjDFfA0fsrkP5JmPMQWPMaufjY8BmoK29VSlfYSw5zqdBzqlWv8H7RRAoVVdEpAPQD/jB3kqULxGRABFZAxwCPjPG1OrvlwaBUrVERCKA/wB3G2Oy7a5H+Q5jTIkxJgFoBwwQkVo9xa1BoFQtcJ67/Q/wjjHmQ7vrUb7JGJMJLAOG1+Z2NQiUOkPOxrw3gM3GmH/YXY/yLSISLSJNnY/DgIuBLbW5D78IAhGZB6wAuovIPhEZb3dNyqcMBsYAF4rIGud0qd1FKZ/RGlgmIuuAVVhtBB/X5g78ovuoUkqpqvnFEYFSSqmqaRAopZSf0yBQSik/p0GglFJ+ToNAKaX8nAaBqjdE5FYRubGWtrVERJo6p9s9XGe6iNx3mvtLcO0y6um2xPKliDR2Ps+paZ0zJSKfi8hZ3t6Pajg0CFS9YYx5zRgzt/J8EQk8jW1d6rwKsyngURCcoQTgdK4duBRYWxdDUjhDxwG8Rd18JqqB0CBQthCRG0VknXOM9bec88q/RYvIVyLynIikAFNEJFlEvncu/6OIRIrIOBF5yWWbH4vIEOfjNBGJAp4AOjsv8nraTR1/EpGtIvIt0N1lfmcR+VREUkXkGxHp4Zw/W0ReE5EU53qXi0gw8Cjwe+d+fu/cTC/n+9gpIndV8VGMBj5yU1eEiHwhIqtFZL2IjHDOf1RE7nZZ7q9l9z8Qkakissr5uf7FOa+DiPwsInOBDUAMsAgYVcW/S46I/NM57v0XIhJdRd3KlxhjdNKpTiegN7AViHI+b+b8OR24z/n4K+AV5+NgYCeQ7HzeGAgExgEvuWz3Y2CI83EaEAV0ADZUUUcisB5o5Nzmdpf9fwF0dT4eCHzpfDwb+BTrS1RXYB8Q6qaW6cD3QIizjgwgyE0Nu4FIl+c5zp+BQGPn4yhnbeJ8P6ud8x3ADqA58FusG5uLc/7HwPnO5UuBQZX2uw1o7qYeA4x2Pn7Y9T3p5LvTKR9yK1ULLgQ+MMYcBjDGVHWviPedP7sDB40xq5zLZwNYQ/yckfOABcaYPOf2Fjl/RgDnAB+47CPEZb1/G2NKgW0ishPoUcX2PzHGHAeOi8ghoCVWcLhqZqx7GFQmwN+cN1Uqxbq/QUtjTJqIZIhIP+f2fjLGZIjIb7HC4Cfn+hFYQbUH2G1OvonJIaANVkC5KuXE5/42oAPo+QENAlWf5dbwejEVT2+G1tJ+HUCmsYb9dafyuCxVjdNy3OVxCe7/vxWLiMMZLK5GA9FAojGmSETSOPH+ZmEdgbQC3nTOE+DvxpjXXTfivD+Cu88xFMivom5XOgaNH9A2AmWHL4FrRKQ5gIg0q2H5n4HWIpLsXD7S2YCcBiSIiENEYoABbtY9BkRWsd2vgatEJEysW0xeAeVHHLtE5Brn/kRE4l3Wu8a5z85AJ2d91e2npvfWyc38JsAhZwgMBdq7vLYAaxjiZGCpc95S4Gbn0Qwi0lZEWrjboViHOa2wPr/KHMDVzsfXY90WUfk4PSJQdc4Ys1FE/gosF5ESrNMZ46pZvtDZAPuiWMPw5gMXAd8Bu4BNWLeHXO1m3QwR+U5ENgD/NcZMdXlttYi8D6zFOlWyymXV0cCrIvIQ1q0B33MuB9bplh+x2hVuNcYUiMgy4H6x7iL191P4OD4BhmC1Abh6B1gsIuuBFFyGHXZ+HsuwjlpKnPP+JyI9gRXO01k5wA1YRyKVJQIrjTHFbl7LxbrxyUNYn8nv3SyjfIyOPqrUKRCR2cDHxpj5tbS91sBcY8zFp7COAyv0rjHGbDuNfT4PLDLGfOHmtRxjTMSpblM1bHpqSCkbGWMOAjPFeUFZTUSkF9bRwxenEwJOG9yFgPJfekSglFJ+To8IlFLKz2kQKKWUn9MgUEopP6dBoJRSfk6DQCml/Nz/A9l5pSUUCP0kAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get results for variational angles\n",
    "gamma = result_angle[:DEPTH]\n",
    "beta = result_angle[DEPTH:]\n",
    "# get array [1, 2, ..., p]\n",
    "pa = np.arange(1, DEPTH + 1)\n",
    "\n",
    "plt.figure(2)\n",
    "plt.plot(pa, gamma / np.pi, '-o', label='gamma')\n",
    "plt.plot(pa, beta / np.pi, '-s', label='beta')\n",
    "plt.xlabel('circuit depth (layer) p')\n",
    "plt.ylabel('optimal angles [pi]')\n",
    "plt.xticks(pa)\n",
    "plt.legend(title='Variational QAOA angles:', loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimal energy found with QAOA: -6.486032631497276\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize solution\n",
    "colorlist = tracker['optimal_bitstring']\n",
    "colorlist[colorlist == -1] = 0\n",
    "\n",
    "# plot_colored_graph(J, N, colorlist, pos)\n",
    "plot_colored_graph_simple(G, colorlist, pos)\n",
    "print('Minimal energy found with QAOA:', tracker['optimal_energy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classical solution: {'s0': -1, 's1': 1, 's2': -1, 's3': -1, 's4': 1, 's5': -1, 's6': 1, 's7': 1, 's8': -1, 's9': -1}\n",
      "Minimal energy found classically: -6.486032631497276\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# validate quantum results with classical algorithm\n",
    "solution, energy_min, colors_classical = solve_classical_ising(J, n_qubits, pos)\n",
    "# plot classical solution\n",
    "plot_colored_graph_simple(G, colors_classical, pos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that QAOA may arrive at a different solution than our classical benchmark code. \n",
    "First of all, the classical optimization routine may get stuck in a local rather than global optimum. \n",
    "To avoid this, more sophisticated optimization strategies may be employed (as proposed for example in Ref.[4]), going beyond the scope of this introductory notebook tutorial. \n",
    "Secondly, even if QAOA arrives at the same classical energy as our classical approach, the coloring may differ since the solution space may be degenerate for the specific example shown here (this means, two different classical bitstrings have the same energy).\n",
    "At minimum, you may find an inverted coloring (by swapping red and blue colors), because of the underlying $\\mathbb{Z}_{2}$ symmetry. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SUMMARY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we have gone through an end-to-end demo on QAOA and its implementation on Amazon Braket. \n",
    "We have built modular core building blocks that may easily adapted to other problems. \n",
    "The QAOA routine is tailored towards solving combinatorial optimization problems such as _Maximum Cut_ [4] and arguably one of the most prominent examples of the emerging class of hybrid, variational algorithms and still very much a field of active research today. \n",
    "For example, as we increase the circuit depth of QAOA, the classical optimization step becomes increasingly difficult (because of the curse of dimensionality as well known in classical machine learning) and may easily get stuck in local sub-optimal solutions. \n",
    "To address this issue some heuristics have already been developed, for example in Ref.[4], but further improvements will arguably be necessary to fully unlock the potential of this approach. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## REFERENCES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] E. Farhi, J. Goldstone, and S. Gutmann, \"A Quantum Approximate Optimization Algorithm\", arXiv: 1411.4028 (2014).\n",
    "\n",
    "[2] Y. Cao, J. Romero, J. P. Olson, M. Degroote, P. D. Johnson, M. Kieferova, I. D. Kivlichan, T. Menke, B. Peropadre, N. P. Sawaya, et al., \"Quantum Chemistry in the Age of Quantum Computing\", Chemical reviews 119, 10856 (2019).\n",
    "\n",
    "[3] A. Smith, M. Kim, F. Pollmann, and J. Knolle, \"Simulating quantum many-body dynamics on a current digital quantum computer\", npj Quantum Information 5, 1 (2019).\n",
    "\n",
    "[4] L. Zhou, S.-T. Wang, S. Choi, H. Pichler, and M. D. Lukin, \"Quantum Approximate Optimization Algorithm: Performance, Mechanism,and Implementation on Near-Term Devices\", arXiv: 1812.01041 (2018). \n",
    "\n",
    "[5] F. Glover, G. Kochenberger, \"A Tutorial on Formulating and Using QUBO Models\", arXiv:1811.11538 (2018).\n",
    "\n",
    "[6] P. Vikstal, M. Groenkvist, M. Svensson, M. Andersson, G. Johansson, and G. Ferrini, \"Applying the Quantum Approximate Optimization Algorithm to the Tail Assignment Problem\", arXiv:1912.10499 (2019). \n",
    "\n",
    "[7] L. Li, M. Fan, M. Coram, P. Riley, and S. Leichenauer, \"Quantum optimization with a novel gibbs objective function and ansatz architecture search\", arXiv:1909.07621 (2019). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## APPENDIX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Version: 1.33.2.dev0\n",
      "Version: 1.10.1.dev0\n"
     ]
    }
   ],
   "source": [
    "# Check SDK version\n",
    "!pip show amazon-braket-sdk | grep Version\n",
    "!pip show amazon-braket-default-simulator | grep Version\n",
    "# !pip list --outdated --format=freeze | grep -v '^\\-e' | cut -d = -f 1  | xargs -n1 pip install -U"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### APPENDIX: Example for Ising Matrix Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this appendix we provide a small code example to showcase how we obtain all edges with corresponding weights. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ising matrix:\n",
      " [[0 1 0]\n",
      " [0 0 3]\n",
      " [0 0 0]]\n",
      "Edges: [(0, 1), (1, 2)]\n",
      "Interaction strength: 1\n",
      "Interaction strength: 3\n",
      "All interactions: [1 3]\n"
     ]
    }
   ],
   "source": [
    "# example Ising matrix with edges between qubit 0 and qubit 1 (weight=1) and qubit 1 and qubit 2 (weight=3)\n",
    "ising = np.array([[0, 1, 0], [0, 0, 3], [0, 0, 0]])\n",
    "print('Ising matrix:\\n', ising)\n",
    "\n",
    "# get all non-zero entries (edges) from Ising matrix \n",
    "idx = ising.nonzero()\n",
    "edges = list(zip(idx[0], idx[1]))\n",
    "print('Edges:', edges)\n",
    "\n",
    "# for every edge print interaction strength\n",
    "for qubit_pair in edges:\n",
    "    # get interaction strength\n",
    "    int_strength = ising[qubit_pair[0], qubit_pair[1]]\n",
    "    print('Interaction strength:', int_strength)\n",
    "\n",
    "# get all non-zero entries from Ising, with proper order\n",
    "interactions = np.array([ising[q[0], q[1]] for q in edges])\n",
    "print('All interactions:', interactions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task Summary\n",
      "{}\n",
      "Estimated cost to run this example with SV1: 0 USD\n"
     ]
    }
   ],
   "source": [
    "print(\"Task Summary\")\n",
    "print(t.quantum_tasks_statistics())\n",
    "print(f\"Estimated cost to run this example with SV1: {t.qpu_tasks_cost() + t.simulator_tasks_cost()} USD\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.15"
  },
  "vscode": {
   "interpreter": {
    "hash": "590fab68195cf107911461461f81d5c472d3d6127f579badfcfad30f03e5cab2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}