intel-qs/notebooks/qaoa_example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "# Example using the extra features for QAOA circuits\n",
    "----\n",
    "\n",
    "The Quantum Approximate Optimization Algorithm (QAOA) is a variational algorithm to solve combinatorial problems.\n",
    "Here we provide the syntax to quickly define and simulate QAOA circuits.\n",
    "\n",
    "As a concrete example, we consider the MaxCut problem on a linear graph of 6 vertices. It is trivially solved analytically, but the numerical procedure extends to more complicated instances.\n",
    "\n",
    "**NOTE:**\n",
    "Currently, the Python implementation only allows for single-core execution and does not take advantages of the MPI protocol."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Intel QS library\n",
    "\n",
    "We start by importing the Python library with the class and methods defined in the C++ implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the Python library with the C++ class and methods of Intel Quantum Simulator.\n",
    "# If the library is not contained in the same folder of this notebook, its path has to be added.\n",
    "import sys\n",
    "sys.path.insert(0, '../build/lib')\n",
    "import intelqs_py as simulator\n",
    "\n",
    "# Import NumPy library with Intel specialization.\n",
    "import numpy as np\n",
    "\n",
    "# Import graphical library for plots.\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize the Max-Cut problem instance via its adjacency matrix\n",
    "\n",
    "Specific instance:\n",
    "0 -- 1 -- 2 -- 3 -- 4 -- 5\n",
    "\n",
    "We describe the instance by its adjacency matrix $A$, represented as a bidimensional NumPy array.\n",
    "\n",
    "Each of the $2^6$ bipartitions of the 6 vertices is associated with a cut value (the number of edges connecting vertices of different color)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The adjacency matrix of the graph is:\n",
      "\n",
      "[[0 1 0 0 0 0]\n",
      " [1 0 1 0 0 0]\n",
      " [0 1 0 1 0 0]\n",
      " [0 0 1 0 1 0]\n",
      " [0 0 0 1 0 1]\n",
      " [0 0 0 0 1 0]]\n",
      "\n",
      "The max value of the cut is :  5\n"
     ]
    }
   ],
   "source": [
    "# Number of vertices.\n",
    "num_vertices = 6;\n",
    "# Adjacency matrix.\n",
    "A = np.zeros((num_vertices,num_vertices),dtype=np.int32);\n",
    "# Since A is sparse, fill it element by element.\n",
    "A[0,1] = 1;\n",
    "A[1,0] = 1;\n",
    "A[1,2] = 1;\n",
    "A[2,1] = 1;\n",
    "A[2,3] = 1;\n",
    "A[3,2] = 1;\n",
    "A[3,4] = 1;\n",
    "A[4,3] = 1;\n",
    "A[4,5] = 1;\n",
    "A[5,4] = 1;\n",
    "print(\"The adjacency matrix of the graph is:\\n\")\n",
    "print(A)\n",
    "#print(list(A.flatten()))\n",
    "\n",
    "# Allocate memory for the diagonal of the objective function.\n",
    "diag_cuts = simulator.QubitRegister(num_vertices, \"base\", 0, 0);\n",
    "max_cut = simulator.InitializeVectorAsMaxCutCostFunction( diag_cuts, list(A.flatten()) );\n",
    "\n",
    "print(\"\\nThe max value of the cut is : {0:2d}\".format(max_cut))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implement a p=2 QAOA circuit\n",
    "----\n",
    "\n",
    "- initialize the state in $|000000\\rangle$\n",
    "- prepare the state in $|++++++\\rangle$\n",
    "- iterate throught the QAOA steps (here p=2)\n",
    "- each step is composed by the global operation defined by the cost function C and the transverse field mixing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of qubits.\n",
    "num_qubits = num_vertices;\n",
    "# Allocate memory for the quantum register's state and initialize it to |000000>.\n",
    "psi = simulator.QubitRegister(num_qubits, \"base\", 0, 0);\n",
    "\n",
    "# Prepare state |++++++>\n",
    "for qubit in range(num_qubits):\n",
    "    psi.ApplyHadamard(qubit);\n",
    "\n",
    "# QAOA circuit:\n",
    "qaoa_depth = 2;\n",
    "# Random choice of QAOA parameters.\n",
    "np.random.seed(7777);\n",
    "gamma = np.random.random_sample((qaoa_depth,))*3.14159;\n",
    "beta  = np.random.random_sample((qaoa_depth,))*3.14159;\n",
    "\n",
    "for p in range(qaoa_depth):\n",
    "    # exp(-i gamma C)\n",
    "    simulator.ImplementQaoaLayerBasedOnCostFunction(psi, diag_cuts, gamma[p]);\n",
    "    # exp(-i beta  B)\n",
    "    for qubit in range(num_qubits):\n",
    "        psi.ApplyRotationX(qubit,beta[p]);\n",
    "\n",
    "# At this point |psi> corresponds to the state at the end of the QAOA circuit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collect the results and visualize them in a histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The probabilities of the cut values are:\n",
      "cut= 0 :  0.0397\n",
      "cut= 1 :  0.1778\n",
      "cut= 2 :  0.3483\n",
      "cut= 3 :  0.2986\n",
      "cut= 4 :  0.1120\n",
      "cut= 5 :  0.0236\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The form of the histogram has been discussed privately.\n",
    "histo = simulator.GetHistogramFromCostFunction(psi, diag_cuts, max_cut);\n",
    "print(\"The probabilities of the cut values are:\")\n",
    "for c in range(max_cut+1):\n",
    "    print(\"cut={0:2d} :  {1:1.4f}\".format(c,histo[c]))\n",
    "\n",
    "# Plot histogram.\n",
    "x = np.arange(max_cut+1)\n",
    "fig = plt.bar(x, histo, align='center', alpha=0.5)\n",
    "#plt.xticks(x)\n",
    "plt.xlabel('cut value')\n",
    "plt.ylabel('probability of cut')\n",
    "#plt.title('Summary of results')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple test\n",
    "\n",
    "This instance represents a disconnected graph with only two edges, namely:\n",
    "0 -- 1    2    3   4 -- 5\n",
    "\n",
    "We describe the instance by its adjacency matrix $A$, represented as a bidimensional NumPy array.\n",
    "\n",
    "Each of the $2^6$ bipartitions of the 6 vertices is associated with a cut value (the number of edges connecting vertices of different color). For Half of the bipartitions the 0--1 edge can be cut and for half of the bipartitions, independently of the previous consideration, the 5--6 edge can be cut. The histogram has three bins (cut values = {0,1,2}) and ratio 1:2:1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.2499999999999999, 0.4999999999999999, 0.2499999999999999]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Number of vertices.\n",
    "num_vertices = 6;\n",
    "# Adjacency matrix.\n",
    "A = np.zeros((num_vertices,num_vertices),dtype=np.int32);\n",
    "# Since A is sparse, fill it element by element.\n",
    "A[0,1] = 1;\n",
    "A[1,0] = 1;\n",
    "A[num_vertices-2,num_vertices-1] = 1;\n",
    "A[num_vertices-1,num_vertices-2] = 1;\n",
    "\n",
    "# Allocate memory for the diagonal of the objective function.\n",
    "diag_cuts = simulator.QubitRegister(num_vertices, \"base\", 0, 0);\n",
    "max_cut = simulator.InitializeVectorAsMaxCutCostFunction( diag_cuts, list(A.flatten()) );\n",
    "\n",
    "# Number of qubits.\n",
    "num_qubits = num_vertices;\n",
    "# Allocate memory for the quantum register's state and initialize it to |000000>.\n",
    "psi = simulator.QubitRegister(num_qubits, \"base\", 0, 0);\n",
    "\n",
    "# Prepare state |++++++>\n",
    "for qubit in range(num_qubits):\n",
    "    psi.ApplyHadamard(qubit);\n",
    "\n",
    "# The form of the histogram has been discussed privately.\n",
    "histo = simulator.GetHistogramFromCostFunction(psi, diag_cuts, max_cut);\n",
    "print(histo)\n",
    "\n",
    "# Plot histogram.\n",
    "x = np.arange(max_cut+1)\n",
    "fig = plt.bar(x, histo, align='center', alpha=0.5)\n",
    "#plt.xticks(x)\n",
    "plt.xlabel('cut value')\n",
    "plt.ylabel('probability of cut')\n",
    "#plt.title('Summary of results')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "## END\n",
    "----"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}