examples/advanced_circuits_algorithms/Grover/Grover.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grover's Search Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:08.639837Z",
     "start_time": "2023-08-29T21:30:08.162009Z"
    }
   },
   "outputs": [],
   "source": [
    "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n",
    "from braket.tracking import Tracker\n",
    "\n",
    "t = Tracker().start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we provide a step-by-step walkthrough explaining Grover's quantum algorithm. We show how to build the corresponding quantum circuit with simple modular building blocks using the Braket SDK. Specifically, we demonstrate how to build custom gates that are not part of the basic gate set provided by the SDK. A custom gate can used as a core quantum gate by registering it as a subroutine. \n",
    "\n",
    "After building the circuit, we will run it on two types of devices: 1) classical simulator, and 2) ion-based quantum machine provided by IonQ. For the latter, we will demonstrate how to recover quantum tasks that may be waiting in queue.\n",
    "\n",
    "1. [Introduction](#introduction)\n",
    "2. [Background: What is a Quantum Oracle?](#background)\n",
    "3. [Anatomy of Grover's Algorithm](#steps)\n",
    "4. [Circuit Diagram](#diagram)\n",
    "5. [Code](#code)\n",
    " 1. [Libraries and Parameters](#setup)\n",
    " 2. [Helper Functions](#wrappers)\n",
    " 3. [Device: Classical Simulator](#sim_c)\n",
    " 4. [Device: IonQ](#ionq)\n",
    "6. [References](#ref)\n",
    "\n",
    "This tutorial is based on ion-trap experiments published as *C. Figgatt, D. Maslov, K. A. Landsman, N. M. Linke, S. Debnath & C. Monroe (2017), \"Complete 3-Qubit Grover search on a programmable quantum computer\", Nature Communications, Vol 8, Art 1918, doi:10.1038/s41467-017-01904-7, arXiv:1703.10535*. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction<a name=\"introduction\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grover's algorithm is arguably one of the canonical quantum algorithms that kick-started the field of quantum computing. In the future, it could possibly serve as a hallmark application of quantum computing. Grover's algorithm allows us to find a particular register in an unordered database with $N$ entries in just $O(\\sqrt{N})$ steps, compared to the best classical algorithm taking on average $N/2$ steps, thereby providing a __quadratic speedup__.\n",
    "\n",
    "For large databases (with a large number of entries, $N$), a quadratic speedup can provide a significant advantage. For a database with one million entries, a quantum computer running Grover's algorithm would need about 1000 runs, while a classical computer would need, on average, $500$k runs.\n",
    "\n",
    "Research has been shown that any optimal quantum solution to an unstructured search problem has a speed limit of $O(\\sqrt{N})$ runtime. This research finding matches the performance of Grover's algorithm, thus proving that the algorithm is asymptotically optimal [2]. In fact, Grover's algorithm can be generalized to accelerate any type of search where one can construct a quantum oracle, as described in the next section. \n",
    "\n",
    "Consider the following problem [2]: \n",
    "In a search space with $N$ elements, we are searching the index of those elements, which is a number in the range $0, 1, \\dots, N-1$. \n",
    "We have $n$ bits at our disposal, with which we can store up to $2^{n}$ elements. \n",
    "Our search problem can then be expressed with the help of a function $f$, which takes as input an element out of our set of indices (that is, an integer $x$) and generates two possible outputs: $f(x^{*})=1$, if $x^{*}$ is the solution to the search problem or $f(x)=0$ otherwise (if $N<2^{n}$ we can just set $f(x)=0$ for all extra unused elements). \n",
    "This is done with the help of a quantum oracle, which recognizes solutions to the search problem. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Background: What is a Quantum Oracle? <a name=\"background\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grover's algorithm, like many other quantum algorithms, utilizes the concept of a quantum oracle which we will denote as $\\mathcal{O}$.  In essence, an oracle $\\mathcal{O}$ is a black-box operation that serves as a subroutine to another algorithm. Typically, oracles are defined using a classical function $f:\\{0,1\\}^{n} \\rightarrow \\{0,1\\}^{m}$, that maps an $n$-input bitstring to an $m$-output bitstring. With $x \\in \\{0,1\\}^{n}$, i.e., $x=(x_{0}, x_{1}, \\dots, x_{n-1})$ is a bitstring vector, and $y \\in \\{0,1\\}^{m}$, the oracle $\\mathcal{O}$ is a unitary operator, commonly defined by its effect on an arbitrary computational basis state as:\n",
    "\n",
    "$$\\mathcal{O} (\\left|x\\right> \\otimes \\left|y\\right>) = \\left|x\\right> \\otimes \\left|y \\oplus f(x)\\right>,$$ where $\\oplus$ denotes addition modulo 2. \n",
    "\n",
    "This means that the second qubit register of size $m$ stores the result of the computation. \n",
    "For $m=1$, which is the scenario we will focus on here, the second register $\\left|y\\right>$ is a single qubit that is flipped if (and only if) $f(x)=1$. \n",
    "In short, the quantum oracle flips the ancilla qubit only if the function $f(x)$ evaluates to one. \n",
    "Accordingly, we can check if $x$ is a solution to our search problem by first preparing the state $\\left|x\\right> \\otimes \\left|0\\right>$, then applying the oracle $\\mathcal{O}$ to that state, before finally measuring the state of the oracle qubit. \n",
    "\n",
    "In Grover's algorithm, it is useful to initialize the oracle qubit in a superposition, as $\\left|y\\right> = (\\left|0\\right> - \\left|1\\right>)/\\sqrt{2}$. \n",
    "We can distinguish two cases: \n",
    "(i) If $x$ is not a solution to our search problem (i.e., $f(x)=0$), then the application of the oracle operator $\\mathcal{O}$ to the input state $\\left|x\\right> \\otimes (\\left|0\\right> - \\left|1\\right>)/\\sqrt{2}$ leaves this state simply untouched. \n",
    "(ii) Conversely, if $x$ is a solution to our search problem (i.e., $f(x)=1$), then the oracle states $\\left|0\\right>$ and $\\left|1\\right>$ are flipped, such that the state picks up a minus sign, giving the final output state $-\\left|x\\right> \\otimes (\\left|0\\right> - \\left|1\\right>)/\\sqrt{2}$. \n",
    "Note that global phase factors do not matter in quantum computing, but the relative minus sign we encounter here does make all the difference for a superposition state, which would include the solution among all other possible input states. \n",
    "\n",
    "For both cases (i) and (ii), the action of the oracle can be summarized as: \n",
    "\n",
    "$$\\left|x\\right> \\otimes (\\left|0\\right> - \\left|1\\right>)/\\sqrt{2} \\longrightarrow (-1)^{f(x)} \\left|x\\right> \\otimes (\\left|0\\right> - \\left|1\\right>)/\\sqrt{2}.$$  \n",
    "Accordingly, the solution to our search problem gets *marked* by shifting the corresponding phase. \n",
    "Because the oracle qubit remains unchanged, one can omit this oracle qubit from further discussion and simply express the action of the oracle as: \n",
    "\n",
    "$$\\left|x\\right> \\longrightarrow (-1)^{f(x)}\\left|x\\right>.$$ \n",
    "\n",
    "This expression also captures the definition of a *phase oracle*, which will be used in our examples below. \n",
    "If a phase oracle is applied on a computational basis state $\\left|x\\right>$, then we only get a global phase that is not observable. However, when applied to a superposition of computational basis states, this phase oracle becomes a powerful tool. As it turns out, the search oracle needs to be applied only $O(\\sqrt{N})$ times to obtain the solution with high probability [2]; more generally, if there are $G$ solutions, the oracle needs to be applied only $O(\\sqrt{N/G})$ times). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Anatomy of Grover's Algorithm <a name=\"steps\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we will be working with three bits $(n=3)$, leading to eight possible items $(N=2^{3}=8)$. \n",
    "To find a given target item, Grover's algorithm uses the following steps:\n",
    "\n",
    "1. **Initialize**: Start with a uniform superposition of all possible bit strings by applying Hadamard gates. This will result in all inputs having the same amplitude. Since we do not have any prior knowledge about the solution, we initialize to an equal superposition of all possible candidate solutions. \n",
    "\n",
    "2. **Oracle**: Item bits are then passed through an oracle. The oracle produces only two results. If it detects the target item, its amplitude will be flipped to negative. For all other items, their amplitudes will remain positive. Because the oracle is specifically engineered to change amplitudes based on a certain bit pattern, each target item would have its own associated oracle.\n",
    "\n",
    "3. **Amplification**: While the oracle in step 2 distinguishes the target item by flipping its amplitude in the negative direction, this difference remains too small to detect. Hence, we use a trick to magnify the difference in amplitudes; by flipping every amplitude around the mean amplitude. Recall that only the target item's amplitude was flipped to negative. In other words, the mean amplitude would still be positive, and its value would only be slightly lower than the amplitudes of other items. By flipping all amplitudes about the mean, the amplitudes of non-target items would decrease only slightly. On the other hand, the amplitude of the target item, being much less than the mean value to start, would be reflected back up into the positive direction by a large margin.\n",
    "\n",
    "4. **Repeat**: By repeating steps 2 and 3, we can magnify the amplitude of the target item to a point where it can be identified with overwhelming probability. To get to this point, we need to repeat these steps approximately $\\sqrt{N}$ times (again assuming a single solution and large $N$). As discussed in more detail in our Quantum Amplification Algorithm (QAA) tutorial, to ensure we measure a solution with high probability, we apply the Grover iterator $\\left\\lfloor\\frac{\\pi}{4\\theta}\\right\\rfloor=\\left\\lfloor\\frac{\\pi}{4}\\sqrt{\\frac{N}{G}}\\right\\rfloor$ times, with $G$ denoting the number of solutions. Since we may not know $G$ in advance, we not know the ideal number of iterations a priori. To address this issue, however, we may use quantum counting techniques with the help of the phase estimation procedure (QPE); for details we refer to Ref.[2]. \n",
    "\n",
    "5. **Measurement**: Measure the resulting amplitudes to identify the target item."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\"><img src=\"anatomy.png\"/></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Circuit Diagram <a name=\"diagram\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following Ref.[1], we will examine Grover's search algorithm for $n=3$ qubits, which corresponds to a search database of size $N = 2^{3} = 8$. Below we show the circuit used to find the item ```111```.  To find other items, we can simply swap out the phase oracle, using the table given in Ref.[1].\n",
    "\n",
    "<div align=\"center\"><img src=\"circuit.png\"/></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code <a name=\"code\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries and Parameters <a name=\"setup\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:12.927295Z",
     "start_time": "2023-08-29T21:30:10.318951Z"
    }
   },
   "outputs": [],
   "source": [
    "# Import Braket libraries\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from braket.aws import AwsDevice, AwsQuantumTask\n",
    "from braket.circuits import Circuit, circuit\n",
    "from braket.devices import Devices, LocalSimulator\n",
    "\n",
    "# magic word for producing visualizations in notebook\n",
    "%matplotlib inline\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper Functions <a name=\"wrappers\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We develop a set of useful helper functions that we will explain in detail below. Specifically, we provide simple building blocks for the four core modules of Grover's search algorithm: 1) initialization, 2) oracle, 3) amplification, and 4) measurement. This approach allows us to solve the problem in a clean and modular way. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:12.952542Z",
     "start_time": "2023-08-29T21:30:12.927636Z"
    }
   },
   "outputs": [],
   "source": [
    "# Helper function to build C-C-Z gate\n",
    "@circuit.subroutine(register=True)\n",
    "def ccz(targets=[0, 1, 2]):\n",
    "    \"\"\"\n",
    "    implementation of three-qubit gate CCZ\n",
    "    \"\"\"\n",
    "    # define three-qubit CCZ gate\n",
    "    ccz_gate = np.array(\n",
    "        [\n",
    "            [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
    "            [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
    "            [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
    "            [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n",
    "            [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n",
    "            [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],\n",
    "            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],\n",
    "            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0],\n",
    "        ],\n",
    "        dtype=complex,\n",
    "    )\n",
    "\n",
    "    # instantiate circuit object\n",
    "    circ = Circuit()\n",
    "\n",
    "    # add CCZ gate\n",
    "    circ.unitary(matrix=ccz_gate, targets=targets)\n",
    "\n",
    "    return circ\n",
    "\n",
    "\n",
    "# All possible items and their corresponding oracles\n",
    "# define oracle dictionary using this CCZ gate\n",
    "oracle_sim = {\n",
    "    \"000\": Circuit().x([0, 1, 2]).ccz(targets=[0, 1, 2]).x([0, 1, 2]),\n",
    "    \"001\": Circuit().x([0, 1]).ccz(targets=[0, 1, 2]).x([0, 1]),\n",
    "    \"010\": Circuit().x([0, 2]).ccz(targets=[0, 1, 2]).x([0, 2]),\n",
    "    \"011\": Circuit().x([0]).ccz(targets=[0, 1, 2]).x([0]),\n",
    "    \"100\": Circuit().x([1, 2]).ccz(targets=[0, 1, 2]).x([1, 2]),\n",
    "    \"101\": Circuit().x([1]).ccz(targets=[0, 1, 2]).x([1]),\n",
    "    \"110\": Circuit().x([2]).ccz(targets=[0, 1, 2]).x([2]),\n",
    "    \"111\": Circuit().ccz(targets=[0, 1, 2]),\n",
    "}\n",
    "\n",
    "\n",
    "# helper function for initialization\n",
    "def initialize(n_qubits=3):\n",
    "    \"\"\"\n",
    "    function to apply hadamard to all qubits\n",
    "    \"\"\"\n",
    "    # Initialize with superposition\n",
    "    circ = Circuit()\n",
    "    circ.h(np.arange(n_qubits))\n",
    "    # print(circ)\n",
    "    return circ\n",
    "\n",
    "\n",
    "# helper function for phase oracle\n",
    "def oracle(item):\n",
    "    \"\"\"\n",
    "    function to apply oracle for given target item\n",
    "    \"\"\"\n",
    "    # instantiate circuit object\n",
    "    circ = Circuit()\n",
    "\n",
    "    # add oracle\n",
    "    circ.add_circuit(oracle_sim[item])\n",
    "\n",
    "    return circ\n",
    "\n",
    "\n",
    "# helper function for amplification\n",
    "def amplify(n_qubits=3):\n",
    "    \"\"\"\n",
    "    function for amplitude amplification\n",
    "    \"\"\"\n",
    "    # instantiate circuit object\n",
    "    circ = Circuit()\n",
    "\n",
    "    # Amplification\n",
    "    circ.h(np.arange(n_qubits))\n",
    "    circ.add_circuit(oracle_sim[\"000\"])\n",
    "    circ.h(np.arange(n_qubits))\n",
    "\n",
    "    return circ\n",
    "\n",
    "\n",
    "# helper function for grover algorithm\n",
    "def grover(item, n_qubits=3, n_reps=1):\n",
    "    \"\"\"\n",
    "    function to put together individual modules of Grover algorithm\n",
    "    \"\"\"\n",
    "    # initialize\n",
    "    grover_circ = initialize()\n",
    "    # oracle and amplify\n",
    "    for ii in range(n_reps):\n",
    "        # get oracle\n",
    "        or_circ = oracle(item)\n",
    "        grover_circ.add(or_circ)\n",
    "        # amplify\n",
    "        amplification = amplify()\n",
    "        grover_circ.add(amplification)\n",
    "\n",
    "    return grover_circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:12.963570Z",
     "start_time": "2023-08-29T21:30:12.960880Z"
    }
   },
   "outputs": [],
   "source": [
    "# Function to run quantum task, check the status thereof, and collect results\n",
    "def get_result(circ):\n",
    "    # get number of qubits\n",
    "    num_qubits = circ.qubit_count\n",
    "\n",
    "    # specify desired results_types\n",
    "    circ.probability()\n",
    "\n",
    "    # submit quantum task: define quantum task (asynchronous)\n",
    "    task = device.run(circ, shots=1000)\n",
    "\n",
    "    # Get ID of submitted quantum task\n",
    "    #     print('Task ID :', task_id)\n",
    "\n",
    "    # Wait for hybrid job to complete\n",
    "    status_list = []\n",
    "    status = task.state()\n",
    "    status_list += [status]\n",
    "    print(\"Status:\", status)\n",
    "\n",
    "    # Only notify the user when there's a status change\n",
    "    while status != \"COMPLETED\":\n",
    "        status = task.state()\n",
    "        if status != status_list[-1]:\n",
    "            print(\"Status:\", status)\n",
    "        status_list += [status]\n",
    "\n",
    "    # get result\n",
    "    result = task.result()\n",
    "\n",
    "    # get metadata\n",
    "\n",
    "    # get output probabilities\n",
    "    probs_values = result.values[0]\n",
    "\n",
    "    # get measurement results\n",
    "    measurement_counts = result.measurement_counts\n",
    "\n",
    "    # print measurement results\n",
    "    print(\"measurement_counts:\", measurement_counts)\n",
    "\n",
    "    # bitstrings\n",
    "    format_bitstring = \"{0:0\" + str(num_qubits) + \"b}\"\n",
    "    bitstring_keys = [format_bitstring.format(ii) for ii in range(2**num_qubits)]\n",
    "\n",
    "    # plot probabalities\n",
    "    plt.bar(bitstring_keys, probs_values)\n",
    "    plt.xlabel(\"bitstrings\")\n",
    "    plt.ylabel(\"probability\")\n",
    "    plt.xticks(rotation=90)\n",
    "    return measurement_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Device: Classical Simulator <a name=\"sim_c\"></a>\n",
    "We demonstrate Grover's algorithm on a classical simulator first. \n",
    "You can choose between a local simulator or an on-demand simulator. \n",
    "In the next section, we will run the same problem on a quantum IonQ device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:13.054236Z",
     "start_time": "2023-08-29T21:30:12.965829Z"
    }
   },
   "outputs": [],
   "source": [
    "# Set up the cloud-based simulator\n",
    "# device = AwsDevice(Devices.Amazon.SV1)\n",
    "\n",
    "# set up the local simulator\n",
    "device = LocalSimulator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:13.065405Z",
     "start_time": "2023-08-29T21:30:13.061498Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Gates supported by StateVectorSimulator:\n",
      " ['ccnot', 'cnot', 'cphaseshift', 'cphaseshift00', 'cphaseshift01', 'cphaseshift10', 'cswap', 'cv', 'cy', 'cz', 'ecr', 'h', 'i', 'iswap', 'pswap', 'phaseshift', 'rx', 'ry', 'rz', 's', 'si', 'swap', 't', 'ti', 'unitary', 'v', 'vi', 'x', 'xx', 'xy', 'y', 'yy', 'z', 'zz']\n"
     ]
    }
   ],
   "source": [
    "# get device name\n",
    "device_name = device.name\n",
    "# show the properties of the device\n",
    "device_properties = device.properties\n",
    "# show supportedQuantumOperations (supported gates for a device)\n",
    "device_operations = device_properties.dict()[\"action\"][\"braket.ir.jaqcd.program\"][\n",
    "    \"supportedOperations\"\n",
    "]\n",
    "# Note: This field also exists for other devices like the QPUs\n",
    "print(\"Quantum Gates supported by {}:\\n {}\".format(device_name, device_operations))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the ```CCZ``` gate is not part of the default gate set, we have used the ```unitary``` method to build a custom, doubly-controlled Z gate ```CCZ``` for the phase oracle operator. \n",
    "We will leverage the Amazon Braket `circuit.subroutine` functionality, which allows us to use such a custom-built gate as if it were any other built-in gate.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are ready to run our circuit for a few test cases. \n",
    "To recap, the steps are as follows:\n",
    "\n",
    "1. Create a uniform superposition\n",
    "2. Apply the phase oracle corresponding to our target item\n",
    "3. Define the diffusion operator to magnify the amplitude difference created by the oracle\n",
    "4. Collect the measurement counts for our target item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:13.372676Z",
     "start_time": "2023-08-29T21:30:13.064936Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │  2  │  3  │  4  │  5  │  6  │\n",
      "      ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ \n",
      "q0 : ─┤ H ├─┤ U ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─\n",
      "      └───┘ └─┬─┘ └───┘ └───┘ └─┬─┘ └───┘ └───┘ \n",
      "      ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ \n",
      "q1 : ─┤ H ├─┤ U ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─\n",
      "      └───┘ └─┬─┘ └───┘ └───┘ └─┬─┘ └───┘ └───┘ \n",
      "      ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ \n",
      "q2 : ─┤ H ├─┤ U ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─\n",
      "      └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ \n",
      "T  : │  0  │  1  │  2  │  3  │  4  │  5  │  6  │\n",
      "Status: COMPLETED\n",
      "measurement_counts: Counter({'111': 791, '010': 41, '001': 31, '101': 30, '000': 29, '011': 28, '100': 26, '110': 24})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Select item to find. Let's start with '111' for now\n",
    "item = \"111\"\n",
    "\n",
    "# get Grover circuit\n",
    "circ = grover(item)\n",
    "\n",
    "# print circuit\n",
    "print(circ)\n",
    "\n",
    "# Measurement\n",
    "counts = get_result(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__DISCUSSION__: We observe a strong peak around the target solution given by the `111` bitstring, with all other bitstrings showing far smaller probabilities. \n",
    "Let us try one more item: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:13.684325Z",
     "start_time": "2023-08-29T21:30:13.370679Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │\n",
      "      ┌───┐       ┌───┐ ┌───┐ ┌───┐       ┌───┐ ┌───┐ ┌───┐ \n",
      "q0 : ─┤ H ├───────┤ U ├─┤ H ├─┤ X ├───────┤ U ├─┤ X ├─┤ H ├─\n",
      "      └───┘       └─┬─┘ └───┘ └───┘       └─┬─┘ └───┘ └───┘ \n",
      "      ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ \n",
      "q1 : ─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─\n",
      "      └───┘ └───┘ └─┬─┘ └───┘ └───┘ └───┘ └─┬─┘ └───┘ └───┘ \n",
      "      ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ \n",
      "q2 : ─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─\n",
      "      └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ \n",
      "T  : │  0  │  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │\n",
      "Status: COMPLETED\n",
      "measurement_counts: Counter({'100': 792, '010': 34, '101': 33, '110': 32, '111': 32, '001': 31, '000': 24, '011': 22})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Select item to find. Let's start with '111' for now\n",
    "item = \"100\"\n",
    "\n",
    "# get Grover circuit\n",
    "circ = grover(item)\n",
    "\n",
    "# print circuit\n",
    "print(circ)\n",
    "\n",
    "# Measurement\n",
    "counts = get_result(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__DISCUSSION__: By repeating steps 2 (oracle) and 3 (amplification), we can further magnify the amplitude of the target item, thus maximizing the single-shot probability of identifying the right answer. This repetition is demonstrated below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:13.948582Z",
     "start_time": "2023-08-29T21:30:13.606504Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │  9  │ 10  │ 11  │ 12  │ 13  │ 14  │ 15  │ 16  │\n",
      "      ┌───┐       ┌───┐ ┌───┐ ┌───┐       ┌───┐ ┌───┐ ┌───┐       ┌───┐ ┌───┐ ┌───┐       ┌───┐ ┌───┐ ┌───┐ \n",
      "q0 : ─┤ H ├───────┤ U ├─┤ H ├─┤ X ├───────┤ U ├─┤ X ├─┤ H ├───────┤ U ├─┤ H ├─┤ X ├───────┤ U ├─┤ X ├─┤ H ├─\n",
      "      └───┘       └─┬─┘ └───┘ └───┘       └─┬─┘ └───┘ └───┘       └─┬─┘ └───┘ └───┘       └─┬─┘ └───┘ └───┘ \n",
      "      ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ \n",
      "q1 : ─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─\n",
      "      └───┘ └───┘ └─┬─┘ └───┘ └───┘ └───┘ └─┬─┘ └───┘ └───┘ └───┘ └─┬─┘ └───┘ └───┘ └───┘ └─┬─┘ └───┘ └───┘ \n",
      "      ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌───┐ ┌───┐ \n",
      "q2 : ─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─┤ X ├─┤ U ├─┤ X ├─┤ H ├─\n",
      "      └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ \n",
      "T  : │  0  │  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │  9  │ 10  │ 11  │ 12  │ 13  │ 14  │ 15  │ 16  │\n",
      "Status: COMPLETED\n",
      "measurement_counts: Counter({'100': 935, '001': 12, '111': 11, '010': 11, '011': 10, '110': 9, '101': 8, '000': 4})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Select item to find\n",
    "item = \"100\"\n",
    "\n",
    "# get Grover circuit\n",
    "circ = grover(item, n_reps=2)\n",
    "\n",
    "# print circuit\n",
    "print(circ)\n",
    "\n",
    "# Measurement\n",
    "counts = get_result(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__DISCUSSION__: We observed how repeated application of the Grover operator has amplified the occurrence of the desired bitstring, while further suppressing wrong answers to our search problem. We get the correct result with high probability.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Device: IonQ <a name=\"ionq\"></a>\n",
    "\n",
    "Finally, we check whether this scheme works on quantum hardware, by submitting our circuit to the IonQ device. To achieve this check, we first need to express the ```CCZ``` gate in terms of the native gate set of IonQ. In doing so, we build a custom gate that can be registered as a subroutine and then used as if it were any other native quantum gate within our SDK. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:14.694017Z",
     "start_time": "2023-08-29T21:30:13.959600Z"
    }
   },
   "outputs": [],
   "source": [
    "# Set up a QPU device\n",
    "device = AwsDevice(Devices.IonQ.Aria1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:14.706515Z",
     "start_time": "2023-08-29T21:30:14.694354Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Gates supported by Aria 1:\n",
      " ['x', 'y', 'z', 'rx', 'ry', 'rz', 'h', 'cnot', 's', 'si', 't', 'ti', 'v', 'vi', 'xx', 'yy', 'zz', 'swap']\n"
     ]
    }
   ],
   "source": [
    "# get device name\n",
    "device_name = device.name\n",
    "# show the properties of the device\n",
    "device_properties = device.properties\n",
    "# show supportedQuantumOperations (supported gates for a device)\n",
    "device_operations = device_properties.dict()[\"action\"][\"braket.ir.openqasm.program\"][\n",
    "    \"supportedOperations\"\n",
    "]\n",
    "# Note: This field also exists for other devices like the QPUs\n",
    "print(\"Quantum Gates supported by {}:\\n {}\".format(device_name, device_operations))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the 𝑁=8 Grover demonstration with three qubits shown in Figgatt et al. (2017), we need to implement the Controlled-Controlled-Z ```CCZ``` gate that is not natively provided on the IonQ device. We will construct this gate using native gates only such as ```CNOT``` and ```T```. Apart from our implementation, other alternative options are available (see [1] and references therein). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:14.722040Z",
     "start_time": "2023-08-29T21:30:14.703202Z"
    }
   },
   "outputs": [],
   "source": [
    "@circuit.subroutine(register=True)\n",
    "def CCNot(controls=[0, 1], target=2):\n",
    "    \"\"\"\n",
    "    build CCNOT from H, CNOT, T, Ti\n",
    "    \"\"\"\n",
    "    cQb1, cQb2 = controls\n",
    "    circ = (\n",
    "        Circuit()\n",
    "        .h(target)\n",
    "        .cnot(cQb2, target)\n",
    "        .ti(target)\n",
    "        .cnot(cQb1, target)\n",
    "        .t(target)\n",
    "        .cnot(cQb2, target)\n",
    "        .ti(target)\n",
    "        .cnot(cQb1, target)\n",
    "        .t(target)\n",
    "        .h(target)\n",
    "        .t(cQb2)\n",
    "        .cnot(cQb1, cQb2)\n",
    "        .t(cQb1)\n",
    "        .ti(cQb2)\n",
    "        .cnot(cQb1, cQb2)\n",
    "    )\n",
    "\n",
    "    return circ\n",
    "\n",
    "\n",
    "def CCZ_ionq(controls=[0, 1], target=2):\n",
    "    \"\"\"\n",
    "    build CCZ from H and CCNOT\n",
    "    \"\"\"\n",
    "    circ = Circuit().h(target).CCNot(controls, target).h(target)\n",
    "    return circ\n",
    "\n",
    "\n",
    "ccz_ionq = CCZ_ionq()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following are oracles defined based on target items:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:14.736070Z",
     "start_time": "2023-08-29T21:30:14.732653Z"
    }
   },
   "outputs": [],
   "source": [
    "# Four possible items and their corresponding oracles\n",
    "oracle_ionq = {\n",
    "    \"000\": Circuit().x([0, 1, 2]).add(ccz_ionq).x([0, 1, 2]),\n",
    "    \"001\": Circuit().x([0, 1]).add(ccz_ionq).x([0, 1]),\n",
    "    \"010\": Circuit().x([0, 2]).add(ccz_ionq).x([0, 2]),\n",
    "    \"011\": Circuit().x([0]).add(ccz_ionq).x([0]),\n",
    "    \"100\": Circuit().x([1, 2]).add(ccz_ionq).x([1, 2]),\n",
    "    \"101\": Circuit().x([1]).add(ccz_ionq).x([1]),\n",
    "    \"110\": Circuit().x([2]).add(ccz_ionq).x([2]),\n",
    "    \"111\": Circuit().add(ccz_ionq),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:14.742074Z",
     "start_time": "2023-08-29T21:30:14.739014Z"
    }
   },
   "outputs": [],
   "source": [
    "# Select some example item to find\n",
    "item = \"111\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same as with the classical simulator, we first initialize the qubits by applying the Hadamard gate ```H``` to every qubit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:14.752785Z",
     "start_time": "2023-08-29T21:30:14.746502Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │\n",
      "      ┌───┐ \n",
      "q0 : ─┤ H ├─\n",
      "      └───┘ \n",
      "      ┌───┐ \n",
      "q1 : ─┤ H ├─\n",
      "      └───┘ \n",
      "      ┌───┐ \n",
      "q2 : ─┤ H ├─\n",
      "      └───┘ \n",
      "T  : │  0  │\n"
     ]
    }
   ],
   "source": [
    "# Initialize with superposition\n",
    "circ = Circuit()\n",
    "circ.h(np.arange(3))\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we apply the phase oracle corresponding to our target item.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:14.764634Z",
     "start_time": "2023-08-29T21:30:14.756639Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │  2  │  3  │  4   │  5  │  6  │  7  │  8   │  9  │ 10  │  11  │ 12  │\n",
      "      ┌───┐                                                               ┌───┐        \n",
      "q0 : ─┤ H ├────────────────────────────●────────────────────────●─────●───┤ T ├────●───\n",
      "      └───┘                            │                        │     │   └───┘    │   \n",
      "      ┌───┐                            │               ┌───┐    │   ┌─┴─┐ ┌────┐ ┌─┴─┐ \n",
      "q1 : ─┤ H ├───────────────●────────────┼───────────●───┤ T ├────┼───┤ X ├─┤ Ti ├─┤ X ├─\n",
      "      └───┘               │            │           │   └───┘    │   └───┘ └────┘ └───┘ \n",
      "      ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌────┐ ┌─┴─┐ ┌───┐ ┌─┴─┐ ┌────┐ ┌─┴─┐ ┌───┐ ┌───┐  ┌───┐ \n",
      "q2 : ─┤ H ├─┤ H ├─┤ H ├─┤ X ├─┤ Ti ├─┤ X ├─┤ T ├─┤ X ├─┤ Ti ├─┤ X ├─┤ T ├─┤ H ├──┤ H ├─\n",
      "      └───┘ └───┘ └───┘ └───┘ └────┘ └───┘ └───┘ └───┘ └────┘ └───┘ └───┘ └───┘  └───┘ \n",
      "T  : │  0  │  1  │  2  │  3  │  4   │  5  │  6  │  7  │  8   │  9  │ 10  │  11  │ 12  │\n"
     ]
    }
   ],
   "source": [
    "# Construct phase oracle\n",
    "circ.add_circuit(oracle_ionq[item])\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To complete the circuit, we define the diffusion operator, whose job is to magnify the amplitude difference created by the oracle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:14.798588Z",
     "start_time": "2023-08-29T21:30:14.770267Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │  2  │  3  │  4   │  5  │  6  │  7  │  8   │  9  │ 10  │  11  │ 12  │ 13  │ 14  │ 15  │ 16  │ 17  │  18  │ 19  │ 20  │ 21  │  22  │ 23  │ 24  │  25  │ 26  │ 27  │ 28  │\n",
      "      ┌───┐                                                               ┌───┐        ┌───┐ ┌───┐                                                               ┌───┐        ┌───┐ ┌───┐ \n",
      "q0 : ─┤ H ├────────────────────────────●────────────────────────●─────●───┤ T ├────●───┤ H ├─┤ X ├────────────────────────────●────────────────────────●─────●───┤ T ├────●───┤ X ├─┤ H ├─\n",
      "      └───┘                            │                        │     │   └───┘    │   └───┘ └───┘                            │                        │     │   └───┘    │   └───┘ └───┘ \n",
      "      ┌───┐                            │               ┌───┐    │   ┌─┴─┐ ┌────┐ ┌─┴─┐ ┌───┐ ┌───┐                            │               ┌───┐    │   ┌─┴─┐ ┌────┐ ┌─┴─┐ ┌───┐ ┌───┐ \n",
      "q1 : ─┤ H ├───────────────●────────────┼───────────●───┤ T ├────┼───┤ X ├─┤ Ti ├─┤ X ├─┤ H ├─┤ X ├───────────────●────────────┼───────────●───┤ T ├────┼───┤ X ├─┤ Ti ├─┤ X ├─┤ X ├─┤ H ├─\n",
      "      └───┘               │            │           │   └───┘    │   └───┘ └────┘ └───┘ └───┘ └───┘               │            │           │   └───┘    │   └───┘ └────┘ └───┘ └───┘ └───┘ \n",
      "      ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌────┐ ┌─┴─┐ ┌───┐ ┌─┴─┐ ┌────┐ ┌─┴─┐ ┌───┐ ┌───┐  ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌─┴─┐ ┌────┐ ┌─┴─┐ ┌───┐ ┌─┴─┐ ┌────┐ ┌─┴─┐ ┌───┐ ┌───┐  ┌───┐ ┌───┐ ┌───┐ \n",
      "q2 : ─┤ H ├─┤ H ├─┤ H ├─┤ X ├─┤ Ti ├─┤ X ├─┤ T ├─┤ X ├─┤ Ti ├─┤ X ├─┤ T ├─┤ H ├──┤ H ├─┤ H ├─┤ X ├─┤ H ├─┤ H ├─┤ X ├─┤ Ti ├─┤ X ├─┤ T ├─┤ X ├─┤ Ti ├─┤ X ├─┤ T ├─┤ H ├──┤ H ├─┤ X ├─┤ H ├─\n",
      "      └───┘ └───┘ └───┘ └───┘ └────┘ └───┘ └───┘ └───┘ └────┘ └───┘ └───┘ └───┘  └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └────┘ └───┘ └───┘ └───┘ └────┘ └───┘ └───┘ └───┘  └───┘ └───┘ └───┘ \n",
      "T  : │  0  │  1  │  2  │  3  │  4   │  5  │  6  │  7  │  8   │  9  │ 10  │  11  │ 12  │ 13  │ 14  │ 15  │ 16  │ 17  │  18  │ 19  │ 20  │ 21  │  22  │ 23  │ 24  │  25  │ 26  │ 27  │ 28  │\n"
     ]
    }
   ],
   "source": [
    "# Amplification\n",
    "circ.h(np.arange(3))\n",
    "circ.add_circuit(oracle_ionq[\"000\"])\n",
    "circ.h(np.arange(3))\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This circuit could potentially be optimized, as detailed in Ref.[1], but we will use this version for simplicity. \n",
    "\n",
    "In the final step, we retrieve the probabilistic counts for our target item. \n",
    "To this end, we submit our circuit to the IonQ device, by setting the device as ```AwsDevice(Devices.IonQ.Aria1)```. \n",
    "\n",
    "This quantum task may not be executed immediately as it enters a queue for this machine. \n",
    "Should we need to interrupt our kernel to work on something else, we can always recover our results using the unique ID of this quantum task, as shown in the following lines. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:17.542439Z",
     "start_time": "2023-08-29T21:30:14.789051Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of task: QUEUED\n"
     ]
    }
   ],
   "source": [
    "# set up device\n",
    "ionq = AwsDevice(Devices.IonQ.Aria1)\n",
    "\n",
    "# run circuit\n",
    "ionq_task = ionq.run(circ, shots=1000)\n",
    "\n",
    "# get id and status of submitted quantum task\n",
    "ionq_task_id = ionq_task.id\n",
    "ionq_status = ionq_task.state()\n",
    "# print('ID of task:', ionq_task_id)\n",
    "print(\"Status of task:\", ionq_status)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:17.695703Z",
     "start_time": "2023-08-29T21:30:17.542733Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of (reconstructed) task: QUEUED\n"
     ]
    }
   ],
   "source": [
    "# print status\n",
    "status = ionq_task.state()\n",
    "print(\"Status of (reconstructed) task:\", status)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:17.829375Z",
     "start_time": "2023-08-29T21:30:17.696647Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of (reconstructed) quantum task: QUEUED\n"
     ]
    }
   ],
   "source": [
    "# print status\n",
    "status = ionq_task.state()\n",
    "print(\"Status of (reconstructed) quantum task:\", status)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:18.323743Z",
     "start_time": "2023-08-29T21:30:17.843212Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of (reconstructed) quantum task: QUEUED\n",
      "Sorry, your quantum task is still being processed and has not been finalized yet.\n"
     ]
    }
   ],
   "source": [
    "# recover quantum task\n",
    "task_load = AwsQuantumTask(arn=ionq_task_id)\n",
    "\n",
    "# print status\n",
    "status = task_load.state()\n",
    "print(\"Status of (reconstructed) quantum task:\", status)\n",
    "\n",
    "# wait for hybrid job to complete\n",
    "# terminal_states = ['COMPLETED', 'FAILED', 'CANCELLED']\n",
    "if status == \"COMPLETED\":\n",
    "    # get results\n",
    "    results = task_load.result()\n",
    "\n",
    "    # get all metadata of submitted quantum task\n",
    "    metadata = task_load.metadata()\n",
    "    # example for metadata\n",
    "    shots = metadata[\"shots\"]\n",
    "    machine = metadata[\"deviceArn\"]\n",
    "    # print example metadata\n",
    "    print(\"{} shots taken on machine {}.\".format(shots, machine))\n",
    "\n",
    "    # get measurement counts\n",
    "    counts = results.measurement_counts\n",
    "    print(\"Measurement counts:\", counts)\n",
    "\n",
    "    # plot results: see effects of noise\n",
    "    plt.bar(counts.keys(), counts.values())\n",
    "    plt.xlabel(\"bitstrings\")\n",
    "    plt.ylabel(\"counts\")\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(\"ionq.png\", dpi=700)\n",
    "elif status in [\"FAILED\", \"CANCELLED\"]:\n",
    "    # print terminal message\n",
    "    print(\"Your quantum task is in terminal status, but has not completed.\")\n",
    "\n",
    "else:\n",
    "    # print current status\n",
    "    print(\"Sorry, your quantum task is still being processed and has not been finalized yet.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output looks relatively noisy due to decoherence and gate errors in this relatively long gate sequence. However, we can still observe a dominant peak for the target item. \n",
    "\n",
    "In summary, we have shown how to implement Grover's search algorithm on a classical simulator, as well as on the IonQ device, using simple modular building blocks. We have also demonstrated how to build custom gates outside of the basic gate set provided by the SDK, and how to register these as subroutines that can be used as if they were any other pre-defined quantum gate. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# References <a name=\"ref\"></a>\n",
    "\n",
    "[1] C. Figgatt, D. Maslov, K. A. Landsman, N. M. Linke, S. Debnath & C. Monroe (2017), \"Complete 3-Qubit Grover search on a programmable quantum computer\", Nature Communications, Vol 8, Art 1918, doi:10.1038/s41467-017-01904-7, arXiv:1703.10535.\n",
    "\n",
    "[2] Nielsen, Michael A., Chuang, Isaac L. (2010). Quantum Computation and Quantum Information (2nd ed.). Cambridge: Cambridge University Press."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:30:18.432730Z",
     "start_time": "2023-08-29T21:30:18.322296Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Task Summary\n",
      "{<_IonQ.Aria1: 'arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1'>: {'shots': 1000, 'tasks': {'QUEUED': 1}}}\n",
      "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n",
      "Estimated cost to run this example: 30.30 USD\n"
     ]
    }
   ],
   "source": [
    "print(\"Quantum Task Summary\")\n",
    "print(t.quantum_tasks_statistics())\n",
    "print(\n",
    "    \"Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\"\n",
    ")\n",
    "print(\n",
    "    f\"Estimated cost to run this example: {t.qpu_tasks_cost() + t.simulator_tasks_cost():.2f} USD\"\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}