notebooks/textbook/Deutsch_Jozsa_Algorithm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5fc92ae8",
   "metadata": {},
   "source": [
    "# Deutsch-Jozsa Algorithm\n",
    "\n",
    "\n",
    "In this notebook, we introduce one of the first quantum algorithm’s developed by pioneers David Deutsch and Richard Jozsa. This algorithm showcases an efficient quantum solution to a problem that cannot be solved classically but instead can be solved using a quantum device [1].\n",
    "\n",
    "## References \n",
    "[1] [Michael A. Nielsen & Isaac L. Chuang Quantum Computation and Quantim Information textbook](http://mmrc.amss.cas.cn/tlb/201702/W020170224608149940643.pdf)\n",
    "\n",
    "\n",
    "## Background\n",
    "Let $U_f$ be an oracle (black box) that computes a Boolean function which only takes binary inputs (0’s or 1’s). These functions can be represented as $f: \\{0, 1\\}^n →  \\{0, 1\\}$. This oracle evaluates two types of functions, constant or balanced. \n",
    "\n",
    "A constant function takes any input and returns only 0’s or only 1’s and a balanced function takes any input and returns exactly half 0’s and half 1’s. \n",
    "\n",
    "**Constant:** 011010 → $U_f$ → 000000  \n",
    "**Balanced:** 000011 → $U_f$ → 111000\n",
    "\n",
    "The goal is to determine what type of function is $U_f$ based on only the outputs. If the input is as large as $2^n$ then the amount of queries a classical computer will have to make is $2^(n - 1)+1$. We can see for a large enough $n$ this problem scales exponentially and becomes inefficient to solve classically. However, leveraging a quantum algorithm we only need to query the oracle once to determine the type of function for $U_f$. This is possible because the state of its output might be in a coherent superposition of states corresponding to different answers, each which solves the problem.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bf749e4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from notebook_plotting import plot_bitstrings\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "from braket.experimental.algorithms.deutsch_jozsa import (\n",
    "    balanced_oracle,\n",
    "    constant_oracle,\n",
    "    deutsch_jozsa_circuit,\n",
    "    get_deutsch_jozsa_results,\n",
    ")\n",
    "\n",
    "from braket.tracking import Tracker\n",
    "tracker = Tracker().start() # to track Braket costs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c9d7774",
   "metadata": {},
   "source": [
    "\n",
    "The initialization function prepares a superposition of all possible input values and the second register is in a superposition of 0 and 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "df2029fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_qubits = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4afefaa",
   "metadata": {},
   "source": [
    "The constant oracle circuit is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6f6c0696",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|\n",
      "        \n",
      "q0 : -I-\n",
      "        \n",
      "q1 : -I-\n",
      "        \n",
      "q2 : -I-\n",
      "        \n",
      "q3 : -X-\n",
      "\n",
      "T  : |0|\n"
     ]
    }
   ],
   "source": [
    "const_oracle = constant_oracle(n_qubits)\n",
    "print(const_oracle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4eacdba1",
   "metadata": {},
   "source": [
    "The balanced oracle circuit is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0c116afe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|1|2|3|4|\n",
      "                \n",
      "q0 : -X-C-X-----\n",
      "        |       \n",
      "q1 : ---|-C-----\n",
      "        | |     \n",
      "q2 : -X-|-|-C-X-\n",
      "        | | |   \n",
      "q3 : ---X-X-X---\n",
      "\n",
      "T  : |0|1|2|3|4|\n"
     ]
    }
   ],
   "source": [
    "bal_oracle = balanced_oracle(n_qubits)\n",
    "print(bal_oracle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "233d42bd",
   "metadata": {},
   "source": [
    "The final circuit for the solved Deutsch-Jozsa problem is below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f8476b46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|1|2|3|4|5|6|Result Types|\n",
      "                                 \n",
      "q0 : -H-X-C-X-H-----Probability--\n",
      "          |         |            \n",
      "q1 : -H---|-C-H-----Probability--\n",
      "          | |       |            \n",
      "q2 : -H-X-|-|-C-X-H-Probability--\n",
      "          | | |                  \n",
      "q3 : -X-H-X-X-X------------------\n",
      "\n",
      "T  : |0|1|2|3|4|5|6|Result Types|\n"
     ]
    }
   ],
   "source": [
    "dj_circuit = deutsch_jozsa_circuit(bal_oracle)\n",
    "print(dj_circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e8022773",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0|1|2|Result Types|\n",
      "                         \n",
      "q0 : -H-I-H-Probability--\n",
      "            |            \n",
      "q1 : -H-I-H-Probability--\n",
      "            |            \n",
      "q2 : -H-I-H-Probability--\n",
      "                         \n",
      "q3 : -X-H-X--------------\n",
      "\n",
      "T  : |0|1|2|Result Types|\n"
     ]
    }
   ],
   "source": [
    "dj_circuit = deutsch_jozsa_circuit(const_oracle)\n",
    "print(dj_circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e3c3216",
   "metadata": {},
   "source": [
    "The oracle is the Boolean function that is applied to the $n$-qubits in the query register. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84eb4276",
   "metadata": {},
   "source": [
    "## Run on a local simulator\n",
    "\n",
    "If the output is \"000\", then the algorithm predicts a constant oracle. If the output is \"111\", it predicts balanced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c7c8d558",
   "metadata": {},
   "outputs": [],
   "source": [
    "from braket.devices import LocalSimulator\n",
    "\n",
    "device = LocalSimulator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bed79bcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "task = device.run(dj_circuit, shots=10_000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bf7c237",
   "metadata": {},
   "source": [
    "We can get the results with "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "60a41e3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'000': 1.0, '001': 0.0, '010': 0.0, '011': 0.0, '100': 0.0, '101': 0.0, '110': 0.0, '111': 0.0}\n"
     ]
    }
   ],
   "source": [
    "dj_probabilities = get_deutsch_jozsa_results(task)\n",
    "print(dj_probabilities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "02adfe3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_bitstrings(dj_probabilities)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "630ac053",
   "metadata": {},
   "source": [
    "We see that the probability of \"000\" is one, so the results correctly indicate that the oracle was constant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ad15c01f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task Summary\n",
      "{} \n",
      "\n",
      "Estimated cost to run this example: 0.00 USD\n"
     ]
    }
   ],
   "source": [
    "print(\"Task Summary\")\n",
    "print(f\"{tracker.quantum_tasks_statistics()} \\n\")\n",
    "print(f\"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost():.2f} USD\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.5 64-bit ('braket')",
   "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.5"
  },
  "vscode": {
   "interpreter": {
    "hash": "5904cb9a2089448a2e1aeb5d493d227c9de33e591d7c07e4016fb81e71061a5d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}