Feature: Add Hadamard Test

Author: blolt

notebooks/textbook/Hadamard_Test.ipynb

@@ -0,0 +1,373 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Hadamard Test\n",
+    "---\n",
+    "\n",
+    "\n",
+    "The Hadamard test is a quantum circuit that allows estimation of the real and imaginary parts of the expected value of a unitary operator. It is a fundamental subroutine used in many quantum algorithms. The test works by applying a controlled-unitary operation between an auxiliary qubit and the system of interest, with the measurement statistics of the auxiliary qubit encoding information about the unitary's expectation value. For the original paper, see [1]. For a more modern treatment, see [2].\n",
+    "\n",
+    "In this notebook, we explore the Braket implementation of the Hadamard test for estimating the real and imaginary parts of the expected value of a unitary operator.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "\n",
+    "[1] R. Cleve, A. Ekert, C. Macchiavello, and M. Mosca (1998). Quantum algorithms revisited. [arXiv:quant-ph/9708016](https://arxiv.org/abs/quant-ph/9708016).\n",
+    "\n",
+    "[2] Nielsen, Michael A., Chuang, Isaac L. (2010). Quantum Computation and Quantum Information (2nd ed.). Cambridge: Cambridge University Press."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "\n",
+    "Given a unitary operator $U$ and qubits $|0\\rangle|\\psi\\rangle$, the Hadamard test is used to estimate the expected value of $U$ on $|\\psi\\rangle$, i.e. $\\langle \\psi | U |\\psi \\rangle$. The algorithm is relatively straightforward, so we will walk through it step by step. First, we apply a Hadamard gate to $|0\\rangle$, putting the system into the state,\n",
+    " \n",
+    "$$\n",
+    "\\dfrac{|0\\rangle + |1\\rangle}{\\sqrt{2}}|\\psi\\rangle.\n",
+    "$$ \n",
+    " \n",
+    "We then apply the unitary operator $U$ on $|\\psi\\rangle$, controlled on the first qubit, to obtain the state, \n",
+    "$$\n",
+    "\\dfrac{|0\\rangle |\\psi\\rangle + |1\\rangle U |\\psi\\rangle}{\\sqrt{2}} .\n",
+    "$$ \n",
+    "Then, a Hadamard gate is applied to the first qubit once more, giving state,\n",
+    "$$\n",
+    "\\dfrac{|0\\rangle(|\\psi\\rangle + U |\\psi\\rangle) + |1\\rangle(|\\psi\\rangle - U |\\psi\\rangle)}{2}.\n",
+    "$$\n",
+    "\n",
+    "And this completes the Hadamard test. Now, we get the probability of measuring the first qubit in the state $|0\\rangle$ as\n",
+    "$$\n",
+    "\\begin{align*}\n",
+    "P_0 &= \\bigg\\lVert\\dfrac{|\\psi\\rangle + U|\\psi\\rangle}{2}\\bigg\\rVert^2 \\\\\n",
+    "    &= \\dfrac{\\langle \\psi | \\psi \\rangle + \\langle \\psi | U |\\psi \\rangle + \\langle \\psi | U^\\dagger |\\psi \\rangle + \\langle \\psi | U^\\dagger U |\\psi \\rangle}{4} \\\\\n",
+    "    &= \\dfrac{1 + 2\\langle \\psi | U |\\psi \\rangle + 1}{4}\\\\\n",
+    "    &= \\dfrac{1 + Re\\langle \\psi | U |\\psi \\rangle}{2},\n",
+    "\\end{align*}\n",
+    "$$\n",
+    "allowing us to estimate the expected value of the real part as $ Re(\\langle \\psi | U |\\psi \\rangle) = 2 P_0 - 1$. The algorithm can be modified to estimate the imaginary part by applying a phase shift to the first qubit after the first Hadamard gate, the proof of which is left as an exercise or inspiration for further reading.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run on a local simulator\n",
+    "\n",
+    "Braket provides a method, `hadamard_test_circuit`, for estimating both the expected values of both the real and imaginary parts of a given unitary operator. Furthermore, methods for the extended Hadamard test are also provided (TODO: write the extended Hadamard test). We will first go through an example of the basic Hadamard test."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from notebook_plotting import plot_bitstrings_formatted\n",
+    "import numpy as np\n",
+    "\n",
+    "%matplotlib inline\n",
+    "\n",
+    "from braket.aws import AwsDevice\n",
+    "from braket.circuits import Circuit\n",
+    "from braket.devices import LocalSimulator\n",
+    "from braket.tracking import Tracker\n",
+    "\n",
+    "from braket.experimental.algorithms.hadamard_test.hadamard_test import hadamard_test_circuit\n",
+    "\n",
+    "tracker = Tracker().start()  # to track Braket costs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For our controlled unitary operator, we will use the Pauli-Z gate, which is represented by the matrix,\n",
+    "$$\n",
+    "\\begin{bmatrix}\n",
+    "1 & 0 \\\\\n",
+    "0 & -1\n",
+    "\\end{bmatrix}\n",
+    "$$\n",
+    "Though braket has built-in support for the Pauli-Z gate, we will use the `unitary` method to apply the gate to the qubit. Consider playing around with different matrices to test your understanding of the algorithm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "T  : │  0  │\n",
+      "      ┌───┐ \n",
+      "q0 : ─┤ U ├─\n",
+      "      └───┘ \n",
+      "T  : │  0  │\n"
+     ]
+    }
+   ],
+   "source": [
+    "controlled_unitary = Circuit().unitary([0], np.array([[1, 0], [0, -1]]), \"U\")\n",
+    "print(controlled_unitary)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Real Part Estimation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "T  : │  0  │  1  │  2  │\n",
+      "      ┌───┐       ┌───┐ \n",
+      "q0 : ─┤ H ├───●───┤ H ├─\n",
+      "      └───┘   │   └───┘ \n",
+      "            ┌─┴─┐       \n",
+      "q1 : ───────┤ U ├───────\n",
+      "            └───┘       \n",
+      "T  : │  0  │  1  │  2  │\n"
+     ]
+    }
+   ],
+   "source": [
+    "ht_circuit = hadamard_test_circuit(controlled_unitary)\n",
+    "print(ht_circuit)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Braket's algorithms do not measure qubits themselves--this is left to the user, particularly because the Hadamard test is a subroutine in many quantum algorithms--so we will need to add a measurement gate to the circuit to see the algorithm's results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "T  : │  0  │  1  │  2  │  3  │\n",
+      "      ┌───┐       ┌───┐ ┌───┐ \n",
+      "q0 : ─┤ H ├───●───┤ H ├─┤ M ├─\n",
+      "      └───┘   │   └───┘ └───┘ \n",
+      "            ┌─┴─┐             \n",
+      "q1 : ───────┤ U ├─────────────\n",
+      "            └───┘             \n",
+      "T  : │  0  │  1  │  2  │  3  │\n"
+     ]
+    }
+   ],
+   "source": [
+    "ht_circuit.measure(0)\n",
+    "print(ht_circuit)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we can run the circuit on a local simulator. Take note of the small bit of algebra we need to extract the real part, which can also be seen in the description of the algorithm above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = LocalSimulator()\n",
+    "task = device.run(ht_circuit, shots=1000)\n",
+    "\n",
+    "counts = task.result().measurement_counts\n",
+    "p_zero = counts.get('0', 0) / 1000\n",
+    "\n",
+    "real_part = 2 * p_zero - 1\n",
+    "\n",
+    "print(real_part)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Imaginary Part Estimation\n",
+    "\n",
+    "Braket's `hadamard_test_circuit` supports the real part estimation by default, but we can also estimate the imaginary part by setting the `component` argument to `'imaginary'`. We will use the same controlled unitary operator as before."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "T  : │  0  │  1  │  2  │  3  │  4  │\n",
+      "      ┌───┐ ┌───┐       ┌───┐ ┌───┐ \n",
+      "q0 : ─┤ H ├─┤ S ├───●───┤ H ├─┤ M ├─\n",
+      "      └───┘ └───┘   │   └───┘ └───┘ \n",
+      "                  ┌─┴─┐             \n",
+      "q1 : ─────────────┤ U ├─────────────\n",
+      "                  └───┘             \n",
+      "T  : │  0  │  1  │  2  │  3  │  4  │\n"
+     ]
+    }
+   ],
+   "source": [
+    "ht_circuit = hadamard_test_circuit(controlled_unitary, component='imaginary')\n",
+    "ht_circuit.measure(0)\n",
+    "print(ht_circuit)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The only difference in the circuit is the addition of a phase shift gate to the first qubit, which allows us to estimate the expected value of the imaginary part."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-0.014000000000000012\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = LocalSimulator()\n",
+    "task = device.run(ht_circuit, shots=1000)\n",
+    "\n",
+    "counts = task.result().measurement_counts\n",
+    "p_zero = counts.get('0', 0) / 1000\n",
+    "\n",
+    "imaginary_part = 2 * p_zero - 1\n",
+    "\n",
+    "print(imaginary_part)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run on a QPU \n",
+    "\n",
+    "To run the Hadamard test on a QPU, we replace the LocalSimulator with an AwsDevice. The cost to run this experiment is $0.3 per task and $0.00145 per shot on the IQM Garnet device, that totals $1.75 USD. Because Garnet does not support arbitrary unitary operators, we will directly apply the Pauli-Z gate in this example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# controlled_unitary = Circuit().z(0)\n",
+    "# ht_circuit = hadamard_test_circuit(controlled_unitary)\n",
+    "# ht_circuit.measure(0)\n",
+    "# print(ht_circuit)\n",
+    "\n",
+    "# device = AwsDevice(\"arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet\")\n",
+    "# task = device.run(ht_circuit, shots=1000)\n",
+    "\n",
+    "# counts = task.result().measurement_counts\n",
+    "# p_zero = counts.get('0', 0) / 1000\n",
+    "\n",
+    "# real_part = 2 * p_zero - 1\n",
+    "\n",
+    "# print(real_part)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "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(\n",
+    "    f\"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost():.2f} USD\"\n",
+    ")"
+   ]
+  },
+  {
+   "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": "env",
+   "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.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

src/braket/experimental/algorithms/hadamard_test/__init__.py

@@ -0,0 +1,16 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+from braket.experimental.algorithms.hadamard_test.hadamard_test import (  # noqa: F401
+    hadamard_test_circuit
+)