qaoa-for-max-cut/01_Max-Cut-with-QAOA.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "eead95ce",
      "metadata": {
        "id": "eead95ce"
      },
      "outputs": [],
      "source": [
        "# SPDX-License-Identifier: Apache-2.0 AND CC-BY-NC-4.0\n",
        "#\n",
        "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# http://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "135f6e3e-e55f-4b5c-80cb-f8979bba94e0",
      "metadata": {
        "id": "135f6e3e-e55f-4b5c-80cb-f8979bba94e0"
      },
      "source": [
        "# Divide-and-Conquer Implementation of QAOA\n",
        "## Lab 1 - Overview: Max cut with QAOA on a small graph\n",
        "\n",
        "This lab introduces the CUDA Quantum (CUDA-Q) platform through an example of a max cut problem solved with the QAOA (Quantum Approximate Optimization Algorithm). By the end of this lab, you will have reviewed the QAOA approach to a max cut problem, written quantum kernels with CUDA-Q, and simulated the QAOA for a max cut problem. Additionally, in preparation for Lab 2, you will have previewed the divide-and-conquer implementation of QAOA.  \n",
        "\n",
        "We assume the reader has some familiarity already with quantum computation and is comfortable with the concepts of qubits, quantum circuits, measurement, Hamiltonians, expectation values, and circuit sampling. Comprehensive references include Nielsen and Chuang's [Quantum Computation and Quantum Information](https://michaelnielsen.org/qcqi/QINFO-book-nielsen-and-chuang-toc-and-chapter1-nov00.pdf), Aaronson's [Intro to Quantum Information Science lecture notes](https://scottaaronson.blog/?p=3943), and [Lecture notes from a Quantum Computing course](https://arxiv.org/pdf/2311.08445) taught at Chalmers University of Technology. Good video series are Nielsen's [Quantum Computing for the Determined](https://www.youtube.com/playlist?list=PL1826E60FD05B44E4) and Ekert's [Introduction to Quantum Information Science](https://youtu.be/feixH-rXPVs?feature=shared) which accompanies the work-in-progress [Introduction to Quantum Information Science ebook](https://qubit.guide).\n",
        "\n",
        "The list below outlines what you'll be doing in each section of this lab:\n",
        "* **1.1** Define the Max Cut problem\n",
        "* **1.2** Experiment with a few NetworkX commands to visualize graphs\n",
        "* **1.3** Identify a max cut solution of the `sampleGraph` through a classical brute-force computation\n",
        "* **1.4** Review QAOA for Max Cut\n",
        "* **1.5** Implement QAOA using CUDA-Q\n",
        "* **1.6** Preview how to scale QAOA for larger graphs using divide-and-conquer QAOA\n",
        "\n",
        "Learning Objectives:\n",
        "* Apply CUDA-Q primitives such as `observe`, `sample`, and `vqe` to kernels\n",
        "* Construct CUDA-Q kernels with and without parameters using function decoration\n",
        "* Visualize the divide, conquer, and merge stage of the divide-and-conquer QAOA as it is applied to a small graph\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4bb3111e",
      "metadata": {
        "id": "4bb3111e"
      },
      "outputs": [],
      "source": [
        "# Instructions for Google Colab. You can ignore this cell if you have cuda-q set up.\n",
        "# Run this notebook in a CPU runtime\n",
        "# Uncomment the line below and execute the cell to install cuda-q\n",
        "# !pip install cuda-quantum==0.7.1\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b5046650",
      "metadata": {
        "id": "b5046650"
      },
      "source": [
        "Execute the cell below to load all the necessary packages for this lab."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "644b9c82",
      "metadata": {
        "id": "644b9c82"
      },
      "outputs": [],
      "source": [
        "# Necessary packages\n",
        "\n",
        "import networkx as nx\n",
        "from networkx import algorithms\n",
        "from networkx.algorithms import community\n",
        "import cudaq\n",
        "from cudaq import spin\n",
        "from cudaq.qis import *\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from typing import List"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c2fa8e57-2f20-4d1b-a8c1-a8291da83fdc",
      "metadata": {
        "id": "c2fa8e57-2f20-4d1b-a8c1-a8291da83fdc"
      },
      "source": [
        "## 1.1 Max Cut\n",
        "\n",
        "If you prefer a video introduction to the material, please execute the cell below to view the video. Otherwise, feel free to skip to the next markdown block to read through the introduction to the max cut problem."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3d3e3118-aaba-4c36-9bfb-21115d1050cb",
      "metadata": {
        "id": "3d3e3118-aaba-4c36-9bfb-21115d1050cb",
        "outputId": "b1069913-df21-471b-f3cb-0eac0af0fa6a"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "<video controls width=\"640\" height=\"360\">\n",
              "    <source src=\"https://d36m44n9vdbmda.cloudfront.net/assets/x-ac-13-v1/max-cut-with-CUDA-Quantum-Lab-1-Part-1.mp4\" type=\"video/mp4\">\n",
              "    Your browser does not support the video tag.\n",
              "</video>\n"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from IPython.display import HTML\n",
        "\n",
        "video_url = \"https://d36m44n9vdbmda.cloudfront.net/assets/x-ac-13-v1/max-cut-with-CUDA-Quantum-Lab-1-Part-1.mp4\"\n",
        "\n",
        "video_html = f\"\"\"\n",
        "<video controls width=\"640\" height=\"360\">\n",
        "    <source src=\"{video_url}\" type=\"video/mp4\">\n",
        "    Your browser does not support the video tag.\n",
        "</video>\n",
        "\"\"\"\n",
        "\n",
        "display(HTML(video_html))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "65e19333",
      "metadata": {
        "id": "65e19333"
      },
      "source": [
        "[Max Cut](https://en.wikipedia.org/wiki/Maximum_cut) is the problem of finding a partition of a graph's nodes into two sets which maximizes the edges between the two sets. There is also a weighted version of this problem which we will explore in [Lab 4](4_Assessment.ipynb). Although this problem is relatively easy to solve for graphs with few vertices, this problem is [NP-hard](https://en.wikipedia.org/wiki/NP-hardness#:~:text=7%20References-,Definition,complete%20problem%20G%20to%20H.). The max cut problem has a wide range of applications including [machine learning](https://jmlr.org/papers/volume14/wang13a/wang13a.pdf), [circuit design](https://math.mit.edu/research/highschool/primes/materials/2020/Hong-Lee-Wei.pdf) and [statistical physics](https://www.researchgate.net/publication/262162554_An_Application_of_Combinatorial_Optimization_to_Statistical_Physics_and_Circuit_Layout_Design), among others. Furthermore, the QAOA algorithm presented in this tutorial can be adapted to other related optimization problems with an even wider application field including [portfolio optimization](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043204) and [job shop scheduling](https://www.sciencedirect.com/science/article/pii/S0377221723002072), just to name a few.\n",
        "\n",
        "**Notation:** We take the convention that $G=(V,E)$ represents a graph with vertex set $V\\subseteq \\mathbb{N}$ and edge set $E\\subseteq V\\times V$. We use the terms vertex and node interchangeably.  For this tutorial we assume that the graphs are undirected (that is, $(u,v)$ and $(v,u)$ represent the same edge). Our graphs contain no self loops (i.e., for every vertex $v$, there is no edge $(v,v)$). A *cut* of the graph $G$ is a partition, $(V_0,V_1)$, of the vertex set such that every vertex of $V$ is a member of exactly one of $V_0$ or $V_1$ (i.e., $V_0\\bigcup V_1 = V$ and $V_0\\bigcap V_0=\\emptyset$). The *cut value* for a partition is the sum of the edges with one node in $V_0$ and one node in $V_1$.\n",
        "\n",
        "In the images below, we illustrate two cuts of a graph with the dotted lines. Each of these cuts partitions the graph into two disjoint sets. The cut on the left is not optimal, and the cut on the right is the max cut. The cut on the left divides the graph into disjoint sets $\\{1,2\\}$ and $\\{0,3,4\\}$, and that cut contains 3 edges. To more easily visualize the cut, we have colored the vertices in one set of the partition green and the vertices in the other set of the partition gray.\n",
        "The cut depicted in the diagram on the right divides the graph vertices into two disjoint sets $V_0=\\{0,2\\}$, colored gray, and $V_1=\\{1,3,4\\}$, colored green. The number of edges connecting vertices in the distinct sets is computed by $$\\sum_{\\substack{u \\in V_0; v\\in V_1\\\\ (u,v) \\in E}}1.$$ For the graph on the right, the number of edges in the cut (in this case there are $5$ edges) is maximal, and this value is referred to as the *max cut value*. The partitioning $(V_0,V_1)$  &mdash; and sometimes the set of edges connecting vertices in $V_0$ and $V_1$  &mdash; is referred to as a *max cut of a graph*. Note that the max cut of a graph need not be unique; that is, two distinct partitions may produce the same cut value.\n",
        "\n",
        "![](https://github.com/NVIDIA/cuda-q-academic/blob/main/qaoa-for-max-cut/images/max-cut-illustration.png?raw=true)\n",
        "\n",
        "Just as it was helpful for visualizing the partitions above, it will be helpful in this tutorial to view a solution of the max cut problem as a $2$-coloring (or a labeling) of the vertices of the graph where all nodes in $V_0$ are colored gray (or $0$) and all nodes in $V_1$ are colored green (or $1$).  Note that we make no requirements other than all nodes receive a color. In particular we do not require that adjacent vertices have distinct colors.  The coloring solely codes the partitioning of the set of vertices.\n",
        "\n",
        "As we encode the max cut problem with CUDA-Q, we will eventually use bitstrings to represent the colors of the vertices in a cut. For example using the ordering of the vertices, the bitstring `01100` captures the partition in the image above on the left with vertices $1$ and $2$ in $V_1$, and the bitstring `01011` codes the partition in the image on the right with vertices $1$, $3$, and $4$ in $V_1$.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8e92e9ec",
      "metadata": {
        "id": "8e92e9ec"
      },
      "source": [
        "## 1.2 Defining a graph\n",
        "For the remainder of this lab, we will work with the graph coded in the cell below and will refer to it as `sampleGraph`. We will be using the [NetworkX library](https://networkx.org/documentation/stable/tutorial.html) for the graphs in this tutorial. Please read through the cell below to familiarize yourself with some of the commands in the NetworkX library used in this tutorial."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f739b12d",
      "metadata": {
        "id": "f739b12d",
        "outputId": "8c027d57-3145-40aa-8d8a-a9913b869195"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The graph has 7 nodes and 8 edges.\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Define a small graph that will be used throughout the Lab 1\n",
        "# We'll refer to this graph as sampleGraph throughout the lab.\n",
        "edgeList = [(0,1),(1,2),(2,0),(0,4),(4,5),(5,3),(4,3), (3,6)]\n",
        "sampleGraph =nx.from_edgelist(edgeList)\n",
        "\n",
        "# We will be adding several attributes to our graph such as colors for the nodes\n",
        "# and later in Lab 4, weights for the edges.\n",
        "# This call sets the color of all nodes of the sampleGraph to 0:\n",
        "nx.set_node_attributes(sampleGraph, values = 0, name = 'color')\n",
        "\n",
        "# We can set or change node colors individually. For instance, let's change the\n",
        "# color of the node 4 from 0 to 1:\n",
        "sampleGraph.nodes[4]['color'] = 1\n",
        "\n",
        "# These commands are helpful to list the nodes and edges of a graph and to compute the total\n",
        "# number of vertices and edges of a graph. We separate out the edges of the graph into two\n",
        "# lists (source and target) so that we can pass edges to the cudaq.kernels\n",
        "node_List : List[int] = list(sampleGraph.nodes())\n",
        "edges_in_graph = list(sampleGraph.edges()) #a list of ordered pairs of vertices representing the edges\n",
        "print('The graph has',sampleGraph.number_of_nodes(),'nodes and', sampleGraph.number_of_edges(), 'edges.')\n",
        "\n",
        "# Next for small graphs, it is sometimes helpful to visualize them and to color code the nodes.\n",
        "# Set color codes for green and grey and assign gray to the nodes with color attribute 0\n",
        "# and green to nodes with color attribute 1.\n",
        "gray ='#8C8C8C'\n",
        "green ='#76B900'\n",
        "color_map = [gray if sampleGraph.nodes[u]['color']==0 else green for u in sampleGraph]\n",
        "\n",
        "# Finally, we can plot the graph.\n",
        "# Set the position of the nodes so that the graphs is easily recognizable each time it's plotted.\n",
        "pos = nx.spring_layout(sampleGraph, seed=311)\n",
        "# Plot the graph with nodes labeled with their name and colored gray for 0 and green for 1.\n",
        "nx.draw(sampleGraph, with_labels=True, pos = pos, node_color=color_map)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ea05f889",
      "metadata": {
        "id": "ea05f889"
      },
      "source": [
        "Notice that the coloring above induces a cut with edges $(3,4)$, $(4,5)$, and $(0,4)$. This is not a maximal cut of this graph. The aim of this lab is to use QAOA to find a maximal cut."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "423c77c7",
      "metadata": {
        "id": "423c77c7"
      },
      "outputs": [],
      "source": [
        "# Since the coloring of the graph above was for demonstration purposes, we'll reset all the node\n",
        "# colors to be 0 as a default. The only node color that needs to be reset is node 4.\n",
        "sampleGraph.nodes[4]['color'] = 0"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "25644ee9",
      "metadata": {
        "id": "25644ee9"
      },
      "source": [
        "## 1.3 Classical solutions to Max Cut\n",
        "\n",
        "For our small graph with seven vertices, there are only $2^7 = 128$ different choices of the partition sets $V_0$ and $V_1$. In fact, there are only $\\frac{2^7}{2} = 64$ distinct partitions since the partition $V_0=W$, $V_1=V\\backslash W$ is equivalent to the partition $V_0 = V\\backslash W$, $V_1= W$ for any subset $W$ of $V$. Our graph is small enough that we can, by brute force, check every single partition to find the max cut.\n",
        "\n",
        "Exercise:  Complete the code block below to find the max cut solution to the `sampleGraph` via brute-force computation. We won't worry about double checking the cut values of partitions $(W, V\\backslash W)$ and $(V\\backslash W, W)$. For this exercise, compute the cut values for each partition of vertices by replacing `FIX_ME` with selections of the following:\n",
        "* `sampleGraph.nodes()`\n",
        "* `sampleGraph.edges()`\n",
        "* `subset_cut_value > max_cut_value`\n",
        "* `u not in V0`\n",
        "\n",
        "If you get stuck, you can click on the triple dots below to view the solution."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e13bdb6e",
      "metadata": {
        "id": "e13bdb6e"
      },
      "outputs": [],
      "source": [
        "# Create a list of all the subsets of vertices of sampleGraph\n",
        "subsets = [[]]\n",
        "for u in FIX_ME: # Iterate through the vertices of the sampleGraph\n",
        "    for i in range(len(subsets)):\n",
        "        subsets += [subsets[i]+[u]]\n",
        "\n",
        "\n",
        "# Cycle through the subsets and compute the cut value for each partition\n",
        "# While doing these computations, identify the max cut of the sampleGraph by\n",
        "# storing the best cut value and cut edges found so far and the corresponding subset\n",
        "max_cut_value = 0\n",
        "max_cut_edges = []\n",
        "for subset in subsets:\n",
        "    subset_cut_value = 0\n",
        "    subset_cut_edges = []\n",
        "    for u,v in FIX_ME: # the max cut depends only on pairs of vertices that are connected by an edge\n",
        "        if ((u in subset) and (v not in subset)) or ((v in subset) and (u not in subset)):\n",
        "            subset_cut_value+=1\n",
        "            subset_cut_edges.append((u,v))\n",
        "    if FIX_ME:\n",
        "        max_cut_value = subset_cut_value\n",
        "        max_cut_edges = subset_cut_edges\n",
        "        V0 = subset # set corresponding to the best cut found so far\n",
        "\n",
        "\n",
        "# Find the complement of V0\n",
        "V1 = []\n",
        "for FIX_ME:\n",
        "    if FIX_ME:\n",
        "        V1.append(u)\n",
        "\n",
        "print('The',max_cut_value,'edges that make up a max cut of sampleGraph are',max_cut_edges)\n",
        "print('The lists',V0,'and',V1,'partition the sampleGraph into a the max cut.' )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e117de89",
      "metadata": {
        "id": "e117de89",
        "jupyter": {
          "source_hidden": true
        },
        "outputId": "1e66faf6-0529-4353-d0d0-94238b7011d0",
        "scrolled": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The 6 edges that make up a max cut of sampleGraph are [(0, 1), (0, 2), (0, 4), (4, 3), (5, 3), (3, 6)]\n",
            "The lists [0, 3] and [1, 2, 4, 5, 6] partition the sampleGraph into a the max cut.\n"
          ]
        }
      ],
      "source": [
        "# Solution\n",
        "\n",
        "# Create a list of all the subsets of vertices of sampleGraph\n",
        "subsets = [[]]\n",
        "for u in sampleGraph.nodes():\n",
        "    for i in range(len(subsets)):\n",
        "        subsets += [subsets[i]+[u]]\n",
        "\n",
        "\n",
        "# Cycle through the subsets to identify the max cut of the sampleGraph\n",
        "\n",
        "max_cut_value = 0\n",
        "max_cut_edges = []\n",
        "for subset in subsets:\n",
        "    subset_cut_value = 0\n",
        "    subset_cut_edges = []\n",
        "    for u,v in sampleGraph.edges():\n",
        "        if ((u in subset) and (v not in subset)) or ((v in subset) and (u not in subset)):\n",
        "            subset_cut_value+=1\n",
        "            subset_cut_edges.append((u,v))\n",
        "    if subset_cut_value > max_cut_value:\n",
        "        max_cut_value = subset_cut_value\n",
        "        max_cut_edges = subset_cut_edges\n",
        "        V0 = subset\n",
        "\n",
        "\n",
        "# Find the complement of V0\n",
        "V1 = []\n",
        "for u in sampleGraph.nodes():\n",
        "    if u not in V0:\n",
        "        V1.append(u)\n",
        "\n",
        "print('The',max_cut_value,'edges that make up a max cut of sampleGraph are',max_cut_edges)\n",
        "print('The lists',V0,'and',V1,'partition the sampleGraph into a the max cut.' )"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "faa2b478",
      "metadata": {
        "id": "faa2b478"
      },
      "source": [
        "## 1.4 Quantum Approximation Optimization Algorithm (QAOA) for Max Cut"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d9b1a528-afe1-4c1b-86ae-9f5438ae642e",
      "metadata": {
        "id": "d9b1a528-afe1-4c1b-86ae-9f5438ae642e",
        "jupyter": {
          "source_hidden": true
        },
        "outputId": "fedb6018-4bc4-4a6a-a212-e1e88ffbd45e"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "<video controls width=\"640\" height=\"360\">\n",
              "    <source src=\"https://d36m44n9vdbmda.cloudfront.net/assets/x-ac-13-v1/max-cut-with-CUDA-Quantum-Lab-1-Part-2.mp4\" type=\"video/mp4\">\n",
              "    Your browser does not support the video tag.\n",
              "</video>\n"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Execute this cell to view a video presentation of section 1.4.1\n",
        "\n",
        "from IPython.display import HTML\n",
        "\n",
        "video_url = \"https://d36m44n9vdbmda.cloudfront.net/assets/x-ac-13-v1/max-cut-with-CUDA-Quantum-Lab-1-Part-2.mp4\"\n",
        "\n",
        "video_html = f\"\"\"\n",
        "<video controls width=\"640\" height=\"360\">\n",
        "    <source src=\"{video_url}\" type=\"video/mp4\">\n",
        "    Your browser does not support the video tag.\n",
        "</video>\n",
        "\"\"\"\n",
        "\n",
        "display(HTML(video_html))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9852e6f8",
      "metadata": {
        "id": "9852e6f8"
      },
      "source": [
        "### 1.4.1 Quadratic Unconstrained Binary Optimization (QUBO) Formualtion of Max Cut\n",
        "Since there are $2^{|V|}$ many distinct $2$-colorings of the graph, and $2^{|V|-1}$ distinct cuts of the graph, the brute-force approach to check every coloring of the graph is not scalable to large graphs.  There are several classical algorithms that perform better than the brute-force approach on certain subclasses of graphs, and there are heuristic algorithms that give good approximations to the max cut rather quickly. For a review of many of the classical approaches to max cut, check out [this paper](https://dl.acm.org/doi/full/10.1145/3609426?casa_token=ZrJI6LlgDHAAAAAA%3AhuO3qe07eG0kXdWEvKY4Xv7kIDpWXpe5SAr-zB9KVzOe3nHnTSE-zqqwbbhN_syDdfrASv8xGmv29sk) and [this one](https://optimization-online.org/wp-content/uploads/2015/05/4895.pdf). In this tutorial, we will be exploring a quantum heuristic algorithm for identifying good (but perhaps not maximal) cuts of graphs.  More specifically, we begin with QAOA (Quantum Approximate Optimization Algorithm) and then explore a [divide-and-conquer implementation of QAOA](https://arxiv.org/abs/2205.11762), which is one of [many adaptations of QAOA](https://arxiv.org/pdf/2306.09198.pdf).\n",
        "\n",
        "In order to employ quantum algorithms, it is helpful to reframe the max cut problem as a quadratic unconstrained binary optimization (QUBO) problem.  Suppose that we have a graph $G=(V,E)$.  We can code a partition $(V_0, V_1)$ of $V$ by defining for each $v\\in V$, a variable $x_v$ so that $x_v = 0$ if vertex $v\\in V_0$ and $x_v =1 $ if $v\\in V_1$. (Another way of thinking about this is that $x_v$ represents the coloring of a vertex $v$ as 0 or 1 depending on whether $v$ is a member of $V_0$ or $V_1$.)  The max cut problem then can be restated as finding an assignment to the variables $\\bar{x} = [x_v\\mid v\\in V]$ so that the function $$C(\\bar{x}) = \\sum_{(u,v)\\in E}(x_u+x_v-2x_u x_v)$$ is maximized.  \n",
        "\n",
        "Let's walk through the formula above to observe that $C(\\bar{x})$ computes the cut value of the graph for the partition coded by $\\bar{x}$. For example, notice that if $(u,v)$ were an edge and we assigned $0$ to $x_u $ and $1$ to $x_v$, this edge would be in the cut given by the partition. Furthermore, the value of the term ($x_u+x_v-2x_ux_v$) associated with this edge in the equation $C(\\bar{x})$ would be $0+1-2*0*1 = 1$.  Take a minute to consider what happens to the term associated with $(u,v)$ in the equation for $C(\\bar{x})$ if $x_u$ and $x_v$ were both assigned 1 (and therefore, the edge between them would not be in the cut). Is the result what you expected?\n",
        "\n",
        "QUBO problems have a natural translation to Ising Hamilitonian problems (see for instance [this article](https://arxiv.org/pdf/1811.11538.pdf)). This translation is carried out by mapping the binary $(0,1)$-variables $x_v$ to variables $z_v$ that take on the values $-1$ and $1$. Take a moment to verify that by assigning $-1$ and $1$ to identify a cut of a graph, the equation below computes the cut value for that cut: $$C(\\bar z) = \\frac{1}{2} \\sum_{(u,v)\\in E} (1-z_uz_v).$$ Take for instance an edge $(u,v)$ with the assignments $z_u=z_v=1$. This edge would not be in the cut determined by these variable assignments.  The term in the equation above associated with this edge would be $\\frac{1}{2}(1-z_uz_v) = \\frac{1}{2}(1-1*1) = 0$ and would not contribute to the cut edge count.  Verify that the assignment $z_u=1$ and $z_v=-1$ and the assignment $z_u=z_v=-1$ both produce the result you would expect for $C(\\bar z)$ to compute the cut value.\n",
        "\n",
        "Notice that if we multiply $C(\\bar z)$ by -1, we can reframe the optimization problem from maximization to minimization.  Furthermore, we can promote this equation to a matrix equation by replacing $z_uz_v-1$ with the Pauli-Z operator acting on qubits associated with nodes $u$ and $v$, respectively, and replacing 1 with the identity matrix. This leads to the reformulation of the problem from one of maximizing $C(\\bar{z})$ to one of minimizing the eigenvalues of $$H= \\frac{1}{2}\\sum_{(u,v)\\in E} (Z_uZ_v-II).$$  \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0b7005fc-276e-468d-89aa-8227bd397219",
      "metadata": {
        "id": "0b7005fc-276e-468d-89aa-8227bd397219"
      },
      "source": [
        "### 1.4.2 QAOA\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8aaa40a2-bc65-4ef5-9cc1-8d65fe6bc581",
      "metadata": {
        "id": "8aaa40a2-bc65-4ef5-9cc1-8d65fe6bc581",
        "jupyter": {
          "source_hidden": true
        },
        "outputId": "28ee10cf-1f47-49a6-f744-c1ab521c074e"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "<video controls width=\"640\" height=\"360\">\n",
              "    <source src=\"https://d36m44n9vdbmda.cloudfront.net/assets/x-ac-13-v1/max-cut-with-CUDA-Quantum-Lab-1-Part-3.mp4\" type=\"video/mp4\">\n",
              "    Your browser does not support the video tag.\n",
              "</video>\n"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Execute this cell to watch an overview of QAOA.\n",
        "from IPython.display import HTML\n",
        "\n",
        "video_url = \"https://d36m44n9vdbmda.cloudfront.net/assets/x-ac-13-v1/max-cut-with-CUDA-Quantum-Lab-1-Part-3.mp4\"\n",
        "\n",
        "video_html = f\"\"\"\n",
        "<video controls width=\"640\" height=\"360\">\n",
        "    <source src=\"{video_url}\" type=\"video/mp4\">\n",
        "    Your browser does not support the video tag.\n",
        "</video>\n",
        "\"\"\"\n",
        "\n",
        "display(HTML(video_html))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d7ef5367",
      "metadata": {
        "id": "d7ef5367"
      },
      "source": [
        "[Farhi et al.](https://arxiv.org/abs/1411.4028) introduced the quantum approximation optimization algorithm (QAOA) to solve optimization problems like the one that we formulated in the previous section. In short, QAOA is a variational algortihm. QAOA is made up of a variational quantum circuit (i.e., a kernel that depends on a set of parameter values) and a classical optimizer. The aim of QAOA is to use the classical optimizer to identify parameter values that generate a quantum circuit whose expectation value for a given cost Hamilitonian is minimized. In our case, the cost Hamiltonian will be $H$ as defined in the previous section. The diagram below depicts the subroutines in QAOA.\n",
        "\n",
        "![](https://github.com/NVIDIA/cuda-q-academic/blob/main/qaoa-for-max-cut/images/QAOA-flowchart.png?raw=true)\n",
        "\n",
        "The two green process blocks in the image above represent the quantum subroutines that we'll execute with CUDA-Q primitives. The green process block on the left will use the `observe` primitive to estimate the expectation value (this primitive is subsumed in a `vqe` call) and the green process on the right will use the `sample` primitive to identify the most probable outcome of the circuit. We'll describe how to program this entire flowchart using CUDA-Q in the following sections.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "349090cb",
      "metadata": {
        "id": "349090cb"
      },
      "source": [
        "## 1.5 CUDA-Q Implementation of QAOA for Max Cut\n",
        "\n",
        "This section starts with a brief review of CUDA-Q syntax. From there, we can define a function to carry out QAOA by creating several helper functions for the problem Hamiltonian, QAOA kernel, etc. If you'd like to treat the QAOA algorithm as a black box, you can jump to section 1.5.6 where we pull everything together and demonstrate how to simulate the kernel on a GPU. However, understanding the code below is necessary for the remainder of the labs."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "433a29f4",
      "metadata": {
        "id": "433a29f4"
      },
      "source": [
        "### 1.5.1 CUDA-Q Basics\n",
        "\n",
        "Before implementing QAOA in CUDA-Q, let's run through [two quick examples](https://nvidia.github.io/cuda-quantum/latest/using/basics/build_kernel.html) highlighting most of the syntax that we will need.  The first thing to note is that we will sometimes refer to quantum circuits as kernels.  While every quantum circuit is a kernel, kernels need not be quantum circuits. CUDA-Q kernels allow for the creation of generic quantum programs that can be compiled and executed on various devices. They provide better interplatform compatability and control flow. We will see some more general quantum kernels towards the end of this lab, but for now you can think of a kernel as a quantum circuit.\n",
        "\n",
        "There are two main primitives common in most quantum algorithms: sampling a circuit to approximate the probability distribution of the state and computing expectation values given a circuit and Hamiltonian. As an introduction to CUDA-Q, we provide two short examples of these routines below.\n",
        "\n",
        "The first example in the code block below demonstrates how to\n",
        "1. select a backend for kernel execution or simulation\n",
        "2. define the kernel which involves initializing the quantum kernel and allocating qubits, applying gates to the kernel (in this case we'll create a 2-qubit [GHZ state](https://en.wikipedia.org/wiki/Greenberger–Horne–Zeilinger_state)), and measuring the state\n",
        "3. sample the outcomes.\n",
        "\n",
        "We will be using CPUs to simulate quantum kernels throughout this tutorial. In other notebooks, we'll discuss how to change the target to access GPUs. While it is easy to switch to a quantum processor, by simply changing the target (refer to [this guide](https://nvidia.github.io/cuda-quantum/latest/using/hardware.html) for more details), there are some differences between how the code is implemented behind the scenes. In simulation mode, the quantum state is built once and then sampled `shots_count` many times. In quantum hardware execution mode, the quantum state collapses upon measurement and hence needs to be rebuilt over and over again.\n",
        "\n",
        "For the example below, we expect to see about 50% of the outcomes to be the `00` state and about 50% to be in the `11` state.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7b4adce4",
      "metadata": {
        "id": "7b4adce4",
        "outputId": "dd72f30c-3570-4587-ad6e-60ef3fc8d877"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{ 00:489 11:511 }\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Example 1\n",
        "\n",
        "\n",
        "##############################################################\n",
        "#  1. Select a backend for kernel execution\n",
        "cudaq.set_target(\"qpp-cpu\")\n",
        "##############################################################\n",
        "\n",
        "##############################################################\n",
        "# 2. Define a kernel function\n",
        "@cudaq.kernel\n",
        "def kernel(qubit_count: int):\n",
        "    # Allocate our `qubit_count` to the kernel.\n",
        "    qvector = cudaq.qvector(qubit_count)\n",
        "\n",
        "    # Apply a Hadamard gate to the qubit indexed by 0.\n",
        "    h(qvector[0])\n",
        "    # Apply a Controlled-X gate between qubit 0 (acting as the control)\n",
        "    # and each of the remaining qubits.\n",
        "    for i in range(1, qubit_count):\n",
        "        x.ctrl(qvector[0], qvector[i])\n",
        "\n",
        "    # Measure the qubits\n",
        "    # If we don't specify measurements, all qubits are measured in\n",
        "    # the Z-basis by default.\n",
        "    mz(qvector)\n",
        "\n",
        "##############################################################\n",
        "# 3. Call the kernel function with the variable qubit_count set to 2 and sample the outcomes\n",
        "qubit_count = 2\n",
        "result = cudaq.sample(kernel, qubit_count, shots_count=1000)\n",
        "\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f634815a",
      "metadata": {
        "id": "f634815a",
        "jupyter": {
          "source_hidden": true
        }
      },
      "source": [
        "The next example shows how to use CUDA-Q to compute the expectation value $\\langle \\psi |H|\\psi\\rangle$, where $H$ is a Hamiltonian and $|\\psi\\rangle$ is a quantum state defined by the kernel. We'll use the GHZ state, $|\\psi\\rangle = \\frac{1}{\\sqrt{2}}|00\\rangle+|11\\rangle$. Therefore, our kernel will be the same as the previous example, but we will remove the measurement. The Hamiltonian $H = ZI + 2IY - XZ$ is encoded using the `spin` operators in `cudaq` and they can be combined together with scalers using `+` and `*`. The `observe` primitive computes many statistics, but we will only need the `.expectation()` value."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b565027b",
      "metadata": {
        "id": "b565027b",
        "outputId": "fca5f335-6534-4063-cc90-f5e0a9c16be2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<psi|H|psi> = 0.040000000000000036\n"
          ]
        }
      ],
      "source": [
        "# Example 2\n",
        "\n",
        "# Define a quantum kernel function.\n",
        "@cudaq.kernel\n",
        "def kernel(qubit_count: int):\n",
        "    # Allocate our `qubit_count` to the kernel.\n",
        "    qvector = cudaq.qvector(qubit_count)\n",
        "\n",
        "    # Apply a Hadamard gate to the qubit indexed by 0.\n",
        "    h(qvector[0])\n",
        "    # Apply a Controlled-X gate between qubit 0 (acting as the control)\n",
        "    # and each of the remaining qubits.\n",
        "    for i in range(1, qubit_count):\n",
        "        x.ctrl(qvector[0], qvector[i])\n",
        "\n",
        "\n",
        "# Define a Hamiltonian in terms of Pauli Spin operators.\n",
        "hamiltonian = spin.z(0) + 2*spin.y(1) - spin.x(0) * spin.z(1)\n",
        "\n",
        "# Compute the expectation value given the state prepared by the kernel.\n",
        "result = cudaq.observe(kernel, hamiltonian, qubit_count, shots_count = 1000).expectation()\n",
        "\n",
        "print('<psi|H|psi> =', result)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "04832e5f",
      "metadata": {
        "id": "04832e5f"
      },
      "source": [
        "### 1.5.2 Problem Hamiltonian\n",
        "\n",
        "**Exercise:** Using the syntax demonstrated in the previous section, edit the line commented as `###FIX_ME###` in the code block below to define the problem Hamiltonian.  Recall that for max cut problems, the problem Hamiltonian is $$H= \\frac{1}{2}\\sum_{(u,v)\\in E} (Z_uZ_v-II),$$ where $E$ is the set of edges in our graph and $Z_u$ is shorthand for the spin $Z$ operator applied to the qubit associated with vertex $u$. In a similar manner $II$ can be thought of as $I_uI_v$. Hint: you will need to use the `spin.z` and `spin.i` operations. Click on the triple dots in the 2nd cell below to view the solution."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b503e230",
      "metadata": {
        "id": "b503e230"
      },
      "outputs": [],
      "source": [
        "# Define a function to generate the Hamiltonian for a max cut problem using the graph G\n",
        "\n",
        "def hamiltonian_max_cut(sources : List[int], targets : List[int]):\n",
        "    \"\"\"Hamiltonian for finding the max cut for the graph  with edges defined by the pairs generated by source and target edges\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    sources: List[int]\n",
        "        list of the source vertices for edges in the graph\n",
        "    targets: List[int]\n",
        "        list of the target vertices for the edges in the graph\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    cudaq.SpinOperator\n",
        "        Hamiltonian for finding the max cut of the graph defined by the given edges\n",
        "    \"\"\"\n",
        "    hamiltonian = 0\n",
        "    # Since our vertices may not be a list from 0 to n, or may not even be integers,\n",
        "\n",
        "    for i in range(len(sources)):\n",
        "        # Add a term to the Hamiltonian for the edge (u,v)\n",
        "        qubitu = sources[i]\n",
        "        qubitv = targets[i]\n",
        "        hamiltonian += spin.z(qubitu) ######FIX_ME\n",
        "\n",
        "    return hamiltonian"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d26aa06d",
      "metadata": {
        "id": "d26aa06d",
        "jupyter": {
          "source_hidden": true
        }
      },
      "outputs": [],
      "source": [
        "# SOLUTION\n",
        "\n",
        "# Define a function to generate the Hamiltonian for a max cut problem using the graph G\n",
        "\n",
        "def hamiltonian_max_cut(sources : List[int], targets : List[int]):\n",
        "    \"\"\"Hamiltonian for finding the max cut for the graph  with edges defined by the pairs generated by source and target edges\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    sources: List[int]\n",
        "        list of the source vertices for edges in the graph\n",
        "    targets: List[int]\n",
        "        list of the target vertices for the edges in the graph\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    cudaq.SpinOperator\n",
        "        Hamiltonian for finding the max cut of the graph defined by the given edges\n",
        "    \"\"\"\n",
        "    hamiltonian = 0\n",
        "    # Since our vertices may not be a list from 0 to n, or may not even be integers,\n",
        "\n",
        "    for i in range(len(sources)):\n",
        "        # Add a term to the Hamiltonian for the edge (u,v)\n",
        "        qubitu = sources[i]\n",
        "        qubitv = targets[i]\n",
        "        hamiltonian += 0.5*(spin.z(qubitu)*spin.z(qubitv)-spin.i(qubitu)*spin.i(qubitv))\n",
        "\n",
        "    return hamiltonian"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "52a50dad",
      "metadata": {
        "id": "52a50dad"
      },
      "source": [
        "\n",
        "### 1.5.3 QAOA Circuit\n",
        "\n",
        "In order to program QAOA for our max cut problem, we need to understand the structure of the variational QAOA quantum circuit. The general structure of the circuit is described and depicted below:\n",
        "* For each vertex in the graph, there is an associated qubit in the circuit.\n",
        "* The circuit is initialized in a superposition state, corresponding to a a state in which each possible coloring of vertices of the graph is equally likely. This is achieved with the Hadamard gates on the left of the diagram.\n",
        "* The QAOA circuit is made up of repeated blocks (referred to as layers) of a problem kernel and a mixer kernel. These layers are outlined in light gray.\n",
        "    * The problem kernel is drawn in blue. It encodes our graph. We'll go into more details about the make up of the problem kernel later in this section.\n",
        "    * The mixer kernel is composed of the green parameterized rotation gates in the diagram below.\n",
        "\n",
        "![](https://github.com/NVIDIA/cuda-q-academic/blob/main/qaoa-for-max-cut/images/qaoa-circuit-layers.png?raw=true)\n",
        "\n",
        "Let's take a closer look at the problem kernel, which encodes the structure of the graph for the max cut problem.  For each edge $(u,v)$ in the `sampleGraph` a contolled-$X$ gate is applied with control qubit associated with $u$ and target qubit associated with $v$.  Then a parameterized $Z$-rotation is applied to the qubit associated with $v$, and this is followed by another controlled-$X$ gate identical to the first one applied. The diagram below illustrates how the edge between node 1 and 2 in the graph drawn below would get encoded in the kernel. Here we have assigned vertex 1 to qubit 1 and vertex 2 to qubit 2. The encoding of edges is repeated for each edge of the graph. Within a given layer of the QAOA cicuit, the same parameter is used for all of the edge encodings in the problem kernel, but new parameters are introduced for each layer.\n",
        "\n",
        "![](https://github.com/NVIDIA/cuda-q-academic/blob/main/qaoa-for-max-cut/images/qaoa-problem-kernel.png?raw=true)\n",
        "\n",
        "In the code block below, edit the FIX_ME commands to define a kernel function that takes as input 2 qubits corresponding to an edge in our graph and a parameter, then applies the parameterized-gate sequence depicted in the image above to those two qubits.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8e06b253",
      "metadata": {
        "id": "8e06b253"
      },
      "outputs": [],
      "source": [
        "# Problem Kernel\n",
        "\n",
        "@cudaq.kernel\n",
        "def qaoaProblem(qubit_0 : cudaq.qubit, qubit_1 : cudaq.qubit, alpha : float):\n",
        "    \"\"\"Build the QAOA gate sequence between two qubits that represent an edge of the graph\n",
        "    Parameters\n",
        "    ----------\n",
        "    qubit_0: cudaq.qubit\n",
        "        Qubit representing the first vertex of an edge\n",
        "    qubit_1: cudaq.qubit\n",
        "        Qubit representing the second vertex of an edge\n",
        "    alpha: List[float]\n",
        "        Free variable\n",
        "\n",
        "\n",
        "    \"\"\"\n",
        "    FIX_ME(qubit_0, qubit_1)\n",
        "    rz(2.0*alpha, qubit_1)\n",
        "    FIX_ME(qubit_0, qubit_1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "76443eb2",
      "metadata": {
        "id": "76443eb2",
        "jupyter": {
          "source_hidden": true
        }
      },
      "outputs": [],
      "source": [
        "# SOLUTION\n",
        "# Problem Kernel\n",
        "\n",
        "@cudaq.kernel\n",
        "def qaoaProblem(qubit_0 : cudaq.qubit, qubit_1 : cudaq.qubit, alpha : float):\n",
        "    \"\"\"Build the QAOA gate sequence between two qubits that represent an edge of the graph\n",
        "    Parameters\n",
        "    ----------\n",
        "    qubit_0: cudaq.qubit\n",
        "        Qubit representing the first vertex of an edge\n",
        "    qubit_1: cudaq.qubit\n",
        "        Qubit representing the second vertex of an edge\n",
        "    alpha: float\n",
        "        Free variable\n",
        "\n",
        "\n",
        "    \"\"\"\n",
        "    x.ctrl(qubit_0, qubit_1)\n",
        "    rz(2.0*alpha, qubit_1)\n",
        "    x.ctrl(qubit_0, qubit_1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "37f7fd1b",
      "metadata": {
        "id": "37f7fd1b"
      },
      "source": [
        "Now, we'll create a kernel function for the mixer.  This kernel will take as input a qubit and a parameter, and applies a parameterized x-rotation gate to the qubit.  Edit FIX_ME statements in the code block below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f107925d",
      "metadata": {
        "id": "f107925d"
      },
      "outputs": [],
      "source": [
        "# Mixer Kernel\n",
        "\n",
        "@cudaq.kernel\n",
        "def qaoaMixer(FIX_ME):\n",
        "    \"\"\"Build the QAOA gate sequence that is applied to each qubit in the mixer portion of the circuit\n",
        "    Parameters\n",
        "    ----------\n",
        "    qubit_0: cudaq.qubit\n",
        "        Qubit\n",
        "    beta: float\n",
        "        Free variable\n",
        "\n",
        "\n",
        "    \"\"\"\n",
        "    rx(2.0*beta, FIX_ME)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "40f189c1",
      "metadata": {
        "id": "40f189c1",
        "jupyter": {
          "source_hidden": true
        }
      },
      "outputs": [],
      "source": [
        "# SOLUTION\n",
        "# Mixer Kernel\n",
        "\n",
        "@cudaq.kernel\n",
        "def qaoaMixer(qubit_0 : cudaq.qubit, beta : float):\n",
        "    \"\"\"Build the QAOA gate sequence that is applied to each qubit in the mixer portion of the circuit\n",
        "    Parameters\n",
        "    ----------\n",
        "    qubit_0: cudaq.qubit\n",
        "        Qubit\n",
        "    beta: float\n",
        "        Free variable\n",
        "\n",
        "\n",
        "    \"\"\"\n",
        "    rx(2.0*beta, qubit_0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "85ae958c",
      "metadata": {
        "id": "85ae958c"
      },
      "source": [
        "We're ready to put these kernels together to build up the QAOA circuit. You are tasked in the exercise below to edit the FIX_MEs to carry out the first steps:  \n",
        "* initialize the qubits - one for each vertex in our graph\n",
        "* place the qubits in superposition.\n",
        "\n",
        "Then, the two kernels that we created in the previous blocks will be added to form the layers in the QAOA circuit.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cdabb46c",
      "metadata": {
        "id": "cdabb46c"
      },
      "outputs": [],
      "source": [
        "# We now define the kernel_qaoa function which will be the QAOA circuit for our graph\n",
        "# Since the QAOA circuit for max cut depends on the structure of the graph,\n",
        "# we'll feed in global concrete variable values into the kernel_qaoa function for the qubit_count, layer_count, edges_src, edges_tgt.\n",
        "# The types for these variables are restricted to Quake Values (e.g. qubit, int, List[int], ...)\n",
        "# The thetas plaeholder will be our free parameters (the alphas and betas in the circuit diagrams depicted above)\n",
        "@cudaq.kernel\n",
        "def kernel_qaoa(qubit_count :int, layer_count: int, edges_src: List[int], edges_tgt: List[int], thetas : List[float]):\n",
        "    \"\"\"Build the QAOA circuit for max cut of the graph with given edges and nodes\n",
        "    Parameters\n",
        "    ----------\n",
        "    qubit_count: int\n",
        "        Number of qubits in the circuit, which is the same as the number of nodes in our graph\n",
        "    layer_count : int\n",
        "        Number of layers in the QAOA kernel\n",
        "    edges_src: List[int]\n",
        "        List of the first (source) node listed in each edge of the graph, when the edges of the graph are listed as pairs of nodes\n",
        "    edges_tgt: List[int]\n",
        "        List of the second (target) node listed in each edge of the graph, when the edges of the graph are listed as pairs of nodes\n",
        "    thetas: List[float]\n",
        "        Free variables to be optimized\n",
        "\n",
        "\n",
        "    \"\"\"\n",
        "    # Let's allocate the qubits\n",
        "    qreg = cudaq.qvector(FIX_ME)\n",
        "\n",
        "    # And then place the qubits in superposition\n",
        "    h(FIX_ME)\n",
        "\n",
        "    # Each layer has two components: the problem kernel and the mixer\n",
        "    for i in range(layer_count):\n",
        "        # Add the problem kernel to each layer\n",
        "        for edge in range(len(edges_src)):\n",
        "            qubitu = edges_src[edge]\n",
        "            qubitv = edges_tgt[edge]\n",
        "            qaoaProblem(qreg[qubitu], qreg[qubitv], thetas[i])\n",
        "        # Add the mixer kernel to each layer\n",
        "        for j in range(qubit_count):\n",
        "            qaoaMixer(qreg[j],thetas[i+layer_count])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "de9052ab",
      "metadata": {
        "id": "de9052ab",
        "jupyter": {
          "source_hidden": true
        }
      },
      "outputs": [],
      "source": [
        "# SOLUTION\n",
        "\n",
        "# We now define the kernel_qaoa function which will be the QAOA circuit for our graph\n",
        "# Since the QAOA circuit for max cut depends on the structure of the graph,\n",
        "# we'll feed in global concrete variable values into the kernel_qaoa function for the qubit_count, layer_count, edges_src, edges_tgt.\n",
        "# The types for these variables are restricted to Quake Values (e.g. qubit, int, List[int], ...)\n",
        "# The thetas plaeholder will be our free parameters (the alphas and betas in the circuit diagrams depicted above)\n",
        "@cudaq.kernel\n",
        "def kernel_qaoa(qubit_count :int, layer_count: int, edges_src: List[int], edges_tgt: List[int], thetas : List[float]):\n",
        "    \"\"\"Build the QAOA circuit for max cut of the graph with given edges and nodes\n",
        "    Parameters\n",
        "    ----------\n",
        "    qubit_count: int\n",
        "        Number of qubits in the circuit, which is the same as the number of nodes in our graph\n",
        "    layer_count : int\n",
        "        Number of layers in the QAOA kernel\n",
        "    edges_src: List[int]\n",
        "        List of the first (source) node listed in each edge of the graph, when the edges of the graph are listed as pairs of nodes\n",
        "    edges_tgt: List[int]\n",
        "        List of the second (target) node listed in each edge of the graph, when the edges of the graph are listed as pairs of nodes\n",
        "    thetas: List[float]\n",
        "        Free variables to be optimized\n",
        "\n",
        "    \"\"\"\n",
        "    # Let's allocate the qubits\n",
        "    qreg = cudaq.qvector(qubit_count)\n",
        "\n",
        "    # And then place the qubits in superposition\n",
        "    h(qreg)\n",
        "\n",
        "    # Each layer has two components: the problem kernel and the mixer\n",
        "    for i in range(layer_count):\n",
        "        # Add the problem kernel to each layer\n",
        "        for edge in range(len(edges_src)):\n",
        "            qubitu = edges_src[edge]\n",
        "            qubitv = edges_tgt[edge]\n",
        "            qaoaProblem(qreg[qubitu], qreg[qubitv], thetas[i])\n",
        "        # Add the mixer kernel to each layer\n",
        "        for j in range(qubit_count):\n",
        "            qaoaMixer(qreg[j],thetas[i+layer_count])"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "949a4ea3-8c64-4591-8cb6-c1d57c5c4203",
      "metadata": {
        "id": "949a4ea3-8c64-4591-8cb6-c1d57c5c4203"
      },
      "source": [
        "**Side Note:**  In this tutorial we defined kernels using the preferred [`PyKernel` decorator](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#cudaq.PyKernel). An alternative method for defining kerels is to use the\n",
        " [kernel builder](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#cudaq.make_kernel) syntax."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3b93ac84",
      "metadata": {
        "id": "3b93ac84"
      },
      "source": [
        "That completes the QAOA kernel.  Next we need to define the optimizer and sampler."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ddfdb690",
      "metadata": {
        "id": "ddfdb690"
      },
      "source": [
        "\n",
        "### 1.5.4 Optimizer Loop\n",
        "\n",
        "CUDA-Q has several built-in optimizers. You can find more information about the optimizers [here](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#optimizers).  \n",
        "\n",
        "The code block below defines our optimizer and sets the initial parameter values. We'll use the COBYLA optimizer.  We'll set a seed and choose initial parameter values randomly. Recall that the number of parameters needed depends on the number of layers in our QAOA circuit.  Each layer calls two parameters, one for the problem kernel and one for the mixer."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ab3b71d3",
      "metadata": {
        "id": "ab3b71d3"
      },
      "outputs": [],
      "source": [
        "# Define the optimizer\n",
        "seed = 110\n",
        "layer_count = 1 # set arbitrarily\n",
        "parameter_count: int = 2 * layer_count\n",
        "\n",
        "# Specify the optimizer and its initial parameters.\n",
        "optimizer = cudaq.optimizers.COBYLA()\n",
        "np.random.seed(seed)\n",
        "optimizer.initial_parameters = np.random.uniform(-np.pi, np.pi,\n",
        "                                                     parameter_count)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3286736c",
      "metadata": {
        "id": "3286736c"
      },
      "source": [
        "The `vqe` function is built into CUDA-Q and carries out the optimization loop once the optimizer, initial parameters, kernel, and Hamiltonian cost function have been defined. Let's add the `vqe` call to the code. The code block below implements the full optimizer loop. When you execute the code, you'll see the optimal parameter values identified for the max cut approximate solution to our `sampleGraph`.  In the next two sections, we'll walk through how to read out an optimal cut from this."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "259c27c2",
      "metadata": {
        "id": "259c27c2",
        "outputId": "b665ee01-8afc-44c9-9b92-8ffa74155f80"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Optimal value =  -4.466292352870948\n",
            "Optimal parameters =  [-1.8965273704724852, 1.0642955325900538]\n"
          ]
        }
      ],
      "source": [
        "# Define the optimizer\n",
        "\n",
        "# Problem parameters\n",
        "seed = 110\n",
        "qubit_count = len(node_List) # The number of qubits we'll need is the same as the number of vertices in our graph\n",
        "layer_count = 1 # set arbitrarily\n",
        "parameter_count: int = 2 * layer_count   # Each layer of the QAOA kernel contains 2 parameters\n",
        "nodes = sorted(list(nx.nodes(sampleGraph)))\n",
        "# In the event our nodes aren't listed as consecutive integers starting with 0, we will map them to qubits\n",
        "edge_qubit_src = []\n",
        "edge_qubit_tgt = []\n",
        "for u, v in nx.edges(sampleGraph):\n",
        "    # We can use the index() command to read out the qubits associated with the vertex u and v.\n",
        "    edge_qubit_src.append(nodes.index(u))\n",
        "    edge_qubit_tgt.append(nodes.index(v))\n",
        "\n",
        "\n",
        "# Specify the optimizer and its initial parameters.\n",
        "optimizer = cudaq.optimizers.COBYLA()\n",
        "np.random.seed(seed)\n",
        "optimizer.initial_parameters = np.random.uniform(-np.pi, np.pi,\n",
        "                                                     parameter_count)\n",
        "\n",
        "\n",
        "# Pass the kernel, spin operator, and optimizer to `cudaq.vqe`.\n",
        "optimal_expectation, optimal_parameters = cudaq.vqe(\n",
        "    kernel=kernel_qaoa,\n",
        "    spin_operator=hamiltonian_max_cut(edge_qubit_src,edge_qubit_tgt),\n",
        "    argument_mapper=lambda parameter_vector: (qubit_count, layer_count, edge_qubit_src, edge_qubit_tgt, parameter_vector),\n",
        "    optimizer=optimizer,\n",
        "    parameter_count=parameter_count)\n",
        "\n",
        "# Print the optimized value and its parameters\n",
        "print(\"Optimal value = \", optimal_expectation)\n",
        "print(\"Optimal parameters = \", optimal_parameters)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fb76da1f",
      "metadata": {
        "id": "fb76da1f"
      },
      "source": [
        "We can read out an approximation for the max cut value from this result.  The optimal value reported is the average value ($\\langle \\psi|H|\\psi\\rangle$) of our problem Hamiltonian $H$ when applied to the state generated by the quantum circuit with the optimal parameter values.  What this means that at our max cut value for the `sampleGraph` is at least 4.466. We'll use the sampling in the next section to identify the most probable measurements of the state generated by the QAOA kernel with these optimal parameter values."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "08f2e1ac",
      "metadata": {
        "id": "08f2e1ac"
      },
      "source": [
        "Since we'll eventually be applying QAOA to several graphs, let's wrap all of this into a function that takes as input the graph, layer count, and seed and outputs the optimal parameters found after executing QAOA with the given layer count and seed for max cut on the given graph. We'll want to apply QAOA to graphs whose vertices may not be indexed by consecutive integers ranging from 0 to n, so we'll need to do some bookkeeping before passing the graph to the QAOA kernel by identifying the each vertex with its position in a sorted list of the vertices of the graph."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4d64fa07",
      "metadata": {
        "id": "4d64fa07"
      },
      "outputs": [],
      "source": [
        "def find_optimal_parameters(G, layer_count, seed):\n",
        "    \"\"\"Function for finding the optimal parameters of QAOA for the max cut of a graph\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G: networkX graph\n",
        "        Problem graph whose max cut we aim to find\n",
        "    layer_count : int\n",
        "        Number of layers in the QAOA circuit\n",
        "    seed : int\n",
        "        Random seed for reproducibility of results\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    list[float]\n",
        "        Optimal parameters for the QAOA applied to the given graph G\n",
        "    \"\"\"\n",
        "    parameter_count: int = 2 * layer_count\n",
        "\n",
        "    # Problem parameters\n",
        "    nodes = sorted(list(nx.nodes(G)))\n",
        "    qubit_src = []\n",
        "    qubit_tgt = []\n",
        "    for u, v in nx.edges(G):\n",
        "        # We can use the index() command to read out the qubits associated with the vertex u and v.\n",
        "        qubit_src.append(nodes.index(u))\n",
        "        qubit_tgt.append(nodes.index(v))\n",
        "    # The number of qubits we'll need is the same as the number of vertices in our graph\n",
        "    qubit_count : int = len(nodes)\n",
        "    # Each layer of the QAOA kernel contains 2 parameters\n",
        "    parameter_count : int = 2*layer_count\n",
        "\n",
        "    # Specify the optimizer and its initial parameters.\n",
        "    optimizer = cudaq.optimizers.COBYLA()\n",
        "    np.random.seed(seed)\n",
        "    optimizer.initial_parameters = np.random.uniform(-np.pi, np.pi,\n",
        "                                                     parameter_count)\n",
        "\n",
        "    # Pass the kernel, spin operator, and optimizer to `cudaq.vqe`.\n",
        "    optimal_expectation, optimal_parameters = cudaq.vqe(\n",
        "        kernel=kernel_qaoa,\n",
        "        spin_operator=hamiltonian_max_cut(qubit_src, qubit_tgt),\n",
        "        argument_mapper=lambda parameter_vector: (qubit_count, layer_count, qubit_src, qubit_tgt, parameter_vector),\n",
        "        optimizer=optimizer,\n",
        "        parameter_count=parameter_count)\n",
        "\n",
        "    return optimal_parameters"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "81ded329",
      "metadata": {
        "id": "81ded329"
      },
      "source": [
        "Let's verify that the `find_optimal_parameters` function executes as expected."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "893b8453",
      "metadata": {
        "id": "893b8453",
        "outputId": "b5c87250-e057-4de9-e6a5-c414ae35f4a0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[-1.8965273704724852, 1.0642955325900538]"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Testing the find_optimal_parameters function\n",
        "layer_count =1\n",
        "seed = 110\n",
        "\n",
        "find_optimal_parameters(sampleGraph, layer_count, seed)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5a1b0260",
      "metadata": {
        "id": "5a1b0260"
      },
      "source": [
        "### 1.5.5 Sampling the results of QAOA\n",
        "\n",
        "The final step of the QAOA is to sample the QAOA circuit using the optimal parameters identified through the optimization loop.  This is carried out with `sample` for which we can specify the number of shots.  The code block below adds the sampling instruction. For now, we'll set the `layer_count` to be 1. Notice that there are $2^7=128$ many colorings of the 7 nodes.  Therefore, we want to make sure that our `shots_count` will be large enough to distinguish the most probable outcome among these 128 states."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "26b7e67d",
      "metadata": {
        "id": "26b7e67d",
        "outputId": "b6531060-b143-44e6-a933-d2c90fbe5087"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "most_probable outcome =  1101011\n"
          ]
        }
      ],
      "source": [
        "# Sampling the results of QAOA\n",
        "# QAOA and sampling parameters\n",
        "cudaq.set_random_seed(seed)\n",
        "shots = 5000\n",
        "layer_count =1\n",
        "parameter_count : int = 2*layer_count # Each layer of the QAOA kernel contains 2 parameters\n",
        "\n",
        "# Problem parameters from the graph\n",
        "nodes = list(sampleGraph.nodes())\n",
        "qubit_count : int = len(nodes) # The number of qubits we'll need is the same as the number of vertices in our graph\n",
        "qubit_src = []\n",
        "qubit_tgt = []\n",
        "for u, v in nx.edges(sampleGraph):\n",
        "    # We can use the index() command to read out the qubits associated with the vertex u and v.\n",
        "    qubit_src.append(nodes.index(u))\n",
        "    qubit_tgt.append(nodes.index(v))\n",
        "\n",
        "\n",
        "# retrieve optimal parameters from running VQE through the find_optimal_parameters function\n",
        "optimal_parameters = find_optimal_parameters(G = sampleGraph, layer_count = 2, seed = 123)\n",
        "\n",
        "# Sample the circuit using the optimized parameters\n",
        "# The structure of the sample call is sample(kernel, *args, shots_count=1000, noise_model=None) where *args are the\n",
        "# concrete values for evaluating the kernel function\n",
        "counts = cudaq.sample(kernel_qaoa, qubit_count, layer_count, qubit_src, qubit_tgt, optimal_parameters, shots_count=shots)\n",
        "print('most_probable outcome = ',counts.most_probable())\n",
        "results = str(counts.most_probable())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "57b83a02",
      "metadata": {
        "id": "57b83a02"
      },
      "source": [
        "### 1.5.6 Creating a function to carry out QAOA for max cut on a graph\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "51ea007e",
      "metadata": {
        "id": "51ea007e"
      },
      "source": [
        "Because we'll want to reuse this code later on and apply the QAOA algorithm to other graphs, we'll create a function that carries out QAOA for max cut on a given graph with specified layer count, number of shots in the sampling subroutine, and a random seed for reproducibility."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1e7a1e74",
      "metadata": {
        "id": "1e7a1e74"
      },
      "outputs": [],
      "source": [
        "def qaoa_for_graph(G, layer_count, shots, seed):\n",
        "    \"\"\"Function for finding the max cut of a graph using QAOA\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G: networkX graph\n",
        "        Problem graph whose max cut we aim to find\n",
        "    layer_count : int\n",
        "        Number of layers in the QAOA circuit\n",
        "    shots : int\n",
        "        Number of shots in the sampling subroutine\n",
        "    seed : int\n",
        "        Random seed for reproducibility of results\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    str\n",
        "        Binary string representing the max cut coloring of the vertinces of the graph\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "    parameter_count: int = 2 * layer_count\n",
        "\n",
        "    # Problem parameters\n",
        "    nodes = sorted(list(nx.nodes(G)))\n",
        "    qubit_src = []\n",
        "    qubit_tgt = []\n",
        "    for u, v in nx.edges(G):\n",
        "        # We can use the index() command to read out the qubits associated with the vertex u and v.\n",
        "        qubit_src.append(nodes.index(u))\n",
        "        qubit_tgt.append(nodes.index(v))\n",
        "    # The number of qubits we'll need is the same as the number of vertices in our graph\n",
        "    qubit_count : int = len(nodes)\n",
        "    # Each layer of the QAOA kernel contains 2 parameters\n",
        "    parameter_count : int = 2*layer_count\n",
        "\n",
        "    optimal_parameters = find_optimal_parameters(sampleGraph, layer_count, seed)\n",
        "\n",
        "    # Print the optimized parameters\n",
        "    print(\"Optimal parameters = \", optimal_parameters)\n",
        "\n",
        "    # Sample the circuit\n",
        "    counts = cudaq.sample(kernel_qaoa, qubit_count, layer_count, qubit_src, qubit_tgt, optimal_parameters, shots_count=shots)\n",
        "    print('most_probable outcome = ',counts.most_probable())\n",
        "    results = str(counts.most_probable())\n",
        "    return results"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1004ccf7",
      "metadata": {
        "id": "1004ccf7"
      },
      "source": [
        "We are ready to run our code to find the max cut of `sampleGraph`! Execute the code block below which calls on the `qaoa_for_graph` function that we've defined in the previous sections, interprets the resulting bitstring as a coloring or partitioning of sample graph, and computes the cut."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8678ac11",
      "metadata": {
        "id": "8678ac11",
        "outputId": "8e8b7ca6-1b55-44e9-ea7e-82f4e57e2bcb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Optimal parameters =  [-1.8965273704724852, 1.0642955325900538]\n",
            "most_probable outcome =  0110101\n",
            "The max cut value for the sampleGraph is  6\n",
            "The optimal cut found by the QAOA algorithm is [0, 5, 3] [1, 2, 4, 6]\n"
          ]
        }
      ],
      "source": [
        "# Apply the QAOA algorithm to the sampleGraph max cut problem using\n",
        "# seed = 110\n",
        "result = qaoa_for_graph(sampleGraph, 1, 5000, 110)\n",
        "\n",
        "# Map the resulting bitstring from the qubit measurements\n",
        "# to a list of integer values in the same order as the nodes\n",
        "# to determine a coloring of the vertices\n",
        "graphColors=[int(i) for i in result]\n",
        "nodes = sorted(list(nx.nodes(sampleGraph)))\n",
        "\n",
        "# compute the cut value associated with resulting coloring\n",
        "sampleGraphMaxCut =0\n",
        "cut_edges = []\n",
        "for u, v in sampleGraph.edges():\n",
        "    indexu = nodes.index(u)\n",
        "    indexv = nodes.index(v)\n",
        "    if graphColors[indexu] != graphColors[indexv]:\n",
        "        sampleGraphMaxCut += 1\n",
        "        cut_edges+=[(u,v)]\n",
        "\n",
        "# compute the partitioning associated with resulting coloring\n",
        "cut0 = []\n",
        "cut1 = []\n",
        "for u in sampleGraph.nodes():\n",
        "    indexu = nodes.index(u)\n",
        "    if graphColors[indexu] == 0:\n",
        "        cut0.append(u)\n",
        "        sampleGraph.nodes[u]['color']= 0\n",
        "    else:\n",
        "        cut1.append(u)\n",
        "        sampleGraph.nodes[u]['color']= 1\n",
        "\n",
        "print('The max cut value for the sampleGraph is ',sampleGraphMaxCut)\n",
        "print('The optimal cut found by the QAOA algorithm is',cut0, cut1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6ad22d1d",
      "metadata": {
        "id": "6ad22d1d"
      },
      "source": [
        "Yay!  Using QAOA, we found the max cut value which matches our brute-force computation earlier in this lab.\n",
        "\n",
        "Let's visualize the result by highlighting the edges in the cut with green."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4c83ac2c",
      "metadata": {
        "id": "4c83ac2c",
        "outputId": "67dadaf8-e98a-4cda-cda9-424b6cc90959"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Draw the graph identifying the max cut\n",
        "# Plot the graph with nodes labeled with their name and colored white for 0 and green for 1.\n",
        "# Edges in the max cut are higlighted in green\n",
        "\n",
        "max_cut_color_map = [gray if sampleGraph.nodes[u]['color']==0 else green for u in sampleGraph]\n",
        "\n",
        "nx.draw_networkx_edges(\n",
        "    sampleGraph,\n",
        "    pos,\n",
        "    edgelist=cut_edges,\n",
        "    width=8,\n",
        "    alpha=0.5,\n",
        "    edge_color=green,\n",
        ")\n",
        "nx.draw(sampleGraph, with_labels=True, pos = pos, node_color=max_cut_color_map)\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c5ebc38e",
      "metadata": {
        "id": "c5ebc38e"
      },
      "source": [
        "## 1.6 Scaling QAOA\n",
        "In the remainder of this lab, we explore another approach to this problem that will allow us to scale QAOA to handle slightly larger graphs than otherwise would be possible.\n",
        "\n",
        "In QAOA the number of qubits scales with the number of vertices in the graph. Additionally, the depth of the QAOA circuit grows with the number of edges and the number of layers. Circuit depth and number of qubits are two factors in determing the cost and feasibilty of executing or simulating a quantum algorithm. Before jumping into the divide-and-conquer QAOA algorithm applied to a larger graph in Lab 2, we apply part of this algorithm to the `sampleGraph` as a warm up.\n",
        "\n",
        "Divide-and-conquer QAOA can be thought of as 3 stages: divide, conquer, and merge. We preview the divide-and-conquer idea of breaking up a larger graph into smaller subgraphs in section 1.6.1, solving the max cut problem for the smaller subgraphs in section 1.6.2, and stitching the subgraph solutions back together to get a solution to the original graph in sections 1.6.3 and 1.6.4. In this example, we will be applying a brute-force algorithm to stitch together the subgraph solutions, but in the next lab we will improve upon this approach with an application of QAOA that identifies an approximately optimal way to merge together the solutions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "07c9ae16-a4c9-434a-984b-32b5fcbd9d0b",
      "metadata": {
        "id": "07c9ae16-a4c9-434a-984b-32b5fcbd9d0b",
        "jupyter": {
          "source_hidden": true
        },
        "outputId": "afec515b-8ed3-4315-d881-93b839b87b1c"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "<video controls width=\"640\" height=\"360\">\n",
              "    <source src=\"https://d36m44n9vdbmda.cloudfront.net/assets/x-ac-13-v1/max-cut-with-CUDA-Quantum-Lab-1-Part-4.mp4\" type=\"video/mp4\">\n",
              "    Your browser does not support the video tag.\n",
              "</video>\n"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Execute this cell for a preview of the Divide-and-Conquer QAOA.\n",
        "from IPython.display import HTML\n",
        "\n",
        "video_url = \"https://d36m44n9vdbmda.cloudfront.net/assets/x-ac-13-v1/max-cut-with-CUDA-Quantum-Lab-1-Part-4.mp4\"\n",
        "\n",
        "video_html = f\"\"\"\n",
        "<video controls width=\"640\" height=\"360\">\n",
        "    <source src=\"{video_url}\" type=\"video/mp4\">\n",
        "    Your browser does not support the video tag.\n",
        "</video>\n",
        "\"\"\"\n",
        "\n",
        "display(HTML(video_html))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4be14c27",
      "metadata": {
        "id": "4be14c27"
      },
      "source": [
        "### 1.6.1 Divide: Dividing the sampleGraph into two smaller subgraphs"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d2c91da6",
      "metadata": {
        "id": "d2c91da6"
      },
      "source": [
        "Our `sampleGraph` is small and easy to visualize.  A natural partition of the graph is to break the graph at the edge $(0,4)$, leaving us with two smaller disjoint subgraphs: `sampleSubgraph0` and `sampleSubgraph1` which we will draw below with node colors blue and yellow, respectively.  Notice that the edge between vertex $0$ and $4$ does not appear in either subgraph, and every vertex from `sampleGraph` appears in exactly one of the subgraphs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "29f1533b",
      "metadata": {
        "id": "29f1533b",
        "outputId": "5c33281b-341c-4e5f-c23e-98196a03c016"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Defining colors not to represent the subgraphs visually\n",
        "blue = '#0071C5'\n",
        "yellow = '#FAC200'\n",
        "\n",
        "# Subgraph definitions\n",
        "subGraph_dictionary = {}\n",
        "subgraphColors={}\n",
        "subGraph_names=[]\n",
        "for i in range(2):\n",
        "    name='sampleSubgraph'+str(i)\n",
        "    subGraph_names.append(name)\n",
        "    if i ==0:\n",
        "        subgraphColors[name] = blue\n",
        "    else:\n",
        "        subgraphColors[name] = yellow\n",
        "\n",
        "\n",
        "nodes0 = [0,1,2]\n",
        "subGraph_dictionary[subGraph_names[0]] = nx.subgraph(sampleGraph, nodes0)\n",
        "\n",
        "nodes1 = [3,4,5,6]\n",
        "subGraph_dictionary[subGraph_names[1]] = nx.subgraph(sampleGraph, nodes1)\n",
        "\n",
        "# draw sampleSubgraph0 in purple and sampleSubGraph1 in yellow\n",
        "# Plot the graphs with nodes and weights labeled.\n",
        "for key in subGraph_dictionary:\n",
        "    nx.draw(subGraph_dictionary[key], pos=pos, with_labels=True, node_color = subgraphColors[key])\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4a000a0b",
      "metadata": {
        "id": "4a000a0b"
      },
      "source": [
        "### 1.6.2 Conquer: Solving the subgraph problems using QAOA\n",
        "\n",
        "Breaking `sampleGraph` into two smaller graphs not only reduces the number of qubits required in each QAOA kernel, but it also affords us the ability to compute the max cut of these subgraphs in parallel. We'll execute these kernels sequentially here, but we'll learn how to parallelize this in [Lab 2](2_One-level-divide-and-conquer-QAOA.ipynb) and [Lab 3](3_Recursive-divide-and-conquer.ipynb)."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ad61a215",
      "metadata": {
        "id": "ad61a215"
      },
      "source": [
        "**Exercise** edit the code block below to find the max cut of each subgraph by replacing the FIX_ME with a function that we've defined in the previous sections."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "91b63b8a",
      "metadata": {
        "id": "91b63b8a",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "# Find the max cut solutions for each of the 2 subgraphs\n",
        "\n",
        "layer_count =1\n",
        "parameter_count: int = 2 * layer_count\n",
        "shots = 5000\n",
        "\n",
        "# Set seeds for reproducibility, since different seeds may lead to different max cut solutions\n",
        "# Don't edit these seeds for your initial reading of this lab.  After you have gone through\n",
        "# the lab, we welcome you to change the seeds to witness the stochasticity of the algorithm.\n",
        "seed={}\n",
        "for key in subGraph_dictionary:\n",
        "    i = 4\n",
        "    seed[key] = i\n",
        "    i +=100\n",
        "\n",
        "results = {}\n",
        "\n",
        "for key in subGraph_dictionary:\n",
        "    # Set initial parameters for each subgraph\n",
        "    np.random.seed(seed[key])\n",
        "\n",
        "    initial_parameters = np.random.uniform(-np.pi, np.pi,\n",
        "                                                    parameter_count)\n",
        "    G = subGraph_dictionary[key]\n",
        "    results[key]= FIX_ME(G, layer_count, shots, seed[key])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "72a92ee6",
      "metadata": {
        "id": "72a92ee6",
        "jupyter": {
          "source_hidden": true
        },
        "outputId": "904f1f10-4bca-4406-b135-332bb403aaad"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The results for sampleSubgraph0 :\n",
            "Optimal parameters =  [2.8327854901167684, 0.333763475746482]\n",
            "most_probable outcome =  110\n",
            "The results for sampleSubgraph1 :\n",
            "Optimal parameters =  [2.8327854901167684, 0.333763475746482]\n",
            "most_probable outcome =  1100\n"
          ]
        }
      ],
      "source": [
        "# SOLUTION\n",
        "\n",
        "layer_count =1\n",
        "parameter_count: int = 2 * layer_count\n",
        "shots =5000\n",
        "\n",
        "# Set seeds for reproducibility, since different seeds may lead to different max cut solutions\n",
        "seed={}\n",
        "for key in subGraph_dictionary:\n",
        "    i = 4\n",
        "    seed[key] = i\n",
        "    i +=100\n",
        "\n",
        "results = {}\n",
        "\n",
        "for key in subGraph_dictionary:\n",
        "    # Set initial parameters for each subgraph\n",
        "    print('The results for',key,':')\n",
        "    np.random.seed(seed[key])\n",
        "\n",
        "    initial_parameters = np.random.uniform(-np.pi, np.pi,\n",
        "                                                    parameter_count)\n",
        "    G = subGraph_dictionary[key]\n",
        "    results[key]= qaoa_for_graph(G, layer_count, shots, seed[key])"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "24ebaf9e",
      "metadata": {
        "id": "24ebaf9e"
      },
      "source": [
        "### 1.6.3 Merge: Determining a (perhaps not-optimal) cut of the sampleGraph from the subgraph solutions"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6e3cd5e0",
      "metadata": {
        "id": "6e3cd5e0"
      },
      "source": [
        "Because no vertex lies in both subgraphs, we can use the subgraph solutions to generate a (possibly non-optimal) cut of the original `sampleGraph` by coloring each node with the colors determined by the subgraph solutions. We'll find a better cut in the next subsection."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "72a95fd5",
      "metadata": {
        "id": "72a95fd5",
        "outputId": "2176da48-7f54-4f62-bbe4-d59ecb4e3cb3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The cut value for this partition is 5\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Visualize subgraph solutions by changing the color\n",
        "# of the nodes according to the max cut\n",
        "# partitions found for each of the subgraphs.\n",
        "# This induces a cut of the original sampleGraph\n",
        "\n",
        "for key in subGraph_dictionary:\n",
        "    graphColors=[int(i) for i in results[key]]\n",
        "    nodes = sorted(list(nx.nodes(subGraph_dictionary[key])))\n",
        "\n",
        "    for u in sampleGraph.nodes():\n",
        "        if u in nodes:\n",
        "            indexu = nodes.index(u)\n",
        "            if graphColors[indexu] == 0:\n",
        "                sampleGraph.nodes[u]['color']= 0\n",
        "            else:\n",
        "                sampleGraph.nodes[u]['color']= 1\n",
        "\n",
        "cut_edges =[]\n",
        "for u, v in sampleGraph.edges():\n",
        "    if sampleGraph.nodes[u]['color']!= sampleGraph.nodes[v]['color']:\n",
        "        cut_edges+=[(u,v)]\n",
        "\n",
        "print ('The cut value for this partition is',len(cut_edges))\n",
        "\n",
        "# Plot sampleGraph with the colors inherited from the subgraph solutions\n",
        "\n",
        "max_cut_color_map = [gray if sampleGraph.nodes[u]['color']==0 else green for u in sampleGraph]\n",
        "\n",
        "nx.draw_networkx_edges(\n",
        "    sampleGraph,\n",
        "    pos,\n",
        "    edgelist=cut_edges,\n",
        "    width=8,\n",
        "    alpha=0.5,\n",
        "    edge_color=green,\n",
        ")\n",
        "nx.draw(sampleGraph, with_labels=True, pos = pos, node_color=max_cut_color_map)\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "db67df6c",
      "metadata": {
        "id": "db67df6c"
      },
      "source": [
        "Notice that the cut value for this partition is 5. This is less than the optimal value of 6 that we found earlier. Therefore, we have not optimally combined the subgraph max cut solutions into a solution for the `sampleGraph`. We can be more careful about how we merge together the subgraph solutions to generate a cut of the original graph. We'll explore this in the next section.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "54ee788a",
      "metadata": {
        "id": "54ee788a"
      },
      "source": [
        "### 1.6.4 Merge: Finding a better merger of the subgraph solutions\n",
        "\n",
        "\n",
        "Instead of directly merging the subgraph solutions together as we did above, we can inspect the edges that do not lie in either subgraph and make some adjustments to the colorings before stitching them together.  This is a common procedure in both classical and quantum max cut algorithms and is sometimes referred to as *local search*.\n",
        "\n",
        "In the example above, the edge $(0,4)$ is not included in the cut deduced from the merger of the subgraph solutions because both $0$ and $4$ were colored gray.  Suppose we could change the coloring of `sampleSubgraph0` without reducing the cut value of the subgraph, but while also ensuring that $0$ gets colored green. Then, we would be able to include edge $(0,4)$ in the merged cut, resulting in a larger cut value for the `sampleGraph`.  Our graphs are small enough that we can visually check to see if this would be possible.\n",
        "\n",
        "Notice that the `sampleSubgraph0` cut value resulting from the node coloring `100` is the same as the one coded by `011`. By simply swapping the colors of the `sampleSubgraph0` result, we can find a better (optimal) cut for the `sampleGraph` because the cut value for `sampleSubgraph0` will remain the same, but we will capture the edge $(0,4)$ in our cut of the `sampelGraph` with this new coloring. Let's see how that works out."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f8826083",
      "metadata": {
        "id": "f8826083",
        "outputId": "79f78c50-d75b-4590-b617-f469525d23b0"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Replace the coloring of the nodes of sampleSubgraph0\n",
        "# with their complement (replace 0s with 1s and 1s with 0s)\n",
        "# to generate another (this time optimal) cut of the sampleGraph.\n",
        "\n",
        "\n",
        "for key in subGraph_dictionary:\n",
        "    # Switch the colors of nodes in sampleSubGraph0\n",
        "    if key == 'sampleSubgraph0':\n",
        "        graphColors=[1-int(i) for i in results[key]]\n",
        "    else:\n",
        "        graphColors=[int(i) for i in results[key]]\n",
        "\n",
        "    nodes = sorted(list(nx.nodes(subGraph_dictionary[key])))\n",
        "\n",
        "    for u in sampleGraph.nodes():\n",
        "        if u in nodes:\n",
        "            indexu = nodes.index(u)\n",
        "            if graphColors[indexu] == 0:\n",
        "                sampleGraph.nodes[u]['color']= 0\n",
        "            else:\n",
        "                sampleGraph.nodes[u]['color']= 1\n",
        "\n",
        "cut_edges =[]\n",
        "for u, v in sampleGraph.edges():\n",
        "    if sampleGraph.nodes[u]['color']!= sampleGraph.nodes[v]['color']:\n",
        "        cut_edges+=[(u,v)]\n",
        "# Plot sampleGraph with the colors inherited from the subgraph solutions\n",
        "\n",
        "max_cut_color_map = [gray if sampleGraph.nodes[u]['color']==0 else green for u in sampleGraph]\n",
        "\n",
        "nx.draw_networkx_edges(\n",
        "    sampleGraph,\n",
        "    pos,\n",
        "    edgelist=cut_edges,\n",
        "    width=8,\n",
        "    alpha=0.5,\n",
        "    edge_color=green,\n",
        ")\n",
        "nx.draw(sampleGraph, with_labels=True, pos = pos, node_color=max_cut_color_map)\n",
        "\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "255bcdd8",
      "metadata": {
        "id": "255bcdd8"
      },
      "source": [
        "Hooray!  We have found a max cut of the original graph using our subgraph solutions. It's a different solution from the one that we originally found, but it's just as good!"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b394caa4",
      "metadata": {
        "id": "b394caa4"
      },
      "source": [
        "## Next\n",
        "In the above example, our graph was small enough that we could inspect the subgraph solutions and realize that the subgraph solutions needed to be altered (by flipping the colors of `sampleSubgraph0`) in order to generate an optimal cut of the original `sampleGraph`.  In [Lab 2](2_One-level-divide-and-conquer-QAOA.ipynb), we will investigate non-brute-force methods for stitching together subgraph solutions to optimize the cut of the parent graph."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fb1d074d",
      "metadata": {
        "id": "fb1d074d"
      },
      "outputs": [],
      "source": [
        "import IPython\n",
        "app = IPython.Application.instance()\n",
        "app.kernel.do_shutdown(True)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "include_colab_link": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "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.10.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}