Multi-Variable Grover's Algorithm Example .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "06d878e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pennylane in /opt/conda/lib/python3.9/site-packages (0.27.0)\n",
      "Requirement already satisfied: semantic-version>=2.7 in /opt/conda/lib/python3.9/site-packages (from pennylane) (2.10.0)\n",
      "Requirement already satisfied: numpy in /opt/conda/lib/python3.9/site-packages (from pennylane) (1.21.6)\n",
      "Requirement already satisfied: cachetools in /opt/conda/lib/python3.9/site-packages (from pennylane) (5.0.0)\n",
      "Requirement already satisfied: scipy in /opt/conda/lib/python3.9/site-packages (from pennylane) (1.8.0)\n",
      "Requirement already satisfied: autoray>=0.3.1 in /opt/conda/lib/python3.9/site-packages (from pennylane) (0.5.3)\n",
      "Requirement already satisfied: toml in /opt/conda/lib/python3.9/site-packages (from pennylane) (0.10.2)\n",
      "Requirement already satisfied: networkx in /opt/conda/lib/python3.9/site-packages (from pennylane) (2.8)\n",
      "Requirement already satisfied: appdirs in /opt/conda/lib/python3.9/site-packages (from pennylane) (1.4.4)\n",
      "Requirement already satisfied: autograd in /opt/conda/lib/python3.9/site-packages (from pennylane) (1.5)\n",
      "Requirement already satisfied: pennylane-lightning>=0.27 in /opt/conda/lib/python3.9/site-packages (from pennylane) (0.27.0)\n",
      "Requirement already satisfied: retworkx in /opt/conda/lib/python3.9/site-packages (from pennylane) (0.12.1)\n",
      "Requirement already satisfied: requests in /opt/conda/lib/python3.9/site-packages (from pennylane) (2.27.1)\n",
      "Requirement already satisfied: ninja in /opt/conda/lib/python3.9/site-packages (from pennylane-lightning>=0.27->pennylane) (1.11.1)\n",
      "Requirement already satisfied: future>=0.15.2 in /opt/conda/lib/python3.9/site-packages (from autograd->pennylane) (0.18.2)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.9/site-packages (from requests->pennylane) (3.3)\n",
      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/conda/lib/python3.9/site-packages (from requests->pennylane) (1.26.9)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.9/site-packages (from requests->pennylane) (2021.10.8)\n",
      "Requirement already satisfied: charset-normalizer~=2.0.0 in /opt/conda/lib/python3.9/site-packages (from requests->pennylane) (2.0.12)\n",
      "Requirement already satisfied: rustworkx==0.12.1 in /opt/conda/lib/python3.9/site-packages (from retworkx->pennylane) (0.12.1)\n"
     ]
    }
   ],
   "source": [
    "!pip install pennylane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f062e8d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import itertools\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a632abb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[39, 55, 21, 12, 82, 63, 5, 87, 10, 65]\n",
      "[1. 0. 1. 1. 1. 0. 0. 0. 0. 1.]\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": [
    "\n",
    "# use some python libaries to solve this problem in a conventional computing method:\n",
    "def conventional_search(count1, values_arr):\n",
    "    total = np.sum(values_arr)\n",
    "    sz = len(values_arr)\n",
    "    \n",
    "    for ele in itertools.combinations(values_arr,sz//2):\n",
    "        count1+=1\n",
    "        if sum(ele)==total//2:\n",
    "            #print(\"Took \"+str(count1)+\" Iterations\")\n",
    "            return ele, count1\n",
    "    return np.zeros(sz//2),-1\n",
    "        \n",
    "def convert_res(count1, size):\n",
    "    \n",
    "    np_values_arr = np.random.randint(1,101,size)\n",
    "    values_arr = np_values_arr.tolist()\n",
    "    print(values_arr)\n",
    "\n",
    "    results_arr = np.zeros(len(values_arr))\n",
    "    if conventional_search(count1, values_arr)[1]>-1:\n",
    "        for ele in conventional_search(count1, values_arr)[0]:\n",
    "            results_arr[values_arr.index(ele)]=1\n",
    "        return results_arr\n",
    "\n",
    "count1=0\n",
    "size = 10\n",
    "values = convert_res(count1,size)\n",
    "plt.bar(range(len(values)), values)\n",
    "print(values)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c9b5d117",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 21, 70, 83, 66, 54, 76, 2, 55, 31]\n",
      "[1. 0. 0. 1. 0. 1. 0. 0. 1. 1.]\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": [
    "count1=0\n",
    "size = 10\n",
    "values = convert_res(count1,size)\n",
    "plt.bar(range(len(values)), values)\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "af42a995",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "69.8269"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test the average number of iterations\n",
    "def find_average(n):\n",
    "    avg_arr = []\n",
    "    count = 0\n",
    "    while count < n:\n",
    "        size = 10\n",
    "        np_property_prices = np.random.randint(1,101,size)\n",
    "        property_prices = np_property_prices.tolist()\n",
    "        \n",
    "        if conventional_search(count1,property_prices)[1] >-1:\n",
    "            avg_arr.append(conventional_search(count1,property_prices)[1])\n",
    "            #print(conventional_search(count1,property_prices))\n",
    "            count+=1\n",
    "        \n",
    "    return np.average(avg_arr)\n",
    "\n",
    "find_average(10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cc31e50",
   "metadata": {},
   "source": [
    "we can see an average about 70 iteration for an array of size 10. Note that this is also for a randomly generated array from with values 1 to 100. We can call this our N, representing the amount of iterations needed on average for a linear searching algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3de2465b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[51, 54, 14, 17, 26, 4, 34, 18, 61, 42]\n",
      "[0 1 0 0 1 1 0 0 0 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 10 artists>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "size = 10\n",
    "np_values_arr = np.random.randint(1,101,size)\n",
    "values_arr = np_values_arr.tolist()\n",
    "count=0\n",
    "wires_set = list(range(len(values_arr)))\n",
    "aux_wires = list(range(len(values_arr),2*len(values_arr)))\n",
    "\n",
    "# this is the function for the oracle operator\n",
    "# it will flip the sign of the operator that meets the conditions\n",
    "def oracle(wires_set, aux_oracle_wires):\n",
    "    \n",
    "    # function for the quantum Fourier transform\n",
    "    def fourier_K(k, wires):\n",
    "        for j in range(len(wires)):\n",
    "            # use the RZ gets on all wires with a value of k*pi/2^j\n",
    "            qml.RZ(k * np.pi / (2**j), wires=wires[j])\n",
    "        \n",
    "    # function that applies the Quantum Fourier transform to the second set of wires\n",
    "    def aux_function():\n",
    "        qml.QFT(wires = aux_oracle_wires)\n",
    "        # loop through the wires\n",
    "        for wire in wires_set:\n",
    "            # create a controlled version of the circuit provided\n",
    "            qml.ctrl(fourier_K, control = wire)(values_arr[wire], wires = aux_oracle_wires)\n",
    "            \n",
    "        qml.adjoint(qml.QFT)(wires = aux_oracle_wires) # apply the adjoint operator the aux wires\n",
    "        \n",
    "    aux_function() # call function\n",
    "    qml.FlipSign(sum(values_arr) // 2, wires = aux_oracle_wires) # this is where we define the solution to flip\n",
    "\n",
    "    qml.adjoint(aux_function)() # apply the adjoint on the aux circuit\n",
    "\n",
    "# define the q circuit device\n",
    "dev = qml.device('default.qubit', wires = wires_set +aux_wires, shots = 1)\n",
    "\n",
    "# function that implements grover's algorithm on a Quantum circuit\n",
    "@qml.qnode(dev)\n",
    "def circuit():\n",
    "    # apply the Hadamard to the circuit\n",
    "    for wire in wires_set:\n",
    "        qml.Hadamard(wires = wire)\n",
    "       \n",
    "    # call the custom oracle function\n",
    "    oracle(wires_set, aux_wires)\n",
    "    \n",
    "    # apply the grover operator on the wires\n",
    "    qml.GroverOperator(wires = wires_set)\n",
    "    \n",
    "    # return the positive states in the circuit\n",
    "    return qml.sample(wires = wires_set)\n",
    "\n",
    "\n",
    "values = circuit()\n",
    "print(values_arr)\n",
    "print(values)\n",
    "plt.bar(range(len(values)), values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8c3e88d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "[88, 88, 25, 19, 96, 77, 70, 85, 60, 39]\n",
      "[0 0 0 0 1 1 1 0 1 1]\n",
      "10\n",
      "10\n",
      "[62, 66, 39, 86, 13, 97, 51, 13, 75, 64]\n",
      "[1 0 1 1 0 1 0 1 0 0]\n",
      "10\n",
      "10\n",
      "[19, 3, 83, 9, 57, 28, 21, 10, 58, 74]\n",
      "[1 0 1 1 0 1 1 1 1 1]\n",
      "10\n",
      "10\n",
      "[85, 29, 45, 46, 35, 75, 2, 82, 67, 72]\n",
      "[0 1 1 1 0 0 1 0 0 1]\n",
      "10\n",
      "10\n",
      "[55, 44, 92, 13, 45, 36, 78, 98, 27, 99]\n",
      "[1 0 0 1 0 0 0 0 0 1]\n"
     ]
    }
   ],
   "source": [
    "def test_Grovers(size,count):\n",
    "    np_values_arr = np.random.randint(1,101,size)\n",
    "    values_arr = np_values_arr.tolist()\n",
    "\n",
    "    wires_set = list(range(len(values_arr)))\n",
    "    aux_wires = list(range(len(values_arr),2*len(values_arr)))\n",
    "\n",
    "    # this is the function for the oracle operator\n",
    "    # it will flip the sign of the operator that meets the conditions\n",
    "    def oracle(wires_set, aux_oracle_wires, count):\n",
    "\n",
    "        # function for the quantum Fourier transform\n",
    "        def fourier_K(count, k, wires):\n",
    "            for j in range(len(wires)):\n",
    "                # use the RZ gets on all wires with a value of k*pi/2^j\n",
    "                qml.RZ(k * np.pi / (2**j), wires=wires[j])\n",
    "                count+=1\n",
    "            \n",
    "            \n",
    "        # function that applies the Quantum Fourier transform to the second set of wires\n",
    "        def aux_function(count):\n",
    "            qml.QFT(wires = aux_oracle_wires)\n",
    "            # loop through the wires\n",
    "            for wire in wires_set:\n",
    "                # create a controlled version of the circuit provided\n",
    "                qml.ctrl(fourier_K, control = wire)(count,values_arr[wire], wires = aux_oracle_wires)\n",
    "                count+=1\n",
    "            print(count)\n",
    "            qml.adjoint(qml.QFT)(wires = aux_oracle_wires) # apply the adjoint operator the aux wires\n",
    "\n",
    "        aux_function(count) # call function\n",
    "        qml.FlipSign(sum(values_arr) // 2, wires = aux_oracle_wires) # this is where we define the solution to flip\n",
    "\n",
    "        qml.adjoint(aux_function)(count) # apply the adjoint on the aux circuit\n",
    "\n",
    "    # define the q circuit device\n",
    "    dev = qml.device('default.qubit', wires = wires_set +aux_wires, shots = 1) # note that shots =1 allows parsing of flipped states\n",
    "\n",
    "    # function that implements grover's algorithm on a Quantum circuit\n",
    "    @qml.qnode(dev)\n",
    "    def circuit():\n",
    "        # apply the Hadamard to the circuit\n",
    "        for wire in wires_set:\n",
    "            qml.Hadamard(wires = wire)\n",
    "\n",
    "        # call the custom oracle function\n",
    "        oracle(wires_set, aux_wires,count)\n",
    "\n",
    "        # apply the grover operator on the wires\n",
    "        qml.GroverOperator(wires = wires_set)\n",
    "\n",
    "        # return the positive states in the circuit\n",
    "        return qml.sample(wires = wires_set)\n",
    "\n",
    "\n",
    "\n",
    "    values = circuit()\n",
    "    print(values_arr)\n",
    "    print(values)\n",
    "    #plt.bar(range(len(values)), values)\n",
    "    #print(count)\n",
    "\n",
    "\n",
    "\n",
    "for _ in range(5):\n",
    "    test_Grovers(10,0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba20524",
   "metadata": {},
   "source": [
    "We can see that regardless of the values in the array sent to the quantum algorithm for an array of size 10 the circuit will take 10 *2 iterations or 20 iterations to return the desired states. This is exactly what was expected. The Linear search on average needed about 70 iteration, which was based on the combinations of the array."
   ]
  }
 ],
 "metadata": {
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}