qaoa-for-max-cut/03_Recursive-divide-and-conquer.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "60ef34e8",
      "metadata": {
        "id": "60ef34e8"
      },
      "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": "2f6225e7-58f5-439b-acff-aa13918f6472",
      "metadata": {
        "id": "2f6225e7-58f5-439b-acff-aa13918f6472"
      },
      "source": [
        "# Approximate Max-Cut using a Divide-and-Conquer Implementation of QAOA\n",
        "## Lab 3 Recursive Divide-and-Conquer QAOA\n",
        "## 3.1 Overview"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fdf10e9e-959c-46f1-992b-8a3a56f084dd",
      "metadata": {
        "id": "fdf10e9e-959c-46f1-992b-8a3a56f084dd",
        "jupyter": {
          "source_hidden": true
        },
        "outputId": "bba2b756-1423-4bde-b0db-492385a1fba5"
      },
      "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-3-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": [
        "# Execute this cell to watch an introduction to this lab.\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-3-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": "fd6bc9e4",
      "metadata": {
        "id": "fd6bc9e4"
      },
      "source": [
        "In the [previous lab](2_One-level-divide-and-conquer-QAOA.ipynb), our example graph was small enough that when divided into subgraphs, there were few subgraphs. Furthermore,  each subgraph was sufficiently small that we could apply QAOA to approximate the max cuts of the subgraphs. In this lab, we'll consider much bigger graphs which have large subgraph partitions, both in terms the size of the subgraphs and the number of subgraphs.  When the subgraphs are prohibitively large to find a max cut approximation with QAOA, we'll recursively apply the divide-and-conquer algorithm to those subgraphs.  Also, if the number of subgraphs in a partition is so large that the QAOA application during the merger stage of the algorithm cannot be carried out, we can recursively apply a divide-and-conquer QAOA to the merger graph as well. Finally, we'll demonstrate a parallel implementation of the algorithm and discuss several options for improving its accuracy.\n",
        "\n",
        "### 3.1.1 Outline of the lab\n",
        "\n",
        "This lab is structured similarly to [Labs 1](1_Overview-Max-Cut-with-QAOA.ipynb) and [2](2_One-level-divide-and-conquer-QAOA.ipynb). We will be translating the code developed in Labs 1 and 2 into functions for recursive implementation.\n",
        "\n",
        "* **3.2 Divide**\n",
        "    * Problem definition and classical approximation\n",
        "    * Define a function to carry out the divide stage of the algorithm recursively\n",
        "* **3.3 Conquer**\n",
        "    * Define a function to carry out the conquer stage of the algorithm recursively\n",
        "* **3.4 Merge**\n",
        "    * Define a function to carry out the merger stage of the algorithm recursively\n",
        "    * Combine all the parts together to find the max cut of `sampleGraph3`\n",
        "* **3.5 Enabling Distributed Quantum Computing**\n",
        "    * Run the recursive algorithm in parallel using MPI\n",
        "* **3.6 Further directions for experimentation**\n",
        "    * Summarize several features of the divide-and-conquer QAOA that could be modified for improved performance\n",
        "\n",
        "### 3.1.2 Learning objectives\n",
        "\n",
        "The learning objectives of this tutorial are:\n",
        "* Implement a recursive divide-and-conquer QAOA for Max Cut using CUDA Quantum\n",
        "* Select from different target devices to execute quantum circuits\n",
        "* Adapt the CUDA Quantum code to run in parallel through MPI\n",
        "* Experiment with different layer counts and seeds to recognize the effect of increased layers and initial parameter choices in QAOA\n",
        "* Identify several of the design choices available for implementing QAOA\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b6e8640a",
      "metadata": {
        "id": "b6e8640a"
      },
      "outputs": [],
      "source": [
        "# Instructions for Google Colab. You can ignore this cell if you have cuda-q set up.\n",
        "# Run this portion of the 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"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "644b9c82",
      "metadata": {
        "id": "644b9c82"
      },
      "outputs": [],
      "source": [
        "# Necessary packages\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": "code",
      "execution_count": null,
      "id": "8b48a195",
      "metadata": {
        "id": "8b48a195"
      },
      "outputs": [],
      "source": [
        "# Identifying and setting target\n",
        "targets = cudaq.get_targets()\n",
        "#for target in targets:\n",
        "#    print(target)\n",
        "cudaq.set_target(\"qpp-cpu\")\n",
        "target = cudaq.get_target()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cd09a7fd",
      "metadata": {
        "id": "cd09a7fd"
      },
      "source": [
        "### 3.1.3 Reusable code from Labs 1 and 2\n",
        "\n",
        "The code blocks in this section were copied over from [Labs 1](1_Overview-Max-Cut-with-QAOA.ipynb) and [2](2_One-level-divide-and-conquer-QAOA.ipynb) and will be reused in this lab.  As you execute these cells, take a moment to read through them to recognize their purpose and logic."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d401fbf6",
      "metadata": {
        "id": "d401fbf6"
      },
      "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 += 0.5*(spin.z(qubitu)*spin.z(qubitv)-spin.i(qubitu)*spin.i(qubitv))\n",
        "\n",
        "    return hamiltonian\n",
        "\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)\n",
        "\n",
        "# Mixer Kernel\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",
        "    rx(2.0*beta, qubit_0)\n",
        "\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",
        "    \"\"\"\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])\n",
        "\n",
        "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",
        "    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": "code",
      "execution_count": null,
      "id": "791e3a5e",
      "metadata": {
        "id": "791e3a5e"
      },
      "outputs": [],
      "source": [
        "# These function from Lab 2 are used to identify the subgraph\n",
        "# that contains a given vertex, and identify the vertices of the parent graph\n",
        "# that lie on the border of the subgraphs in the subgraph dictionary\n",
        "\n",
        "def subgraph_of_vertex(graph_dictionary, vertex):\n",
        "    \"\"\"\n",
        "    A function that takes as input a subgraph partition (in the form of a graph dictionary) and a vertex.\n",
        "    The function should return the key associated with the subgraph that contains the given vertex.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    graph_dictionary: dict of networkX.Graph with str as keys\n",
        "    v : int\n",
        "        v is a name for a vertex\n",
        "    Returns\n",
        "    -------\n",
        "    str\n",
        "        the key associated with the subgraph that contains the given vertex.\n",
        "    \"\"\"\n",
        "    # in case a vertex does not appear in the graph_dictionary, return the empty string\n",
        "    location = ''\n",
        "\n",
        "    for key in graph_dictionary:\n",
        "        if vertex in graph_dictionary[key].nodes():\n",
        "            location = key\n",
        "    return location\n",
        "\n",
        "def border(G, subgraph_dictionary):\n",
        "    \"\"\"Build a graph made up of border vertices from the subgraph partition\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G: networkX.Graph\n",
        "        Graph whose max cut we want to find\n",
        "    subgraph_dictionary: dict of networkX graph with str as keys\n",
        "        Each graph in the dictionary should be a subgraph of G\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    networkX.Graph\n",
        "        Subgraph of G made up of only the edges connecting subgraphs in the subgraph dictionary\n",
        "    \"\"\"\n",
        "    borderGraph = nx.Graph()\n",
        "    for u,v in G.edges():\n",
        "        border = True\n",
        "        for key in subgraph_dictionary:\n",
        "            SubG = subgraph_dictionary[key]\n",
        "            edges = list(nx.edges(SubG))\n",
        "            if (u,v) in edges:\n",
        "                border = False\n",
        "        if border==True:\n",
        "            borderGraph.add_edge(u,v)\n",
        "\n",
        "    return borderGraph"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e3d96bc2",
      "metadata": {
        "id": "e3d96bc2"
      },
      "outputs": [],
      "source": [
        "# Returns the cut value of G based on the coloring of the nodes of G\n",
        "\n",
        "def cutvalue(G):\n",
        "    \"\"\"Returns the cut value of G based on the coloring of the nodes of G\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G: networkX.Graph\n",
        "        Graph with binary value colors assigned to the vertices\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    int\n",
        "        cut value of the graph determined by the vertex colors\n",
        "    \"\"\"\n",
        "    cut = 0\n",
        "    for u, v in G.edges():\n",
        "        if G.nodes[u]['color'] != G.nodes[v]['color']:\n",
        "            cut+=1\n",
        "    return cut"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d3721df5",
      "metadata": {
        "id": "d3721df5"
      },
      "source": [
        "## 3.2 Divide\n",
        "### 3.2.1 Defining a larger example graph"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "92a9d25d",
      "metadata": {
        "id": "92a9d25d"
      },
      "source": [
        "In [Lab 2](2_One-level-divide-and-conquer-QAOA.ipynb) we experimented with a graph of 30 vertices. Let's ramp this up and start with a graph of 100 vertices!\n",
        "\n",
        "We'll consider a randomly generated graph with a little more structure than the previous lab. The graph type is called the Newman Watts Strogatz network model. After you've completed the lab with this example, feel free to edit the parameters and uncomment/comment portions of the code below to test out other graphs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8772d4c2",
      "metadata": {
        "id": "8772d4c2",
        "outputId": "cb0e0e7c-d7bd-4661-f89e-a1fc645b618e"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Newman Watts Strogatz network model\n",
        "n = 100 # number of numdes\n",
        "k = 4 # each node joined to k nearest neighbors\n",
        "p =0.8 # probability of adding a new edge\n",
        "seed = 1234\n",
        "sampleGraph3=nx.newman_watts_strogatz_graph(n, k, p, seed=seed)\n",
        "\n",
        "\n",
        "# Random d-regular graphs used in the paper arxiv:2205.11762\n",
        "# d from 3, 9 inclusive\n",
        "# number of vertices from from 60 to 80\n",
        "# taking d=6 and n =100, works well\n",
        "# d = 6\n",
        "# n =100\n",
        "# seed = 1234\n",
        "#sampleGraph3=nx.random_regular_graph(d,n,seed=seed)\n",
        "\n",
        "\n",
        "#random graph from lab 2\n",
        "#n = 30  # number of nodes\n",
        "#m = 70  # number of edges\n",
        "#seed= 20160  # seed random number generators for reproducibility\n",
        "# Use seed for reproducibility\n",
        "#sampleGraph3= nx.gnm_random_graph(n, m, seed=seed)\n",
        "\n",
        "\n",
        "# Plot example graph for which we will be trying to compute the max cut\n",
        "nx.draw(sampleGraph3, with_labels=True)\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d6f5a873",
      "metadata": {
        "id": "d6f5a873"
      },
      "source": [
        "Let's approximate the max cut for this graph classically.  This will take a little longer than the classical approximation of max cut for the smaller graph in [Lab 2](2_One-level-divide-and-conquer-QAOA.ipynb), and as you'll see there is a much larger variation in approximation results."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "744c2f54",
      "metadata": {
        "id": "744c2f54",
        "outputId": "73f062cf-93e4-41b2-f5cf-3ae42a328f1e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "A few runs of the greedy modularity maximization algorithm gives an average approximate Max Cut value of 247.1\n",
            "with approximations ranging from 243 to 253\n"
          ]
        }
      ],
      "source": [
        "number_of_approx =10\n",
        "randomlist = np.random.choice(3000,number_of_approx)\n",
        "\n",
        "\n",
        "minapprox = nx.algorithms.approximation.one_exchange(sampleGraph3, initial_cut=None, seed=int(randomlist[0]))[0]\n",
        "maxapprox = minapprox\n",
        "sum_of_approximations = 0\n",
        "for i in range(number_of_approx):\n",
        "   seed = int(randomlist[i])\n",
        "   ith_approximation = nx.algorithms.approximation.one_exchange(sampleGraph3, initial_cut=None, seed=seed)[0]\n",
        "   if ith_approximation < minapprox:\n",
        "      minapprox = ith_approximation\n",
        "   if ith_approximation > maxapprox:\n",
        "      maxapprox = ith_approximation\n",
        "   sum_of_approximations += nx.algorithms.approximation.one_exchange(sampleGraph3, initial_cut=None, seed=seed)[0]\n",
        "\n",
        "average_approx = sum_of_approximations/number_of_approx\n",
        "\n",
        "print('A few runs of the greedy modularity maximization algorithm gives an average approximate Max Cut value of',average_approx)\n",
        "print('with approximations ranging from',minapprox,'to',maxapprox)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "82cb6fed",
      "metadata": {
        "id": "82cb6fed"
      },
      "source": [
        " The code for the subgraph partitioning from [Lab 2](2_One-level-divide-and-conquer-QAOA.ipynb) is copied below.  We'll need to adapt this code for recursion.  But first, to appreciate the need for a recursive algorithm, let's use this code to partition the `sampleGraph3` graph into smaller subgraphs to get a sense of the scale of the graph."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "14b6034c",
      "metadata": {
        "id": "14b6034c"
      },
      "outputs": [],
      "source": [
        "# Function from Lab 2 to return a dictionary of subgraphs of the input graph\n",
        "# using the greedy modularity maximization algorithm\n",
        "\n",
        "def Lab2SubgraphPartition(G,n):\n",
        "    \"\"\"Divide the graph up into at most n subgraphs\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G: networkX.Graph\n",
        "        Graph that we want to subdivide\n",
        "    n : int\n",
        "        n is the maximum number of subgraphs in the partition\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    dict of str : networkX.Graph\n",
        "        Dictionary of networkX graphs with a string as the key\n",
        "    \"\"\"\n",
        "    # n is the maximum number of subgraphs in the partition\n",
        "    greedy_partition = community.greedy_modularity_communities(G, weight=None, resolution=1.1, cutoff=1, best_n=n)\n",
        "    number_of_subgraphs = len(greedy_partition)\n",
        "\n",
        "    graph_dictionary = {}\n",
        "    graph_names=[]\n",
        "    for i in range(number_of_subgraphs):\n",
        "        name='G'+str(i)\n",
        "        graph_names.append(name)\n",
        "\n",
        "    for i in range(number_of_subgraphs):\n",
        "        nodelist = sorted(list(greedy_partition[i]))\n",
        "        graph_dictionary[graph_names[i]] = nx.subgraph(G, nodelist)\n",
        "\n",
        "    return(graph_dictionary)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f7b2ba2a",
      "metadata": {
        "id": "f7b2ba2a",
        "outputId": "61f43689-ab35-4ac8-8edd-41da08a8bf2c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The parent graph is subdivided into 6 subgraphs.\n",
            "Graph G0 has 22 vertices.\n",
            "Graph G0 has 50 edges.\n",
            "Graph G1 has 19 vertices.\n",
            "Graph G1 has 42 edges.\n",
            "Graph G2 has 18 vertices.\n",
            "Graph G2 has 37 edges.\n",
            "Graph G3 has 17 vertices.\n",
            "Graph G3 has 36 edges.\n",
            "Graph G4 has 13 vertices.\n",
            "Graph G4 has 24 edges.\n",
            "Graph G5 has 11 vertices.\n",
            "Graph G5 has 20 edges.\n"
          ]
        }
      ],
      "source": [
        "num_subgraphs = min(12, sampleGraph3.number_of_nodes()) # maximum number of subgraphs for the partition\n",
        "subgraph_dictionary = Lab2SubgraphPartition(sampleGraph3,num_subgraphs)\n",
        "\n",
        "# Print the subgraphs and their information\n",
        "print('The parent graph is subdivided into',len(subgraph_dictionary),'subgraphs.')\n",
        "for key in subgraph_dictionary:\n",
        "    print('Graph',key,'has',len(nx.nodes(subgraph_dictionary[key])),'vertices.')\n",
        "    print('Graph',key,'has',len\n",
        "          (nx.edges(subgraph_dictionary[key])),'edges.')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4f40dc9c",
      "metadata": {
        "id": "4f40dc9c"
      },
      "source": [
        "The graph `G0` may be too large for a standard implementation of QAOA, especially if many layers of the QAOA kernel are used or if the algorithm is executed on a CPU. Even larger and denser graphs will lead to partitions that are just unmanageable for even the most powerful machines. Therefore, we will recursively call the divide-and-conquer QAOA algorithm to find the max cut solution.  In fact, in the interest of time, we will apply the divide stage of the algorithm to any subgraph that has more than 14 vertices. To keep track of the original graph, its subgraphs, their subgraphs, etc. we will need to edit the subgraph partitioning function from [Lab 2](2_One-level-divide-and-conquer-QAOA.ipynb) and adapt a new subgraph naming scheme. In the new naming scheme, `Global:0` will be the first subgraph in the partitioning of `sampleGraph3`.  If `Global:0` was large and was further subdivided, the the name `Global:0:1` will represent the second subgraph of the subgraph partitioning of `Global:0`. The naming scheme continues to follow this pattern. This new naming scheme is added to the `subgraph_partition` function in the code block below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "348f5f61",
      "metadata": {
        "id": "348f5f61"
      },
      "outputs": [],
      "source": [
        "def subgraphpartition(G,n, name, globalGraph):\n",
        "    # G is a graph to be partitioned\n",
        "\n",
        "    \"\"\"Divide the graph up into at most n subgraphs\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G: networkX.Graph\n",
        "        Graph that we want to subdivide which lives inside of or is equatl to globalGraph\n",
        "    n : int\n",
        "        n is the maximum number of subgraphs in the partition\n",
        "    name : str\n",
        "        prefix for the graphs (in our case we'll use 'Global')\n",
        "    globalGraph: networkX.Graph\n",
        "        original problem graph\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    dict of str : networkX.Graph\n",
        "        Dictionary of networkX graphs with a string as the key\n",
        "    \"\"\"\n",
        "    greedy_partition = community.greedy_modularity_communities(G, weight=None, resolution=1.1, cutoff=1, best_n=n)\n",
        "    number_of_subgraphs = len(greedy_partition)\n",
        "\n",
        "    graph_dictionary = {}\n",
        "    graph_names=[]\n",
        "    for i in range(number_of_subgraphs):\n",
        "        subgraphname=name+':'+str(i)\n",
        "        graph_names.append(subgraphname)\n",
        "\n",
        "    for i in range(number_of_subgraphs):\n",
        "        nodelist = sorted(list(greedy_partition[i]))\n",
        "        graph_dictionary[graph_names[i]] = nx.subgraph(globalGraph, nodelist)\n",
        "\n",
        "    return(graph_dictionary)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f3c884d7",
      "metadata": {
        "id": "f3c884d7"
      },
      "source": [
        "Edit the three `FIX_ME` lines in the code block below to call `subgraphpartition` recursively.  We'll assume that we can handle QAOA instances of 14 qubits.  Therefore any subgraph of more than 14 vertices will get subdivided."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "15e199d5",
      "metadata": {
        "id": "15e199d5"
      },
      "outputs": [],
      "source": [
        "# EXERCISE\n",
        "num_qubits = 14\n",
        "n = 12 # maximum number of subgraphs in a subgraph partitioning\n",
        "def recursive_partition(G,name, global_graph):\n",
        "    \"\"\"Divide the graph up into subgraphs of at most num_qubits vertices recursively\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G: networkX.Graph\n",
        "        Graph that we want to subdivide which is a subgraph of global_graph\n",
        "    name : str\n",
        "        prefix for the graphs (in our case we'll use 'Global')\n",
        "    global_graph : networkX.Graph\n",
        "        parent graph\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    dict of str : networkX.Graph\n",
        "        Dictionary of networkX graphs with a string as the key\n",
        "    \"\"\"\n",
        "    if nx.number_of_nodes(G)<FIX_ME:                             # Edit this line\n",
        "        print('Graph',name,'has',len(nx.nodes(G)),'vertices.')\n",
        "    else:\n",
        "        max_num_subgraphs = min(n, nx.number_of_nodes(G))\n",
        "        new_subgraphs = FIX_ME(G, max_num_subgraphs, name, global_graph)   # Edit this line\n",
        "        for key in new_subgraphs:\n",
        "            FIX_ME(new_subgraphs[key],key, global_graph)        # Edit this line\n",
        "\n",
        "# Apply the partitioning function to the sampleGraph3\n",
        "recursive_partition(sampleGraph3, 'Global', sampleGraph3)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e336921e",
      "metadata": {
        "id": "e336921e",
        "jupyter": {
          "source_hidden": true
        },
        "outputId": "9dc9ef10-0f31-4d7e-912c-8f5ee5f188e4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Graph Global:0:0 has 6 vertices.\n",
            "Graph Global:0:1 has 6 vertices.\n",
            "Graph Global:0:2 has 6 vertices.\n",
            "Graph Global:0:3 has 4 vertices.\n",
            "Graph Global:1:0 has 8 vertices.\n",
            "Graph Global:1:1 has 6 vertices.\n",
            "Graph Global:1:2 has 5 vertices.\n",
            "Graph Global:2:0 has 6 vertices.\n",
            "Graph Global:2:1 has 5 vertices.\n",
            "Graph Global:2:2 has 5 vertices.\n",
            "Graph Global:2:3 has 2 vertices.\n",
            "Graph Global:3:0 has 7 vertices.\n",
            "Graph Global:3:1 has 5 vertices.\n",
            "Graph Global:3:2 has 5 vertices.\n",
            "Graph Global:4 has 13 vertices.\n",
            "Graph Global:5 has 11 vertices.\n"
          ]
        }
      ],
      "source": [
        "# SOLUTION\n",
        "num_qubits = 14\n",
        "n = 12 # maximum number of subgraphs in a subgraph partitioning\n",
        "def recursive_partition(G,name, global_graph):\n",
        "    \"\"\"Divide the graph up into subgraphs of at most num_qubits vertices recursively\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G: networkX.Graph\n",
        "        Graph that we want to subdivide which is a subgraph of global_graph\n",
        "    name : str\n",
        "        prefix for the graphs (in our case we'll use 'Global')\n",
        "    global_graph : networkX.Graph\n",
        "        parent graph\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    dict of str : networkX.Graph\n",
        "        Dictionary of networkX graphs with a string as the key\n",
        "    \"\"\"\n",
        "    if nx.number_of_nodes(G)<num_qubits+1:\n",
        "        print('Graph',name,'has',len(nx.nodes(G)),'vertices.')\n",
        "    else:\n",
        "        max_num_subgraphs = min(n, nx.number_of_nodes(G))\n",
        "        new_subgraphs = subgraphpartition(G, max_num_subgraphs, name, global_graph)\n",
        "        for key in new_subgraphs:\n",
        "            recursive_partition(new_subgraphs[key],key, global_graph)\n",
        "\n",
        "# Apply the partitioning function to the sampleGraph3\n",
        "recursive_partition(sampleGraph3, 'Global', sampleGraph3)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "009e0fe1",
      "metadata": {
        "id": "009e0fe1"
      },
      "source": [
        "## 3.3 Conquer"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "db33d583",
      "metadata": {
        "id": "db33d583"
      },
      "source": [
        "As you experiment with subdividing other graphs, you might notice that the last few subgraphs may only contain 1 vertex and/or no edges.  The max cut for these subgraphs is trivial. It would be wasteful to run the QAOA subroutine on these subgraphs, and a Hamiltonian = 0 will cause problems with the optimizer loop.  Let's edit the QAOA code below to return a random assignment of 0s and 1s for graphs that contain only one vertex and/or no edges.  "
      ]
    },
    {
      "cell_type": "markdown",
      "id": "baaab974",
      "metadata": {
        "id": "baaab974"
      },
      "source": [
        "**Exercise:** Edit the code below to return a random string of 0s and 1s, with the same length as the number of vertices of the graph."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f78595c8",
      "metadata": {
        "id": "f78595c8"
      },
      "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",
        "    ### Edit code below to return a random string of 0s and 1s\n",
        "    ### if G has only one vertex and/or no edges\n",
        "    ### The string should have the same length as the number of\n",
        "    ### vertices of G.\n",
        "    if FIX_ME:\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    ### Edit code above\n",
        "    else:\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(G, 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": "code",
      "execution_count": null,
      "id": "a3cf8a0e",
      "metadata": {
        "id": "a3cf8a0e"
      },
      "outputs": [],
      "source": [
        "# SOLUTION\n",
        "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",
        "    if nx.number_of_nodes(G) ==1 or nx.number_of_edges(G) ==0:\n",
        "        # The first condition implies the second condition so we really don't need\n",
        "        # to consider the case nx.number_of_nodes(G) ==1\n",
        "        results = ''\n",
        "        for u in list(nx.nodes(G)):\n",
        "            np.random.seed(seed)\n",
        "            random_assignment = str(np.random.randint(0, 1))\n",
        "            results+=random_assignment\n",
        "\n",
        "    else:\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(G, 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": "7b021993",
      "metadata": {
        "id": "7b021993"
      },
      "source": [
        "## 3.4 Merge"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f12aea49",
      "metadata": {
        "id": "f12aea49"
      },
      "source": [
        "The functions below are based on code from [Lab 2](2_One-level-divide-and-conquer-QAOA.ipynb) that carry out the merger step of the divide-and-conquer QAOA. As you execute the code blocks, familiarize yourself with the function definitions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "33184229",
      "metadata": {
        "id": "33184229"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Define the mergerGraph for a given border graph and subgraph\n",
        "# partitioning. And color code the vertices\n",
        "# according to the subgraph that the vertex represents\n",
        "def createMergerGraph(border, subgraphs):\n",
        "    \"\"\"Build a graph containing a vertex for each subgraph\n",
        "    and edges between vertices are added if there is an edge between\n",
        "    the corresponding subgraphs\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    border : networkX.Graph\n",
        "        Graph of connections between vertices in distinct subgraphs\n",
        "    subgraphs : dict of networkX graph with str as keys\n",
        "        The nodes of border should be a subset of the the graphs in the subgraphs dictionary\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    networkX.Graph\n",
        "        Merger graph containing a vertex for each subgraph\n",
        "        and edges between vertices are added if there is an edge between\n",
        "        the corresponding subgraphs\n",
        "    \"\"\"\n",
        "    M = nx.Graph()\n",
        "\n",
        "    for u, v in border.edges():\n",
        "        subgraph_id_for_u = subgraph_of_vertex(subgraphs, u)\n",
        "        subgraph_id_for_v = subgraph_of_vertex(subgraphs, v)\n",
        "        if subgraph_id_for_u != subgraph_id_for_v:\n",
        "            M.add_edge(subgraph_id_for_u, subgraph_id_for_v)\n",
        "    return M\n",
        "\n",
        "\n",
        "# Compute the penalties for edges in the supplied mergerGraph\n",
        "# for the subgraph partitioning of graph G\n",
        "def merger_graph_penalties(mergerGraph, subgraph_dictionary, G):\n",
        "    \"\"\"Compute penalties for the edges in the mergerGraph and add them\n",
        "    as edge attributes.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    mergerGraph : networkX.Graph\n",
        "        Graph of connections between vertices in distinct subgraphs of G\n",
        "    subgraph_dictionary : dict of networkX graph with str as keys\n",
        "        subgraphs of G that are represented as nodes in the mergerGraph\n",
        "    G : networkX.Graph\n",
        "        graph whose vertices has an attribute 'color'\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    networkX.Graph\n",
        "        Merger graph containing penalties\n",
        "    \"\"\"\n",
        "    nx.set_edge_attributes(mergerGraph, int(0), 'penalty')\n",
        "    for i, j in mergerGraph.edges():\n",
        "        penalty_ij = 0\n",
        "        for u in nx.nodes(subgraph_dictionary[i]):\n",
        "            for neighbor_u in nx.all_neighbors(G, u):\n",
        "                if neighbor_u in nx.nodes(subgraph_dictionary[j]):\n",
        "                    if G.nodes[u]['color'] != G.nodes[neighbor_u]['color']:\n",
        "                        penalty_ij += 1\n",
        "                    else:\n",
        "                        penalty_ij += -1\n",
        "        mergerGraph[i][j]['penalty'] = penalty_ij\n",
        "    return mergerGraph\n",
        "\n",
        "\n",
        "# Define the Hamiltonian for applying QAOA during the merger stage\n",
        "# The variables s_i are defined so that s_i = 1 means we will not\n",
        "# flip the subgraph Gi's colors and s_i = -1 means we will flip the colors of subgraph G_i\n",
        "def mHamiltonian(merger_edge_src, merger_edge_tgt, penalty):\n",
        "    \"\"\"Hamiltonian for finding the optimal swap schedule for the subgraph partitioning encoded in the merger graph\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    merger_edge_src: List[int]\n",
        "        list of the source vertices of edges of a graph\n",
        "    merger_edge_tgt: List[int]\n",
        "        list of target vertices of edges of a graph\n",
        "    penalty: List[int]\n",
        "        list of penalty terms associated with the edge determined by the source and target vertex of the same index\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    cudaq.SpinOperator\n",
        "        Hamiltonian for finding the optimal swap schedule for the subgraph partitioning encoded in the merger graph\n",
        "    \"\"\"\n",
        "    mergerHamiltonian = 0\n",
        "\n",
        " # Add Hamiltonian terms for edges within a subgraph that contain a border element\n",
        "    for i in range(len(merger_edge_src)):\n",
        "        # Add a term to the Hamiltonian for the edge (u,v)\n",
        "        qubitu = merger_edge_src[i]\n",
        "        qubitv = merger_edge_tgt[i]\n",
        "        mergerHamiltonian+= -penalty[i]*(spin.z(qubitu))*(spin.z(qubitv))\n",
        "    return mergerHamiltonian"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5939ea67",
      "metadata": {
        "id": "5939ea67"
      },
      "outputs": [],
      "source": [
        "# Next we define some functions to keep track of the unaltered cuts\n",
        "# (recorded as unaltered_colors) and the merged cuts (recorded as new_colors).\n",
        "# The new_colors are derived from flipping the colors\n",
        "# of all the nodes in a subgraph based on the flip_colors variable which\n",
        "# captures the solution to the merger QAOA problem.\n",
        "\n",
        "def unaltered_colors(G, graph_dictionary, max_cuts):\n",
        "    \"\"\"Adds colors to each vertex, v, of G based on the color of v in the subgraph containing v which is\n",
        "    read from the max_cuts dictionary\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G : networkX.Graph\n",
        "        Graph with vertex color attributes\n",
        "    subgraph_dictionary : dict of networkX graph with str as keys\n",
        "        subgraphs of G\n",
        "    max_cuts : dict of str\n",
        "        dictionary of node colors for subgraphs in the subgraph_dictionary\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    networkX.Graph, str\n",
        "        returns G with colored nodes\n",
        "    \"\"\"\n",
        "    subgraphColors={}\n",
        "\n",
        "\n",
        "    for key in graph_dictionary:\n",
        "        SubG = graph_dictionary[key]\n",
        "        sorted_subgraph_nodes = sorted(list(nx.nodes(SubG)))\n",
        "        for v in sorted_subgraph_nodes:\n",
        "            G.nodes[v]['color']=max_cuts[key][sorted_subgraph_nodes.index(v)]\n",
        "    # returns the input graph G with a coloring of the nodes based on the unaltered merger\n",
        "    # of the max cut solutions of the subgraphs in the graph_dictionary\n",
        "    return G\n",
        "\n",
        "def new_colors(graph_dictionary, G, mergerGraph, flip_colors):\n",
        "    \"\"\"For each subgraph in the flip_colors list, changes the color of all the vertices in that subgraph\n",
        "    and records this information in the color attribute of G\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    graph_dictionary : dict of networkX graph with str as keys\n",
        "        subgraphs of G\n",
        "    G : networkX.Graph\n",
        "        Graph with vertex color attributes\n",
        "    mergerGraph: networkX.Graph\n",
        "        Graph whose vertices represent subgraphs in the graph_dictionary\n",
        "    flip_colors : dict of str\n",
        "        dictionary of binary strings for subgraphs in the subgraph_dictionary\n",
        "        key:0 indicates the node colors remain fixed in subgraph called key\n",
        "        key:1 indicates the node colors should be flipped in subgraph key\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    networkX.Graph, str\n",
        "        returns G with the revised vertex colors\n",
        "    \"\"\"\n",
        "    flipGraphColors={}\n",
        "    mergerNodes = sorted(list(nx.nodes(mergerGraph)))\n",
        "    for u in mergerNodes:\n",
        "        indexu = mergerNodes.index(u)\n",
        "        flipGraphColors[u]=int(flip_colors[indexu])\n",
        "\n",
        "    for key in graph_dictionary:\n",
        "        if flipGraphColors[key]==1:\n",
        "            for u in graph_dictionary[key].nodes():\n",
        "                G.nodes[u]['color'] = str(1 - int(G.nodes[u]['color']))\n",
        "\n",
        "    revised_colors = ''\n",
        "    for u in sorted(G.nodes()):\n",
        "        revised_colors += str(G.nodes[u]['color'])\n",
        "\n",
        "    return G, revised_colors\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c5b1e576",
      "metadata": {
        "id": "c5b1e576"
      },
      "outputs": [],
      "source": [
        "# A function to carry out QAOA during the merger stage of the\n",
        "# divide-and-conquer QAOA algorithm for graph G, its subgraphs (graph_dictionary)\n",
        "# and merger_graph\n",
        "\n",
        "def merging(G, graph_dictionary, merger_graph):\n",
        "    \"\"\"\n",
        "    Using QAOA, identify which subgraphs should be in the swap schedule (e.g. which subgraphs will require\n",
        "    flipping of the colors when merging the subgraph solutions into a solution of the graph G\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G : networkX.Graph\n",
        "        Graph with vertex color attributes\n",
        "    graph_dictionary : dict of networkX graph with str as keys\n",
        "        subgraphs of G\n",
        "    mergerGraph : networkX.Graph\n",
        "        Graph whose vertices represent subgraphs in the graph_dictionary\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    str\n",
        "        returns string of 0s and 1s indicating which subgraphs should have their colors swapped\n",
        "    \"\"\"\n",
        "\n",
        "    merger_graph_with_penalties = merger_graph_penalties(merger_graph,graph_dictionary, G)\n",
        "    # In the event that the merger penalties are not trivial, run QAOA, else don't flip any graph colors\n",
        "    if (True in (merger_graph_with_penalties[u][v]['penalty'] != 0 for u, v in nx.edges(merger_graph_with_penalties))):\n",
        "\n",
        "        penalty = []\n",
        "        merger_edge_src = []\n",
        "        merger_edge_tgt = []\n",
        "        merger_nodes = sorted(list(merger_graph_with_penalties.nodes()))\n",
        "        for u, v in nx.edges(merger_graph_with_penalties):\n",
        "            # We can use the index() command to read out the qubits associated with the vertex u and v.\n",
        "            merger_edge_src.append(merger_nodes.index(u))\n",
        "            merger_edge_tgt.append(merger_nodes.index(v))\n",
        "            penalty.append(merger_graph_with_penalties[u][v]['penalty'])\n",
        "\n",
        "        merger_Hamiltonian = mHamiltonian(merger_edge_src, merger_edge_tgt, penalty)\n",
        "\n",
        "        # Run QAOA on the merger subgraph to identify which subgraphs\n",
        "        # if any should change colors\n",
        "        layer_count_merger = 2 # set arbitrarily\n",
        "        parameter_count_merger: int = 2 * layer_count_merger\n",
        "        nodes_merger = sorted(list(nx.nodes(merger_graph)))\n",
        "        merger_edge_src = []\n",
        "        merger_edge_tgt = []\n",
        "        for u, v in nx.edges(merger_graph_with_penalties):\n",
        "            # We can use the index() command to read out the qubits associated with the vertex u and v.\n",
        "            merger_edge_src.append(nodes_merger.index(u))\n",
        "            merger_edge_tgt.append(nodes_merger.index(v))\n",
        "        # The number of qubits we'll need is the same as the number of vertices in our graph\n",
        "        qubit_count_merger : int = len(nodes_merger)\n",
        "\n",
        "        # Specify the optimizer and its initial parameters. Make it repeatable.\n",
        "        cudaq.set_random_seed(12345)\n",
        "        optimizer_merger = cudaq.optimizers.COBYLA()\n",
        "        np.random.seed(4321)\n",
        "        optimizer_merger.initial_parameters = np.random.uniform(-np.pi, np.pi,\n",
        "                                                     parameter_count_merger)\n",
        "        optimizer_merger.max_iterations=150\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=merger_Hamiltonian,\n",
        "            argument_mapper=lambda parameter_vector: (qubit_count_merger, layer_count_merger, merger_edge_src, merger_edge_tgt, parameter_vector),\n",
        "            optimizer=optimizer_merger,\n",
        "            parameter_count=parameter_count_merger,\n",
        "            shots = 10000)\n",
        "\n",
        "        # Sample the circuit using the optimized parameters\n",
        "        # Sample enough times to distinguish the most_probable outcome for\n",
        "        # merger graphs with 12 vertices\n",
        "        sample_number=30000\n",
        "        counts = cudaq.sample(kernel_qaoa, qubit_count_merger, layer_count_merger, merger_edge_src, merger_edge_tgt, optimal_parameters, shots_count=10000)\n",
        "        mergerResultsString = str(counts.most_probable())\n",
        "\n",
        "    else:\n",
        "        mergerResultsList = [0]*nx.number_of_nodes(merger_graph)\n",
        "        mergerResultsString = ''.join(str(x) for x in mergerResultsList)\n",
        "        print('Merging stage is trivial')\n",
        "    return mergerResultsString\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b0100411",
      "metadata": {
        "id": "b0100411"
      },
      "source": [
        "In this lab, we have capped our subgraph partitions to only have 11 subgraphs. This means that the merger graphs that we generate are all limited in size. Therefore, few qubits are needed for the QAOA circuits that are created during the `merging` phase of the algorithm. For much larger and denser graphs, we may find partitions that result in dozens of subgraphs whose solutions need to be merged together. For these cases, we can apply another divide-and-conquer protocol at the merger stage of the algorithm. We leave this as an optional bonus exercise."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "db20e2e3",
      "metadata": {
        "id": "db20e2e3"
      },
      "source": [
        "## 3.4 Putting it all together"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "836425bd",
      "metadata": {
        "id": "836425bd"
      },
      "source": [
        "We now have all of the components necessary to define a function `subgraph_solution` that will carry out the divide-and-conquer QAOA recursively."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "573845fe",
      "metadata": {
        "id": "573845fe"
      },
      "source": [
        "**Exercise:** Fill in the `FIX_ME`s with the functions from the list:\n",
        "\n",
        "\n",
        "* `border`\n",
        "* `createMergerGraph`\n",
        "* `merging`\n",
        "* `new_colors`\n",
        "* `qaoa_for_subgraph`\n",
        "* `subgraphpartition`\n",
        "* `subgraph_solution`\n",
        "* `unaltered_colors`\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4bd347bd",
      "metadata": {
        "id": "4bd347bd"
      },
      "outputs": [],
      "source": [
        "# Exercise\n",
        "\n",
        "def subgraph_solution(G, key, vertex_limit, subgraph_limit, layer_count, global_graph,seed ):\n",
        "    \"\"\"\n",
        "    Recursively finds max cut approximations of the subgraphs of the global_graph\n",
        "    Parameters\n",
        "    ----------\n",
        "    G : networkX.Graph\n",
        "        Graph with vertex color attributes\n",
        "    key : str\n",
        "        name of subgraph\n",
        "    vertex_limit : int\n",
        "        maximum size of graph to which QAOA will be applied directly\n",
        "    subgraph_limit : int\n",
        "        maximum size of the merger graphs, or maximum number of subgraphs in any subgraph decomposition\n",
        "    layer_count : int\n",
        "        number of layers in QAOA circuit for finding max cut solutions\n",
        "    global_graph : networkX.Graph\n",
        "        the parent graph\n",
        "    seed : int\n",
        "        random seed for reproducibility\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    str\n",
        "        returns string of 0s and 1s representing colors of vertices of global_graph for the approx max cut solution\n",
        "    \"\"\"\n",
        "    results ={}\n",
        "    seed +=1\n",
        "    # Find the max cut of G using QAOA, provided G is small enough\n",
        "    if nx.number_of_nodes(G)<vertex_limit+1:\n",
        "        print('Working on finding max cut approximations for ',key)\n",
        "\n",
        "        result = FIX_ME(G, seed=seed, shots = 10000, layer_count=layer_count)\n",
        "        results[key]=result\n",
        "        # color the global graph's nodes according to the results\n",
        "        nodes_of_G = sorted(list(G.nodes()))\n",
        "        for u in G.nodes():\n",
        "            global_graph.nodes[u]['color']=results[key][nodes_of_G.index(u)]\n",
        "        return result\n",
        "    else: # Recursively apply the algorithm in case G is too big\n",
        "        # Divide the graph and identify the subgraph dictionary\n",
        "        subgraph_limit =min(subgraph_limit, nx.number_of_nodes(G) )\n",
        "        subgraph_dictionary = FIX_ME(G,subgraph_limit, str(key), global_graph)\n",
        "\n",
        "        # Conquer: solve the subgraph problems recursively\n",
        "        for skey in subgraph_dictionary:\n",
        "            results[skey]=FIX_ME(subgraph_dictionary[skey], skey, vertex_limit, subgraph_limit, \\\n",
        "                                            layer_count, global_graph, seed )\n",
        "\n",
        "        print('Found max cut approximations for ',list(subgraph_dictionary.keys()))\n",
        "\n",
        "\n",
        "        # Color the nodes of G to indicate subgraph max cut solutions\n",
        "        G = FIX_ME(G, subgraph_dictionary, results)\n",
        "        unaltered_cut_value = cutvalue(G)\n",
        "        print('prior to merging, the max cut value of',key,'is', unaltered_cut_value)\n",
        "\n",
        "        # Merge: merge the results from the conquer stage\n",
        "        print('Merging these solutions together for a solution to',key)\n",
        "        # Define the border graph\n",
        "        bordergraph = FIX_ME(G, subgraph_dictionary)\n",
        "        # Define the merger graph\n",
        "        merger_graph = FIX_ME(bordergraph, subgraph_dictionary)\n",
        "\n",
        "        try:\n",
        "            # Apply QAOA to the merger graph\n",
        "            merger_results = FIX_ME(G, subgraph_dictionary, merger_graph)\n",
        "        except:\n",
        "            # In case QAOA for merger graph does not converge, don't flip any of the colors for the merger\n",
        "            mergerResultsList = [0]*nx.number_of_nodes(merger_graph)\n",
        "            merger_results = ''.join(str(x) for x in mergerResultsList)\n",
        "            print('Merging subroutine opted out with an error for', key)\n",
        "\n",
        "        # Color the nodes of G to indicate the merged subgraph solutions\n",
        "        alteredG, new_color_list = FIX_ME(subgraph_dictionary, G, merger_graph, merger_results)\n",
        "        newcut = cutvalue(alteredG)\n",
        "        print('the merger algorithm produced a new coloring of',key,'with cut value,',newcut)\n",
        "\n",
        "        return new_color_list\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "063fb142",
      "metadata": {
        "id": "063fb142",
        "jupyter": {
          "source_hidden": true
        }
      },
      "outputs": [],
      "source": [
        "# Solution\n",
        "\n",
        "def subgraph_solution(G, key, vertex_limit, subgraph_limit, layer_count, global_graph,seed ):\n",
        "    \"\"\"\n",
        "    Recursively finds max cut approximations of the subgraphs of the global_graph\n",
        "    Parameters\n",
        "    ----------\n",
        "    G : networkX.Graph\n",
        "        Graph with vertex color attributes\n",
        "    key : str\n",
        "        name of subgraph\n",
        "    vertex_limit : int\n",
        "        maximum size of graph to which QAOA will be applied directly\n",
        "    subgraph_limit : int\n",
        "        maximum size of the merger graphs, or maximum number of subgraphs in any subgraph decomposition\n",
        "    layer_count : int\n",
        "        number of layers in QAOA circuit for finding max cut solutions\n",
        "    global_graph : networkX.Graph\n",
        "        the parent graph\n",
        "    seed : int\n",
        "        random seed for reproducibility\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    str\n",
        "        returns string of 0s and 1s representing colors of vertices of global_graph for the approx max cut solution\n",
        "    \"\"\"\n",
        "    results ={}\n",
        "    seed +=1\n",
        "    # Find the max cut of G using QAOA, provided G is small enough\n",
        "    if nx.number_of_nodes(G)<vertex_limit+1:\n",
        "        print('Working on finding max cut approximations for ',key)\n",
        "\n",
        "        result =qaoa_for_graph(G, seed=seed, shots = 10000, layer_count=layer_count)\n",
        "        results[key]=result\n",
        "        # color the global graph's nodes according to the results\n",
        "        nodes_of_G = sorted(list(G.nodes()))\n",
        "        for u in G.nodes():\n",
        "            global_graph.nodes[u]['color']=results[key][nodes_of_G.index(u)]\n",
        "        return result\n",
        "    else: # Recursively apply the algorithm in case G is too big\n",
        "        # Divide the graph and identify the subgraph dictionary\n",
        "        subgraph_limit =min(subgraph_limit, nx.number_of_nodes(G) )\n",
        "        subgraph_dictionary = subgraphpartition(G,subgraph_limit, str(key), global_graph)\n",
        "\n",
        "        # Conquer: solve the subgraph problems recursively\n",
        "        for skey in subgraph_dictionary:\n",
        "            results[skey]=subgraph_solution(subgraph_dictionary[skey], skey, vertex_limit, subgraph_limit, \\\n",
        "                                            layer_count, global_graph, seed )\n",
        "\n",
        "        print('Found max cut approximations for ',list(subgraph_dictionary.keys()))\n",
        "\n",
        "\n",
        "        # Color the nodes of G to indicate subgraph max cut solutions\n",
        "        G = unaltered_colors(G, subgraph_dictionary, results)\n",
        "        unaltered_cut_value = cutvalue(G)\n",
        "        print('prior to merging, the max cut value of',key,'is', unaltered_cut_value)\n",
        "\n",
        "        # Merge: merge the results from the conquer stage\n",
        "        print('Merging these solutions together for a solution to',key)\n",
        "        # Define the border graph\n",
        "        bordergraph = border(G, subgraph_dictionary)\n",
        "        # Define the merger graph\n",
        "        merger_graph = createMergerGraph(bordergraph, subgraph_dictionary)\n",
        "\n",
        "        try:\n",
        "            # Apply QAOA to the merger graph\n",
        "            merger_results = merging(G, subgraph_dictionary, merger_graph)\n",
        "        except:\n",
        "            # In case QAOA for merger graph does not converge, don't flip any of the colors for the merger\n",
        "            mergerResultsList = [0]*nx.number_of_nodes(merger_graph)\n",
        "            merger_results = ''.join(str(x) for x in mergerResultsList)\n",
        "            print('Merging subroutine opted out with an error for', key)\n",
        "\n",
        "        # Color the nodes of G to indicate the merged subgraph solutions\n",
        "        alteredG, new_color_list = new_colors(subgraph_dictionary, G, merger_graph, merger_results)\n",
        "        newcut = cutvalue(alteredG)\n",
        "        print('the merger algorithm produced a new coloring of',key,'with cut value,',newcut)\n",
        "\n",
        "        return new_color_list\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e7efdcf5",
      "metadata": {
        "id": "e7efdcf5"
      },
      "source": [
        "Now let's run the recursive algorithm on a `sampleGraph3`.  Execute the cell below to run the algorithm sequentially.  This might be a good time to stand up and stretch or grab a cup of coffee.  It may take a few minutes for the program to run on one GPU sequentially. We'll explore how to parallelize this routine in the next section."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bb7818fa",
      "metadata": {
        "id": "bb7818fa",
        "outputId": "affd48ed-cf6a-469b-fea8-a7d6baf2e02d",
        "scrolled": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Working on finding max cut approximations for  Global:0:0\n",
            "Optimal parameters =  [-2.85564571541018, -0.32425349445141555]\n",
            "most_probable outcome =  110010\n",
            "Working on finding max cut approximations for  Global:0:1\n",
            "Optimal parameters =  [-2.884267580068141, -0.3057534524232721]\n",
            "most_probable outcome =  000110\n",
            "Working on finding max cut approximations for  Global:0:2\n",
            "Optimal parameters =  [-1.3026899772514002, -1.8887376045196276]\n",
            "most_probable outcome =  000101\n",
            "Working on finding max cut approximations for  Global:0:3\n",
            "Optimal parameters =  [-1.8163052146581165, -1.8535167728107051]\n",
            "most_probable outcome =  1001\n",
            "Found max cut approximations for  ['Global:0:0', 'Global:0:1', 'Global:0:2', 'Global:0:3']\n",
            "prior to merging, the max cut value of Global:0 is 32\n",
            "Merging these solutions together for a solution to Global:0\n",
            "the merger algorithm produced a new coloring of Global:0 with cut value, 35\n",
            "Working on finding max cut approximations for  Global:1:0\n",
            "Optimal parameters =  [-2.8939498395065444, -1.9028472245843802]\n",
            "most_probable outcome =  11001100\n",
            "Working on finding max cut approximations for  Global:1:1\n",
            "Optimal parameters =  [-1.2215335482902332, -0.34131790681046387]\n",
            "most_probable outcome =  110001\n",
            "Working on finding max cut approximations for  Global:1:2\n",
            "Optimal parameters =  [-1.1716080872424532, -0.554269374020866]\n",
            "most_probable outcome =  00111\n",
            "Found max cut approximations for  ['Global:1:0', 'Global:1:1', 'Global:1:2']\n",
            "prior to merging, the max cut value of Global:1 is 24\n",
            "Merging these solutions together for a solution to Global:1\n",
            "the merger algorithm produced a new coloring of Global:1 with cut value, 25\n",
            "Working on finding max cut approximations for  Global:2:0\n",
            "Optimal parameters =  [-1.22240232970507, -0.5054596678086096]\n",
            "most_probable outcome =  101101\n",
            "Working on finding max cut approximations for  Global:2:1\n",
            "Optimal parameters =  [-2.842662655757869, -0.32411767854900536]\n",
            "most_probable outcome =  10010\n",
            "Working on finding max cut approximations for  Global:2:2\n",
            "Optimal parameters =  [-1.1717092620228822, -0.553873162475442]\n",
            "most_probable outcome =  10001\n",
            "Working on finding max cut approximations for  Global:2:3\n",
            "Optimal parameters =  [-2.35459340394073, -0.3927161865946948]\n",
            "most_probable outcome =  10\n",
            "Found max cut approximations for  ['Global:2:0', 'Global:2:1', 'Global:2:2', 'Global:2:3']\n",
            "prior to merging, the max cut value of Global:2 is 25\n",
            "Merging these solutions together for a solution to Global:2\n",
            "the merger algorithm produced a new coloring of Global:2 with cut value, 25\n",
            "Working on finding max cut approximations for  Global:3:0\n",
            "Optimal parameters =  [-1.2593120786558587, -0.4266978545930792]\n",
            "most_probable outcome =  1001101\n",
            "Working on finding max cut approximations for  Global:3:1\n",
            "Optimal parameters =  [-1.1712013980959695, -0.5534027659107387]\n",
            "most_probable outcome =  10001\n",
            "Working on finding max cut approximations for  Global:3:2\n",
            "Optimal parameters =  [-1.1717092620228822, -0.553873162475442]\n",
            "most_probable outcome =  10001\n",
            "Found max cut approximations for  ['Global:3:0', 'Global:3:1', 'Global:3:2']\n",
            "prior to merging, the max cut value of Global:3 is 23\n",
            "Merging these solutions together for a solution to Global:3\n",
            "the merger algorithm produced a new coloring of Global:3 with cut value, 23\n",
            "Working on finding max cut approximations for  Global:4:0\n",
            "Optimal parameters =  [-1.324868262631158, -0.41606979573387115]\n",
            "most_probable outcome =  00110\n",
            "Working on finding max cut approximations for  Global:4:1\n",
            "Optimal parameters =  [-1.0270264384926249, -0.6802641237160026]\n",
            "most_probable outcome =  0110\n",
            "Working on finding max cut approximations for  Global:4:2\n",
            "Optimal parameters =  [-1.0267092775977966, -0.6804732418169003]\n",
            "most_probable outcome =  0110\n",
            "Found max cut approximations for  ['Global:4:0', 'Global:4:1', 'Global:4:2']\n",
            "prior to merging, the max cut value of Global:4 is 17\n",
            "Merging these solutions together for a solution to Global:4\n",
            "the merger algorithm produced a new coloring of Global:4 with cut value, 17\n",
            "Working on finding max cut approximations for  Global:5\n",
            "Optimal parameters =  [1.3549622231274008, -1.9689184971582998]\n",
            "most_probable outcome =  11100111101\n",
            "Found max cut approximations for  ['Global:0', 'Global:1', 'Global:2', 'Global:3', 'Global:4', 'Global:5']\n",
            "prior to merging, the max cut value of Global is 214\n",
            "Merging these solutions together for a solution to Global\n",
            "the merger algorithm produced a new coloring of Global with cut value, 214\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "'1110010001110011111101101101000110010111100110011001111001011000011000110011010110011011100110011010'"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "num_subgraphs=11 # limits the size of the merger graphs\n",
        "num_qubits = 14 # max number of qubits allowed in a quantum circuit\n",
        "layer_count =1 # Layer count for the QAOA max cut\n",
        "seed = 101\n",
        "\n",
        "subgraph_solution(sampleGraph3, 'Global', num_subgraphs, num_qubits, layer_count, sampleGraph3, seed)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cf3ad518",
      "metadata": {
        "id": "cf3ad518"
      },
      "source": [
        "This solution isn't as good as the classical approximations. In the remaining sections of this notebook, we'll suggest a few ways to improve the results."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2c16d534",
      "metadata": {
        "id": "2c16d534"
      },
      "source": [
        "##  3.5 Enabling Distributed Quantum Computing\n",
        "\n",
        "There are many opportunities for parallelization of quantum circuits. In this section we'll run the QAOA kernels for each subgraph simultaneously on multiple GPU processes, and this can easily be adapted to run on multiple QPUs in the future."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7740c6d8-01ad-4083-b5a5-1289d82e69bc",
      "metadata": {
        "id": "7740c6d8-01ad-4083-b5a5-1289d82e69bc",
        "jupyter": {
          "source_hidden": true
        },
        "outputId": "618811f4-c7db-474a-c938-3a8953226728"
      },
      "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-3-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 presentation about how to implement the recursive Divide-and-Conquer QAOA in parallel.\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-3-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": "5f184113",
      "metadata": {
        "id": "5f184113"
      },
      "source": [
        "**Important** Before proceeding, you will need to switch to a runtime with access to a GPU.  If you do restart your kernel, make sure to reload the packages below.  If you are running on Google Colab and switch to a GPU runtime, you'll need to reinstall CUDA-Q by commenting out the indicated code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7dbdc16b",
      "metadata": {
        "id": "7dbdc16b"
      },
      "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 lines below and execute the cell to install cuda-q\n",
        "# !wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb\n",
        "# !dpkg -i cuda-keyring_1.1-1_all.deb\n",
        "# !apt-get update\n",
        "# !apt-get -y install libcublas-11-8 libcusolver-11-8 cuda-cudart-11-8\n",
        "# %pip install cuda-quantum"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "862c47a7",
      "metadata": {
        "id": "862c47a7"
      },
      "outputs": [],
      "source": [
        "#@title Execute this cell to reload the necessary packages\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\n",
        "import sys"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e03558f6",
      "metadata": {},
      "outputs": [],
      "source": [
        "#@title Execute this cell to install mpi4py if necessary\n",
        "%pip install mpi4py"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ca3015e1",
      "metadata": {
        "id": "ca3015e1"
      },
      "source": [
        "\n",
        "\n",
        "The max cut problem for the `sampleGraph3` took some time to solve sequentially.  Like we did in [Lab 2](2_One-level-divide-and-conquer-QAOA.ipynb), we can create a python script to run the recursive algorithm in parallel. One option is to distribute the top-level of the recursion (e.g. solutions to `Global:0`, `Global:1`, ...`Global:n`) to the GPU processes, and then merge those results back together on GPU process 0.  We've created the script for this and saved it as Example-03.py. If you have not yet already done so, download [Example-03.py](https://github.com/NVIDIA/cuda-q-academic/blob/main/qaoa-for-max-cut/Example-03.py) and save it in your working directory.   Execute the cell below to find a max cut approximation of `sampleGraph3` using 4 GPU processes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ba5acf6e",
      "metadata": {
        "id": "ba5acf6e",
        "outputId": "532e619f-c365-435b-d2a2-256b21c149d6",
        "scrolled": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Subgraph problems to be computed on each processor have been assigned\n",
            "Processor 1 received {'Global:1': <networkx.classes.graph.Graph object at 0x7f90c3d39540>, 'Global:5': <networkx.classes.graph.Graph object at 0x7f8fb8720a30>} from processor 0\n",
            "Processor 2 received {'Global:2': <networkx.classes.graph.Graph object at 0x7fa913091540>} from processor 0\n",
            "Processor 3 received {'Global:3': <networkx.classes.graph.Graph object at 0x7faee05b9570>} from processor 0\n",
            "Working on finding max cut approximations for  Global:2:0\n",
            "Working on finding max cut approximations for  Global:3:0\n",
            "Working on finding max cut approximations for  Global:0:0\n",
            "Working on finding max cut approximations for  Global:1:0\n",
            "Optimal parameters =  [0.28617781045515917, -1.8949633330759343]\n",
            "most_probable outcome =  001101\n",
            "Working on finding max cut approximations for  Global:0:1\n",
            "Optimal parameters =  [1.310617651748266, -1.94050078740244]\n",
            "most_probable outcome =  00011110\n",
            "Working on finding max cut approximations for  Global:1:1\n",
            "Optimal parameters =  [1.9190508499831969, -0.5046110785077547]\n",
            "most_probable outcome =  101101\n",
            "Working on finding max cut approximations for  Global:2:1\n",
            "Optimal parameters =  [1.882915989837707, -0.42786103817980325]\n",
            "most_probable outcome =  0100110\n",
            "Working on finding max cut approximations for  Global:3:1\n",
            "Optimal parameters =  [1.9203680591937724, -0.34211194527215666]\n",
            "most_probable outcome =  110001\n",
            "Working on finding max cut approximations for  Global:1:2\n",
            "Optimal parameters =  [1.3035619406571815, -1.9720212325938513]\n",
            "most_probable outcome =  000111\n",
            "Working on finding max cut approximations for  Global:0:2\n",
            "Optimal parameters =  [1.2608939608364766, -1.935500715815723]\n",
            "most_probable outcome =  01101\n",
            "Working on finding max cut approximations for  Global:2:2\n",
            "Optimal parameters =  [1.9702986735089674, -0.5548136222467029]\n",
            "most_probable outcome =  10001\n",
            "Working on finding max cut approximations for  Global:3:2\n",
            "Optimal parameters =  [1.970654403972823, -0.5541114306617723]\n",
            "most_probable outcome =  11000\n",
            "Found max cut approximations for  ['Global:1:0', 'Global:1:1', 'Global:1:2']\n",
            "prior to merging, the max cut value of Global:1 is 21\n",
            "Merging these solutions together for a solution to Global:1\n",
            "Optimal parameters =  [1.970290031394797, -0.5534578150493502]\n",
            "most_probable outcome =  10001\n",
            "Working on finding max cut approximations for  Global:2:3\n",
            "Optimal parameters =  [1.970290031394797, -0.5534578150493502]\n",
            "most_probable outcome =  10001\n",
            "Found max cut approximations for  ['Global:3:0', 'Global:3:1', 'Global:3:2']\n",
            "prior to merging, the max cut value of Global:3 is 24\n",
            "Merging these solutions together for a solution to Global:3\n",
            "Optimal parameters =  [1.8389263049839577, -0.3182218562405519]\n",
            "most_probable outcome =  000101\n",
            "Working on finding max cut approximations for  Global:0:3\n",
            "Optimal parameters =  [0.7856194864736818, -1.9635088789904906]\n",
            "most_probable outcome =  01\n",
            "Found max cut approximations for  ['Global:2:0', 'Global:2:1', 'Global:2:2', 'Global:2:3']\n",
            "prior to merging, the max cut value of Global:2 is 22\n",
            "Merging these solutions together for a solution to Global:2\n",
            "Optimal parameters =  [1.816909229111494, -2.8593549211114877]\n",
            "most_probable outcome =  0101\n",
            "Found max cut approximations for  ['Global:0:0', 'Global:0:1', 'Global:0:2', 'Global:0:3']\n",
            "prior to merging, the max cut value of Global:0 is 32\n",
            "Merging these solutions together for a solution to Global:0\n",
            "the merger algorithm produced a new coloring of Global:1 with cut value, 22\n",
            "Working on finding max cut approximations for  Global:5\n",
            "the merger algorithm produced a new coloring of Global:3 with cut value, 24\n",
            "{'Global:3': '10001100010100110'} sent by processor 3\n",
            "Optimal parameters =  [0.2576803165407968, -1.9077229378551241]\n",
            "most_probable outcome =  10010010110\n",
            "{'Global:1': '0101000100111100111', 'Global:5': '10010010110'} sent by processor 1\n",
            "the merger algorithm produced a new coloring of Global:2 with cut value, 25\n",
            "{'Global:2': '101101101000110010'} sent by processor 2\n",
            "the merger algorithm produced a new coloring of Global:0 with cut value, 32\n",
            "Working on finding max cut approximations for  Global:4:0\n",
            "Optimal parameters =  [1.8173369280949347, -0.41457199891407154]\n",
            "most_probable outcome =  00110\n",
            "Working on finding max cut approximations for  Global:4:1\n",
            "Optimal parameters =  [2.115106664328783, -0.6806979284584729]\n",
            "most_probable outcome =  0110\n",
            "Working on finding max cut approximations for  Global:4:2\n",
            "Optimal parameters =  [2.1149974546329067, -0.680480704615675]\n",
            "most_probable outcome =  0110\n",
            "Found max cut approximations for  ['Global:4:0', 'Global:4:1', 'Global:4:2']\n",
            "prior to merging, the max cut value of Global:4 is 17\n",
            "Merging these solutions together for a solution to Global:4\n",
            "the merger algorithm produced a new coloring of Global:4 with cut value, 17\n",
            "Received {'Global:1': '0101000100111100111', 'Global:5': '10010010110'} from processor 1\n",
            "Received {'Global:2': '101101101000110010'} from processor 2\n",
            "Received {'Global:3': '10001100010100110'} from processor 3\n",
            "The results dictionary on GPU 0 = {'Global:0': '0000110010101001110101', 'Global:4': '0011001100110', 'Global:1': '0101000100111100111', 'Global:5': '10010010110', 'Global:2': '101101101000110010', 'Global:3': '10001100010100110'}\n",
            "The divide-and-conquer QAOA unaltered cut approximation of the graph, prior to the final merge, is  200\n",
            "The divide-and-conquer QAOA max cut approximation of the graph is  246\n",
            "This compares to a few runs of the greedy modularity maximization algorithm gives an average approximate Max Cut value of 250.1\n",
            "with approximations ranging from 245 to 254\n"
          ]
        }
      ],
      "source": [
        "# MPI call\n",
        "print(sys.executable)\n",
        "python_path = sys.executable\n",
        "!mpiexec -np 4 --oversubscribe --allow-run-as-root {python_path} Example-03.py"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "906425d0",
      "metadata": {
        "id": "906425d0"
      },
      "source": [
        "Notice how much more quickly the solution was found compared to the sequential implementation.  With this speed up, let's try to find even better approximations.  Try editing the `layer_count` for the QAOA max cut solution of the small graphs. You can find this on  `line 502: layer_count =1 # Layer count for the QAOA max cut` of the [Example-03.py](Example-03.py) file. Also, try out different seed values (`line 647: seed = 13 # Edit this seed for new initial parameters among other seed-dependent elements`). See how much our results change!  \n",
        "\n",
        "Feel free to experiment with different sample graphs (`lines 706-730`) by commenting the code and changing the number of vertices and other graph variables.\n",
        "\n",
        "Can you think of alternative methods of parallelizing the tasks in the divide-and-conquer QAOA?"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9be026cb",
      "metadata": {
        "id": "9be026cb"
      },
      "source": [
        "## 3.6 Further Directions for Experimentation\n",
        "\n",
        "There were many aspects of the QAOA algorithm that we held constant throughout this series of labs.  These include the choice of the graph partitioning routine, the initial superposition state in the QAOA kernel, the number of layers in the QAOA kernels, the initial parameters used in the optimization loop, and the optimizer selected for the optimization loop. In addition to making changes to these features, the QAOA kernel could be swapped out for an alternative variational ansatz, and the parallelization protocol could be optimized for the given problem.\n",
        "\n",
        "* **Graph partitioning:** The graph partitioning can drastically affect the results of the algorithm.  There are many ways to subdivide a graph, and we encourage you to explore other possibilities. For example, the Louvain algorithm was used by [Yue et al.](https://arxiv.org/abs/2310.05062) and by [Guerreschi](https://arxiv.org/abs/2101.07813) for quantum divide-and-conquer approaches to the Max Cut problem. [Angel Rodriquez-Fernandez et al.](https://www.mdpi.com/2079-3197/8/3/75) analyzed five other clustering algorithms to improve the Goemans-Williamson classical approximation for Max-Cut, and these clustering algorithms could be experimented with here.\n",
        "\n",
        "* **Initial state:** In [Lab 1](1_Overview-Max-Cut-with-QAOA.ipynb), we initiated the QAOA kernel in an equal superposition state to represent all possible colorings of the vertices.  However, if we had some information about the structure of the graph, for instance an approximate solution from a classical relaxation of the problems, we could \"warm start\" the circuit with this information as in [Egger et al.](https://quantum-journal.org/papers/q-2021-06-17-479/) and [Tate et al.](https://quantum-journal.org/papers/q-2023-09-26-1121/). For this to work, the mixer Hamiltonian would also need to be adjusted.\n",
        "\n",
        "* **Layer count:** We've already begun to experiment with the layer count. It is known that as the number of layers increase to infinity, the QAOA max cut approximations approach the max cut value of the graph ([Farhi and Goldstone](https://arxiv.org/pdf/1411.4028.pdf)).\n",
        "\n",
        "* **Initial parameters:** As we saw in this lab, by varying the seed for generating the random initial parameters, we obtained quite different results.  Recent work points to several protocols for selecting better performing initial parameters (see for instance the work of [Sureshbabu et al.](https://arxiv.org/abs/2305.15201)).\n",
        "\n",
        "* **Optimizer:** Throughout this series of labs we defaulted to the COBYLA optimizer for the optimizer loop in the  algorithm.  There are several other non-gradient and gradient-based optimizers available in CUDA-Q for you to try, and you can use your favorite sci.py optimizer as well.  See the full list of built-in CUDA-Q optimizers [here](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#cudaq.optimizers.optimizer).\n",
        "\n",
        "* **QAOA kernel:** We used a standard QAOA kernel throughout this tutorial. There are several adaptations that could be made to the QAOA kernel. For example, one could replace the QAOA kernel with a similarly structured [multi-angle QAOA kernel](https://www.nature.com/articles/s41598-022-10555-8). The difference between the QAOA kernel and the multi-angle QAOA kernel is that instead of each layer having distinct parameters for the problem and the mixer kernels, each parameterized rotational gate would have its own distinct parameter. Furthermore, other completely different variational circuit structures could replace the QAOA kernel in our algorithm. [Lee et al.](https://arxiv.org/abs/2105.01114) compared several options and concluded that noncommunativity and entanglement in the variational kernel were important for improving algorithm performance.\n",
        "\n",
        "* **Parallelization:** Finally, our choice of how to distribute the subgraph problems onto the GPU was quite arbitrary, and some GPU processes sat idle while others were finishing their tasks.  By first analyzing the subgraph partition, we might find a better distribution of tasks to the GPU to avoid down time.  Also, our parallelization protocol used one GPU to simulate multiple QPUs.  It is possible to assign multiple GPUs to simulate one QPU, which would be necessary for larger circuits.  To learn more about this option, check out the documentation on [the `remote-mqpu` platform](https://nvidia.github.io/cuda-quantum/0.6.0/using/cudaq/platform.html#remote-mqpu-platform).  Additionally, CUDA Quantum offers an `execution()` option for `observe` and asynchronous primitives `sample_async` and `observe_async`. You can read more about these functions [here](https://nvidia.github.io/cuda-quantum/0.6.0/examples/python/tutorials/multi_gpu_workflows.html).\n",
        "  "
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a148ef90",
      "metadata": {
        "id": "a148ef90"
      },
      "source": [
        "## Next\n",
        "Congratulations on solving max cut problems with the divide-and-conquer QAOA!  It's now time to see if you can apply what you have learned to a weighted graph in the [next notebook](4_Weighted-max-cut.ipynb).  Good luck!\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "01a63e35",
      "metadata": {
        "id": "01a63e35",
        "outputId": "3a9dad63-e5b1-44b6-ebfc-9165ee0dd0cc"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'status': 'ok', 'restart': True}"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import IPython\n",
        "app = IPython.Application.instance()\n",
        "app.kernel.do_shutdown(True)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1e090881",
      "metadata": {
        "id": "1e090881"
      },
      "source": [
        "![](https://github.com/NVIDIA/cuda-q-academic/blob/main/qaoa-for-max-cut/images/nvidia-logo.png?raw=1)"
      ]
    }
  ],
  "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
}