{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "3a271506", "metadata": {}, "source": [ "# 2-mode Grover's search algorithm" ] }, { "attachments": {}, "cell_type": "markdown", "id": "34fa32af", "metadata": {}, "source": [ "We implement in this notebook a 2-mode optical realization of Grover's search algorithm, based on Kwiat et al. (2000). Grover’s search algorithm: An optical approach. [Journal of Modern Optics](https://doi.org/10.1080/09500340008244040), 47(2–3), 257–266." ] }, { "attachments": {}, "cell_type": "markdown", "id": "e22c5dde", "metadata": {}, "source": [ "## Introduction" ] }, { "attachments": {}, "cell_type": "markdown", "id": "c04c528f", "metadata": {}, "source": [ "### Motivation\n", "\n", "Searching for a specific item (called the marked item) in an unstructured list of $N$ items requires $O(N)$ accesses to the list classically. Grover showed in 1996 that is possible for a quantum computer to achieve this using only $O\\left(\\sqrt{N}\\right)$ iterations." ] }, { "attachments": {}, "cell_type": "markdown", "id": "08145e4a", "metadata": {}, "source": [ "### Algorithm summary\n", "\n", "For a list of size $N$, Grover's algorithm requires $\\log (N)$ qubits. The algorithm starts by setting each qubit in the superposition state $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)$. Then it applies $O\\left(\\sqrt{N}\\right)$ iterations of a subroutine called inversion-about-mean, whose goal is to skew this initial uniform superposition state towards the desired marked state such the probability of measuring the marked state is amplified. This subroutine requires the application of an oracle unitary, which applies a relative $\\pi$ phase shift only to the quantum state encoding the item we are looking for in the database." ] }, { "attachments": {}, "cell_type": "markdown", "id": "5690fa9d", "metadata": {}, "source": [ "### Kwiat et al. implementation details\n", "\n", "The optical implementation of Kwiat et al. uses the polarization and path degree of freedom of a single beam to achieve a 2-qubit optical implementation of Grover's search algorithm. Although $N=4$ here, calculations show that only a single application of the inversion-about-mean subroutine is required.\n", "\n", "In an effort to reduce the number of optical components used in the experimental setup, the authors work with a compiled version of the circuit, which we will reproduce here using Perceval." ] }, { "attachments": {}, "cell_type": "markdown", "id": "7bc2f8dc", "metadata": {}, "source": [ "## Perceval implementation" ] }, { "attachments": {}, "cell_type": "markdown", "id": "904f535e", "metadata": {}, "source": [ "### Initialisation" ] }, { "cell_type": "code", "execution_count": 1, "id": "4d4c8ff1", "metadata": {}, "outputs": [], "source": [ "import math\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "import perceval as pcvl\n", "from perceval.algorithm import Analyzer" ] }, { "attachments": {}, "cell_type": "markdown", "id": "09fa856a", "metadata": {}, "source": [ "We create in Perceval a circuit with two spatial modes, $a$ and $b$ denoting resapectively the lower and upper spatial modes. For clarity, the different equivalent encodings for each of the four basis states are given below in order:\n", "- marked item encoding: $\\left|\"00\"\\right\\rangle$, $\\left|\"01\"\\right\\rangle$, $\\left|\"10\"\\right\\rangle$, $\\left|\"11\"\\right\\rangle$\n", "- Kwiat et al. path and polarization encoding: $\\left|aH\\right\\rangle$, $\\left|aV\\right\\rangle$, $\\left|bH\\right\\rangle$, $\\left|bV\\right\\rangle$\n", "- Perceval path and polarization encoding: $\\left|0, 1:H\\right\\rangle$, $\\left|0, 1:V\\right\\rangle$, $\\left|1:H, 0\\right\\rangle$, $\\left|1:V, 0\\right\\rangle$\n", "\n", "We first define these states and their mode equivalent in Perceval:" ] }, { "cell_type": "code", "execution_count": 2, "id": "b8084f08", "metadata": {}, "outputs": [], "source": [ "states = [pcvl.BasicState(\"|0,{P:H}>\"),\n", " pcvl.BasicState(\"|0,{P:V}>\"),\n", " pcvl.BasicState(\"|{P:H},0>\"),\n", " pcvl.BasicState(\"|{P:V},0>\"),\n", " ]\n", "\n", "states_modes = [\n", " pcvl.BasicState([0, 0, 0, 1]),\n", " pcvl.BasicState([0, 0, 1, 0]),\n", " pcvl.BasicState([0, 1, 0, 0]),\n", " pcvl.BasicState([1, 0, 0, 0])\n", "]" ] }, { "attachments": {}, "cell_type": "markdown", "id": "fab191db", "metadata": {}, "source": [ "We use the following unitary matrix to represent the beamsplitters:" ] }, { "cell_type": "code", "execution_count": 3, "id": "a3560b8f", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}\\\\\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\end{matrix}\\right]$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "bsry = pcvl.BS.Ry()\n", "pcvl.pdisplay(bsry.U)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "54638f8d", "metadata": {}, "source": [ "The half-wave plates are defined in the article as:" ] }, { "cell_type": "code", "execution_count": 4, "id": "54d17968", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "ξ=pi/2\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "0\n", "0\n", "" ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def HWP(xsi):\n", " hwp = pcvl.Circuit(m=1)\n", " hwp.add(0, pcvl.HWP(xsi)).add(0, pcvl.PS(-math.pi/2))\n", " return hwp\n", "\n", "pcvl.pdisplay(HWP(math.pi/2))" ] }, { "attachments": {}, "cell_type": "markdown", "id": "3d3c98ab", "metadata": {}, "source": [ "### Circuit Construction" ] }, { "attachments": {}, "cell_type": "markdown", "id": "b2c267cb", "metadata": {}, "source": [ "We divide the compiled circuit of Kwiat et al. in three parts: [state initialization](#state-initialization-circuit), [oracle](#oracle) and [inversion about mean](#inversion-about-mean). However, due to the compilation, each individual part does not act exactly as described in the introduction." ] }, { "attachments": {}, "cell_type": "markdown", "id": "14ee9683", "metadata": {}, "source": [ "\n", "#### State initialization circuit" ] }, { "cell_type": "code", "execution_count": 5, "id": "f6718866", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "ξ=pi/8\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Ry\n", "\n", "\n", "Φ=pi\n", "\n", "\n", "\n", "0\n", "1\n", "0\n", "1\n", "" ], "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "init_circuit = (pcvl.Circuit(m=2, name=\"Initialization\")\n", " // (1,HWP(math.pi / 8))\n", " // bsry\n", " // pcvl.PS(-math.pi))\n", "\n", "pcvl.pdisplay(init_circuit)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "e8278f70", "metadata": {}, "source": [ "#### Oracle\n", "\n", "The oracle circuit can be initialised so that any one of the four list elements are marked. This is controlled via the integer parameter $mark \\in [0, 3]$." ] }, { "cell_type": "code", "execution_count": 6, "id": "96aba62a", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "ξ=0\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "\n", "\n", "δ=pi/2\n", "\n", "\n", "\n", "ξ=0\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "\n", "ξ=0\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "\n", "ξ=0\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "\n", "0\n", "1\n", "0\n", "1\n", "" ], "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def oracle(mark: int):\n", " \"\"\"Values 0, 1, 2 and 3 for parameter 'mark' respectively mark the elements \"00\", \"01\", \"10\" and \"11\" of the list.\"\"\"\n", " oracle_circuit = pcvl.Circuit(m=2, name='Oracle')\n", " # The following dictionary translates n into the corresponding component settings\n", " oracle_dict = {0: (1, 0), 1: (0, 1), 2: (1, 1), 3: (0, 0)}\n", " PC_state, LC_state = oracle_dict[mark]\n", " # Mode b\n", " if PC_state == 1:\n", " oracle_circuit //= HWP(0)\n", " oracle_circuit.add(0, pcvl.PR(math.pi/2))\n", " if LC_state == 1:\n", " oracle_circuit //= HWP(0)\n", " # Mode a\n", " if LC_state == 1:\n", " oracle_circuit //= (1, HWP(0))\n", " if PC_state == 1:\n", " oracle_circuit //= (1, HWP(0))\n", " return oracle_circuit\n", "\n", "pcvl.pdisplay(oracle(2))" ] }, { "attachments": {}, "cell_type": "markdown", "id": "50596a16", "metadata": {}, "source": [ "#### Inversion about mean" ] }, { "cell_type": "code", "execution_count": 7, "id": "ef839994", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Ry\n", "\n", "\n", "\n", "ξ=pi/4\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Ry\n", "\n", "\n", "0\n", "1\n", "0\n", "1\n", "" ], "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "inversion_circuit = (pcvl.Circuit(m=2, name='Inversion')\n", " // bsry\n", " // (1,HWP(math.pi / 4))\n", " // bsry)\n", "\n", "pcvl.pdisplay(inversion_circuit)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "4daf70f2", "metadata": {}, "source": [ "#### Detection\n", "\n", "The article also uses a detection circuit of the form:" ] }, { "cell_type": "code", "execution_count": 8, "id": "31ad50c7", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "0\n", "1\n", "2\n", "3\n", "" ], "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "detection_circuit = pcvl.Circuit(m=4, name='Detection')\n", "detection_circuit.add((0, 1), pcvl.PBS())\n", "detection_circuit.add((2, 3), pcvl.PBS())\n", "\n", "pcvl.pdisplay(detection_circuit)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "76acc62f", "metadata": {}, "source": [ "However, Perceval allows us to filter out the photon's polarization state, meaning that there is no need to expand the circuit to four output spatial modes.\n", "\n", "For now, we will need this particular circuit." ] }, { "attachments": {}, "cell_type": "markdown", "id": "2326568e", "metadata": {}, "source": [ "#### Final circuit setup \n", "\n", "As above, the value of parameter 'mark' indicates which element of the list needs to be found." ] }, { "cell_type": "code", "execution_count": 9, "id": "1b0bffde", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Grover optical circuit for searching database element \"00\":\n" ] }, { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "INITIALIZATION\n", "\n", "\n", "\n", "ξ=pi/8\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Ry\n", "\n", "\n", "Φ=pi\n", "\n", "\n", "ORACLE\n", "\n", "\n", "\n", "ξ=0\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "\n", "\n", "δ=pi/2\n", "\n", "\n", "\n", "ξ=0\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "INVERSION\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Ry\n", "\n", "\n", "\n", "ξ=pi/4\n", "δ=pi/2\n", "\n", "\n", "Φ=3*pi/2\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Ry\n", "\n", "\n", "\n", "\n", "\n", "\n", "DETECTION\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "0\n", "1\n", "2\n", "3\n", "" ], "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def grover_circuit(mark: int):\n", " grover = pcvl.Circuit(m=4, name='Grover')\n", " grover.add(0, init_circuit).add(0, oracle(mark)).add(0, inversion_circuit)\n", " grover.add(1, pcvl.PERM([1, 0])).add(0, detection_circuit)\n", " return grover\n", "\n", "print('Grover optical circuit for searching database element \"00\":')\n", "pcvl.pdisplay(grover_circuit(0), recursive=True)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "922a8f12", "metadata": {}, "source": [ "## Grover algorithm execution\n", "\n", "We can finally simulate Grover's algorithm for marked database elements \"00\", \"01\", \"10\" and \"11\"." ] }, { "cell_type": "code", "execution_count": 10, "id": "0f000dac", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Circuit simulation\n", "input_state = pcvl.BasicState(\"|0,{P:H}, 0, 0>\")\n", "results_list = [] # probability amplitudes storage\n", "computer = pcvl.SimulatedComputer(\"SLOS\")\n", "\n", "with computer.acquire():\n", " for mark in range(4):\n", " experiment = pcvl.Experiment(grover_circuit(mark))\n", " analyzer = Analyzer(computer, experiment, input_states=[input_state], output_states=states_modes)\n", " results_list.append(analyzer.distribution[0])\n", "\n", "# Plot data\n", "labels = ['\"00\"', '\"01\"', '\"10\"', '\"11\"']\n", "x = np.arange(4) # label locations\n", " \n", "fig, ax = plt.subplots(dpi=150)\n", "for result, state in zip(results_list, states):\n", " ax.bar(x, result.real, 0.1, label=str(state))\n", "\n", "ax.set_xlabel('Marked database element')\n", "ax.set_ylabel('Detection probability') \n", "ax.set_xticks(x, labels)\n", "ax.legend()\n", "ax.grid(True, axis='x')\n", "plt.show()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "659482dd", "metadata": {}, "source": [ "As demonstrated by the graph above, Grover's algorithm indeed finds the marked database element!" ] }, { "attachments": {}, "cell_type": "markdown", "id": "d32d028f", "metadata": {}, "source": [ "## Reference\n", "\n", "> Kwiat et al. Grover’s search algorithm: An optical approach. [Journal of Modern Optics](https://doi.org/10.1080/09500340008244040), 47(2–3), 257–266 (2000).\n" ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }