tutorial/combinatorial_optimization/MAXCUT_EN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-06T07:10:17.389768Z",
     "start_time": "2021-01-06T07:10:17.379639Z"
    }
   },
   "source": [
    "# Solving Max-Cut Problem with QAOA\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-06T07:12:18.621281Z",
     "start_time": "2021-01-06T07:12:18.308211Z"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "In the [tutorial on Quantum Approximate Optimization Algorithm](./QAOA_EN.ipynb), we talked about how to encode a classical combinatorial optimization problem into a quantum optimization problem and slove it with Quantum Approximate Optimization Algorithm [1] (QAOA). In this tutorial, we will take the Max-Cut Problem as an example to further elaborate on QAOA.\n",
    "\n",
    "### Max-Cut Problem\n",
    "\n",
    "The Max-Cut Problem is a common combinatorial optimization problem in graph theory, and it has important applications in statistical physics and circuit design. The maximum cut problem is an NP-hard problem, so there is no efficient algorithm that can solve this problem perfectly.\n",
    "\n",
    "In graph theory, a graph is represented by a pair of sets $G=(V, E)$, where the elements in the set $V$ are the vertices of the graph, and each element in the set $E$ is a pair of vertices, representing an edge connecting these two vertices. For example, the graph in the figure below is represented by $V=\\{0,1,2,3\\}$ and $E=\\{(0,1),(1,2),(2,3),(3, 0)\\}$.\n",
    "\n",
    "![G](figures/maxcut-fig-maxcut_g.png \"Figure 1: A graph with four vertices and four edges\")\n",
    "<div style=\"text-align:center\">Figure 1: A graph with four vertices and four edges </div>\n",
    "\n",
    "A cut on a graph refers to a partition of the graph's vertex set $V$ into two disjoint sets. Each cut corresponds to a set of edges, in which the two vertices of each edge are divided into different sets. So we can define the size of this cut as the size of this set of edges, that is, the number of edges being cut. The Max-Cut Problem is to find a cut that maximizes the number of edges being cut. Figure 2 shows a maximum cut of the graph in Figure 1. The size of the maximum cut is $4$, which means that all edges in the graph are cut.\n",
    "\n",
    "![Max cut on G](figures/maxcut-fig-maxcut_cut.png \"Figure 2: A maximum cut of the graph in Figure 1\")\n",
    "<div style=\"text-align:center\">Figure 2: A maximum cut of the graph in Figure 1 </div>\n",
    "\n",
    "Assuming that the input graph $G=(V, E)$ has $n=|V|$ vertices and $m=|E|$ edges, we can describe the Max-Cut Problem as a combinatorial optimization problem with $n$ bits and $m$ clauses. Each bit corresponds to a vertex $v$ in the graph $G$, and its value $z_v$ is $0$ or $1$, corresponding to the vertex belonging to the set $S_{0}$ or $S_{1}$, respectively. Thus, each value $z$ of these $n$ bits corresponds to a distinct cut. Each clause corresponds to an edge $(u,v)$ in the graph $G$. A clause requires that the two vertices connected by its corresponding edge take different values, namely $z_u\\neq z_v$, which means the edge is cut. In other words, when the two vertices connected by the edge are divided into different sets, we say that the clause is satisfied. Therefore, for each edge $(u,v)$ in the graph $G$, we have\n",
    "\n",
    "$$\n",
    "C_{(u,v)}(z) = z_u+z_v-2z_uz_v,\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "where $C_{(u,v)}(z) = 1$ if and only if the edge is cut. Otherwise, the function is equal to $0$. The objective function of the entire combinatorial optimization problem is\n",
    "\n",
    "$$\n",
    "C(z) = \\sum_{(u,v)\\in E}C_{(u,v)}(z) = \\sum_{(u,v)\\in E}z_u+z_v-2z_uz_v.\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "Therefore, to solve the maximum cut problem is to find a value $z$ that maximizes the objective function in equation (2).\n",
    "\n",
    "### Encoding Max-Cut Problem\n",
    "\n",
    "Here we take the Max-Cut Problem as an example to further elaborate on QAOA. In order to transform the Max-Cut Problem into a quantum problem, we need to use $n$ qubits, where each qubit corresponds to a vertex in the graph $G$. A qubit being in a quantum state $|0\\rangle$ or $|1\\rangle$ indicates that its corresponding vertex belongs to the set $S_{0}$ or $S_{1}$, respectively. It is worth noting that $|0\\rangle$ and $|1\\rangle$ are the two eigenstates of Pauli $Z$ gate, and their eigenvalues are respectively $1$ and $-1$, namely\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "Z|0\\rangle&=|0\\rangle,\\tag{3}\\\\\n",
    "Z|1\\rangle&=-|1\\rangle.\\tag{4}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "Therefore, we can use Pauli $Z$ gate to construct the Hamiltonian $H_C$ of the Max-Cut Problem. Because mapping $f(x):x\\to(x+1)/2$ maps $-1$ to $0$ and $1$ to $1$, we can replace $z$ in equation (2) with $(Z+I)/2$ ($I$ is the identity matrix) to get the Hamiltonian corresponding to the objective function of the original problem:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "H_C &= \\sum_{(u,v)\\in E} \\frac{Z_u+I}{2} + \\frac{Z_v+I}{2}-2\\cdot\\frac{Z_u+I}{2} \\frac{Z_v+I}{2}\\tag{5}\\\\\n",
    "&= \\sum_{(u,v)\\in E} \\frac{Z_u+Z_v+2I-(Z_uZ_v+Z_u+Z_v+I)}{2}\\tag{6}\\\\\n",
    "&= \\sum_{(u,v)\\in E} \\frac{I-Z_uZ_v}{2}.\\tag{7}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "The expected value of this Hamiltonian for a quantum state $|\\psi\\rangle$ is\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\langle\\psi|H_C|\\psi\\rangle &= \\langle\\psi|\\sum_{(u,v)\\in E} \\frac{I-Z_uZ_v}{2}|\\psi\\rangle\\tag{8} \\\\\n",
    "&= \\langle\\psi|\\sum_{(u,v)\\in E} \\frac{I}{2}|\\psi\\rangle-\\langle\\psi|\\sum_{(u,v)\\in E} \\frac{Z_uZ_v}{2}|\\psi\\rangle\\tag{9}\\\\\n",
    "&= \\frac{|E|}{2}-\\frac{1}{2}\\langle\\psi|\\sum_{(u,v)\\in E} Z_uZ_v|\\psi\\rangle.\\tag{10}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "If we define\n",
    "\n",
    "$$\n",
    "H_D = -\\sum_{(u,v)\\in E} Z_uZ_v,\n",
    "\\tag{11}\n",
    "$$\n",
    "\n",
    "then finding the quantum state $|\\psi\\rangle$ that maximizes $\\langle\\psi|H_C|\\psi\\rangle$ is equivalent to finding the quantum state $|\\psi\\rangle$ such that $\\langle\\psi|H_D|\\psi \\rangle$ is the largest."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paddle Quantum Implementation\n",
    "\n",
    "Now, let's implement QAOA with Paddle Quantum to solve the Max-Cut Problem. There are many ways to find the parameters $\\vec{\\gamma},\\vec{\\beta}$. Here we use the gradient descent method in classical machine learning.\n",
    "\n",
    "To implement QAOA with Paddle Quantum, the first thing to do is to import the required packages. Among them, the `networkx` package can help us handle graphs conveniently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:07:36.250220Z",
     "start_time": "2021-04-30T09:07:36.223934Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>pre { white-space: pre !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "display(HTML(\"<style>pre { white-space: pre !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:07:40.001750Z",
     "start_time": "2021-04-30T09:07:36.983994Z"
    }
   },
   "outputs": [],
   "source": [
    "# Import related modules from Paddle Quantum and PaddlePaddle\n",
    "import paddle\n",
    "from paddle_quantum.circuit import UAnsatz\n",
    "from paddle_quantum.utils import pauli_str_to_matrix\n",
    "\n",
    "# Import additional packages needed\n",
    "import numpy as np\n",
    "from numpy import pi as PI\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we generate the graph $G$ in the Max-Cut Problem. For the convenience of computation, the vertices here are labeled starting from $0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:07:40.192343Z",
     "start_time": "2021-04-30T09:07:40.007013Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAj/0lEQVR4nO3deXyV1bXw8d8KgUAYo6KCcJuKgOKEc6vgRJVqnG61Uq1tUXCotCqKpbF2sINR63D1qnXAwnvb19q+ttdeG1vHq4JVq4iigqDgURFBZAqQBBKy3j/WDqAMkpznPM9zzlnfz4fPRzbJ8yxzstfZZz97ry2qinPOuXiUJB2Ac84VE0+6zjkXI0+6zjkXI0+6zjkXI0+6zjkXI0+6zjkXI0+6zjkXI0+6zjkXI0+6zjkXI0+6zjkXI0+6zjkXI0+6zjkXI0+6zjkXo9KkA3Bue1VW15YAA4BBQBegE7AOaADmAvMyNVUtyUXo3OcTL+3o0iok2RFAFTAc2AtoAZoBCX80/CnFPrnNBqYCtcCTnoRd2njSdalTWV1bAZwLTAC6A12xBLu9FFgD1AE3AZMzNVXLo47TufbwpOtSo7K6thy4HhiLjWjLI7hsPTYCngRMzNRU1UdwTefazZOuS4XK6trhwANABTZfG7UGYDkwKlNTNS0H13duu3jSdYmqrK4tA24BRpObZPtZDcAUYHympmptDPdz7lM86brEVFbXdgMeA4YST8Jt1QDMAEZmaqpWx3hf5zzpumSEhDsNGAx0TiCERmAOMMwTr4uTb45wsQtTCo+RXMIl3Hcw8GiIx7lYeNJ1SbgFm1JIKuG26gwcANyccByuiPj0gotVWKXwKPHO4X6eBuB4X9Xg4uBJ18UmrMN9G+ibdCxbsBAY6Ot4Xa759IKL0w3YOtw0qgCuSzoIV/h8pOtiEbb2LiT5edxtaQT6+pZhl0s+0nVxORfb2ptmLdgmDedyxke6LudCtbAFQJ+kY9kOC4H+Xp3M5YrX03VxGIFVC2u3YXvsxDGDe7NP354M6duD7p07bvi3b9zzPC+8uyzbGFv1AI4Fnojqgs5typOui0MVVp6x3b79pS9w/N67RhTONpUDJ+JJ1+WIJ10Xh+G0rR7uZhRYtLKRNxauZPXaZk4buls0kW2uBDgyVxd3zud0XU6F+dw1ZLlqoXPHEhqbbJr1S1/cgQcu+PKGf4t4egFss0TXTE2Vdw4XOV+94HJtALA+24u0JtyYtGBxOxc5T7ou1wZhZ5rlk2Ysbuci50nX5VoXspzPTYCQrtoQroB40nW51on8TLpe7tHlhCddl2vrsMUH+UQBP8rH5YQnXZdrDeRn0m1IOghXmDzpulybS/6tBy/F4nYucvnWGVz+mUcEb+4n7duH/fr1AqBvr08v+T3nS1/g2D13AWDmghX87fWPsr1dCRa3c5HzzREu5yqra6cDB2ZzjRvP2I8zDur/uV/34PQPmPDgzGxuBTA9U1N1cLYXcW5LfHrBxWEq+TOv2wI8m3QQrnD59IKLQy0wBujW3gtMeHBmFCPY7VEPPBLHjVxx8pGui8OTwKqkg9hOdcBTSQfhCpcnXZdzoSD4jdgoMs3qgRu9gLnLJU+6Li6TSf/vWwkwJekgXGFLeydwBeK9605asXbhnGktTenc6KWqDcC9fiilyzVPui7nROQLwN8X33/VV1oaVycdzha11K/ouPDe7/4p6Thc4fOk63JGREpEZBzwBjBSm9cuX/XSQ78Mo8rUaGlap0v+cm1p09IPnhGRG0WkPOmYXOHypOtyQkQGA88At2NLxR4E9lr54l9+LCJTSE9tgwYRuXfth7N/Hf5+BTBTRI5OLiRXyDzpukiJSEcR+SHwGjAMWAScrqpfV9XF4cvGAzOAxoTCbNUIzJDSjpeo6g+Aw4DXsVMj/ldE7haRnolG6AqObwN2kRGRA4D7gANC02TgClXd7OFUZXVtN2AaMJgsz09rp0ZgDjAsU1O1YaJZRDoBE4EfAx2BD4HvqurDCcToCpAnXZc1EekM/AT4AdAByAAXqOrj2/q+kHgfA4YS70kNDdhIe+SmCXdTIrI39gZyWGj6A3Cpqi6JJ0RXqHx6wWVFRI4AXgWqsd+n24B9Py/hAoSEdww2Io5rjrch3O/YrSVcAFV9EzgCmwqpB84CZovI2SKSbydhuBTxka5rFxHpDlwLjMOOt3kLGKOq/2zP9Sqra4cBfwQqyM2otwFYDozK1FRNa8s3isjuwD3AiND0N2zKYUG0Ibpi4CNd12YiMhJbBvY97Hj1XwJD25twAUIiHAhMwuZbo9oyXB+uNwkY2NaEC6Cq84HjsKI9K4GTgFkicqGIeB9ybeIjXbfdRGQH4GbgO6FpOja6fS3K+1RW11YAo4EJQA+gnLYNEFqwZFuH1XyYEtVOMxHpC9wJnBqangbOV9V3ori+K3yedN12EZEzgDuAnbGR40+Bm1W1OVf3rKyuLcE+0p8AHAkMwRJqMzalIVidXsXKlJYAs7B6uI8AT+WieE2Y0z0DW4Pc+vP4MfAfufx5uMLgSddtk4j0wZLL10LTVGCsqsZ+hlhIwrsDg7B53zLs1N4G7EyzeZmaqth+oUVkR+AW4Fuh6WVs5B9L4V+Xnzzpui0Ko7nR2HRCL2A1tiTsblX10oebEJETgLuB/tgo/FrgWlVNZ3UflyhPum4zIlKJPa0/LjT9HbhIVd9PLKiUE5EeQA1wcWiahY16X0guKpdG/uTVbSAiHUTkEmxlwnHAUuAcoMoT7rapap2qjsPmnt/G5p//KSI3i0jXZKNzaeIjXQeAiOyF7cD6cmj6I3CJqn6cXFT5SUS6YDv0rsR26L2LrXB4MtHAXCp40i1yItIRm6v9CdAJ+Ahb+P/XRAMrACJyEPZGtn9oug+YoKorEgvKJc6TbhELSeG3wH6haRJwpSeF6IQ3tSuxJXb+puY86Raj8PH3p9jmgw7AfKxAjX/8zZEwfTMJODw0/Qmbvlm89e9yhcgfpBUZETkSq3U7EdtccDOwnyfc3FLV2cBw4BJgDXAmtpX4HC+gU1x8pFsktrKk6TxVfTG5qIqTL8krbj7SLQIiciK2DOxibPH+NcCBnnCToaoZYCRwLrAC2+b8pohc7AV0Cp+PdAuYiOyEbVM9JzS9jI1uX08uKrcpEdkVq2mR+DZrFw9/Vy1AYs7EphDOwQqyTAC+7Ak3XVR1kaqejhXQWYzN+84UkYkiUppsdC4XfKRbYLz0YP4KpTNvwmpeALyCfTKJtHSmS5aPdAtEGN2OwUa3p2K1ZC8ERnjCzQ+qukxVz8Xme98DDgReFpFfhnPoXAHwkW4BCMfJ3AscG5r8OJk8JyLdsGpl3yOC45BcevhIN4+FAjXjgdexhPsJcDZwiifc/Kaqq1X1EmyOdw6wJzBNRG4NCdnlKR/p5qktHBF+P3CZHxFeeMLUwo+xDS0dsKmHC1T1sUQDc+3iSTfPiEgn4IfA1UBH4ENsKuHhRANzOSciQ7FaGQeEpinA5aoayflvLh6edPOIiByCjW73DU13AxNVdWVyUbk4hQI6l2MbXMqARcA4Vf1LooG57eZJNw+ISDnWyS7H5uHnYQvon04yLpccERmMFdAZFpr+DHxPVRclF5XbHv4gLeVE5GisQM2E0HQjVqDm6YRCcimgqnOAo4Bx2Pl1p2MFdL7jBXTSzUe6KSUiPYHrsbW2YCsUxqjqS8lF5dJIRL4A3AV8NTQ9BlwYajy4lPGRbgqJyEnAm1jCbcJq3x7sCddtiaq+B5wIfBtYBhwPvCEi3/cCOunjI90UEZHewK3AWaHpRWx0+2ZyUbl8IiK7AP8JfD00PYfN/7+VXFRuU/4umAJhC+9Z2Bbes4B6YDxwhCdc1xaqulhVz8Sqli0CjgBeE5GrwsoHlzAf6SZMRPoBvwFOCk1PYgvf5ycXlSsEIlIB/BoYE5pexQrozEgsKOcj3aSISImIXIDN3Z4ErATGAsd5wnVRUNXlqjoWO6EiAwwFXhKRmnBOnkuAj3QTICJ7YAVqjg5NfwUuVtWFiQXlCpqIdAV+CVyKFdCZiz0vmJZoYEXIR7oxEpFSEZmALf86GlgCjAL+3ROuyyVVXaOq47E53tnAIGCqiNwuIt2Tja64+Eg3JiKyL7aF95DQ9DtgvKouTS4qV4xEpAz4EVANlALvY+t6/5FoYEXCk26OhV/wq8KfUuAD7Bf874kG5oqeiOyHFdA5KDT9F1ZAxwcCOVRQSbeyurYEGIB9dOoCdALWAQ3YHNa8TE1VS1zxiMhh2Oh279B0J1CtqnVxxeDctoRz2MYDPwc6Ax9jW4v/rDEmh7T13VzK66QbXqgRQBVW7HkvoAU7ZlzCHw1/SrE57NnYiau1wJO5eCHDQ4tfAJeFGN7GFqg/G/W9nIuCiAzECugcGZr+G6te9lEu7pfWvhuHvEy6ldW1FcC5WBGY7kBX7EXaXgqswc4RuwmYnKmpiqQmqYiMwFYmfBFYjxWouUZVG6K4vnO5ErYMXwDcgPWrlVhlu8lRjXrT3HfjkldJt7K6thwrAjMWe1csj+Cy9di76CRgYqamqr49FxGRXthC9LGh6TVsSc70CGJ0LjYi0h8roHNiaHoC27Dzbnuvmea+G7e8SbqV1bXDgQeACmzOJ2oNwHJgVKamqk1rF0XkVGxXWR9sHurnwA2q2hR5lM7FIJSHPAu4DdgRS3BXAber6vq2XCvNfTcJqU+6ldW1ZcAtwGhy84J9VgN2DMr4TE3V2m19oYjsjP1SjgpNz2Oj29k5jdC5mIQiTLcB3whNz2PPJ2Z93vemue8mKdVJt7K6thtWG3Qo8bxorRqAGcDITE3V6s/+YxgFfBOrCLYDNsdUDdzZ1lGAc/lARE7BPs31xT7N/QK4fmuf5tLad9MgtUk3vGjTgMHYUpa4NWJHXw/b9MXbwnzX49h8Vyb2CJ2LUSis/2vg/NA0E/tk9/KmX5fWvpsWqdwGHD6WPEZyLxrhvoOBRyura8tCgZrvYuUXTwRWYE9hR3rCdcVAVVeq6gXYUq/5wH7AiyJyQ2sBnTT23YRi2KpUJl1sHmgoyb1orToDBzSvXnYf8DS2uaEbtoZxiKpOiXMBuXNpoKpPYSdS3xyargRmishRpKzvsjHG1Ehd0g1POkcT7zzQtnQpKev6zbJ+Q4YDi4EzVPVruVo07lw+UNV6Vb0COBwrT7pHWb+9n9b1TeeTor4LnFtZXTvsc78yRqma0w1r+d7GJutTZX3DqoblT9wzcPUbT32YdCzOpYmIdCrp0v0nfc67/Uel3XdMOpwtWQgMTMs63rSNdG/A1vKlTocu3dnp5CsmJh2Hc2mjquv6X/qHXh26VjQmHctWVADXJR1Eq9SMdMP2wIUkPxe0LY1A33zbduhcLnnfbZs0jXTPxbYHplkLNt/snNvI+24bpGKkGyoOLcC20bZLj86lHDdkFw6t3JG9+/agd/cyKso7sbZ5PZml9Tz11sf89rl3WdmQ9c7chUD/fK1w5FyUoui7AL3KO3L+sN0ZsdfO9K+wsgwfLK/nydkfc8/U+VH0W0hJ3y1N8uabGIFVHGq3I/bYiZu+PnSz9k6lJey7W0/23a0n3zikP2dPeoF5S9Zkc6sewLFYERDnil3WfXfQLt343XmHsUuPT89O7LlrD/bctQdnHNSPb/32ReYuznqfQyr6blqmF6qwEm9Zq2to4uHXFnLT43O459n5LK7bOLe/S4/OXHvavtneopyNu9GcK3ZZ9d2y0hLuOuegDQl3ZUMTdz0zj7uembdhdLtLj8785psHUVaadbpKRd9Ny0h3OG2rqbmZFfVNXPPwm/zhpfdpbNr46eGuZ+fx6KVH0ru7bUw5pHIHunbqwJp17S6RUMLGQs/OFbus+u5pQ3dj9526bfj7pQ/M4Om5SwB44d2lTBl9KAADenfj1KG78aeXP8gm1lT03cRHumFOaEi213l+/lIm/zPzqYQLsGzNOl7KLNvw95ISoWP275hDKqtrs3qTcC7fRdF3R+6964b/rmts2pBwAZ6Zu4RVjRvncr+6yddmIfG+m3jSxc5FymllrgG9N76TZpauYUV91pPyLVjczhWzrPvukD49Nvz3gmWf3rugCguWbzxwZa8+kZwUn3jfTUPSHYSdi5QTl44YyOBdN75YNz8+N4rLNmNxO1fMsu67FeUdN/z3qrWbX2pV48a2Hco7ZXOrVon33TTM6XYhy/ncLRGBH524F2OH7b6h7T+emMv/vLYwksuTnv3lziUl0r4rW7iURD8RkHjfTUPS7UTESbdrpw7cdtYBjNhzFwBaWpSaf7zFvVPnR3ULAVJXMs65mGXdd5fXN7Frzw4AdO+8eTrqVraxbVn9umxu1SrxvpuGpLsOO+EzErv16sKkbx/MXmGuqH5dM+P/9BqPvrkoqluAxZva40Cci0nWfXfWR3Xs2tOWi/Wr6IKIzeWCjXL777Dx/MrZH63K5latEu+7aZjTbSCipHtA/148dPHhGxLuwhUNfP2u56NOuGDx+pHqrthl3Xcfm7Wxb3bv3JGjB+284e9HD9r5UyPdiPpx4n03DSPduUQQx4H/VsH9Yw+jc0f7qNK8voW/zfyIw/fYicP32OlTX/u3mQv5aGVWBZFKsbidK2ZZ993/nvEhFxy5+4a1ureOGsr9/3ofgLMO/bcNXzf/k9U89GokVVUT77tpSLrziGDEvftOXTckXIDSDiVccOTuW/za1xesyDbplmBxO1fMsu67a5tbuOj30/n9eYexc4/O9OjSkYuO+vSKro/rGrno99NZ2xxJyYTE+27i0wuh+ES+HVk+K1NTlXylIOcSFFXfnbt4Ncff+ix3Pv0Ocxevon5dM/Xrmpm7eBV3Pv0Ox9/6bBR1F1ol3nfTMNIFmIqdZ9TuJ6EPvrKAB19ZEF1EW9cCPBvHjZzLA1n3XbBt/Dc8OocbHp0TTVRbloq+m/hIN6gFsir9FaN64JGkg3AuJbzvtlFaku6TQCTrQWJQBzyVdBDOpYT33TZKRdINc0M3Yu9EaVYP3Jh0EWTn0sL7btulIukGk0lXPFtSAkxJOgjnUsb7bhuk5gcVDoybREo3Hej65iZtWX9fGg62cy5N3rvupBVrF73zTEvT2rSu6GkA7k1L301N0g0mAqn4wXzW+voVHT+4ZdThIjI06VicSwsR6Qs8tPj3E0e2NK5Oa43pZcAPkw6iVaqSbqamqh4YRcpGu9rSsvaTh29apE2NBwAvi8ivRCTNx007l1NixgKzgFO0eW1d3Yt/vkFVU9V3sVwyKuSWVEhV0gXI1FRNw+Ze0vLiNUhJyX1r3399IHAb9jO7CnhVRI5INjTn4iciA7BVC/cCPYGHgSF1L/11oohMIUV9F5icqal6LulANpW6pBuMB2YAWe3VjUBjiONyVV2tqpdiZ0K9BQwGporIbSLSbVsXca4QiEgHEbkceB04BvgEOAs4VVVbCyOkru8mHMdmRDWdc9+V1bXdgGlYckvio3wjMAcYlqmp+tQexDC1cDU2B10KvAdcoKqPxR6lczEQkX2A+4BDQ9P/BS5T1U8++7Vp7rtpkNaRLuGHNQx7t4r740oD8ApbedFUtVFVrwYOCV/3BeBREZksIjvEG6pzuSMinUTkp9jv+aHAAuAkVT1nSwkX0t130yC1SRc2vHjHYOsA43rxGsL9jv28F01VXwUOw56MrgVGA7NE5PQcx+hczonIIcB04GdAR+AuYG9Vrf287017301SaqcXPquyunYY8EeggtyccdSALVcbFR7mtYmIDMLWGQ8PTX8GvqeqkVdQdy6XRKQc+Dk2P1sCvAOMVdVn2nO9tPfduKV6pLup8MMciCW2RqLbdlgfrjcJGNjeF01V5wJHA+OA1cDpwGwRGS2Sg+P1nMsBETkGe1B2RWj6NbB/exMupL/vxi1vRrqbqqyurcA+yk8AegDltO0NpAV7weqwfeNTotytIiL/BtwNfDU0PY49aMtEdQ/noiQiPYEbgAtC0+vAear6cpT3SXvfjUNeJt1WldW1JcAI4ATgSGAI9qI0Y/U9BTsTSbFVBiXYYu5nsRJvT+WqAEYY3X4TuBXYASt/Vw3coaqJF91wrpWInIzN1/YFmoBfANeraiTH725JmvturuV10v2s8ELuDgzC5o7KsAdcDdi5SPPirhovIjsD/wmcGZr+ic2P5dtpGa7AiEhvbFBwVmh6ARijqrPijiWNfTdXCirpppmInAbcCfTBjq6+Bvi1qjYlGZcrPuFT2FnYDssdsY/rVwG3q+r6JGMrBp50YyQivbB5qDGh6TVs3uyVxIJyRUVE+gO/AapC05PY84b5yUVVXPJm9UIhUNUVqjoW+ArwLrA/8C8RuU5EcrGUxjkARKRERC4E3sQS7krszf84T7jx8pFuQkSkK/bA4jLsocFcbK53apJxucIjIgOx4jRHhaaHgHGqujCxoIqYj3QToqprVPVy4HDsqewg4FkRuUNEuicbnSsEIlIqIhOAmVjC/Rh7oPs1T7jJ8ZFuCohIGfYg4ypsecwHwIWq+vdEA3N5S0T2wwrUHBya/gurlrc0uagceNJNlS10lN8B472juO0V3sB/hK0J9zfwFPKkmzIiUorN8/4CK4u3BPge8P/UXyy3DSLyJexNe0hougOoVtV8OSK9KHjSTSkR2QPbU+4PP9w2hYeyvwQuxR7Kvo1tcvCHsinkD9JSSlXfAY4FLgJWAadhZSPHeAEd10pERmB1Ei7DttFehxWo8YSbUj7SzQMi0g/bG+8L2h2wxY02r2KjW99ok3I+0s0DqroAOBk4GzuXagTwuohcJiIdEg3OxU5ETsWWGY7BtpT/CDjUE25+8JFunklTkRIXLxHZBauXsGnxpDGq+lZyUbm28pFunlHVJap6NnAK8CHwJew4+B+LSKdko3O5IOZb2Oj2TKxM6CXAcE+4+cdHunlsK4Wnx6jqS8lF5aIUCuLfhdWdBS+In/d8pJvHVHWlql6IrXKYB+wLvCAiN4RzrlyeCgVqLsYK1JyAnQE2GhjpCTe/+Ui3QIQkew1wOREcJuiS44ecFjZPugVGRA7FdiXtE5ruAiaqal1yUbntEXYjXoG9eZYBi7ENMX9ONDAXKU+6BSg8UPshcDXQEVgAXKSqtYkG5rZKRIZib5YHhqYpwBWquiypmFxueNItYCKyD9aRDw1N9wOXqeqS5KJymxKRzsCPgYlAB+A97EHZY4kG5nLGH6QVMFV9A6vXezl2wN/Z2Fbib/hW4uSJyOHADKykZwl2gOk+nnALm490i4SIDADuwVY6ADwMfFdVP0wuquIkIt2Aa7HqcQK8hT30fC7RwFwsfKRbJFR1HnY22/lAHbateJaInO+j3viIyPHAG8D3sQI1vwIO8IRbPHykW4REZDfsOPhTQtP/YvOI7yQXVWETkR2Am7C1tmDTCuep6qtJxeSS4SPdIhSmFE4DvoEVST8GmCkiV3gBneiJyOnYFt7RwFpsZcmhnnCLk490i5yI7ATcApwTml7CRmBvJBdVYRCRXYHbgdND0zRs7nZOclG5pPlIt8ip6ieq+i3gJGw97yHAKyLyMy+g0z6hQM1obHR7OrAaGAcc5QnX+UjXbSAiPbCTB74bmt7ERr3/Si6q/CIilcDdwPGh6R/YwZDvJxaUSxUf6boNVLVOVS/GzmV7G9gbeF5EbvICOtsWCtR8H1uZcDywDPg2cKInXLcpH+m6LRKRLsDPgAnYm/N84HxVfSrJuNJIRPbECtQcEZr+BFyiqouTi8qllSddt00icjC2lXi/0DQJuFJVVyQWVEqISEfgSuCnQCdgEbbh5KEk43Lp5knXfa6QXCZiNQI6AQux5PI/ccZRWV1bAgwABgFdQizrsC3Oc4F5mZqqljhiEZEDsTejoaHpPuzNaHkc93f5y5Ou224iMgQb6X45NP0R+xj9cS7uF5LsCOwU5OHAXtgurmZs+6wAGv6UYtMgs4GpQC3wZNRJOEy7/AQb4XYA3sU2ljwR5X1c4fKk69okbJ4YB9QA5cBS4FLgfo3ol6myurYCOBebT+4OdMUS7PZS7ByxOmwX2ORMTVXWI1ARGYaNaAeFe9wKXK2qa7K9tisennRdu4jIF7ECOl8JTbXYlMMH7b1mZXVtOXA9MBYb0UaxYqIeGwFPAiZmaqrq23oBEemOvcmMC02zsLPoXoggPldkPOm6dguFckYDNwO9gFXAD4B7VLVNH+srq2uHAw8AFdh8bdQasHPGRmVqqqZt7zeJyAnYutv+2LRGDfArVV2bgxhdEfCk67ImIn2AO4B/D03PYttd3/68762sri3DtiGPJjfJ9rMasFMZxmdqqraaOEVkxxDXt0LTdGyjyMycR+gKmiddF4kw6j0dS747A43YUqqbVbV5S99TWV3bDXgMWwEQR8Jt1YBV+RqZqalavek/hP+PM7CaCa3/Hz8Bbtna/4dzbeFJ10UqjBBvAr4TmqZj85+vbfp1IeFOAwYDnWMN0jQCc4BhrYk3jNjvxCqwATyDbQj53BG7c9vLtwG7SKnqUlUdDXwVeB84CHhZRH4hImWwYUrhMZJLuIT7DgYe7Xfx5DIROQ9bbnYaNjd9EXCsJ1wXNU+6LidU9VHsGPjbsTW0VwMzROTL2FzpUJJLuK06q7YcuPbDt97BloL1xFZhDFHVu9v6MNC57eFJ1+WMqq5S1e9jGxvmAHuV9dv7OV3ffD7xzuFulUhJ5y4DD+tX1n+flcA3gZNVdUHScbnC5XO6LhYi0rmkc7ef9xlzx5Wl3XdMOpzNaEvLIikpGdCedbzOtYWPdF0sVLWx/2UPlHfoWpHK9a1SUtITqyXsXE75SNfFImztXUjy87jb0gj0jWLLsHNb4yNdF5dzsa29adbCxtN6ncsJH+m6nAvVwhYAfdp7jfFfGcjefXuyx87dqCjvRNdOHWhoWs+HKxp4ObOc373wHnMWr4oi3IVA/7hKRLriU5p0AK4ojMCqhbXbpSMGbdbWvUMJe+7akT137cGZB/dn3P2v8PjsrA9r6AEcC3ipRpcTnnRdHKqw8ozttmTVWl5+bxnvL6tnZX0T5WWlDB+4E/v36wVAp9ISfjBycBRJtxw4EU+6Lkc86bo4DKdt9XA3c8i1m+fAmx6fwxPjj2JA724A9N8hkrMzS4Ajo7iQc1viD9JcToX53CFRXlMEepV35OT9+rJbr417LN5aFMmcLsCQyurarN4knNsaH+m6XBsArI/iQv16dWHaxGO3+G/L1qzjmoffjOI2YKsYBgDvRHVB51r5SNfl2iCs+HfOvL14FWfd+wIzPlgR1SWbsbidi5wnXZdrXchyPrfVioYmfvXIbK7/x1v89rl3ySy1o8kG7tKdv447glP27xvFbcDiTUVtCFd4fHrB5VonIkq6q9c2c+/U+Rv+/qtHZvN/zj2UYXvsROeOHbjua/vy/LylLFmd9U5jAcqyvYhzW+IjXZdr67CTcyO3vkV5cpMlYuWdShnav1cUl1YglTUiXP7zpOtyrYEsk+6hlTvQs0vHzdpF4OjBvT/VptHkd8Xidi5yPr3gcm0uWf6enXlwP07evy8vzl/GmwtXUtfYTEV5J44Z3JuBu2zc6FbX2MSL85dlGy9YvHOjuJBzn+VJ1+XaPCL4RFVW2oEjB/XmyEG9t/jvqxqbuOQPM1i1NpKFEiVY3M5FzgveuJyrrK6dDhzY3u8/pLKCE/ftwwH9K+jTszO9ym2qoa6hiflL1jBt3if84V/v88nqdVGFPD1TU3VwVBdzblM+0nVxmAocQDtXMbyUWc5LmdhK3LYAz8Z1M1d8/EGai0MtsCbpILZTPfBI0kG4wuVJ18XhSexY83xQBzyVdBCucHnSdTkXCoLfiI0i06weuNELmLtc8qTr4jKZ9P++lQBTkg7CFba0dwJXIMJhj5NI76aDBuBeP5TS5ZonXReniUBak9oy4IdJB+EKnyddF5tMTVU9MIr0jXYbgFEhPudyypOui1WmpmoaNm+alsTbAEzO1FQ9l3Qgrjh40nVJGA/MABoTjqMxxHF5wnG4IuLbgF0iKqtruwHTgMFA5wRCaATmAMMyNVWrE7i/K1I+0nWJCIluGDbSjHuqoQF4BU+4LgGedF1iQsI7BlvDG1fibQj3O9YTrkuCTy+4VKisrh0G/BGoIDfnkzVgy9VGhYd5ziXCR7ouFUIiHIhtoGgkui3D9eF6k4CBnnBd0nyk61Knsrq2AhgNTAB6AOW0bYDQgiXbOqzmwxTfaebSwpOuS63K6toSYARwAnAkMARLqM1YbV7BzjNTrDZ0CTALq4f7CPCUF69xaeNJ1+WNkIR3BwZh875l2Km9DdiZZvMyNVX+C+1SzZOuc87FyB+kOedcjDzpOudcjDzpOudcjDzpOudcjDzpOudcjDzpOudcjDzpOudcjDzpOudcjDzpOudcjDzpOudcjDzpOudcjDzpOudcjDzpOudcjP4/hQKfvCjES0EAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# n is the number of vertices in the graph G, which is also the number of qubits\n",
    "n = 4\n",
    "G = nx.Graph()\n",
    "V = range(n)\n",
    "G.add_nodes_from(V)\n",
    "E = [(0, 1), (1, 2), (2, 3), (3, 0)]\n",
    "G.add_edges_from(E)\n",
    "\n",
    "# Print out the generated graph G\n",
    "pos = nx.circular_layout(G)\n",
    "options = {\n",
    "    \"with_labels\": True,\n",
    "    \"font_size\": 20,\n",
    "    \"font_weight\": \"bold\",\n",
    "    \"font_color\": \"white\",\n",
    "    \"node_size\": 2000,\n",
    "    \"width\": 2\n",
    "}\n",
    "nx.draw_networkx(G, pos, **options)\n",
    "ax = plt.gca()\n",
    "ax.margins(0.20)\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encoding Hamiltonian\n",
    "\n",
    "In Paddle Quantum, a Hamiltonian can be input in the form of `list`. Here we construct the Hamiltonian $H_D$ in equation (11)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:07:40.206426Z",
     "start_time": "2021-04-30T09:07:40.197339Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.0, 'z0,z1'], [-1.0, 'z1,z2'], [-1.0, 'z2,z3'], [-1.0, 'z3,z0']]\n"
     ]
    }
   ],
   "source": [
    "# Construct the Hamiltonian H_D in the form of list\n",
    "H_D_list = []\n",
    "for (u, v) in E:\n",
    "    H_D_list.append([-1.0,'z'+str(u) +',z' + str(v)])\n",
    "print(H_D_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, in this example, the Hamiltonian $H_D$ is\n",
    "\n",
    "$$\n",
    "H_D = -Z_0Z_1-Z_1Z_2-Z_2Z_3-Z_3Z_0.\n",
    "\\tag{12}\n",
    "$$\n",
    "\n",
    "We can view the matrix form of the Hamiltonian $H_D$ and get information of its eigenvalues:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:07:40.501135Z",
     "start_time": "2021-04-30T09:07:40.491760Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-4.  0.  0.  0.  0.  4.  0.  0.  0.  0.  4.  0.  0.  0.  0. -4.]\n",
      "H_max: 4.0\n"
     ]
    }
   ],
   "source": [
    "# Convert Hamiltonian H_D from list form to matrix form\n",
    "H_D_matrix = pauli_str_to_matrix(H_D_list, n)\n",
    "# Take out the elements on the diagonal of H_D\n",
    "H_D_diag = np.diag(H_D_matrix).real\n",
    "# Get the maximum eigenvalue of H_D\n",
    "H_max = np.max(H_D_diag)\n",
    "\n",
    "print(H_D_diag)\n",
    "print('H_max:', H_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building the QAOA circuit\n",
    "\n",
    "Earlier we introduced that QAOA needs to apply two unitary transformations $U_C(\\gamma)$ and $U_B(\\beta)$ alternately on the initial state $|s\\rangle = |+\\rangle^{\\otimes n}$. Here, we use the quantum gates and quantum circuit templates provided in Paddle Quantum to build a quantum circuit to achieve this step. It should be noted that in the Max-Cut Problem, we simplify the problem of maximizing the expected value of the Hamiltonian $H_C$ to the problem of maximizing the expected value of the Hamiltonian $H_D$, so the unitary transformations to be used are $U_D(\\gamma)$ and $U_B(\\beta)$. By alternately placing two circuit modules with adjustable parameters, we are able to build a QAOA circuit\n",
    "\n",
    "$$\n",
    "U_B(\\beta_p)U_D(\\gamma_p)\\cdots U_B(\\beta_1)U_D(\\gamma_1),\n",
    "\\tag{13}\n",
    "$$\n",
    "\n",
    "where $U_D(\\gamma) = e^{-i\\gamma H_D}$ can be constructed with the circuit in the figure below. Another unitary transformation $U_B(\\beta)$ is equivalent to applying a $R_x$ gate to each qubit.\n",
    "\n",
    "![U_D circuit](figures/maxcut-fig-cir_ud.png \"Figure 3: Quantum circuit of unitary transformation $e^{i\\gamma Z\\otimes Z}$\")\n",
    "<div style=\"text-align:center\">Figure 3: Quantum circuit of unitary transformation $e^{i\\gamma Z\\otimes Z}$</div>\n",
    "\n",
    "Therefore, the quantum circuit that realizes a layer of unitary transformation $U_B(\\beta)U_D(\\gamma)$ is shown in Figure 4.\n",
    "\n",
    "![U_BU_D circuit](figures/maxcut-fig-cir_ubud.png \"Figure 4: Quantum circuit of unitary transformation $U_B(\\beta)U_D(\\gamma)$\")\n",
    "<div style=\"text-align:center\">Figure 4: Quantum circuit of unitary transformation $U_B(\\beta)U_D(\\gamma)$  </div>\n",
    "\n",
    "In Paddle Quantum, the default initial state of each qubit is $|0\\rangle$ (the initial state can be customized by input parameters). We can add a layer of Hadamard gates to change the state of each qubit from $|0\\rangle$ to $|+\\rangle$ so that we get the initial state $|s\\rangle = |+\\rangle^{\\otimes n}$ required by QAOA. In Paddle Quantum, we can add a layer of Hadamard gates to the quantum circuit by calling `superposition_layer()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:07:41.987233Z",
     "start_time": "2021-04-30T09:07:41.977734Z"
    }
   },
   "outputs": [],
   "source": [
    "def circuit_QAOA(p, gamma, beta):\n",
    "    # Initialize the quantum circuit of n qubits\n",
    "    cir = UAnsatz(n)\n",
    "    # Prepare quantum state |s>\n",
    "    cir.superposition_layer()\n",
    "    # Build a circuit with p layers\n",
    "    for layer in range(p):\n",
    "        # Build the circuit of U_D\n",
    "        for (u, v) in E:\n",
    "            cir.cnot([u, v])\n",
    "            cir.rz(gamma[layer], v)\n",
    "            cir.cnot([u, v])\n",
    "\n",
    "        # Build the circuit of U_B, that is, add a layer of R_x gates\n",
    "        for v in V:\n",
    "            cir.rx(beta[layer], v)\n",
    "\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After running the constructed QAOA quantum circuit, we obtain the output state\n",
    "\n",
    "$$\n",
    "|\\vec{\\gamma},\\vec{\\beta}\\rangle = U_B(\\beta_p)U_D(\\gamma_p)\\cdots U_B(\\beta_1)U_D(\\gamma_1)|s\\rangle.\n",
    "\\tag{14}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating the loss function\n",
    "\n",
    "From the output state of the circuit built in the previous step, we can calculate the objective function of the maximum cut problem\n",
    "\n",
    "$$\n",
    "F_p(\\vec{\\gamma},\\vec{\\beta}) = \\langle\\vec{\\gamma},\\vec{\\beta}|H_D|\\vec{\\gamma},\\vec{\\beta}\\rangle.\n",
    "\\tag{15}\n",
    "$$\n",
    "\n",
    "To maximize the objective function is equivalent to minimizing $-F_p$. Therefore, we define $L(\\vec{\\gamma},\\vec{\\beta}) = -F_p(\\vec{\\gamma},\\vec{\\beta})$ as the loss function, that is, the function to be minimized. Then, we use a classical optimization algorithm to find the optimal parameters $\\vec{\\gamma},\\vec{\\beta}$. The following code shows a complete QAOA network built with Paddle Quantum and PaddlePaddle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:07:43.856891Z",
     "start_time": "2021-04-30T09:07:43.846753Z"
    }
   },
   "outputs": [],
   "source": [
    "class Net(paddle.nn.Layer):\n",
    "    def __init__(self, p, dtype=\"float64\",):\n",
    "        super(Net, self).__init__()\n",
    "\n",
    "        self.p = p\n",
    "        self.gamma = self.create_parameter(shape=[self.p], \n",
    "                                           default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI), \n",
    "                                           dtype=dtype, is_bias=False)\n",
    "        self.beta = self.create_parameter(shape=[self.p], \n",
    "                                          default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI), \n",
    "                                          dtype=dtype, is_bias=False)\n",
    "\n",
    "    def forward(self):\n",
    "        # Define QAOA's quantum circuit\n",
    "        cir = circuit_QAOA(self.p, self.gamma, self.beta)\n",
    "        # Run the quantum circuit\n",
    "        cir.run_state_vector()\n",
    "        # Calculate the loss function\n",
    "        loss = -cir.expecval(H_D_list)\n",
    "\n",
    "        return loss, cir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training quantum neural network\n",
    "\n",
    "After defining the quantum neural network for QAOA, we use the gradient descent method to update the parameters in the network to maximize the expected value in equation (15)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:07:44.907375Z",
     "start_time": "2021-04-30T09:07:44.901678Z"
    }
   },
   "outputs": [],
   "source": [
    "p = 4      # Number of layers in the quantum circuit\n",
    "ITR = 120  # Number of training iterations\n",
    "LR = 0.1   # Learning rate of the optimization method based on gradient descent\n",
    "SEED = 1024 # Set global RNG seed "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we optimize the network defined above in PaddlePaddle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:10:00.930860Z",
     "start_time": "2021-04-30T09:09:27.825635Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 10 loss: -3.8886\n",
      "iter: 20 loss: -3.9134\n",
      "iter: 30 loss: -3.9659\n",
      "iter: 40 loss: -3.9906\n",
      "iter: 50 loss: -3.9979\n",
      "iter: 60 loss: -3.9993\n",
      "iter: 70 loss: -3.9998\n",
      "iter: 80 loss: -3.9999\n",
      "iter: 90 loss: -4.0000\n",
      "iter: 100 loss: -4.0000\n",
      "iter: 110 loss: -4.0000\n",
      "iter: 120 loss: -4.0000\n",
      "\n",
      "The trained circuit:\n",
      "--H----*-----------------*--------------------------------------------------X----Rz(3.140)----X----Rx(0.824)----*-----------------*--------------------------------------------------X----Rz(0.737)----X----Rx(2.506)----*-----------------*--------------------------------------------------X----Rz(4.999)----X----Rx(4.854)----*-----------------*--------------------------------------------------X----Rz(0.465)----X----Rx(1.900)--\n",
      "       |                 |                                                  |                 |                 |                 |                                                  |                 |                 |                 |                                                  |                 |                 |                 |                                                  |                 |               \n",
      "--H----X----Rz(3.140)----X----*-----------------*---------------------------|-----------------|----Rx(0.824)----X----Rz(0.737)----X----*-----------------*---------------------------|-----------------|----Rx(2.506)----X----Rz(4.999)----X----*-----------------*---------------------------|-----------------|----Rx(4.854)----X----Rz(0.465)----X----*-----------------*---------------------------|-----------------|----Rx(1.900)--\n",
      "                              |                 |                           |                 |                                        |                 |                           |                 |                                        |                 |                           |                 |                                        |                 |                           |                 |               \n",
      "--H---------------------------X----Rz(3.140)----X----*-----------------*----|-----------------|----Rx(0.824)---------------------------X----Rz(0.737)----X----*-----------------*----|-----------------|----Rx(2.506)---------------------------X----Rz(4.999)----X----*-----------------*----|-----------------|----Rx(4.854)---------------------------X----Rz(0.465)----X----*-----------------*----|-----------------|----Rx(1.900)--\n",
      "                                                     |                 |    |                 |                                                               |                 |    |                 |                                                               |                 |    |                 |                                                               |                 |    |                 |               \n",
      "--H--------------------------------------------------X----Rz(3.140)----X----*-----------------*----Rx(0.824)--------------------------------------------------X----Rz(0.737)----X----*-----------------*----Rx(2.506)--------------------------------------------------X----Rz(4.999)----X----*-----------------*----Rx(4.854)--------------------------------------------------X----Rz(0.465)----X----*-----------------*----Rx(1.900)--\n",
      "                                                                                                                                                                                                                                                                                                                                                                                                                                         \n",
      "Optimized parameters gamma:\n",
      " [3.14046713 0.73681226 4.99897226 0.46481489]\n",
      "Optimized parameters beta:\n",
      " [0.82379898 2.50618308 4.85422542 1.90024859]\n"
     ]
    }
   ],
   "source": [
    "paddle.seed(SEED)\n",
    "\n",
    "net = Net(p)\n",
    "# Use Adam optimizer\n",
    "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n",
    "# Gradient descent iteration\n",
    "for itr in range(1, ITR + 1):\n",
    "    # Run the network defined above\n",
    "    loss, cir = net()\n",
    "    # Calculate the gradient and optimize\n",
    "    loss.backward()\n",
    "    opt.minimize(loss)\n",
    "    opt.clear_grad()\n",
    "    if itr% 10 == 0:\n",
    "        print(\"iter:\", itr, \"loss:\", \"%.4f\"% loss.numpy())\n",
    "    if itr == ITR:\n",
    "        print(\"\\nThe trained circuit:\") \n",
    "        print(cir)\n",
    "\n",
    "gamma_opt = net.gamma.numpy()\n",
    "print(\"Optimized parameters gamma:\\n\", gamma_opt)\n",
    "beta_opt = net.beta.numpy()\n",
    "print(\"Optimized parameters beta:\\n\", beta_opt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decoding the quantum solution\n",
    "\n",
    "After obtaining the minimum value of the loss function and the corresponding set of parameters $\\vec{\\gamma}^*,\\vec{\\beta}^*$, our task has not been completed. In order to obtain an approximate solution to the Max-Cut Problem, it is necessary to decode the solution to the classical optimization problem from the quantum state $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ output by QAOA. Physically, to decode a quantum state, we need to measure it and then calculate the probability distribution of the measurement results:\n",
    "\n",
    "$$\n",
    "p(z)=|\\langle z|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle|^2.\n",
    "\\tag{16}\n",
    "$$\n",
    "\n",
    "Usually, the greater the probability of a certain bit string, the greater the probability that it corresponds to an optimal solution of the Max-Cut problem.\n",
    "\n",
    "Paddle Quantum provides a function to view the probability distribution of the measurement results of the state output by the QAOA quantum circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:10:21.794006Z",
     "start_time": "2021-04-30T09:10:21.392963Z"
    }
   },
   "outputs": [
    {
     "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": [
    "# Repeat the simulated measurement of the circuit output state 1024 times\n",
    "prob_measure = cir.measure(plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After measurement, we can find the bit string with the highest probability of occurrence. Let the vertices whose bit values are $0$ in the bit string belong to the set $S_0$ and the vertices whose bit values are $1$ belong to the set $S_1$. The set of edges between these two vertex sets is a possible maximum cut of the graph.\n",
    "\n",
    "The following code selects the bit string with the greatest chance of appearing in the measurement result, then maps it back to the classic solution, and draws the corresponding maximum cut:\n",
    "- The red vertex belongs to the set $S_0$,\n",
    "- The blue vertex belongs to the set $S_1$,\n",
    "- The dashed line indicates the edge being cut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:10:36.652097Z",
     "start_time": "2021-04-30T09:10:36.465888Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The bit string form of the cut found: 1010\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Find the most frequent bit string in the measurement results\n",
    "cut_bitstring = max(prob_measure, key=prob_measure.get)\n",
    "print(\"The bit string form of the cut found:\", cut_bitstring)\n",
    "\n",
    "# Draw the cut corresponding to the bit string obtained above on the graph\n",
    "node_cut = [\"blue\" if cut_bitstring[v] == \"1\" else \"red\" for v in V]\n",
    "\n",
    "edge_cut = [\n",
    "    \"solid\" if cut_bitstring[u] == cut_bitstring[v] else \"dashed\"\n",
    "    for (u, v) in E\n",
    "    ]\n",
    "nx.draw(\n",
    "        G,\n",
    "        pos,\n",
    "        node_color=node_cut,\n",
    "        style=edge_cut,\n",
    "        **options\n",
    ")\n",
    "ax = plt.gca()\n",
    "ax.margins(0.20)\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, in this example, QAOA has found a maximum cut on the graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_______\n",
    "\n",
    "## References\n",
    "\n",
    "[1] Farhi, E., Goldstone, J. & Gutmann, S. A Quantum Approximate Optimization Algorithm. [arXiv:1411.4028 (2014).](https://arxiv.org/abs/1411.4028)"
   ]
  }
 ],
 "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.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "426.667px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}