{ "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": [ "
" ] }, "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 }