From 5d98b9f330a113f2e7209aa117b41e2f703a63ad Mon Sep 17 00:00:00 2001 From: Prakash Bhat Date: Thu, 13 Oct 2022 17:52:10 -0400 Subject: [PATCH 1/7] initial --- .../Violation_of_Bells_Inequality.ipynb | 408 ++++++++++++++++++ 1 file changed, 408 insertions(+) create mode 100644 examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb diff --git a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb new file mode 100644 index 000000000..5ad791e2f --- /dev/null +++ b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb @@ -0,0 +1,408 @@ +{ + "cells": [ + { + "attachments": { + "Bell_test.drawio.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Demonstrating Violation of Bell's Inequality\n", + "\n", + "This tutorial shows how to run a version of Bell's inequality experiment in Braket on different QPUs. \n", + "\n", + "\n", + "## EPR state\n", + "\n", + "Consider two spin-1/2 particles in the singlet state:\n", + "$$ |\\psi^{-}\\rangle = \\frac{1}{\\sqrt{2}} \\left(|0\\rangle_{Alice}|1\\rangle_{\\text Bob} - |1\\rangle_{Alice}|0\\rangle_{\\text Bob} \\right).$$\n", + "\n", + "Suppose the particles are separated and sent to different experimentalists: Alice and Bob. The property of interest is that the two particles are entangled. If a measurement on particle 1 along $\\mathbf{\\hat n}$ gives $+1$, then measuring particle 2 in $\\mathbf{\\hat n}$ will give $-1$. This is perfect anti-correlation when both particles are measured in the same basis. A remarkable property of quantum mechancis is that this anti-correlation is basis independent. If the pair is entangled, it's entangled in all possible measurement bases. \n", + "\n", + "\n", + "What about the case where Alice measures in $\\mathbf{\\hat n_1}$ and Bob measures in a different directoin $\\mathbf{\\hat n_2}$? \n", + "It can be shown that the expected value of the measurement outcomes is\n", + "\n", + "$$E^{\\psi^{-}}(\\mathbf{\\hat n_1}, \\mathbf{\\hat n_2}) = -\\cos\\left(\\theta_{\\mathbf{\\hat n_1}, \\mathbf{\\hat n_2}}\\right) $$\n", + "\n", + "where $\\theta_{\\mathbf{\\hat n_1}, \\mathbf{\\hat n_2}}$ is the angle between the two directions. If $\\mathbf{\\hat n_1}$ and $\\mathbf{\\hat n_2}$ are aligned (angle between them is 0), then the results will be perfectly anticorrelated. If they are perpendicular (angle $\\pi/2$), the results will be independent.\n", + "\n", + "## Bell's Inequality\n", + "\n", + "Bell's experiment considers that would happen if Alice and Bob each measure in two different directions.Alice will measure in $\\mathbf{\\hat a}$ and $\\mathbf{\\hat b}$, while Bob will measure in $\\mathbf{\\hat a}$ and $\\mathbf{\\hat c}$.\n", + "\n", + "![Bell_test.drawio.png](attachment:Bell_test.drawio.png)\n", + "\n", + "\n", + "Bell derived that if there was some pre-existing physical property that the measurement \"uncovers\", and if the measurements are not causally related, then the expectation values of the singlet state must obey:\n", + "\n", + "$$ |E^{\\psi^{-}}(\\mathbf{\\hat a}, \\mathbf{\\hat b}) - E^{\\psi^{-}}(\\mathbf{\\hat a}, \\mathbf{\\hat c})| - E^{\\psi^{-}}(\\mathbf{\\hat b}, \\mathbf{\\hat c}) \\leq 1$$\n", + "\n", + "for three directions $\\mathbf{\\hat a}, \\mathbf{\\hat b}, \\mathbf{\\hat c}$. Violation of this inequality undermines the assumptions of local hidden variables to explain entanglement. This is the original version of Bell's inequality [1]. \n", + "\n", + "Without loss of generality, we choose $\\mathbf{\\hat a}, \\mathbf{\\hat b}, \\mathbf{\\hat c}$ to lie in the $y-z$ plane. We can also choose $\\mathbf{\\hat a} = \\mathbf{\\hat z}$ so that $\\mathbf{\\hat b}, \\mathbf{\\hat c}$ are completely defined by their angles $\\theta_{\\mathbf{\\hat b}}$ and $\\theta_{\\mathbf{\\hat c}}$ from the $z$-axis. Bell's inequality then becomes \n", + "\n", + "$$\n", + "|-\\cos\\theta_{\\mathbf{\\hat b}} + \\cos\\theta_{\\mathbf{\\hat c}}| + \\cos(\\theta_{\\mathbf{\\hat c}}-\\theta_{\\mathbf{\\hat b}}) \\leq 1\n", + "$$\n", + "In the cell below, we plot the lef-hand-side of this equation for various values of $\\theta_{AB}, \\theta_{BC}$. The maximum value is $1.5 \\nleq 1$ which occurs at $\\theta_{\\mathbf{\\hat b}}=\\pi/3$, $\\theta_{\\mathbf{\\hat c}} = 2\\pi/3$as confirmed in the plot. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from matplotlib import cm, ticker\n", + "\n", + "N = 1_00\n", + "a, b = np.mgrid[0:N, 0:N] / (2 * N)\n", + "bell_terms = np.abs(np.cos(a * np.pi + b * np.pi) - np.cos(a * np.pi)) + np.cos(\n", + " b * np.pi\n", + ")\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 3))\n", + "cs = ax.contourf(a, b, bell_terms, cmap=cm.PuBu_r, levels=30)\n", + "ax.xaxis.set_major_formatter(ticker.FormatStrFormatter(r\"%g$\\pi$\"))\n", + "ax.yaxis.set_major_formatter(ticker.FormatStrFormatter(r\"%g$\\pi$\"))\n", + "cbar = fig.colorbar(cs, ticks=[1, 1.5])\n", + "cbar.ax.set_yticklabels([\"1\", \"1.5\"])\n", + "ax.set(\n", + " xlim=(0, 0.5),\n", + " ylim=(0, 0.5),\n", + " xlabel=r\"$\\theta_{\\mathbf{\\hat b}}$\",\n", + " ylabel=r\"$\\theta_{\\mathbf{\\hat c}}-\\theta_{\\mathbf{\\hat b}}$\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing Bell's inequality on quantum computers\n", + "\n", + "We start by preparing the Bell singlet state in Braket. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from braket.aws import AwsDevice, AwsQuantumTask\n", + "from braket.circuits import Circuit, Gate, Observable\n", + "from braket.devices import LocalSimulator" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def bell_singlet(qubit0, qubit1):\n", + " return Circuit().x(qubit0).x(qubit1).h(qubit0).cnot(qubit0, qubit1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T : |0|1|2|\n", + " \n", + "q0 : -X-H-C-\n", + " | \n", + "q1 : -X---X-\n", + "\n", + "T : |0|1|2|\n" + ] + } + ], + "source": [ + "print(bell_singlet(0, 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we want to measure in different basis defined by $\\mathbf{\\hat b}$ or $\\mathbf{\\hat c}$. Since the directions lie in the $y-z$ plane, we can get we must rotate the state by by $\\theta_{\\mathbf{\\hat b}}$ and $\\theta_{\\mathbf{\\hat c}}$ around the $x$-axis using a rotation gate $Rx(\\theta)$. Alice applies rotation $Rx(\\theta)$ on the first spin, and Bob applied $Rx(\\theta)$ to the second spin. The three experiments we need to perform are summarized in the table below.\n", + "\n", + "| | $\\text{Alice}$ | $\\text{Bob}$ |\n", + "| :-: | :-: | :-: |\n", + "| AB | $0$ | $\\pi/3$ |\n", + "| AC | $0$ | $2\\pi/3$ |\n", + "| BC | $\\pi/3$ | $2\\pi/3$ |\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def bell_singlet_rotated(qubit0, qubit1, rotation0, rotation1):\n", + " c = bell_singlet(qubit0, qubit1)\n", + " if rotation0 != 0:\n", + " c = c.rx(qubit0, rotation0)\n", + " if rotation1 != 0:\n", + " c = c.rx(qubit1, rotation1)\n", + " c.sample(Observable.Z())\n", + " return c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The three Bell circuits to run are:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T : |0|1|2| 3 |Result Types|\n", + " \n", + "q0 : -X-H-C-Rx(1.05)-Sample(Z)----\n", + " | | \n", + "q1 : -X---X-Rx(2.09)-Sample(Z)----\n", + "\n", + "T : |0|1|2| 3 |Result Types|\n" + ] + } + ], + "source": [ + "circAB = bell_singlet_rotated(0, 1, 0, np.pi / 3.0)\n", + "circAC = bell_singlet_rotated(0, 1, 0, 2 * np.pi / 3.0)\n", + "circBC = bell_singlet_rotated(0, 1, np.pi / 3.0, 2 * np.pi / 3.0)\n", + "print(circBC)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P(a,b) = -0.4938,P(a,c) = 0.5042,P(b,c) = -0.5047999999999999\n", + "Bell inequality: 1.5028 ≤ 1\n" + ] + } + ], + "source": [ + "res = [\n", + " LocalSimulator().run(circ, shots=10_000).result().measurement_probabilities\n", + " for circ in [circAB, circAC, circBC]\n", + "]\n", + "prob_same = [d[\"00\"] + d[\"11\"] for d in res]\n", + "prob_different = [d[\"01\"] + d[\"10\"] for d in res]\n", + "pAB, pAC, pBC = np.array(prob_same) - np.array(prob_different)\n", + "print(\n", + " f\"P(a,b) = {pAB},P(a,c) = {pAC},P(b,c) = {pBC}\\nBell inequality: {np.abs(pAB - pAC) - pBC} ≤ 1\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Bell inequality is violated just as predicted by quantum mechanics! \n", + "\n", + "# Running on QPUs\n", + "\n", + "Let's wrap those methods into a function so we can easily run on different QPUs." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def submit_bell_tasks(device, shots=1_000):\n", + " circAB = bell_singlet_rotated(0, 1, 0, np.pi / 3.0)\n", + " circAC = bell_singlet_rotated(0, 1, 0, 2 * np.pi / 3.0)\n", + " circBC = bell_singlet_rotated(0, 1, np.pi / 3.0, 2 * np.pi / 3.0)\n", + " tasks = [device.run(circ, shots=shots) for circ in [circAB, circAC, circBC]]\n", + " return tasks\n", + "\n", + "\n", + "def get_results(tasks, verbose=True):\n", + " results = [task.result().measurement_probabilities for task in tasks]\n", + " prob_same = [d[\"00\"] + d[\"11\"] for d in results]\n", + " prob_different = [d[\"01\"] + d[\"10\"] for d in results]\n", + " pAB, pAC, pBC = np.array(prob_same) - np.array(prob_different)\n", + " if verbose == True:\n", + " print(\n", + " f\"P(a,b) = {pAB},P(a,c) = {pAC},P(b,c) = {pBC}\\nBell inequality: {np.abs(pAB - pAC) - pBC} ≤ 1\"\n", + " )\n", + " return results, pAB, pAC, pBC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we test the Bell inequality on OQC Lucy device. The cost to run this experiment is $\\$ 0.3$ per task and $\\$0.00035$ per shot. Since we have three circuits of 1000 shots each, that totals $\\$1.95$ USD.\n", + "\n", + "**Cost: $\\$1.95$ USD**" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "oqc_lucy = AwsDevice(\"arn:aws:braket:eu-west-2::device/qpu/oqc/Lucy\")\n", + "oqc_tasks = submit_bell_tasks(oqc_lucy)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If above taking long time, you can check your tasks if queued: https://us-east-1.console.aws.amazon.com/braket/home?region=eu-west-2#/tasks" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P(a,b) = -0.451,P(a,c) = 0.488,P(b,c) = -0.431\n", + "Bell inequality: 1.37 ≤ 1\n" + ] + } + ], + "source": [ + "results, pAB, pAC, pBC = get_results(ionq_tasks)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bell's inequality is violated! Notice that the quantity is not exactly $1.5$ as predicted by theory. This is due to the effects of noise on the QPU. See https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Noise_models/Noise_models_on_Rigetti_AspenM2.ipynb for an example of modeling the noise properties of a QPU. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we submit our example Bell state circuit to IonQ. This task may not readily be executed but enter a queue for this specific machine. While we can interrupt our kernel (and work on something else), we can always recover our results using the unique ID of this task.\n", + "\n", + "**Cost: $\\$30$ USD**" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "ionq_harmony = AwsDevice(\"arn:aws:braket:::device/qpu/ionq/ionQdevice\")\n", + "ionq_tasks = submit_bell_tasks(ionq_harmony)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P(a,b) = -0.476,P(a,c) = 0.496,P(b,c) = -0.45599999999999996\n", + "Bell inequality: 1.428 ≤ 1\n" + ] + } + ], + "source": [ + "results, pAB, pAC, pBC = get_results(ionq_tasks)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we see that Bell's inequality is violated. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "[1] Bell, J. S. On the Einstein Podolsky Rosen Paradox. Physics Physique Fizika 1, no. 3 (November 1, 1964): 195–200. https://doi.org/10.1103/PhysicsPhysiqueFizika.1.195.\n", + "\n", + "\n", + "[2] Greenberger, Daniel M., Michael A. Horne, Abner Shimony, and Anton Zeilinger (1990). Bell’s Theorem without Inequalities. American Journal of Physics 58, no. 12: 1131–43. https://doi.org/10.1119/1.16243." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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": "7c1d46b20c29fdc8b64b33c273bbdafe88648e7d75a1d0d158ccf067a4c62493" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 2b2b273daed572fffea584edb7559bf0497645bf Mon Sep 17 00:00:00 2001 From: Prakash Bhat Date: Sun, 16 Oct 2022 14:38:08 -0400 Subject: [PATCH 2/7] Fixed some typo, made some info explicit, made inequality similar to one in Bells Paper --- .../Violation_of_Bells_Inequality.ipynb | 91 +++++++++++++------ 1 file changed, 64 insertions(+), 27 deletions(-) diff --git a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb index 5ad791e2f..7a16e7954 100644 --- a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb +++ b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb @@ -31,23 +31,28 @@ "\n", "## Bell's Inequality\n", "\n", - "Bell's experiment considers that would happen if Alice and Bob each measure in two different directions.Alice will measure in $\\mathbf{\\hat a}$ and $\\mathbf{\\hat b}$, while Bob will measure in $\\mathbf{\\hat a}$ and $\\mathbf{\\hat c}$.\n", + "Bell's experiment considers that would happen if Alice and Bob each measure in two different directions.Alice will measure in $\\mathbf{\\hat a}$ and $\\mathbf{\\hat b}$, while Bob will measure in $\\mathbf{\\hat b}$ and $\\mathbf{\\hat c}$.\n", "\n", "![Bell_test.drawio.png](attachment:Bell_test.drawio.png)\n", "\n", "\n", "Bell derived that if there was some pre-existing physical property that the measurement \"uncovers\", and if the measurements are not causally related, then the expectation values of the singlet state must obey:\n", "\n", - "$$ |E^{\\psi^{-}}(\\mathbf{\\hat a}, \\mathbf{\\hat b}) - E^{\\psi^{-}}(\\mathbf{\\hat a}, \\mathbf{\\hat c})| - E^{\\psi^{-}}(\\mathbf{\\hat b}, \\mathbf{\\hat c}) \\leq 1$$\n", + "$$ |P(\\mathbf{\\hat a}, \\mathbf{\\hat b}) - P(\\mathbf{\\hat a}, \\mathbf{\\hat c})| - P(\\mathbf{\\hat b}, \\mathbf{\\hat c}) \\leq 1$$\n", "\n", "for three directions $\\mathbf{\\hat a}, \\mathbf{\\hat b}, \\mathbf{\\hat c}$. Violation of this inequality undermines the assumptions of local hidden variables to explain entanglement. This is the original version of Bell's inequality [1]. \n", "\n", + "$P(\\mathbf{\\hat a}, \\mathbf{\\hat b}) $ is also called correlation or singlet state expectation $E^{\\psi^{-}}(\\mathbf{\\hat a}, \\mathbf{\\hat b})$. \n", + "\n", "Without loss of generality, we choose $\\mathbf{\\hat a}, \\mathbf{\\hat b}, \\mathbf{\\hat c}$ to lie in the $y-z$ plane. We can also choose $\\mathbf{\\hat a} = \\mathbf{\\hat z}$ so that $\\mathbf{\\hat b}, \\mathbf{\\hat c}$ are completely defined by their angles $\\theta_{\\mathbf{\\hat b}}$ and $\\theta_{\\mathbf{\\hat c}}$ from the $z$-axis. Bell's inequality then becomes \n", "\n", "$$\n", "|-\\cos\\theta_{\\mathbf{\\hat b}} + \\cos\\theta_{\\mathbf{\\hat c}}| + \\cos(\\theta_{\\mathbf{\\hat c}}-\\theta_{\\mathbf{\\hat b}}) \\leq 1\n", "$$\n", - "In the cell below, we plot the lef-hand-side of this equation for various values of $\\theta_{AB}, \\theta_{BC}$. The maximum value is $1.5 \\nleq 1$ which occurs at $\\theta_{\\mathbf{\\hat b}}=\\pi/3$, $\\theta_{\\mathbf{\\hat c}} = 2\\pi/3$as confirmed in the plot. " + "\n", + "In the cell below, we plot the lef-hand-side of this equation for various values of $ \\theta_{\\mathbf{\\hat b}} \\ and \\ (\\theta_{\\mathbf{\\hat c}}-\\theta_{\\mathbf{\\hat b}}) $\\.\n", + "\n", + "The maximum value is $1.5 \\nleq 1$ which occurs at $\\theta_{\\mathbf{\\hat b}}=\\pi/3$, $\\theta_{\\mathbf{\\hat c}} = 2\\pi/3$as confirmed in the plot. " ] }, { @@ -57,7 +62,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -72,13 +77,15 @@ "from matplotlib import cm, ticker\n", "\n", "N = 1_00\n", - "a, b = np.mgrid[0:N, 0:N] / (2 * N)\n", - "bell_terms = np.abs(np.cos(a * np.pi + b * np.pi) - np.cos(a * np.pi)) + np.cos(\n", - " b * np.pi\n", + "#b is grid index for angle: theta b\n", + "#cmb is grid index for angle: theta c - theta b\n", + "b, cmb = np.mgrid[0:N, 0:N] / (2 * N)\n", + "bell_terms = np.abs(np.cos(b * np.pi + cmb * np.pi) - np.cos(b * np.pi)) + np.cos(\n", + " cmb * np.pi\n", ")\n", "\n", "fig, ax = plt.subplots(figsize=(5, 3))\n", - "cs = ax.contourf(a, b, bell_terms, cmap=cm.PuBu_r, levels=30)\n", + "cs = ax.contourf(b, cmb, bell_terms, cmap=cm.PuBu_r, levels=30)\n", "ax.xaxis.set_major_formatter(ticker.FormatStrFormatter(r\"%g$\\pi$\"))\n", "ax.yaxis.set_major_formatter(ticker.FormatStrFormatter(r\"%g$\\pi$\"))\n", "cbar = fig.colorbar(cs, ticks=[1, 1.5])\n", @@ -125,7 +132,9 @@ { "cell_type": "code", "execution_count": 4, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", @@ -149,7 +158,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Next, we want to measure in different basis defined by $\\mathbf{\\hat b}$ or $\\mathbf{\\hat c}$. Since the directions lie in the $y-z$ plane, we can get we must rotate the state by by $\\theta_{\\mathbf{\\hat b}}$ and $\\theta_{\\mathbf{\\hat c}}$ around the $x$-axis using a rotation gate $Rx(\\theta)$. Alice applies rotation $Rx(\\theta)$ on the first spin, and Bob applied $Rx(\\theta)$ to the second spin. The three experiments we need to perform are summarized in the table below.\n", + "In quantum computers we can not make measurement in any aribtrary angle (please refer to documentation about Observable in https://docs.aws.amazon.com/braket/latest/developerguide/braket-result-types.html). But, we can rotate the qubit state by same angle but in opposite direction to achive effectively the same outcome. For example, to effectively measure in basis $\\mathbf{\\hat b}$ which is in counterclockwise angle $\\theta_{\\mathbf{\\hat b}}$ in the above depicted diagram, we need to rotate the qubit by clockwise by angle $\\theta_{\\mathbf{\\hat b}}$. We can rotate each entangled qubit by different angles and do the measurement effectively in different basis at respective angles.\n", + "\n", + "Next, we want to measure in different basis defined by $\\mathbf{\\hat b}$ or $\\mathbf{\\hat c}$. \n", + "Since the directions lie in the $y-z$ plane, we can get we must rotate the state by by $\\theta_{\\mathbf{\\hat b}}$ and $\\theta_{\\mathbf{\\hat c}}$ around the $x$-axis using a rotation gate $Rx(\\theta)$. Alice applies rotation $Rx(\\theta)$ on the first spin, and Bob applied $Rx(\\theta)$ to the second spin. The three experiments we need to perform are summarized in the table below.\n", "\n", "| | $\\text{Alice}$ | $\\text{Bob}$ |\n", "| :-: | :-: | :-: |\n", @@ -204,6 +216,7 @@ "circAB = bell_singlet_rotated(0, 1, 0, np.pi / 3.0)\n", "circAC = bell_singlet_rotated(0, 1, 0, 2 * np.pi / 3.0)\n", "circBC = bell_singlet_rotated(0, 1, np.pi / 3.0, 2 * np.pi / 3.0)\n", + "#printing circBC as an example of the three circuits\n", "print(circBC)" ] }, @@ -228,6 +241,8 @@ "]\n", "prob_same = [d[\"00\"] + d[\"11\"] for d in res]\n", "prob_different = [d[\"01\"] + d[\"10\"] for d in res]\n", + "\n", + "#P() below refers to expectation or corellation of the measurement of the entangled qubits with value ranging from 1 to -1\n", "pAB, pAC, pBC = np.array(prob_same) - np.array(prob_different)\n", "print(\n", " f\"P(a,b) = {pAB},P(a,c) = {pAC},P(b,c) = {pBC}\\nBell inequality: {np.abs(pAB - pAC) - pBC} ≤ 1\"\n", @@ -238,11 +253,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The Bell inequality is violated just as predicted by quantum mechanics! \n", + "The Bell inequality is violated just as predicted by quantum mechanics by the simulator! Some times you may see inequality values little bit above 1.5 depending on the quantum randomness simulated by the simulator eventhough theoretical maximum is 1.5.\n", "\n", "# Running on QPUs\n", "\n", - "Let's wrap those methods into a function so we can easily run on different QPUs." + "Let's wrap those steps into couple of python functions so we can easily run on different QPUs." ] }, { @@ -255,10 +270,12 @@ " circAB = bell_singlet_rotated(0, 1, 0, np.pi / 3.0)\n", " circAC = bell_singlet_rotated(0, 1, 0, 2 * np.pi / 3.0)\n", " circBC = bell_singlet_rotated(0, 1, np.pi / 3.0, 2 * np.pi / 3.0)\n", - " tasks = [device.run(circ, shots=shots) for circ in [circAB, circAC, circBC]]\n", + " tasks = [\n", + " device.run(circ, shots=shots)\n", + " for circ in [circAB, circAC, circBC]\n", + " ]\n", " return tasks\n", "\n", - "\n", "def get_results(tasks, verbose=True):\n", " results = [task.result().measurement_probabilities for task in tasks]\n", " prob_same = [d[\"00\"] + d[\"11\"] for d in results]\n", @@ -271,6 +288,13 @@ " return results, pAB, pAC, pBC" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If below QPU related cells taking a long time, you can check the task status in braket console tasks page in the right region. QPU avaiability hours differ and documented in the braket console devices page. You can also export this notebook as a python program and submit it as a braket job in the console." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -281,26 +305,28 @@ ] }, { - "cell_type": "code", - "execution_count": 9, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "oqc_lucy = AwsDevice(\"arn:aws:braket:eu-west-2::device/qpu/oqc/Lucy\")\n", - "oqc_tasks = submit_bell_tasks(oqc_lucy)" + "If below QPU related cells taking long time, you can check the task status in braket console tasks page in the right region. QPU avaiability hours differ and documented in the braket console devices page. You can also export this notebook as a python program and submit it as a braket job in the console." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 9, "metadata": {}, + "outputs": [], "source": [ - "If above taking long time, you can check your tasks if queued: https://us-east-1.console.aws.amazon.com/braket/home?region=eu-west-2#/tasks" + "oqc_lucy = AwsDevice(\"arn:aws:braket:eu-west-2::device/qpu/oqc/Lucy\")\n", + "oqc_tasks = submit_bell_tasks(oqc_lucy)" ] }, { "cell_type": "code", "execution_count": 10, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", @@ -312,7 +338,7 @@ } ], "source": [ - "results, pAB, pAC, pBC = get_results(ionq_tasks)" + "results, pAB, pAC, pBC = get_results(oqc_lucy)" ] }, { @@ -366,6 +392,17 @@ "Again, we see that Bell's inequality is violated. " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Related non-peer reviewed links:\n", + "\n", + "https://en.wikipedia.org/wiki/Singlet_state#Singlets_and_entangled_states\n", + "\n", + "https://en.wikipedia.org/wiki/Bell%27s_theorem#Bell_(1964)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -375,15 +412,15 @@ "[1] Bell, J. S. On the Einstein Podolsky Rosen Paradox. Physics Physique Fizika 1, no. 3 (November 1, 1964): 195–200. https://doi.org/10.1103/PhysicsPhysiqueFizika.1.195.\n", "\n", "\n", - "[2] Greenberger, Daniel M., Michael A. Horne, Abner Shimony, and Anton Zeilinger (1990). Bell’s Theorem without Inequalities. American Journal of Physics 58, no. 12: 1131–43. https://doi.org/10.1119/1.16243." + "[2] Greenberger, Daniel M., Michael A. Horne, Abner Shimony, and Anton Zeilinger (1990). Bell’s Theorem without Inequalities. American Journal of Physics 58, no. 12: 1131–43. https://doi.org/10.1119/1.16243.\n" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "conda_braket", "language": "python", - "name": "python3" + "name": "conda_braket" }, "language_info": { "codemirror_mode": { @@ -395,7 +432,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.7.13" }, "vscode": { "interpreter": { From 267bbd0228ef514626cef5b2dcca54306e508817 Mon Sep 17 00:00:00 2001 From: Prakash Bhat Date: Sun, 16 Oct 2022 15:43:57 -0400 Subject: [PATCH 3/7] moved to subdir --- .../Violation_of_Bells_Inequality.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename examples/advanced_circuits_algorithms/{ => Violation_of_Bells_Inequality}/Violation_of_Bells_Inequality.ipynb (100%) diff --git a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb similarity index 100% rename from examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality.ipynb rename to examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb From a8e263c28713d5334dddd73bd7481d21a540ef40 Mon Sep 17 00:00:00 2001 From: Prakash Bhat Date: Sun, 16 Oct 2022 15:46:33 -0400 Subject: [PATCH 4/7] nbqa black Violation_of_Bells_Inequality.ipynb --- .../Violation_of_Bells_Inequality.ipynb | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb index 7a16e7954..4cfd1fc3b 100644 --- a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb +++ b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb @@ -77,8 +77,8 @@ "from matplotlib import cm, ticker\n", "\n", "N = 1_00\n", - "#b is grid index for angle: theta b\n", - "#cmb is grid index for angle: theta c - theta b\n", + "# b is grid index for angle: theta b\n", + "# cmb is grid index for angle: theta c - theta b\n", "b, cmb = np.mgrid[0:N, 0:N] / (2 * N)\n", "bell_terms = np.abs(np.cos(b * np.pi + cmb * np.pi) - np.cos(b * np.pi)) + np.cos(\n", " cmb * np.pi\n", @@ -216,7 +216,7 @@ "circAB = bell_singlet_rotated(0, 1, 0, np.pi / 3.0)\n", "circAC = bell_singlet_rotated(0, 1, 0, 2 * np.pi / 3.0)\n", "circBC = bell_singlet_rotated(0, 1, np.pi / 3.0, 2 * np.pi / 3.0)\n", - "#printing circBC as an example of the three circuits\n", + "# printing circBC as an example of the three circuits\n", "print(circBC)" ] }, @@ -242,7 +242,7 @@ "prob_same = [d[\"00\"] + d[\"11\"] for d in res]\n", "prob_different = [d[\"01\"] + d[\"10\"] for d in res]\n", "\n", - "#P() below refers to expectation or corellation of the measurement of the entangled qubits with value ranging from 1 to -1\n", + "# P() below refers to expectation or corellation of the measurement of the entangled qubits with value ranging from 1 to -1\n", "pAB, pAC, pBC = np.array(prob_same) - np.array(prob_different)\n", "print(\n", " f\"P(a,b) = {pAB},P(a,c) = {pAC},P(b,c) = {pBC}\\nBell inequality: {np.abs(pAB - pAC) - pBC} ≤ 1\"\n", @@ -270,12 +270,10 @@ " circAB = bell_singlet_rotated(0, 1, 0, np.pi / 3.0)\n", " circAC = bell_singlet_rotated(0, 1, 0, 2 * np.pi / 3.0)\n", " circBC = bell_singlet_rotated(0, 1, np.pi / 3.0, 2 * np.pi / 3.0)\n", - " tasks = [\n", - " device.run(circ, shots=shots)\n", - " for circ in [circAB, circAC, circBC]\n", - " ]\n", + " tasks = [device.run(circ, shots=shots) for circ in [circAB, circAC, circBC]]\n", " return tasks\n", "\n", + "\n", "def get_results(tasks, verbose=True):\n", " results = [task.result().measurement_probabilities for task in tasks]\n", " prob_same = [d[\"00\"] + d[\"11\"] for d in results]\n", From d0e8bd2a44d76532a939a9157fff199ac50e4d78 Mon Sep 17 00:00:00 2001 From: Prakash Bhat Date: Sun, 16 Oct 2022 21:06:14 -0400 Subject: [PATCH 5/7] Fixed a typo in code for oqc and added a note on top. --- .../Violation_of_Bells_Inequality.ipynb | 74 +++++++++++-------- 1 file changed, 44 insertions(+), 30 deletions(-) diff --git a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb index 4cfd1fc3b..d81490cfe 100644 --- a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb +++ b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb @@ -11,8 +11,9 @@ "source": [ "# Demonstrating Violation of Bell's Inequality\n", "\n", - "This tutorial shows how to run a version of Bell's inequality experiment in Braket on different QPUs. \n", + "This tutorial shows how to run a version of Bell's inequality experiment in Braket on local simulator and different QPUs. \n", "\n", + "Till the \"Running on QPUs\" cell below, you can run this notebook on your own choice of jupyter server without even an AWS account. You may need to install AWS braket sdk. Refer to: https://github.com/aws/amazon-braket-sdk-python \n", "\n", "## EPR state\n", "\n", @@ -229,8 +230,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "P(a,b) = -0.4938,P(a,c) = 0.5042,P(b,c) = -0.5047999999999999\n", - "Bell inequality: 1.5028 ≤ 1\n" + "P(a,b) = -0.5091999999999999,P(a,c) = 0.504,P(b,c) = -0.508\n", + "Bell inequality: 1.5211999999999999 ≤ 1\n" ] } ], @@ -255,8 +256,6 @@ "source": [ "The Bell inequality is violated just as predicted by quantum mechanics by the simulator! Some times you may see inequality values little bit above 1.5 depending on the quantum randomness simulated by the simulator eventhough theoretical maximum is 1.5.\n", "\n", - "# Running on QPUs\n", - "\n", "Let's wrap those steps into couple of python functions so we can easily run on different QPUs." ] }, @@ -290,23 +289,56 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "If below QPU related cells taking a long time, you can check the task status in braket console tasks page in the right region. QPU avaiability hours differ and documented in the braket console devices page. You can also export this notebook as a python program and submit it as a braket job in the console." + "Test the above functions by running on local simulator." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "local_sim = LocalSimulator()\n", + "local_sim_tasks = submit_bell_tasks(local_sim)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P(a,b) = -0.488,P(a,c) = 0.488,P(b,c) = -0.46399999999999997\n", + "Bell inequality: 1.44 ≤ 1\n" + ] + } + ], + "source": [ + "results, pAB, pAC, pBC = get_results(local_sim_tasks)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "First we test the Bell inequality on OQC Lucy device. The cost to run this experiment is $\\$ 0.3$ per task and $\\$0.00035$ per shot. Since we have three circuits of 1000 shots each, that totals $\\$1.95$ USD.\n", + "# Running on QPUs\n", + "Following need AWS account as they run on AWS QPUs.\n", "\n", - "**Cost: $\\$1.95$ USD**" + "If below QPU related cells taking a long time, you can check the task status in braket console tasks page in the right region. QPU avaiability hours differ and documented in the braket console devices page. You can also export this notebook as a python program and submit it as a braket job in the console." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "If below QPU related cells taking long time, you can check the task status in braket console tasks page in the right region. QPU avaiability hours differ and documented in the braket console devices page. You can also export this notebook as a python program and submit it as a braket job in the console." + "First we test the Bell inequality on OQC Lucy device. The cost to run this experiment is $\\$ 0.3$ per task and $\\$0.00035$ per shot. Since we have three circuits of 1000 shots each, that totals $\\$1.95$ USD.\n", + "\n", + "**Cost: $\\$1.95$ USD**" ] }, { @@ -325,18 +357,9 @@ "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "P(a,b) = -0.451,P(a,c) = 0.488,P(b,c) = -0.431\n", - "Bell inequality: 1.37 ≤ 1\n" - ] - } - ], + "outputs": [], "source": [ - "results, pAB, pAC, pBC = get_results(oqc_lucy)" + "results, pAB, pAC, pBC = get_results(oqc_tasks)" ] }, { @@ -369,16 +392,7 @@ "cell_type": "code", "execution_count": 12, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "P(a,b) = -0.476,P(a,c) = 0.496,P(b,c) = -0.45599999999999996\n", - "Bell inequality: 1.428 ≤ 1\n" - ] - } - ], + "outputs": [], "source": [ "results, pAB, pAC, pBC = get_results(ionq_tasks)" ] From 2e59ad05707e23a962881b9e7a4f365ab4e600e7 Mon Sep 17 00:00:00 2001 From: Prakash Bhat Date: Thu, 20 Oct 2022 09:58:53 -0400 Subject: [PATCH 6/7] modified inequality comment after the result and added cost/task summary --- .../Violation_of_Bells_Inequality.ipynb | 51 ++++++++++++------- 1 file changed, 34 insertions(+), 17 deletions(-) diff --git a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb index d81490cfe..c940ce363 100644 --- a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb +++ b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb @@ -56,6 +56,17 @@ "The maximum value is $1.5 \\nleq 1$ which occurs at $\\theta_{\\mathbf{\\hat b}}=\\pi/3$, $\\theta_{\\mathbf{\\hat c}} = 2\\pi/3$as confirmed in the plot. " ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n", + "from braket.tracking import Tracker\n", + "t = Tracker().start()" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -230,8 +241,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "P(a,b) = -0.5091999999999999,P(a,c) = 0.504,P(b,c) = -0.508\n", - "Bell inequality: 1.5211999999999999 ≤ 1\n" + "P(a,b) = -0.5026,P(a,c) = 0.5074000000000001,P(b,c) = -0.5087999999999999\n", + "Bell inequality: 1.5188000000000001 ≤ 1\n" ] } ], @@ -261,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -278,10 +289,16 @@ " prob_same = [d[\"00\"] + d[\"11\"] for d in results]\n", " prob_different = [d[\"01\"] + d[\"10\"] for d in results]\n", " pAB, pAC, pBC = np.array(prob_same) - np.array(prob_different)\n", + " bell_ineqality_lhs=np.abs(pAB - pAC) - pBC\n", " if verbose == True:\n", " print(\n", - " f\"P(a,b) = {pAB},P(a,c) = {pAC},P(b,c) = {pBC}\\nBell inequality: {np.abs(pAB - pAC) - pBC} ≤ 1\"\n", + " f\"P(a,b) = {pAB},P(a,c) = {pAC},P(b,c) = {pBC}\\nBell\\'s' inequality: {bell_ineqality_lhs} ≤ 1\"\n", " )\n", + " if bell_ineqality_lhs>1:\n", + " print(\"Bell\\'s inequality is violated!\")\n", + " print(\"Notice that the quantity is not exactly 1.5 as predicted by theory. This is may be due to less number shots or the effects of noise on the QPU.\")\n", + " else:\n", + " print(\"Bell\\'s inequality is not violated due to noise.\")\n", " return results, pAB, pAC, pBC" ] }, @@ -294,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -304,7 +321,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 22, "metadata": { "scrolled": true }, @@ -313,8 +330,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "P(a,b) = -0.488,P(a,c) = 0.488,P(b,c) = -0.46399999999999997\n", - "Bell inequality: 1.44 ≤ 1\n" + "P(a,b) = -0.476,P(a,c) = 0.512,P(b,c) = -0.522\n", + "Bell's' inequality: 1.51 ≤ 1\n", + "Bell's inequality is violated!\n", + "Notice that the quantity is not exactly 1.5 as predicted by theory. This is may be due to less number shots or the effects of noise on the QPU.\n" ] } ], @@ -362,13 +381,6 @@ "results, pAB, pAC, pBC = get_results(oqc_tasks)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Bell's inequality is violated! Notice that the quantity is not exactly $1.5$ as predicted by theory. This is due to the effects of noise on the QPU. See https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Noise_models/Noise_models_on_Rigetti_AspenM2.ipynb for an example of modeling the noise properties of a QPU. " - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -398,10 +410,15 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "Again, we see that Bell's inequality is violated. " + "print(\"Task Summary\")\n", + "print(t.quantum_tasks_statistics())\n", + "print('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", + "print(f\"Estimated cost to run this example: {t.qpu_tasks_cost() + t.simulator_tasks_cost():.2f} USD\")" ] }, { From 5dcf9c039d7a8e55f00fcfe9b209c9bfa6fafc19 Mon Sep 17 00:00:00 2001 From: Prakash Bhat Date: Tue, 25 Oct 2022 14:20:40 -0400 Subject: [PATCH 7/7] after 10/25 job run of the full notebook --- .../Violation_of_Bells_Inequality.ipynb | 221 ++++++++++++++---- 1 file changed, 181 insertions(+), 40 deletions(-) diff --git a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb index c940ce363..99a7ff0be 100644 --- a/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb +++ b/examples/advanced_circuits_algorithms/Violation_of_Bells_Inequality/Violation_of_Bells_Inequality.ipynb @@ -58,8 +58,15 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:23.937827Z", + "iopub.status.busy": "2022-10-24T13:25:23.937072Z", + "iopub.status.idle": "2022-10-24T13:25:24.496214Z", + "shell.execute_reply": "2022-10-24T13:25:24.495066Z" + } + }, "outputs": [], "source": [ "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n", @@ -69,12 +76,19 @@ }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:24.504046Z", + "iopub.status.busy": "2022-10-24T13:25:24.503013Z", + "iopub.status.idle": "2022-10-24T13:25:27.389111Z", + "shell.execute_reply": "2022-10-24T13:25:27.387999Z" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -122,8 +136,15 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:27.476497Z", + "iopub.status.busy": "2022-10-24T13:25:27.476065Z", + "iopub.status.idle": "2022-10-24T13:25:30.794969Z", + "shell.execute_reply": "2022-10-24T13:25:30.793788Z" + } + }, "outputs": [], "source": [ "from braket.aws import AwsDevice, AwsQuantumTask\n", @@ -133,8 +154,15 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:30.802476Z", + "iopub.status.busy": "2022-10-24T13:25:30.801779Z", + "iopub.status.idle": "2022-10-24T13:25:30.811403Z", + "shell.execute_reply": "2022-10-24T13:25:30.810331Z" + } + }, "outputs": [], "source": [ "def bell_singlet(qubit0, qubit1):\n", @@ -143,8 +171,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:30.816989Z", + "iopub.status.busy": "2022-10-24T13:25:30.816495Z", + "iopub.status.idle": "2022-10-24T13:25:30.827279Z", + "shell.execute_reply": "2022-10-24T13:25:30.826259Z" + }, "scrolled": true }, "outputs": [ @@ -184,8 +218,15 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:30.834443Z", + "iopub.status.busy": "2022-10-24T13:25:30.833797Z", + "iopub.status.idle": "2022-10-24T13:25:30.841126Z", + "shell.execute_reply": "2022-10-24T13:25:30.840224Z" + } + }, "outputs": [], "source": [ "def bell_singlet_rotated(qubit0, qubit1, rotation0, rotation1):\n", @@ -207,8 +248,15 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:30.847025Z", + "iopub.status.busy": "2022-10-24T13:25:30.846515Z", + "iopub.status.idle": "2022-10-24T13:25:30.856701Z", + "shell.execute_reply": "2022-10-24T13:25:30.855734Z" + } + }, "outputs": [ { "name": "stdout", @@ -234,15 +282,22 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:30.863736Z", + "iopub.status.busy": "2022-10-24T13:25:30.863237Z", + "iopub.status.idle": "2022-10-24T13:25:31.384171Z", + "shell.execute_reply": "2022-10-24T13:25:31.383035Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "P(a,b) = -0.5026,P(a,c) = 0.5074000000000001,P(b,c) = -0.5087999999999999\n", - "Bell inequality: 1.5188000000000001 ≤ 1\n" + "P(a,b) = -0.49340000000000006,P(a,c) = 0.5224,P(b,c) = -0.4778\n", + "Bell inequality: 1.4936 ≤ 1\n" ] } ], @@ -272,8 +327,15 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": {}, + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:31.390576Z", + "iopub.status.busy": "2022-10-24T13:25:31.390107Z", + "iopub.status.idle": "2022-10-24T13:25:31.408540Z", + "shell.execute_reply": "2022-10-24T13:25:31.407410Z" + } + }, "outputs": [], "source": [ "def submit_bell_tasks(device, shots=1_000):\n", @@ -311,8 +373,15 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": {}, + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:31.417008Z", + "iopub.status.busy": "2022-10-24T13:25:31.416175Z", + "iopub.status.idle": "2022-10-24T13:25:31.504790Z", + "shell.execute_reply": "2022-10-24T13:25:31.503134Z" + } + }, "outputs": [], "source": [ "local_sim = LocalSimulator()\n", @@ -321,8 +390,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:31.514330Z", + "iopub.status.busy": "2022-10-24T13:25:31.512062Z", + "iopub.status.idle": "2022-10-24T13:25:31.523627Z", + "shell.execute_reply": "2022-10-24T13:25:31.522518Z" + }, "scrolled": true }, "outputs": [ @@ -330,8 +405,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "P(a,b) = -0.476,P(a,c) = 0.512,P(b,c) = -0.522\n", - "Bell's' inequality: 1.51 ≤ 1\n", + "P(a,b) = -0.544,P(a,c) = 0.52,P(b,c) = -0.51\n", + "Bell's' inequality: 1.574 ≤ 1\n", "Bell's inequality is violated!\n", "Notice that the quantity is not exactly 1.5 as predicted by theory. This is may be due to less number shots or the effects of noise on the QPU.\n" ] @@ -362,8 +437,15 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:31.532859Z", + "iopub.status.busy": "2022-10-24T13:25:31.530536Z", + "iopub.status.idle": "2022-10-24T13:25:34.483427Z", + "shell.execute_reply": "2022-10-24T13:25:34.482120Z" + } + }, "outputs": [], "source": [ "oqc_lucy = AwsDevice(\"arn:aws:braket:eu-west-2::device/qpu/oqc/Lucy\")\n", @@ -372,11 +454,27 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": { + "execution": { + "iopub.execute_input": "2022-10-24T13:25:34.490128Z", + "iopub.status.busy": "2022-10-24T13:25:34.489285Z", + "iopub.status.idle": "2022-10-25T09:03:01.600062Z", + "shell.execute_reply": "2022-10-25T09:03:01.598897Z" + }, "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P(a,b) = -0.38399999999999995,P(a,c) = 0.4140000000000001,P(b,c) = 0.12599999999999995\n", + "Bell's' inequality: 0.6720000000000002 ≤ 1\n", + "Bell's inequality is not violated due to noise.\n" + ] + } + ], "source": [ "results, pAB, pAC, pBC = get_results(oqc_tasks)" ] @@ -392,8 +490,15 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, + "execution_count": 14, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-25T09:03:01.606872Z", + "iopub.status.busy": "2022-10-25T09:03:01.605257Z", + "iopub.status.idle": "2022-10-25T09:03:07.275084Z", + "shell.execute_reply": "2022-10-25T09:03:07.273959Z" + } + }, "outputs": [], "source": [ "ionq_harmony = AwsDevice(\"arn:aws:braket:::device/qpu/ionq/ionQdevice\")\n", @@ -402,18 +507,54 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], + "execution_count": 15, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-25T09:03:07.294268Z", + "iopub.status.busy": "2022-10-25T09:03:07.285434Z", + "iopub.status.idle": "2022-10-25T09:05:03.506451Z", + "shell.execute_reply": "2022-10-25T09:05:03.505420Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P(a,b) = -0.42600000000000005,P(a,c) = 0.44399999999999995,P(b,c) = -0.5379999999999999\n", + "Bell's' inequality: 1.408 ≤ 1\n", + "Bell's inequality is violated!\n", + "Notice that the quantity is not exactly 1.5 as predicted by theory. This is may be due to less number shots or the effects of noise on the QPU.\n" + ] + } + ], "source": [ "results, pAB, pAC, pBC = get_results(ionq_tasks)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2022-10-25T09:05:03.511886Z", + "iopub.status.busy": "2022-10-25T09:05:03.510231Z", + "iopub.status.idle": "2022-10-25T09:05:03.818846Z", + "shell.execute_reply": "2022-10-25T09:05:03.817724Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Task Summary\n", + "{'arn:aws:braket:eu-west-2::device/qpu/oqc/Lucy': {'shots': 3000, 'tasks': {'COMPLETED': 3}}, 'arn:aws:braket:::device/qpu/ionq/ionQdevice': {'shots': 3000, 'tasks': {'COMPLETED': 3}}}\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: 32.85 USD\n" + ] + } + ], "source": [ "print(\"Task Summary\")\n", "print(t.quantum_tasks_statistics())\n", @@ -447,9 +588,9 @@ ], "metadata": { "kernelspec": { - "display_name": "conda_braket", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "conda_braket" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -461,7 +602,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.13" + "version": "3.7.10" }, "vscode": { "interpreter": {