Dynex_Grover_Search.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "85c5ecda-b216-4d8e-928c-d3e4ea55fe91",
   "metadata": {},
   "source": [
    "# Dynex Grover Search Example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6afc03ae-3d35-4384-9b68-e367942be174",
   "metadata": {},
   "source": [
    "Grover's search algorithm is a quantum algorithm designed to search an unsorted database or solve unstructured search problems with quadratic speedup compared to classical algorithms. In classical computing, finding a specific item in an unsorted list of N items requires O(N) time in the worst case. Grover's algorithm, however, can accomplish this task in O(√N) time. The algorithm operates by initializing a superposition of all possible states and then iteratively amplifying the probability amplitude of the correct solution while diminishing the amplitudes of the incorrect ones. This process is achieved through the application of two main operations: the Oracle, which marks the correct solution, and the Diffusion operator, which amplifies the marked state's probability. After approximately √N iterations, measuring the quantum state yields the correct solution with high probability. Grover's algorithm exemplifies the power of quantum computing to solve specific problems more efficiently than classical counterparts, making it a cornerstone of quantum search techniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e586cb11-bae8-4d82-82c0-9e14255c0afe",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import dynex\n",
    "import random\n",
    "from tqdm import tqdm\n",
    "from dwave.samplers import SimulatedAnnealingSampler\n",
    "from dimod import BinaryQuadraticModel, SampleSet\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4c31a18-441e-401c-9d3c-354fe042b298",
   "metadata": {},
   "source": [
    "## Function to create a quantum circuit with all variables in superposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c19fc252-6dd0-4960-804a-99ea052b9acf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_qubo(matrix_size):\n",
    "    '''\n",
    "    Function to create a quantum circuit with all variables in superposition\n",
    "    '''\n",
    "    # Initialize a QUBO matrix with zeros\n",
    "    size = matrix_size\n",
    "    qubo = np.zeros((size, size))\n",
    "    \n",
    "    # Construct a QUBO matrix with multiple low-energy solutions\n",
    "    for i in range(size):\n",
    "        qubo[i, i] = -1  # Encourages x_i to be 1\n",
    "    \n",
    "    # Add off-diagonal elements to create interactions between different variables\n",
    "    # Ensuring multiple solutions can be done by having multiple possible pairs or sets that minimize the energy\n",
    "    for i in range(size):\n",
    "        for j in range(i+1, size):\n",
    "            qubo[i, j] = 1.0 / (matrix_size-1) * 2 # off-diagonal interactions\n",
    "\n",
    "    # Symmetrize the matrix to ensure QUBO properties\n",
    "    qubo = (qubo + qubo.T) / 2\n",
    "    \n",
    "    return qubo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7356166a-c64a-4d0f-998e-e5938fd3d123",
   "metadata": {},
   "source": [
    "This function creates and initiates a quantum circuit with all variables in superposition, spinning between -1.0 and +1.0 volt. To validate the function, we run this circuit multiple times and measure the variable voltages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8db0b955-f5ba-42d3-a55e-cd238593994e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1004. 1013. 1021. 1013. 1014. 1025. 1012.  956.  991.  988. 1027. 1005.\n",
      " 1005.  989.  981.  979. 1004.  980.  987.  994.  979. 1012. 1031.  995.\n",
      " 1013. 1002.  967.  989. 1006. 1007. 1005. 1006.] shots: 2000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Define our parameters:\n",
    "qubits = 32;\n",
    "shots = 2000;\n",
    "\n",
    "# Create the quantum circuit:\n",
    "Q = initialize_qubo(qubits)\n",
    "bqm = BinaryQuadraticModel.from_qubo(Q)\n",
    "\n",
    "# Run the circuit and measure results:\n",
    "solver = SimulatedAnnealingSampler()\n",
    "sampleset = solver.sample(bqm, num_reads=shots, annealing_time=1000)\n",
    "res = np.zeros(qubits)\n",
    "cnt = 0;\n",
    "for s in sampleset.record:\n",
    "    for i in range(0, len(s.sample)):\n",
    "        if s[0][i]==1:\n",
    "            res[i]+=1\n",
    "    cnt += 1;\n",
    "\n",
    "plt.title('Number of positive spins ('+str(cnt)+' shots)');\n",
    "plt.bar(list(sampleset.first.sample), res, alpha=0.2);\n",
    "plt.axhline(y=cnt/2, color='b', linestyle='--');\n",
    "\n",
    "print(res, 'shots:',cnt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2f23e0-c2fb-43ac-a904-3826f6944e63",
   "metadata": {},
   "source": [
    "We can observe that the number of positive spins correctly averages at 50% of the number of shots."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e96bec1-105d-4470-a405-286cc4653747",
   "metadata": {},
   "source": [
    "## Grover Oracle"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d7230dd-e99b-4acc-a345-a412dc9bd14a",
   "metadata": {},
   "source": [
    "The Grover Oracle is a crucial component of Grover's search algorithm, responsible for marking the correct solution among the possible candidates in a quantum search problem. It is a quantum subroutine designed to flip the sign of the amplitude of the correct solution's quantum state, effectively distinguishing it from all other states. The Oracle achieves this by utilizing a black-box function, often represented as 𝑂(𝑥), which outputs 1 for the target solution and 0 for all other inputs. This phase inversion is essential for the iterative amplification process in Grover's algorithm, as it sets the stage for the subsequent Diffusion operator to increase the probability of measuring the correct solution. By precisely marking the target state, the Grover Oracle enables the algorithm to converge towards the correct solution with quadratic speedup, highlighting its fundamental role in the efficiency of quantum search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "59b4e548-a599-4583-ac96-f6a039358f17",
   "metadata": {},
   "outputs": [],
   "source": [
    "def grover_oracle(target_index, num_elements):\n",
    "    '''\n",
    "    Grover Oracle black box function which marks the correct solution among the possible candidates\n",
    "    in a quantum search problem\n",
    "    '''\n",
    "    # Initialise all qubits in superposition:\n",
    "    Q = initialize_qubo(num_elements);\n",
    "    # O(x) function outputs 1 for the target solution and 0 for all other inputs:\n",
    "    for q in range(0,num_elements):\n",
    "        Q[q,q] = 2.0\n",
    "    # Flip sign for target index:\n",
    "    Q[(target_index, target_index)] = -2.0\n",
    "    return Q"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b3912d8-9daa-4b73-88c9-6cec36b792ad",
   "metadata": {},
   "source": [
    "## Diffusion Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "566ea1ea-ef7f-4535-8620-3d1ef67efae1",
   "metadata": {},
   "source": [
    "The Diffusion Operator, also known as the Grover Diffusion Operator or the Inversion about the Mean, is a key component in Grover's search algorithm that amplifies the probability amplitude of the correct solution. After the Oracle marks the correct state by flipping its amplitude, the Diffusion Operator performs an inversion about the average amplitude of all states. This process enhances the marked state's amplitude while reducing the amplitudes of the incorrect states, effectively concentrating the probability distribution towards the correct solution. Mathematically, it involves reflecting the quantum state vector through the uniform superposition state. By repeatedly applying the Oracle and the Diffusion Operator, Grover's algorithm iteratively increases the likelihood of measuring the correct solution. The Diffusion Operator is thus vital in the quadratic speedup achieved by the algorithm, enabling it to solve search problems more efficiently than classical methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d2b250bf-010e-4084-8c55-0eb20ad06528",
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialise_diffusion_operator(num_bits):\n",
    "    '''\n",
    "    Initialises the Diffusion operator which amplifies the probability amplitude of the correct solution\n",
    "    '''\n",
    "    Q = {}\n",
    "    for i in range(2**num_bits):\n",
    "        Q[(i, i)] = 1\n",
    "    return Q"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7c8b309-0604-419e-b753-65ca7706a712",
   "metadata": {},
   "source": [
    "## Grover Quantum Search on Dynex"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e06c8ac0-7130-44dc-9656-6adcb3793f7d",
   "metadata": {},
   "source": [
    "We will apply Grover's search algorithm to find an element in a unstructured dataset as defined as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "38ca51af-dc8a-4f94-b8e5-da58b1538e7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the dataset and target value\n",
    "dataset = [12, 5, 7, 14, 6, 11, 9, 10, 13, 2, 3, 8, 4, 15, 0, 1, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]\n",
    "target_value = 15"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71a17ff6-a534-48b3-934c-7d6099759df0",
   "metadata": {},
   "source": [
    "Next we convert the dataset to binary format (if needed) and find the target index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1d30c63e-425d-477e-83fa-274cbf612dbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_elements: 32 num_bits: 5 target_index: 13\n"
     ]
    }
   ],
   "source": [
    "# Convert the dataset to a binary format if needed and find the target index\n",
    "num_elements = len(dataset)\n",
    "num_bits = int(np.ceil(np.log2(num_elements)))\n",
    "target_index = dataset.index(target_value)\n",
    "print('num_elements:',num_elements,'num_bits:',num_bits,'target_index:',target_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d10d688-50d7-4319-a5d3-c90af5f7ad27",
   "metadata": {},
   "source": [
    "We construct and initialise our Grover quantum circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3d742e46-7ebb-49e9-a4af-e4a51b18e9e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Oracle\n",
    "oracle_qubo = grover_oracle(target_index, num_elements)\n",
    "oracle_bqm = BinaryQuadraticModel.from_qubo(oracle_qubo)\n",
    "\n",
    "# Create Diffusion QUBO\n",
    "diffusion_qubo = initialise_diffusion_operator(num_bits)\n",
    "diffusion_bqm = BinaryQuadraticModel.from_qubo(diffusion_qubo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fa2aa93-5652-4f10-88c6-75485b6793b2",
   "metadata": {},
   "source": [
    "The following function performs a Grover iteration by querying the oracle and applying the diffusion operator to the output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "63158279-4a15-4276-b4a5-e26f46ed4029",
   "metadata": {},
   "outputs": [],
   "source": [
    "def grover_iteration(oracle_bqm, diffusion_bqm):\n",
    "    '''\n",
    "    Grover iteration step querying the oracle and applying the diffusion operator. Each step requires two calls to \n",
    "    the Dynex platform\n",
    "    '''\n",
    "    # Apply the oracle\n",
    "    sampleset_oracle = dynex.sample(oracle_bqm, mainnet=False, num_reads=1000, annealing_time = 1000, logging=False)\n",
    "    best_sample = sampleset_oracle.first.sample\n",
    "\n",
    "    # Update the diffusion operator to reflect the oracle's output\n",
    "    for v in diffusion_bqm.variables:\n",
    "        diffusion_bqm.add_linear(v, -2 * best_sample[v])\n",
    "   \n",
    "    # Apply the diffusion operator\n",
    "    sampleset_diffusion = dynex.sample(diffusion_bqm, mainnet=False, num_reads=1000, annealing_time = 1000, logging=False)\n",
    "    \n",
    "    return sampleset_diffusion, diffusion_bqm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "180ce81e-f6e3-4626-99b8-6266fc2389ce",
   "metadata": {},
   "source": [
    "And finally perform Grover's algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "37337897-111c-4c0e-b86a-5b6a938de4ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_iterations (max SQRT of elements): 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:24<00:00,  6.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best sample:  {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 1, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0}\n",
      "Best index:  13\n",
      "Dataset value at best index:  15 target was 15\n",
      "Energy:  -29.0\n",
      "SUCCESS. GROVER SEARCH FOUND THE TARGET VALUE IN 4 ITERATIONS\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Perform Grover's algorithm iterations\n",
    "num_iterations = int(np.pi / 4 * np.sqrt(num_elements))\n",
    "print('num_iterations (max SQRT of elements):',num_iterations)\n",
    "for _ in tqdm(range(num_iterations)):\n",
    "    sampleset, diffusion_bqm = grover_iteration(oracle_bqm, diffusion_bqm)\n",
    "\n",
    "# Output the result\n",
    "best_sample = sampleset.first.sample\n",
    "\n",
    "# Convert the binary sample to an index\n",
    "best_index = list(best_sample.values()).index(1);\n",
    "\n",
    "print(\"Best sample: \", best_sample)\n",
    "print(\"Best index: \", best_index)\n",
    "print(\"Dataset value at best index: \", dataset[best_index], 'target was',target_value)\n",
    "print(\"Energy: \", sampleset.first.energy)\n",
    "\n",
    "if dataset[best_index]==target_value:\n",
    "    print('SUCCESS. GROVER SEARCH FOUND THE TARGET VALUE IN',num_iterations,'ITERATIONS');"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56f7c037-b1f4-43d7-8630-6efb3d031381",
   "metadata": {},
   "source": [
    "We can visualise the qubit voltages at the end of the Grover iterations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "5b10a25f-4849-495f-a1f4-e45fce27fbb0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Qubit voltages after '+str(num_iterations)+' Grover iterations');\n",
    "plt.bar(list(best_sample), list(best_sample.values()), alpha=0.2);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7748486f-913d-4950-878d-4b6483ebd526",
   "metadata": {},
   "source": [
    "The Dynex Grover Search algorithm demonstrated remarkable efficiency by finding the solution in a database of 32 elements in just 4 iterations. This performance aligns perfectly with the expected quadratic speedup of Grover's algorithm, which theoretically requires 𝑂(𝑁) iterations, where \n",
    "𝑁 is the number of elements. In this case, 32 approximates to 4, illustrating that the Dynex implementation achieved optimal performance. This is significantly faster than traditional linear search methods, which would typically require up to 32 iterations to find the target element in the worst case. The successful application of the Dynex Grover Search algorithm not only validates the theoretical speedup of quantum search algorithms but also underscores the potential of quantum computing to outperform classical approaches in solving complex search problems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0aba1f7-7fa0-4a4e-8fc8-d3e9765c79f5",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}