intel-qs/docs/source/qaoa_example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example using the extra features for QAOA circuits\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",
    "from numpy import random_intel\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": {},
     "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": {},
     "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}