notebooks/textbook/Quantum_Phase_Estimation_Algorithm.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Quantum Phase Estimation"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "This example provides an implementation of the Quantum Phase Estimation (QPE) algorithm using the Amazon Braket SDK.\n",
                "The Quantum Phase Estimation algorithm is designed to estimate the eigenvalues of a unitary operator $U$ [1, 2]; \n",
                "It is a very important subroutine to many quantum algorithms, most famously Shor's algorithm for factoring and the HHL algorithm (named after the physicists Harrow, Hassidim and Lloyd) for solving linear systems of equations on a quantum computer [1, 2]. \n",
                "Moreover, eigenvalue problems can be found across many disciplines and application areas, including principal component analysis (PCA) as used in machine learning or the solution of differential equations as relevant across mathematics, physics, engineering and chemistry. \n",
                "This notebook implements the Quantum Phase Estimation algorithm in code using the Amazon Braket SDK and run a simple example. \n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## References\n",
                "\n",
                "[[1] Quantum Algorithm Implementations for Beginners](https://arxiv.org/abs/1804.03719)\n",
                "\n",
                "[[2] Wikipedia Quantum_phase_estimation_algorithm](https://en.wikipedia.org/wiki/Quantum_phase_estimation_algorithm)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "import matplotlib.pyplot as plt\n",
                "from braket.aws import AwsDevice\n",
                "from braket.circuits import Circuit, circuit\n",
                "from braket.devices import LocalSimulator\n",
                "\n",
                "from braket.experimental.algorithms.quantum_phase_estimation import (\n",
                "    get_quantum_phase_estimation_results,\n",
                "    run_quantum_phase_estimation,\n",
                "    quantum_phase_estimation_circuit,\n",
                ")\n",
                "\n",
                "# magic word for producing visualizations in notebook\n",
                "%matplotlib inline\n",
                "%load_ext autoreload\n",
                "%autoreload 2"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Prepare Quantum Phase Estimation inputs\n",
                "\n",
                "The QPE algorithm requires two input register and a unitary on which you want to estimate eigenvalues. The first register is the precision register with n qubits which sets the achievable precision of results.\n",
                "The second is the query register which hosts the eigenstate."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [],
            "source": [
                "# Define a callback function to apply your controlled unitary to a given circuit.\n",
                "# This is used by the Quantum Phase Estimation algorithm to apply your controlled unitary.\n",
                "# To run on a QPU this controlled unitary needs to be decomposed into gates available for a given QPU.\n",
                "def unitary_apply_cnot_func(quantum_phase_estimation_circ, control_qubit, query_qubits):\n",
                "    quantum_phase_estimation_circ.cnot(control_qubit, query_qubits)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {},
            "outputs": [],
            "source": [
                "# Define first (precision) and second (query) registers. Qubits must be contiguous.\n",
                "# Braket simulator and Quantum Phase Estimation post procssing logic assumes contiguous qubits.\n",
                "precision_qubits = [0, 1]\n",
                "query_qubits = [2]\n",
                "\n",
                "# The query register needs to be prepared in an eigenstate depending on the unitary chosen.\n",
                "# For this example prepare the query register with Hadamard gates.\n",
                "quantum_phase_estimation_circ = Circuit().h(query_qubits)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Create and visualize the Quantum Phase Estimation circuit\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Quantum Phase Estimation Circuit:\n",
                        "T  : |0|1| 2  |3|     4      |5|Result Types|\n",
                        "                                             \n",
                        "q0 : -H---SWAP---PHASE(-1.57)-H-Probability--\n",
                        "          |      |              |            \n",
                        "q1 : -H-C-SWAP-H-C--------------Probability--\n",
                        "        |                       |            \n",
                        "q2 : -H-X-----------------------Probability--\n",
                        "\n",
                        "T  : |0|1| 2  |3|     4      |5|Result Types|\n"
                    ]
                }
            ],
            "source": [
                "# Now that you have prepped the unitary, precision qubits, and query qubits,\n",
                "# create the quantum phase estimation circuit with all three as input.\n",
                "quantum_phase_estimation_circ = quantum_phase_estimation_circuit(\n",
                "    quantum_phase_estimation_circ, precision_qubits, query_qubits, unitary_apply_cnot_func\n",
                ")\n",
                "print(\"Quantum Phase Estimation Circuit:\")\n",
                "print(quantum_phase_estimation_circ)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Run on a local simulator"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Quantum Phase Estimation Running\n",
                        "Quantum Phase Estimation Run Complete\n",
                        "Quantum Phase Estimation Results:\n",
                        "Measurement counts: Counter({'001': 545, '000': 455})\n",
                        "Results in precision register: {'00': 1000}\n",
                        "Quantum Phase Estimation phase estimates: [0.0]\n",
                        "Quantum phase estimation eigenvalue estimates: [1.+0.j]\n",
                        "Measurement Counts Graph:\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 640x480 with 1 Axes>"
                        ]
                    },
                    "metadata": {
                        "needs_background": "light"
                    },
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# define device and run quantum phase estimation\n",
                "device = LocalSimulator()\n",
                "print(\"Quantum Phase Estimation Running\")\n",
                "task = run_quantum_phase_estimation(quantum_phase_estimation_circ, device)\n",
                "print(\"Quantum Phase Estimation Run Complete\")\n",
                "# pretty print results. Comment out these lines if you don't want results printed\n",
                "print(\"Quantum Phase Estimation Results:\")\n",
                "agg_result = get_quantum_phase_estimation_results(\n",
                "    task, precision_qubits, query_qubits, verbose=True\n",
                ")\n",
                "# plot probabalities\n",
                "plt.bar(agg_result[\"bitstring_keys\"], agg_result[\"probs_values\"])\n",
                "plt.xlabel(\"bitstrings\")\n",
                "plt.ylabel(\"probability\")\n",
                "plt.xticks(rotation=90)\n",
                "print(\"Measurement Counts Graph:\")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Run on a Managed Simulator or QPU\n",
                "The call to run on the QPU device is commented out by default and instead runs on a managed simulator. See the follow cells to switch to run on a QPU.\n",
                "Note that 1) this may take time depending on QPU availability and 2) results will be noisy relative to the simulator run."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {},
            "outputs": [],
            "source": [
                "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n",
                "from braket.tracking import Tracker\n",
                "\n",
                "tracker = Tracker().start()"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Quantum Phase Estimation Running\n",
                        "Quantum Phase Estimation Run Complete\n",
                        "Quantum Phase Estimation Results:\n",
                        "Measurement counts: Counter({'000': 505, '001': 495})\n",
                        "Results in precision register: {'00': 1000}\n",
                        "Quantum phase estimation phase estimates: [0.0]\n",
                        "Quantum phase estimation eigenvalue estimates: [1.+0.j]\n",
                        "Measurement Counts Graph:\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 640x480 with 1 Axes>"
                        ]
                    },
                    "metadata": {
                        "needs_background": "light"
                    },
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# define device and run quantum phase estimation\n",
                "# managed_device = AwsDevice('arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-2')\n",
                "managed_device = AwsDevice('arn:aws:braket:::device/quantum-simulator/amazon/sv1')\n",
                "print('Quantum Phase Estimation Running')\n",
                "task = run_quantum_phase_estimation(quantum_phase_estimation_circ, managed_device, shots=1000)\n",
                "print('Quantum Phase Estimation Run Complete')\n",
                "# pretty print results\n",
                "print('Quantum Phase Estimation Results:')\n",
                "agg_result = get_quantum_phase_estimation_results(task, precision_qubits, query_qubits, verbose=True)\n",
                "# plot probabalities\n",
                "plt.bar(agg_result[\"bitstring_keys\"], agg_result[\"probs_values\"])\n",
                "plt.xlabel(\"bitstrings\")\n",
                "plt.ylabel(\"probability\")\n",
                "plt.xticks(rotation=90)\n",
                "print(\"Measurement Counts Graph:\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Task Summary\n",
                        "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1000, 'tasks': {'COMPLETED': 1}, 'execution_duration': datetime.timedelta(microseconds=5000), 'billed_execution_duration': datetime.timedelta(seconds=3)}} \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.8.10 ('venv': venv)",
            "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.8.10"
        },
        "vscode": {
            "interpreter": {
                "hash": "590fab68195cf107911461461f81d5c472d3d6127f579badfcfad30f03e5cab2"
            }
        }
    },
    "nbformat": 4,
    "nbformat_minor": 4
}