From 399d9dbefdf8bea1aa67375e639653d569016c9b Mon Sep 17 00:00:00 2001 From: Jean-Christophe Jaskula <99367153+jcjaskula-aws@users.noreply.github.com> Date: Tue, 20 Feb 2024 09:46:56 -0500 Subject: [PATCH] Update notebooks (#157) * update notebooks * clean data folder and black * simplify tutorial #3 first cell * isort and exclude eigen optimizer notebook * fix linters * fix typos * fix typo * fix a second typo * fix more typos * fix even more typos * Update docs/tutorials/1_tutorial_vqe.ipynb Co-authored-by: Tim (Yi-Ting) --------- Co-authored-by: Tim (Yi-Ting) --- ...rial_qiskit-braket-provider_overview.ipynb | 652 +++++------------- docs/tutorials/1_tutorial_vqe.ipynb | 81 +-- docs/tutorials/2_tutorial_hybrid_jobs.ipynb | 201 +++--- .../3_tutorial_minimum_eigen_optimizer.ipynb | 471 ++++++++----- docs/tutorials/data/2_hybrid_jobs/Dockerfile | 5 - .../data/2_hybrid_jobs/job_script.py | 45 -- tox.ini | 2 +- 7 files changed, 589 insertions(+), 868 deletions(-) delete mode 100644 docs/tutorials/data/2_hybrid_jobs/Dockerfile delete mode 100644 docs/tutorials/data/2_hybrid_jobs/job_script.py diff --git a/docs/tutorials/0_tutorial_qiskit-braket-provider_overview.ipynb b/docs/tutorials/0_tutorial_qiskit-braket-provider_overview.ipynb index 41aced0b..642e7798 100644 --- a/docs/tutorials/0_tutorial_qiskit-braket-provider_overview.ipynb +++ b/docs/tutorials/0_tutorial_qiskit-braket-provider_overview.ipynb @@ -10,7 +10,7 @@ } }, "source": [ - "# Tutorial: Qiskit-Braket provider overview" + "# Getting started with the Qiskit-Braket provider" ] }, { @@ -39,46 +39,32 @@ "![qiskit-to-braket-diagram](./data/qiskit-braket-mapping.png)" ] }, - { - "cell_type": "code", - "execution_count": 1, - "id": "8ab8a5f0", - "metadata": {}, - "outputs": [], - "source": [ - "# pip install qiskit_braket_provider" - ] - }, { "attachments": {}, "cell_type": "markdown", "id": "04160f91", "metadata": {}, "source": [ - "---------------\n", - "\n", - "Import all required classes and functions for this overview" + "We first start by importing all required classes and functions for this notebook. We also start the cost tracker to print the costs at the end of this notebook." ] }, { "cell_type": "code", - "execution_count": 2, - "id": "5339c690", + "execution_count": 1, + "id": "445cc5d9", "metadata": {}, "outputs": [], "source": [ - "from qiskit.algorithms.minimum_eigensolvers import VQE\n", - "from qiskit.quantum_info import SparsePauliOp\n", - "from qiskit import transpile, QuantumCircuit\n", + "from qiskit import QuantumCircuit\n", "from qiskit.circuit.random import random_circuit\n", "from qiskit.visualization import plot_histogram\n", - "from qiskit.algorithms.optimizers import SLSQP\n", - "from qiskit.circuit.library import TwoLocal\n", - "from qiskit.primitives import BackendEstimator\n", "\n", - "from braket.aws import AwsQuantumJob\n", + "from braket.tracking import Tracker\n", "\n", - "from qiskit_braket_provider import AWSBraketProvider, BraketLocalBackend" + "from qiskit_braket_provider import AWSBraketProvider, BraketLocalBackend, to_braket\n", + "\n", + "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n", + "t = Tracker().start()" ] }, { @@ -116,59 +102,38 @@ }, "outputs": [ { - "data": { - "text/plain": [ - "[BraketBackend[Aria 1],\n", - " BraketBackend[Aspen-10],\n", - " BraketBackend[Aspen-11],\n", - " BraketBackend[Aspen-8],\n", - " BraketBackend[Aspen-9],\n", - " BraketBackend[Aspen-M-1],\n", - " BraketBackend[Aspen-M-2],\n", - " BraketBackend[Aspen-M-3],\n", - " BraketBackend[Harmony],\n", - " BraketBackend[Lucy],\n", - " BraketBackend[SV1],\n", - " BraketBackend[TN1],\n", - " BraketBackend[dm1]]" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "[BraketBackend[Aria 1], BraketBackend[Aria 2], BraketBackend[Aspen-M-3], BraketBackend[Forte 1], BraketBackend[Harmony], BraketBackend[Lucy], BraketBackend[SV1], BraketBackend[TN1], BraketBackend[dm1]]\n" + ] } ], "source": [ "provider = AWSBraketProvider()\n", - "backends = provider.backends()\n", - "backends" + "print(provider.backends())" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "edbae0ee", + "id": "cf366038", "metadata": {}, "source": [ - "For prototyping it is usually a good practice to use simulators \n", - "to set up workflow of your program and then change it to real device.\n", - "We can access local simulator by creating instance of class `BraketLocalBackend`" + "If you want to explore what is available by specific contraints, you can specify query arguments to `backends` method of provider.\n", + "Arguments are fully compatible with Braket's `get_device` method. See the documentation at [braket.aws.aws_device.AwsDevice.get_devices](https://amazon-braket-sdk-python.readthedocs.io/en/stable/_apidoc/braket.aws.aws_device.html#braket.aws.aws_device.AwsDevice.get_devices). For example, you can retrieve the list of online simulators via:" ] }, { "cell_type": "code", "execution_count": 4, - "id": "2517f020", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, + "id": "e182e1a4", + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "BraketBackend[default]" + "[BraketBackend[SV1], BraketBackend[TN1], BraketBackend[dm1]]" ] }, "execution_count": 4, @@ -177,29 +142,35 @@ } ], "source": [ - "local_simulator = BraketLocalBackend()\n", - "local_simulator" + "online_simulators_backends = provider.backends(statuses=[\"ONLINE\"], types=[\"SIMULATOR\"])\n", + "online_simulators_backends" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "390c3a64", + "id": "edbae0ee", "metadata": {}, "source": [ - "We also get get cloud state vector simulator by using method `get_backend` for provider." + "For prototyping it is usually a good practice to use simulators \n", + "to set up workflow of your program and then change it to real device.\n", + "We can access local simulator by creating instance of class `BraketLocalBackend`" ] }, { "cell_type": "code", "execution_count": 5, - "id": "ad2b852f", - "metadata": {}, + "id": "2517f020", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { "text/plain": [ - "BraketBackend[SV1]" + "BraketBackend[default]" ] }, "execution_count": 5, @@ -208,17 +179,17 @@ } ], "source": [ - "aws_statevector_simulator = provider.get_backend(\"SV1\")\n", - "aws_statevector_simulator" + "local_simulator = BraketLocalBackend()\n", + "local_simulator" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "e13d6409", + "id": "390c3a64", "metadata": {}, "source": [ - "Of course we can query for specific real devices " + "Any backend can be instantiated via the `get_backend` method of the provider. Here is an example where we create a Backend object for the IonQ `Aria 1` device." ] }, { @@ -226,56 +197,9 @@ "execution_count": 6, "id": "64a9cb24", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(BraketBackend[Harmony], BraketBackend[Aspen-M-1])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ionq_device = provider.get_backend(\"Harmony\")\n", - "rigetti_device = provider.get_backend(\"Aspen-M-1\")\n", - "\n", - "ionq_device, rigetti_device" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "cf366038", - "metadata": {}, - "source": [ - "And if you want to explore what is available by specific contraints, \n", - "you can specify query arguments to `backends` method of provider.\n", - "Arguments are fully compatible with Braket's `get_device` method. See full doc [here](https://amazon-braket-sdk-python.readthedocs.io/en/stable/_apidoc/braket.aws.aws_device.html#braket.aws.aws_device.AwsDevice.get_devices)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "e182e1a4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[BraketBackend[SV1], BraketBackend[TN1], BraketBackend[dm1]]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "online_simulators_backends = provider.backends(statuses=[\"ONLINE\"], types=[\"SIMULATOR\"])\n", - "online_simulators_backends" + "Aria_1 = provider.get_backend(\"Aria 1\")" ] }, { @@ -288,7 +212,7 @@ } }, "source": [ - "### Running circuits on AWS devices\n", + "### Running circuits on Braket devices\n", "\n" ] }, @@ -298,12 +222,12 @@ "id": "137ae345", "metadata": {}, "source": [ - "Let's create circuit first. We will start with \"Hello World\" example :)" + "Let's first create Qiskit circuit. We will start with a Bell circuit." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "22d4a07a", "metadata": {}, "outputs": [ @@ -324,7 +248,7 @@ " └───┘" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -342,38 +266,29 @@ "id": "512cfd00", "metadata": {}, "source": [ - "Run job agains selected device" + "This circuit can be used to submit a task to the local simulator. In the [tutorials](https://github.com/qiskit-community/qiskit-braket-provider/tree/main/docs/tutorials) associated to the Qiskit-Braket provider, we will use the Braket taxonomy:\n", + "- a task is an atomic request to a device or a simulator. \n", + "- an hybrid job is a mean to run hybrid quantum-classical algorithms requiring both classical AWS resources and quantum processing units (QPUs). See [What is a Hybrid Job](https://docs.aws.amazon.com/braket/latest/developerguide/braket-what-is-hybrid-job.html) for more details.\n", + "\n", + "Here, quantum tasks are analogous to Qiskit jobs, which is why tasks have a `job_id` property. If a task has been submitted to Braket managed device, `job_id` will return a Task ARN (Amazon Resource number) which identifies the task and allows to retrieve it in the Braket Console and in your notebooks. " ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "d00d454c", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "job = aws_statevector_simulator.run(qc, shots=10)\n", - "job" + "task = local_simulator.run(qc, shots=10)" ] }, { - "attachments": {}, "cell_type": "markdown", - "id": "851eab0e", + "id": "0d22adcd", "metadata": {}, "source": [ - "Plot histogram" + "Results are returned via a `Result` object, from which you can extract counts and plot them in a histogram." ] }, { @@ -384,9 +299,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": 10, @@ -395,7 +310,8 @@ } ], "source": [ - "plot_histogram(job.result().get_counts())" + "results = task.result()\n", + "plot_histogram(results.get_counts())" ] }, { @@ -404,7 +320,7 @@ "id": "43128a91", "metadata": {}, "source": [ - "Retrieve the measured state of each single shot." + "Each single shot measurements are also retrievable." ] }, { @@ -416,7 +332,7 @@ { "data": { "text/plain": [ - "['11', '11', '00', '11', '11', '11', '00', '00', '00', '00']" + "['00', '00', '11', '00', '11', '11', '00', '00', '00', '00']" ] }, "execution_count": 11, @@ -425,7 +341,7 @@ } ], "source": [ - "job.result().get_memory()" + "results.get_memory()" ] }, { @@ -434,7 +350,7 @@ "id": "d48764e8", "metadata": {}, "source": [ - "Now it's time to run more complex circuits on devices we got in previous paragraphs.\n", + "More complex circuits on devices can be submitted to the Braket devices and simulators. Behind the scenes, the qiskit transpiler will adapt the circuits such that they are executable on all devices. In the following, we will focus on running circuit in the IonQ Aria-1 device. \n", "\n", "We will start with generating random circuit and printing it out." ] @@ -448,34 +364,26 @@ { "data": { "text/html": [ - "
     ┌────────────────────────┐                                       ┌─────────────────────────┐┌────┐   ┌───────────────────┐                                                     ┌──────┐                                                                                               ┌────────────────────┐┌───────────┐┌─────────────────────────┐                                   ┌──────────────┐       ┌───┐        ┌────────────┐                                   ┌────────────────────┐  ┌───┐                                                           ┌──────────────────┐                   \n",
-       "q_0: ┤0                       ├────■──────────────────────────────────┤1                        ├┤ Sx ├───┤ U2(1.8116,4.2882) ├─────────────────────────────────────────────────────┤1     ├─────────────────────────────────────────X───────────────────────────────────────────────────X─┤ U2(0.56579,4.5387) ├┤ Rx(2.394) ├┤ U3(4.893,4.5044,2.8234) ├───────────────────────────────────┤0             ├───────┤ Y ├────────┤ Ry(3.7128) ├───────────────────────────■───────┤ U2(0.13579,5.1917) ├──┤ H ├──────────────────────────■────────────────────────■───────┤ R(4.1573,2.3478) ├───────────────────\n",
-       "     │                        │    │ ┌───┐┌────────────┐┌────────────┐│                         │└─┬──┘   └───────────────────┘                                     ┌──────────────┐│      │                                         │                                                   │ └────────────────────┘└───────────┘└──────┬────────────┬─────┘        ┌───┐            ┌─────┐   │              │       └─┬─┘        └────────────┘             ┌──────┐      │       └────────────────────┘  ├───┴┐ ┌──────────────┐┌────┐  │        ┌───┐           │       └──────────────────┘                   \n",
-       "q_1: ┤  (XX+YY)(4.7824,4.939) ├─■──┼─┤ X ├┤ Ry(6.0991) ├┤ Rx(1.1905) ├┤                         ├──┼────────────────────────────────────────────────────────────────┤0             ├┤      ├─────────────────■───────────■───────────┼──────────────────────────────────────────────■────┼───────────■───────────────────────────────┤ Rx(1.8945) ├──────────────┤ Y ├────────────┤ Sdg ├───┤              ├─────────■─────────────────────────────────────┤1     ├──────┼─────────────■─────────────────┤ Sx ├─┤0             ├┤ Sx ├──┼────────┤ T ├───────────┼────────────────■─────────────────────────────\n",
-       "     │                        │ │  │ └─┬─┘└──┬─────┬───┘└──┬─────┬───┘│                         │  │   ┌─────────────────────────┐                                  │              ││      │┌──────────────┐ │           │           │ ┌────────────────────────────────┐ ┌───┐     │    │     ┌─────┴──────┐                        └─────┬──────┘      ┌───────┴───┴────────┐   └─────┘   │  Rzx(5.3823) │                                               │      │      │             │P(5.8925)        └─┬──┘ │  Rxx(4.5678) │└─┬──┘  │    ┌───┴───┴────┐      │                │          ┌─────────────────┐\n",
-       "q_2: ┤1                       ├─┼──┼───┼─────┤ Sdg ├───────┤ Tdg ├────┤  (XX-YY)(5.6116,4.8907) ├──┼───┤1                        ├────────────────■─────────────────┤              ├┤  Ecr ├┤0             ├─┼───────────┼───────────┼─┤ U(3.5136,1.9098,0.19363,2.744) ├─┤ X ├─────┼────┼─────┤ Ry(1.0491) ├──────────■───────────────────┼─────────────┤ U2(1.7105,0.60564) ├─■───────────┤              ├────■──────────────────────────────■───────────┤      ├──────┼─────────────■───────────────────■────┤1             ├──┼─────┼────┤ U1(1.9926) ├──────X────────────────┼──────────┤ R(1.985,4.8507) ├\n",
-       "     └─────────┬────┬─────────┘ │  │   │     └──┬──┘       └─────┘    │                         │  │   │  (XX-YY)(2.3277,2.9503) │┌───────────────┴────────────────┐│  Rxx(2.4346) ││      ││  Rxx(2.8835) │ │           │           │ └───────────────┬────────────────┘┌┴───┴─┐   │    │     └──┬──────┬──┘          │                   │             └───────┬───┬────────┘ │           │              │    │U1(0.26147)    ┌────────────┐ │           │  Ecr │      │              ┌──────┐       ┌───────┐├──────────────┤  │     │   ┌┴────────────┤      │              ┌─┴─┐        └─────────────────┘\n",
-       "q_3: ──────────┤ √X ├───────────┼──┼───■────────┼─────────────■───────┤                         ├──┼───┤0                        ├┤ U(4.3999,1.9627,5.2292,5.0565) ├┤              ├┤      ├┤1             ├─┼───────────┼───────────X─────────────────┼─────────────────┤ √Xdg ├───┼────┼────────┤1     ├─────────────■───────────────────┼─────────────────────┤ H ├──────────┼───────────┤1             ├────■───────────────┤ Ry(3.6509) ├─┼───────────┤      ├──────┼──────────────┤0     ├───────┤1      ├┤1             ├──■─────┼───┤ Ry(0.28218) ├──────┼──────────────┤ X ├───────────────────────────\n",
-       "               └────┘           │  │            │             │       │                         │  │   └──────┬────────────┬─────┘└────────────────────────────────┘│              ││      │└──────────────┘ │           │P(3.4782)                    │                 └──────┘┌──┴──┐ │        │  Ecr │             │                   │                     ├───┤          │           └┬────────────┬┘┌──────────────────┐└────────────┘ │           │      │      │              │  Ecr │       │       ││  Rxx(4.8296) │      ┌─┴──┐└──────┬──────┘      │              └─┬─┘                           \n",
-       "q_4: ───────────────────────────■──┼────────────■─────────────┼───────┤0                        ├──┼──────────┤ Rx(2.0472) ├────────────────────────────────────────┤1             ├┤0     ├─────────────────┼───────────■─────────────────────────────┼─────────────────────────┤ Sdg ├─┼────────┤0     ├─────────────■───────────────────┼─────────────────────┤ S ├──────────┼────────────┤ U1(4.7659) ├─┤ R(3.1038,2.0726) ├───────────────┼───────────┤0     ├──────┼──────────────┤1     ├───────┤0 Rccx ├┤0             ├──────┤ Sx ├───────┼─────────────X────────────────■─────────────────────────────\n",
-       "        ┌─────────────────┐        │                        ┌─┴─┐     └─────────────────────────┘  │          └──┬──────┬──┘                                        └──────────────┘└──────┘                 │P(3.5735)                                │                         └─────┘ │     ┌──┴──────┴──┐                              │              ┌──────┴───┴───────┐  │ZZ(1.1107)  ├────────────┤ └──────────────────┘               │U1(2.1794) └──────┘┌─────┴──────┐       └──────┘       │       │└────┬───┬─────┘┌───┐ └────┘       │       ┌────────────┐                                       \n",
-       "q_5: ───┤ R(0.59173,6.13) ├────────■────────────────────────┤ Y ├──────────────────────────────────■─────────────┤ √Xdg ├────────────────────────────────────────────────────────────────────────────────────■─────────────────────────────────────────■─────────────────────────────────X─────┤ Ry(0.1427) ├──────────────────────────────■──────────────┤ R(1.6705,6.0895) ├──■────────────┤ Rx(2.6126) ├────────────────────────────────────■───────────────────┤ Rx(3.0832) ├──────────────────────┤2      ├─────┤ H ├──────┤ Y ├──────────────■───────┤ Rx(3.2601) ├───────────────────────────────────────\n",
-       "        └─────────────────┘                                 └───┘                                                └──────┘                                                                                                                                                                      └────────────┘                                             └──────────────────┘               └────────────┘                                                        └────────────┘                      └───────┘     └───┘      └───┘                      └────────────┘
" + "
                          ┌───────────────────────┐    ┌───┐                  ┌────────────┐     \n",
+       "q_0: ─────────────────────┤0                      ├────┤ H ├───────■──────■───┤ Rz(2.9325) ├─────\n",
+       "     ┌───────────────────┐│                       │    └─┬─┘     ┌─┴──┐   │   ├────────────┤┌───┐\n",
+       "q_1: ┤ R(4.3817,0.59173) ├┤                       ├──────■───────┤ Sx ├───┼───┤ Ry(2.2276) ├┤ X ├\n",
+       "     └───┬───────────┬───┘│  (XX+YY)(6.13,4.7824) │              ├───┬┘ ┌─┴─┐ └────────────┘└─┬─┘\n",
+       "q_2: ────┤ Ry(4.939) ├────┤                       ├──────■───────┤ H ├──┤ Y ├─────────────────■──\n",
+       "         └───────────┘    │                       │┌─────┴──────┐└─┬─┘ ┌┴───┴┐                │  \n",
+       "q_3: ─────────────────────┤1                      ├┤ Ry(4.0455) ├──■───┤ Tdg ├────────────────■──\n",
+       "                          └───────────────────────┘└────────────┘      └─────┘
" ], "text/plain": [ - " ┌────────────────────────┐ ┌─────────────────────────┐┌────┐ ┌───────────────────┐ ┌──────┐ ┌────────────────────┐┌───────────┐┌─────────────────────────┐ ┌──────────────┐ ┌───┐ ┌────────────┐ ┌────────────────────┐ ┌───┐ ┌──────────────────┐ \n", - "q_0: ┤0 ├────■──────────────────────────────────┤1 ├┤ Sx ├───┤ U2(1.8116,4.2882) ├─────────────────────────────────────────────────────┤1 ├─────────────────────────────────────────X───────────────────────────────────────────────────X─┤ U2(0.56579,4.5387) ├┤ Rx(2.394) ├┤ U3(4.893,4.5044,2.8234) ├───────────────────────────────────┤0 ├───────┤ Y ├────────┤ Ry(3.7128) ├───────────────────────────■───────┤ U2(0.13579,5.1917) ├──┤ H ├──────────────────────────■────────────────────────■───────┤ R(4.1573,2.3478) ├───────────────────\n", - " │ │ │ ┌───┐┌────────────┐┌────────────┐│ │└─┬──┘ └───────────────────┘ ┌──────────────┐│ │ │ │ └────────────────────┘└───────────┘└──────┬────────────┬─────┘ ┌───┐ ┌─────┐ │ │ └─┬─┘ └────────────┘ ┌──────┐ │ └────────────────────┘ ├───┴┐ ┌──────────────┐┌────┐ │ ┌───┐ │ └──────────────────┘ \n", - "q_1: ┤ (XX+YY)(4.7824,4.939) ├─■──┼─┤ X ├┤ Ry(6.0991) ├┤ Rx(1.1905) ├┤ ├──┼────────────────────────────────────────────────────────────────┤0 ├┤ ├─────────────────■───────────■───────────┼──────────────────────────────────────────────■────┼───────────■───────────────────────────────┤ Rx(1.8945) ├──────────────┤ Y ├────────────┤ Sdg ├───┤ ├─────────■─────────────────────────────────────┤1 ├──────┼─────────────■─────────────────┤ Sx ├─┤0 ├┤ Sx ├──┼────────┤ T ├───────────┼────────────────■─────────────────────────────\n", - " │ │ │ │ └─┬─┘└──┬─────┬───┘└──┬─────┬───┘│ │ │ ┌─────────────────────────┐ │ ││ │┌──────────────┐ │ │ │ ┌────────────────────────────────┐ ┌───┐ │ │ ┌─────┴──────┐ └─────┬──────┘ ┌───────┴───┴────────┐ └─────┘ │ Rzx(5.3823) │ │ │ │ │P(5.8925) └─┬──┘ │ Rxx(4.5678) │└─┬──┘ │ ┌───┴───┴────┐ │ │ ┌─────────────────┐\n", - "q_2: ┤1 ├─┼──┼───┼─────┤ Sdg ├───────┤ Tdg ├────┤ (XX-YY)(5.6116,4.8907) ├──┼───┤1 ├────────────────■─────────────────┤ ├┤ Ecr ├┤0 ├─┼───────────┼───────────┼─┤ U(3.5136,1.9098,0.19363,2.744) ├─┤ X ├─────┼────┼─────┤ Ry(1.0491) ├──────────■───────────────────┼─────────────┤ U2(1.7105,0.60564) ├─■───────────┤ ├────■──────────────────────────────■───────────┤ ├──────┼─────────────■───────────────────■────┤1 ├──┼─────┼────┤ U1(1.9926) ├──────X────────────────┼──────────┤ R(1.985,4.8507) ├\n", - " └─────────┬────┬─────────┘ │ │ │ └──┬──┘ └─────┘ │ │ │ │ (XX-YY)(2.3277,2.9503) │┌───────────────┴────────────────┐│ Rxx(2.4346) ││ ││ Rxx(2.8835) │ │ │ │ └───────────────┬────────────────┘┌┴───┴─┐ │ │ └──┬──────┬──┘ │ │ └───────┬───┬────────┘ │ │ │ │U1(0.26147) ┌────────────┐ │ │ Ecr │ │ ┌──────┐ ┌───────┐├──────────────┤ │ │ ┌┴────────────┤ │ ┌─┴─┐ └─────────────────┘\n", - "q_3: ──────────┤ √X ├───────────┼──┼───■────────┼─────────────■───────┤ ├──┼───┤0 ├┤ U(4.3999,1.9627,5.2292,5.0565) ├┤ ├┤ ├┤1 ├─┼───────────┼───────────X─────────────────┼─────────────────┤ √Xdg ├───┼────┼────────┤1 ├─────────────■───────────────────┼─────────────────────┤ H ├──────────┼───────────┤1 ├────■───────────────┤ Ry(3.6509) ├─┼───────────┤ ├──────┼──────────────┤0 ├───────┤1 ├┤1 ├──■─────┼───┤ Ry(0.28218) ├──────┼──────────────┤ X ├───────────────────────────\n", - " └────┘ │ │ │ │ │ │ │ └──────┬────────────┬─────┘└────────────────────────────────┘│ ││ │└──────────────┘ │ │P(3.4782) │ └──────┘┌──┴──┐ │ │ Ecr │ │ │ ├───┤ │ └┬────────────┬┘┌──────────────────┐└────────────┘ │ │ │ │ │ Ecr │ │ ││ Rxx(4.8296) │ ┌─┴──┐└──────┬──────┘ │ └─┬─┘ \n", - "q_4: ───────────────────────────■──┼────────────■─────────────┼───────┤0 ├──┼──────────┤ Rx(2.0472) ├────────────────────────────────────────┤1 ├┤0 ├─────────────────┼───────────■─────────────────────────────┼─────────────────────────┤ Sdg ├─┼────────┤0 ├─────────────■───────────────────┼─────────────────────┤ S ├──────────┼────────────┤ U1(4.7659) ├─┤ R(3.1038,2.0726) ├───────────────┼───────────┤0 ├──────┼──────────────┤1 ├───────┤0 Rccx ├┤0 ├──────┤ Sx ├───────┼─────────────X────────────────■─────────────────────────────\n", - " ┌─────────────────┐ │ ┌─┴─┐ └─────────────────────────┘ │ └──┬──────┬──┘ └──────────────┘└──────┘ │P(3.5735) │ └─────┘ │ ┌──┴──────┴──┐ │ ┌──────┴───┴───────┐ │ZZ(1.1107) ├────────────┤ └──────────────────┘ │U1(2.1794) └──────┘┌─────┴──────┐ └──────┘ │ │└────┬───┬─────┘┌───┐ └────┘ │ ┌────────────┐ \n", - "q_5: ───┤ R(0.59173,6.13) ├────────■────────────────────────┤ Y ├──────────────────────────────────■─────────────┤ √Xdg ├────────────────────────────────────────────────────────────────────────────────────■─────────────────────────────────────────■─────────────────────────────────X─────┤ Ry(0.1427) ├──────────────────────────────■──────────────┤ R(1.6705,6.0895) ├──■────────────┤ Rx(2.6126) ├────────────────────────────────────■───────────────────┤ Rx(3.0832) ├──────────────────────┤2 ├─────┤ H ├──────┤ Y ├──────────────■───────┤ Rx(3.2601) ├───────────────────────────────────────\n", - " └─────────────────┘ └───┘ └──────┘ └────────────┘ └──────────────────┘ └────────────┘ └────────────┘ └───────┘ └───┘ └───┘ └────────────┘ " + " ┌───────────────────────┐ ┌───┐ ┌────────────┐ \n", + "q_0: ─────────────────────┤0 ├────┤ H ├───────■──────■───┤ Rz(2.9325) ├─────\n", + " ┌───────────────────┐│ │ └─┬─┘ ┌─┴──┐ │ ├────────────┤┌───┐\n", + "q_1: ┤ R(4.3817,0.59173) ├┤ ├──────■───────┤ Sx ├───┼───┤ Ry(2.2276) ├┤ X ├\n", + " └───┬───────────┬───┘│ (XX+YY)(6.13,4.7824) │ ├───┬┘ ┌─┴─┐ └────────────┘└─┬─┘\n", + "q_2: ────┤ Ry(4.939) ├────┤ ├──────■───────┤ H ├──┤ Y ├─────────────────■──\n", + " └───────────┘ │ │┌─────┴──────┐└─┬─┘ ┌┴───┴┐ │ \n", + "q_3: ─────────────────────┤1 ├┤ Ry(4.0455) ├──■───┤ Tdg ├────────────────■──\n", + " └───────────────────────┘└────────────┘ └─────┘ " ] }, "execution_count": 12, @@ -484,8 +392,8 @@ } ], "source": [ - "circuit = random_circuit(6, 20, seed=42)\n", - "circuit.draw(fold=-1)" + "qiskit_random_circuit = random_circuit(4, 5, seed=42)\n", + "qiskit_random_circuit.draw(fold=-1)" ] }, { @@ -494,18 +402,31 @@ "id": "d9d69137", "metadata": {}, "source": [ - "Here is a good point to talk about circuit transpilation. \n", - "\n", - "Transpilation is the process of rewriting a given input circuit \n", - "to match the topology of a specific quantum device, and/or to optimize the \n", - "circuit for execution on present day noisy quantum systems.\n", - "\n", - "Let's transpile our generated circuit agains selected device." + "Each device has a set of supported operations which are accessible via the backend." ] }, { "cell_type": "code", "execution_count": 13, + "id": "fd631f39", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'x', 't', 'h', 'ry', 's', 'sx', 'rz', 'ryy', 'y', 'rzz', 'rxx', 'rx', 'sxdg', 'sdg', 'cx', 'swap', 'z', 'tdg'}\n" + ] + } + ], + "source": [ + "aria_supported_gates = Aria_1._get_gateset()\n", + "print(aria_supported_gates)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "id": "51e60f77", "metadata": { "slideshow": { @@ -514,48 +435,28 @@ }, "outputs": [ { - "data": { - "text/html": [ - "
global phase: 1.0121\n",
-       "          ┌────────────┐                  ┌───┐     ┌─────────────┐     ┌───┐┌─────────────┐                           ┌────────────┐                                                                ┌───┐┌─────────────┐               ┌───┐┌─────────────┐  ┌─────────┐                                           ┌───┐ ┌──────────┐                ┌───┐┌─────────────┐┌────────────┐┌──────────────┐                     ┌───┐                                                                                                                          ┌──────────────┐┌────────────┐┌─────────────┐                                                                                                                                                                                                                                                                        ┌──────────┐     ┌───┐     ┌──────────┐┌────────────┐                                                                                                     ┌───────────────┐ ┌────────────┐┌────────────┐ ┌────────────┐                                                                                                                                                                                                                                                                                              ┌─────────┐      ┌────────────┐┌────────────┐┌─────────────┐                                                                        \n",
-       "q_0 -> 0 ─┤ Rz(0.2266) ├──────────────────┤ X ├─────┤ Ry(-2.3912) ├─────┤ X ├┤ Rz(-0.2266) ├───────────────────────■───┤ Rz(2.9633) ├────────────────────────────────────────────────────────────────┤ X ├┤ Ry(-2.8058) ├───────────────┤ X ├┤ Rz(0.17834) ├──┤ Ry(π/2) ├───────────────────────────────────────────┤ X ├─┤ Rz(-π/4) ├────────────────┤ X ├┤ Rz(-2.2555) ├┤ Ry(1.3517) ├┤ Rz(-0.43523) ├─────────────────────┤ X ├────────────────────X───────────────────────────────────────────────────────────────────────────────────────────────────X─┤ Rz(-0.27086) ├┤ Ry(2.2172) ├┤ Rz(0.43785) ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────■───────────────────────────────────────────■───────┤ Rz(-π/2) ├─────┤ X ├─────┤ Rz(-π/2) ├┤ Ry(-2.142) ├─────────────────────────────────────────────────────────────────────────────────────────────────────┤0              ├─┤ Rz(3.0787) ├┤ Ry(1.4504) ├─┤ Rz(2.8393) ├───────────────────────────────────────────────────────────────────────────────────────────────■─────────────────────■────────────────────────────────────────────────────────────────────────────────────────────────────────■──────────────────────────────────────────■─────────────────■──┤ Rz(π/4) ├───■──┤ Rz(2.3646) ├┤ Ry(2.1258) ├┤ Rz(-2.3646) ├────────────────────────────────────────────────────────────────────────\n",
-       "          └┬──────────┬┘  ┌────────┐      └─┬─┘     └─────────────┘┌───┐└─┬─┘└─┬──────────┬┘┌────────┐   ┌───┐     │  ┌┴────────────┴┐┌────────────┐                                                 └─┬─┘└─────────────┘               └─┬─┘└─────────────┘  └─────────┘                ┌──────────────┐           └─┬─┘ └──────────┘                └─┬─┘└─────────────┘└────────────┘└──────────────┘┌───┐┌─────────────┐ └─┬─┘                    │    ┌───┐ ┌────────────┐┌───┐┌─────────────┐               ┌───┐ ┌────────────┐                    │ └──────────────┘└┬─────────┬─┘└─────────────┘                                                           ┌─────────────┐            ┌────────────────┐  ┌─────────┐    ┌───────┐                                                                                  │                                           │       └──────────┘     └─┬─┘     ├─────────┬┘└───┬───┬────┘                                                                                                ┌───┐│               │┌┴────────────┤└───┬───┬────┘┌┴────────────┴┐┌─────────┐ ┌───┐┌──────────┐┌───┐ ┌───────────┐  ┌─────────┐ ┌──────────────┐ ┌──────────┐   │   ┌────────┐ ┌───┐  │   ┌──────────┐   ┌───┐    ┌───────────┐ ┌─────────┐┌─────────┐                                         │                                          │                 │  └─────────┘   │  └────────────┘└────────────┘└─────────────┘                    ┌─────────┐                   ┌───┐┌──────────┐┌───┐\n",
-       "q_1 -> 1 ──┤ Ry(-π/2) ├───┤ Rz(-π) ├────────┼──────────────────────┤ X ├──┼────┤ Ry(-π/2) ├─┤ Rz(-π) ├───┤ X ├─────┼──┤ Ry(-0.18411) ├┤ Rx(1.1905) ├───────────────────────────────────────────────────┼──────────────────────────────────┼──────────────────────────────────────────────┤0             ├─────────────┼─────────────────────────────────┼───────────────────────────────────────────────┤ X ├┤ Rz(-1.7868) ├───┼──────────────────────┼────┤ X ├─┤ Rz(1.7868) ├┤ X ├┤ Rz(-1.7391) ├───────────────┤ X ├─┤ Rz(1.7391) ├────────────────────┼────────■─────────┤ Rz(π/4) ├───────────────────■────────────────■───────■──────────────────────────■────┤ Rx(0.94723) ├────────────┤1               ├──┤ Rz(π/2) ├────┤ Ry(π) ├──────────────────────────────────────────────────────────────────────────────────┼───────────────────────────────────────────┼──────────────────────────■───────┤ Rx(π/2) ├─────┤ X ├─────────────────────────────────────────────────────────────────────────────────────────────────────┤ X ├┤               ├┤ Rz(-2.9463) ├────┤ X ├─────┤ Rz(-0.19532) ├┤ Ry(π/2) ├─┤ X ├┤ Rz(-π/4) ├┤ X ├─┤ Rz(-3π/4) ├──┤ Ry(π/2) ├─┤0             ├─┤ Ry(-π/2) ├───┼───┤ Rz(-π) ├─┤ X ├──┼───┤ Rz(-π/4) ├───┤ X ├────┤ Rz(-3π/4) ├─┤ Ry(π/2) ├┤ Rz(π/4) ├─────────────────────────────────────────┼────────────────────■─────────────────────┼─────────────────┼────────────────┼──────────────────────────────────────────────────────────────■──┤ Rz(π/4) ├───────────────────┤ X ├┤ Rz(-π/4) ├┤ X ├\n",
-       "           ├─────────┬┘   └────────┘        │       ┌─────────────┐└─┬─┘  │    └┬───────┬─┘ └─┬───┬──┘   └─┬─┘     │  └─┬──────────┬─┘└─┬────────┬─┘┌───┐┌──────────┐            ┌───┐┌─────────────┐  │       ┌───┐     ┌─────────────┐  │       ┌───┐     ┌─────────────┐              │              │             │                                 │                                               └─┬─┘├─────────────┴┐  │  ┌──────────────┐    │    └─┬─┘ └────────────┘└─┬─┘└────┬───┬────┘┌─────────────┐└─┬─┘┌┴────────────┤┌───┐┌────────────┐ │        │        ┌┴─────────┴─┐┌─────────────┐  │                │     ┌─┴─┐    ┌──────────────┐  ┌─┴─┐  └────┬───┬────┘┌──────────┐│                │  └──┬───┬──┘   ┌┴───────┴┐       ┌───┐      ┌──────────┐┌───┐┌───────────┐┌─────────┐ ┌────────────┐       │                                           │                                  └──┬───┬──┘     └─┬─┘     ┌──────────────┐┌───┐┌─────────────┐           ┌───┐┌─────────────┐         ┌───┐┌─────────────┐└─┬─┘│               │└─────────────┘    └─┬─┘     └─┬─────────┬──┘└─────────┘ └─┬─┘└──────────┘└─┬─┘ └───────────┘  └─────────┘ │  Rxx(4.5678) │┌┴──────────┴┐  │   └────────┘ └─┬─┘  │   └──────────┘   └─┬─┘    └───────────┘ └─────────┘├─────────┴┐   ┌────────┐   ┌───┐┌──────────┐     ┌─┴─┐     ┌─────────┐  │  ┌───┐┌──────────┐┌─┴─┐┌───────────┐  │  ┌─────────┐   │                ┌────────────┐ ┌───────────┐ ┌─────────────┐  │  └─────────┘                   └─┬─┘└──────────┘└─┬─┘\n",
-       "q_2 -> 2 ──┤ Ry(π/2) ├──────────────────────■───────┤ Ry(-2.3912) ├──┼────■─────┤ Rx(π) ├─────┤ X ├────────┼───────┼────┤ Ry(-π/2) ├────┤ Rz(-π) ├──┤ X ├┤ Rz(-π/4) ├────────────┤ X ├┤ Rz(-1.3795) ├──┼───────┤ X ├─────┤ Ry(-1.1638) ├──┼───────┤ X ├─────┤ Rz(-2.5344) ├──────────────┤              ├─────■───────┼─────────────────────────────────┼─────────■───────────────────────────────────────┼──┤0             ├──┼──┤ Rz(-0.85807) ├────┼──────┼───────────────────┼───────┤ X ├─────┤ Rz(-1.0517) ├──┼──┤ Ry(-1.7568) ├┤ X ├┤ Rz(2.6189) ├─┼────────┼────────┤ Ry(1.2411) ├┤ Rz(-1.7732) ├──┼────────────────┼─────┤ X ├────┤ Ry(-0.52456) ├──┤ X ├───────┤ X ├─────┤ Rz(-π/4) ├┤                ├─────┤ X ├──────┤ Rz(π/4) ├───────┤ X ├──────┤ Rz(-π/4) ├┤ X ├┤ Rz(1.391) ├┤ Ry(π/2) ├─┤ Rz(1.7105) ├───────┼─────────■─────────────────────────────────┼─────────────────────────────────────┤ X ├──────────┼───────┤ Rz(-0.13073) ├┤ X ├┤ Rz(0.13073) ├───────────┤ X ├┤ Rz(-1.0897) ├─────────┤ X ├┤ Rz(-2.2472) ├──■──┤               ├─────────────────────■─────────┤ Rz(π/4) ├─────────────────■────────────────■──────────────────────────────┤1             ├┤ Rz(1.9926) ├──┼────────────────┼────┼────────────────────┼─────────────────────────■─────┤ Ry(-π/2) ├───┤ Rz(-π) ├───┤ X ├┤ Rz(-π/4) ├─────┤ X ├─────┤ Rz(π/4) ├──┼──┤ X ├┤ Rz(-π/4) ├┤ X ├┤ Rz(-3π/4) ├──┼──┤ Ry(π/2) ├───┼────────■───────┤ Rz(3.0033) ├─┤ Ry(1.985) ├─┤ Rz(-3.0033) ├──┼──────────────────────────────────┼────────────────┼──\n",
-       "           ├─────────┤                              └─────────────┘  │          └───────┘     └─┬─┘        │       │    └──────────┘    └────────┘  └─┬─┘└──────────┘┌─────────┐ └─┬─┘└─────────────┘  │       └─┬─┘     └┬────────────┤  │       └─┬─┘     └─┬──────────┬┘┌────────────┐│  Rxx(2.4346) │   ┌─┴─┐     │  ┌────────────┐┌─────────────┐  │       ┌─┴─┐     ┌────────────┐ ┌────────────┐   │  │  Rxx(2.8835) │  │  └──────────────┘    │      │                   │       └─┬─┘     └─────────────┘  │  └─────────────┘└─┬─┘└────────────┘ │        │        └────────────┘└─────────────┘  │                │     └───┘    └────┬───┬─────┘  └───┘       └─┬─┘     └──────────┘│                │     └─┬─┘      └─────────┘       └─┬─┘      ├─────────┬┘└─┬─┘└───┬───┬───┘├─────────┴┐└───┬───┬────┘     ┌─┴─┐       │           ┌──────────────┐    ┌─┴─┐     ┌──────────┐┌─────────────┐   └─┬─┘          │       └──────────────┘└─┬─┘├─────────────┤┌─────────┐└─┬─┘└─────────────┘┌───────┐└─┬─┘└─────────────┘     │  Rxx(-1.5416) │                               └─────────┘                                     ┌──────────────┐┌─────────┐ └──────────────┘└────────────┘  │                │    │                    │     ┌─────────────┐     │     └──┬───┬───┘┌──┴────────┴──┐└─┬─┘└──┬───┬───┘  ┌──┴───┴───┐ └┬────────┤┌─┴─┐└─┬─┘├──────────┤└───┘└───────────┘  │  └─────────┘   │        │       └───┬───┬────┘ └┬─────────┬┘ └─────────────┘┌─┴─┐┌──────────┐┌───┐┌───────────┐  │  ┌─────────┐   │  \n",
-       "q_3 -> 3 ──┤ Rx(π/2) ├───────────────────────────────────────────────┼──────────────────────────┼──────────■───────┼──────────────────────────────────┼───────■──────┤ Ry(π/2) ├───┼───────────────────┼─────────■────────┤ Ry(1.1638) ├──┼─────────■─────────┤ Ry(-π/2) ├─┤ Rz(1.6333) ├┤              ├───┤ X ├─────┼──┤ Rz(2.6872) ├┤ Ry(-2.1999) ├──┼───────┤ X ├─────┤ Ry(2.1999) ├─┤ Rz(1.9627) ├───┼──┤1             ├──┼──────────────────────X──────┼───────────────────┼─────────┼────────────────────────┼───────────────────┼─────────────────┼────────┼───────────────────────────────────────┼────────────────┼───────────────────┤ X ├──────────────────────■───────────────────┤  Rxx(-0.94723) ├───────┼────────────────────────────■────────┤ Rz(π/4) ├───┼──────┤ X ├────┤ Rz(-π/4) ├────┤ X ├──────────┤ X ├───────┼───────────┤ Rz(-0.90092) ├────┤ X ├─────┤ Ry(-π/2) ├┤ Rz(-3.0109) ├─────■────────────┼─────────────────────────■──┤ Ry(-2.6323) ├┤ Rz(π/2) ├──┼─────────■───────┤ Rx(π) ├──┼──────────────────────┤               ├────────────────────────────────────■───────────────────────────────────────■──┤1             ├┤ Rz(π/4) ├─────────────────────────────────┼────────────────■────┼────────────────────■─────┤ Ry(0.14109) ├─────┼────────┤ X ├────┤ Ry(-0.14109) ├──┼─────┤ X ├──────┤ Ry(-π/2) ├──┤ Rz(-π) ├┤ X ├──┼──┤ Rz(-π/4) ├────────────────────┼────────────────┼────────┼───────────┤ X ├───────┤ Rz(π/4) ├─────────────────┤ X ├┤ Rz(-π/4) ├┤ X ├┤ Rz(-3π/4) ├──┼──┤ Ry(π/2) ├───┼──\n",
-       "           └─────────┘                                               │                          │     ┌─────────┐  │                                  │       │      └─────────┘   │    ┌─────────┐    │   ┌────────────┐ └────────────┘  │  ┌─────────────┐  ├──────────┤ └────────────┘│              │┌──┴───┴──┐  │  └────────────┘└─────────────┘  │       └───┘     └────────────┘ └────────────┘   │  └──────────────┘  │   ┌────────────┐ ┌───────┐  │                   │         │                        │    ┌──────────┐   │    ┌────────┐   │      ┌─┴─┐       ┌──────────┐    ┌────────┐  ┌─┴─┐┌──────────┐┌─┴─┐┌──────────┐     └─┬─┘      ┌───────┐                           │                │       │                                     └─────────┘   │      └─┬─┘    ├─────────┬┘    └─┬─┘     ┌────┴───┴─────┐ │           └┬────────────┬┘┌───┴───┴────┐└──────────┘└─────────────┘                  │         ┌──────────┐       └─────────────┘└─────────┘  │       ┌─┴─┐     └───────┘  │                      │               │                                    │                                       │  │  Rxx(4.8296) │├─────────┴┐   ┌────────┐                 ┌─┴─┐┌──────────┐     ┌─┴─┐┌───────────┐┌─────────┐└─────────────┘   ┌─┴─┐      └─┬─┘    └──────────────┘  │     └─┬─┘      └──────────┘  └────────┘└───┘  │  ├─────────┬┘                  ┌─┴─┐┌──────────┐┌─┴─┐    ┌─┴─┐         └─┬─┘       └─────────┘                 └───┘└──────────┘└─┬─┘└───────────┘  │  ├─────────┤   │  \n",
-       "q_4 -> 4 ────────────────────────────────────────────────────────────■──────────────────────────■─────┤ Rz(π/4) ├──┼──────────────────────────────────■───────┼────────────────────■────┤ Ry(π/2) ├────■───┤ Ry(2.8058) ├─────────────────■──┤ Rz(-2.0472) ├──┤ Ry(-π/2) ├───────────────┤1             ├┤ Rz(π/2) ├──┼─────────────────────────────────┼─────────────────────────────────────────────────┼────────────────────■───┤ Rz(1.4025) ├─┤ Ry(π) ├──┼───────────────────■─────────┼────────────────────────■────┤ Ry(-π/2) ├───┼────┤ Rz(-π) ├───┼──────┤ X ├───────┤ Ry(-π/2) ├────┤ Rz(-π) ├──┤ X ├┤ Rz(-π/4) ├┤ X ├┤ Rz(3π/4) ├───────■────────┤ Rx(π) ├───────────────────────────┤                ├───────■───────────────────────────────────────────────────■────────■──────┤ Rz(π/4) ├───────■───────┤ Rz(-0.44825) ├─┼────────────┤ Ry(3.1038) ├─┤ Rz(2.0726) ├─────────────────────────────────────────────■─────────┤ Rx(-π/2) ├───────────────────────────────────┼───────┤ X ├────────────────┼──────────────────────┤               ├────────────────────────────────────┼──────────────────────■────────────────┼──┤0             ├┤ Ry(-π/2) ├───┤ Rz(-π) ├─────────────────┤ X ├┤ Rz(-π/4) ├─────┤ X ├┤ Rz(-3π/4) ├┤ Ry(π/2) ├──────────────────┤ X ├────────┼────────────────────────■───────┼───────────────────────────────────────■──┤ Rz(π/4) ├───────────────────┤ X ├┤ Rz(-π/4) ├┤ X ├────┤ X ├───────────■────────────────────────────────────────────────────────■─────────────────■──┤ Rz(π/4) ├───■──\n",
-       "         ┌─────────────┐┌───────────┐┌─────────────┐                                                  └─────────┘┌─┴─┐  ┌──────────┐   ┌─────────┐          ┌─┴─┐    ┌──────────┐       └─────────┘        └────────────┘                    └─────────────┘  └──────────┘               └──────────────┘└─────────┘  │                                 │    ┌──────────┐ ┌────────────┐                  │                        └────────────┘ └───────┘  │  ┌─────────────┐            │                             └──────────┘   │    └────────┘   │ ┌────┴───┴────┐  └┬────────┬┘    └────────┘  └───┘└──────────┘└───┘└──────────┘                └───────┘                           │                │┌─────────────┐┌────────────┐┌──────────────┐                              └─────────┘               └──────────────┘ │ZZ(1.1107)  ├────────────┤ ├────────────┤                                                       └──────────┘                                   │       └───┘                │   ┌────────────┐     │               │  ┌──────────┐ ┌───────────┐      ┌─┴─┐      ┌──────────┐┌─┴─┐┌─────────┐ ┌─┴─┐└─┬──────────┬─┘└┬───────┬─┘   └────────┘                 └───┘└──────────┘     └───┘└───────────┘└─────────┘                  └───┘        │                                │      ┌─────────────┐                     └─────────┘                   └───┘└──────────┘└───┘    └───┘                                                                                         └─────────┘      \n",
-       "q_5 -> 5 ┤ Rz(-3.1159) ├┤ Ry(1.656) ├┤ Rz(0.58629) ├─────────────────────────────────────────────────────────────┤ X ├──┤ Ry(-π/2) ├───┤ Rz(π/2) ├──────────┤ X ├────┤ Rz(3π/4) ├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────■─────────────────────────────────■────┤ Rx(-π/2) ├─┤ Rz(1.7868) ├──────────────────■──────────────────────────────────────────────────■──┤ Rz(-2.4875) ├────────────■────────────────────────────────────────────■─────────────────X─┤ Ry(-1.4281) ├───┤ Rz(-π) ├───────────────────────────────────────────────────────────────────────────────────────────────────────┤0               ├┤ Rz(-1.4692) ├┤ Ry(1.3781) ├┤ Rz(-0.21319) ├─────────────────────────────────────────────────────────────────────────■────────────┤ Rx(2.6126) ├─┤ Rz(1.0897) ├──────────────────────────────────────────────────────────────────────────────────────────────────────■────────────────────────────■───┤ Rx(1.5416) ├─────┤1              ├──┤ Ry(-π/2) ├─┤ Rz(-3π/4) ├──────┤ X ├──────┤ Rz(-π/4) ├┤ X ├┤ Rz(π/4) ├─┤ X ├──┤ Rz(-π/4) ├───┤ Ry(π) ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────■────────────────────────────────■──────┤ Rx(-3.0231) ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
-       "         └─────────────┘└───────────┘└─────────────┘                                                             └───┘  └──────────┘   └─────────┘          └───┘    └──────────┘                                                                                                                                                                            └──────────┘ └────────────┘                                                                        └─────────────┘                                                                             └─────────────┘   └────────┘                                                                                                       └────────────────┘└─────────────┘└────────────┘└──────────────┘                                                                                      └────────────┘ └────────────┘                                                                                                                                       └────────────┘     └───────────────┘  └──────────┘ └───────────┘      └───┘      └──────────┘└───┘└─────────┘ └───┘  └──────────┘   └───────┘                                                                                                                                                          └─────────────┘
" - ], - "text/plain": [ - "global phase: 1.0121\n", - " ┌────────────┐ ┌───┐ ┌─────────────┐ ┌───┐┌─────────────┐ ┌────────────┐ ┌───┐┌─────────────┐ ┌───┐┌─────────────┐ ┌─────────┐ ┌───┐ ┌──────────┐ ┌───┐┌─────────────┐┌────────────┐┌──────────────┐ ┌───┐ ┌──────────────┐┌────────────┐┌─────────────┐ ┌──────────┐ ┌───┐ ┌──────────┐┌────────────┐ ┌───────────────┐ ┌────────────┐┌────────────┐ ┌────────────┐ ┌─────────┐ ┌────────────┐┌────────────┐┌─────────────┐ \n", - "q_0 -> 0 ─┤ Rz(0.2266) ├──────────────────┤ X ├─────┤ Ry(-2.3912) ├─────┤ X ├┤ Rz(-0.2266) ├───────────────────────■───┤ Rz(2.9633) ├────────────────────────────────────────────────────────────────┤ X ├┤ Ry(-2.8058) ├───────────────┤ X ├┤ Rz(0.17834) ├──┤ Ry(π/2) ├───────────────────────────────────────────┤ X ├─┤ Rz(-π/4) ├────────────────┤ X ├┤ Rz(-2.2555) ├┤ Ry(1.3517) ├┤ Rz(-0.43523) ├─────────────────────┤ X ├────────────────────X───────────────────────────────────────────────────────────────────────────────────────────────────X─┤ Rz(-0.27086) ├┤ Ry(2.2172) ├┤ Rz(0.43785) ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────■───────────────────────────────────────────■───────┤ Rz(-π/2) ├─────┤ X ├─────┤ Rz(-π/2) ├┤ Ry(-2.142) ├─────────────────────────────────────────────────────────────────────────────────────────────────────┤0 ├─┤ Rz(3.0787) ├┤ Ry(1.4504) ├─┤ Rz(2.8393) ├───────────────────────────────────────────────────────────────────────────────────────────────■─────────────────────■────────────────────────────────────────────────────────────────────────────────────────────────────────■──────────────────────────────────────────■─────────────────■──┤ Rz(π/4) ├───■──┤ Rz(2.3646) ├┤ Ry(2.1258) ├┤ Rz(-2.3646) ├────────────────────────────────────────────────────────────────────────\n", - " └┬──────────┬┘ ┌────────┐ └─┬─┘ └─────────────┘┌───┐└─┬─┘└─┬──────────┬┘┌────────┐ ┌───┐ │ ┌┴────────────┴┐┌────────────┐ └─┬─┘└─────────────┘ └─┬─┘└─────────────┘ └─────────┘ ┌──────────────┐ └─┬─┘ └──────────┘ └─┬─┘└─────────────┘└────────────┘└──────────────┘┌───┐┌─────────────┐ └─┬─┘ │ ┌───┐ ┌────────────┐┌───┐┌─────────────┐ ┌───┐ ┌────────────┐ │ └──────────────┘└┬─────────┬─┘└─────────────┘ ┌─────────────┐ ┌────────────────┐ ┌─────────┐ ┌───────┐ │ │ └──────────┘ └─┬─┘ ├─────────┬┘└───┬───┬────┘ ┌───┐│ │┌┴────────────┤└───┬───┬────┘┌┴────────────┴┐┌─────────┐ ┌───┐┌──────────┐┌───┐ ┌───────────┐ ┌─────────┐ ┌──────────────┐ ┌──────────┐ │ ┌────────┐ ┌───┐ │ ┌──────────┐ ┌───┐ ┌───────────┐ ┌─────────┐┌─────────┐ │ │ │ └─────────┘ │ └────────────┘└────────────┘└─────────────┘ ┌─────────┐ ┌───┐┌──────────┐┌───┐\n", - "q_1 -> 1 ──┤ Ry(-π/2) ├───┤ Rz(-π) ├────────┼──────────────────────┤ X ├──┼────┤ Ry(-π/2) ├─┤ Rz(-π) ├───┤ X ├─────┼──┤ Ry(-0.18411) ├┤ Rx(1.1905) ├───────────────────────────────────────────────────┼──────────────────────────────────┼──────────────────────────────────────────────┤0 ├─────────────┼─────────────────────────────────┼───────────────────────────────────────────────┤ X ├┤ Rz(-1.7868) ├───┼──────────────────────┼────┤ X ├─┤ Rz(1.7868) ├┤ X ├┤ Rz(-1.7391) ├───────────────┤ X ├─┤ Rz(1.7391) ├────────────────────┼────────■─────────┤ Rz(π/4) ├───────────────────■────────────────■───────■──────────────────────────■────┤ Rx(0.94723) ├────────────┤1 ├──┤ Rz(π/2) ├────┤ Ry(π) ├──────────────────────────────────────────────────────────────────────────────────┼───────────────────────────────────────────┼──────────────────────────■───────┤ Rx(π/2) ├─────┤ X ├─────────────────────────────────────────────────────────────────────────────────────────────────────┤ X ├┤ ├┤ Rz(-2.9463) ├────┤ X ├─────┤ Rz(-0.19532) ├┤ Ry(π/2) ├─┤ X ├┤ Rz(-π/4) ├┤ X ├─┤ Rz(-3π/4) ├──┤ Ry(π/2) ├─┤0 ├─┤ Ry(-π/2) ├───┼───┤ Rz(-π) ├─┤ X ├──┼───┤ Rz(-π/4) ├───┤ X ├────┤ Rz(-3π/4) ├─┤ Ry(π/2) ├┤ Rz(π/4) ├─────────────────────────────────────────┼────────────────────■─────────────────────┼─────────────────┼────────────────┼──────────────────────────────────────────────────────────────■──┤ Rz(π/4) ├───────────────────┤ X ├┤ Rz(-π/4) ├┤ X ├\n", - " ├─────────┬┘ └────────┘ │ ┌─────────────┐└─┬─┘ │ └┬───────┬─┘ └─┬───┬──┘ └─┬─┘ │ └─┬──────────┬─┘└─┬────────┬─┘┌───┐┌──────────┐ ┌───┐┌─────────────┐ │ ┌───┐ ┌─────────────┐ │ ┌───┐ ┌─────────────┐ │ │ │ │ └─┬─┘├─────────────┴┐ │ ┌──────────────┐ │ └─┬─┘ └────────────┘└─┬─┘└────┬───┬────┘┌─────────────┐└─┬─┘┌┴────────────┤┌───┐┌────────────┐ │ │ ┌┴─────────┴─┐┌─────────────┐ │ │ ┌─┴─┐ ┌──────────────┐ ┌─┴─┐ └────┬───┬────┘┌──────────┐│ │ └──┬───┬──┘ ┌┴───────┴┐ ┌───┐ ┌──────────┐┌───┐┌───────────┐┌─────────┐ ┌────────────┐ │ │ └──┬───┬──┘ └─┬─┘ ┌──────────────┐┌───┐┌─────────────┐ ┌───┐┌─────────────┐ ┌───┐┌─────────────┐└─┬─┘│ │└─────────────┘ └─┬─┘ └─┬─────────┬──┘└─────────┘ └─┬─┘└──────────┘└─┬─┘ └───────────┘ └─────────┘ │ Rxx(4.5678) │┌┴──────────┴┐ │ └────────┘ └─┬─┘ │ └──────────┘ └─┬─┘ └───────────┘ └─────────┘├─────────┴┐ ┌────────┐ ┌───┐┌──────────┐ ┌─┴─┐ ┌─────────┐ │ ┌───┐┌──────────┐┌─┴─┐┌───────────┐ │ ┌─────────┐ │ ┌────────────┐ ┌───────────┐ ┌─────────────┐ │ └─────────┘ └─┬─┘└──────────┘└─┬─┘\n", - "q_2 -> 2 ──┤ Ry(π/2) ├──────────────────────■───────┤ Ry(-2.3912) ├──┼────■─────┤ Rx(π) ├─────┤ X ├────────┼───────┼────┤ Ry(-π/2) ├────┤ Rz(-π) ├──┤ X ├┤ Rz(-π/4) ├────────────┤ X ├┤ Rz(-1.3795) ├──┼───────┤ X ├─────┤ Ry(-1.1638) ├──┼───────┤ X ├─────┤ Rz(-2.5344) ├──────────────┤ ├─────■───────┼─────────────────────────────────┼─────────■───────────────────────────────────────┼──┤0 ├──┼──┤ Rz(-0.85807) ├────┼──────┼───────────────────┼───────┤ X ├─────┤ Rz(-1.0517) ├──┼──┤ Ry(-1.7568) ├┤ X ├┤ Rz(2.6189) ├─┼────────┼────────┤ Ry(1.2411) ├┤ Rz(-1.7732) ├──┼────────────────┼─────┤ X ├────┤ Ry(-0.52456) ├──┤ X ├───────┤ X ├─────┤ Rz(-π/4) ├┤ ├─────┤ X ├──────┤ Rz(π/4) ├───────┤ X ├──────┤ Rz(-π/4) ├┤ X ├┤ Rz(1.391) ├┤ Ry(π/2) ├─┤ Rz(1.7105) ├───────┼─────────■─────────────────────────────────┼─────────────────────────────────────┤ X ├──────────┼───────┤ Rz(-0.13073) ├┤ X ├┤ Rz(0.13073) ├───────────┤ X ├┤ Rz(-1.0897) ├─────────┤ X ├┤ Rz(-2.2472) ├──■──┤ ├─────────────────────■─────────┤ Rz(π/4) ├─────────────────■────────────────■──────────────────────────────┤1 ├┤ Rz(1.9926) ├──┼────────────────┼────┼────────────────────┼─────────────────────────■─────┤ Ry(-π/2) ├───┤ Rz(-π) ├───┤ X ├┤ Rz(-π/4) ├─────┤ X ├─────┤ Rz(π/4) ├──┼──┤ X ├┤ Rz(-π/4) ├┤ X ├┤ Rz(-3π/4) ├──┼──┤ Ry(π/2) ├───┼────────■───────┤ Rz(3.0033) ├─┤ Ry(1.985) ├─┤ Rz(-3.0033) ├──┼──────────────────────────────────┼────────────────┼──\n", - " ├─────────┤ └─────────────┘ │ └───────┘ └─┬─┘ │ │ └──────────┘ └────────┘ └─┬─┘└──────────┘┌─────────┐ └─┬─┘└─────────────┘ │ └─┬─┘ └┬────────────┤ │ └─┬─┘ └─┬──────────┬┘┌────────────┐│ Rxx(2.4346) │ ┌─┴─┐ │ ┌────────────┐┌─────────────┐ │ ┌─┴─┐ ┌────────────┐ ┌────────────┐ │ │ Rxx(2.8835) │ │ └──────────────┘ │ │ │ └─┬─┘ └─────────────┘ │ └─────────────┘└─┬─┘└────────────┘ │ │ └────────────┘└─────────────┘ │ │ └───┘ └────┬───┬─────┘ └───┘ └─┬─┘ └──────────┘│ │ └─┬─┘ └─────────┘ └─┬─┘ ├─────────┬┘└─┬─┘└───┬───┬───┘├─────────┴┐└───┬───┬────┘ ┌─┴─┐ │ ┌──────────────┐ ┌─┴─┐ ┌──────────┐┌─────────────┐ └─┬─┘ │ └──────────────┘└─┬─┘├─────────────┤┌─────────┐└─┬─┘└─────────────┘┌───────┐└─┬─┘└─────────────┘ │ Rxx(-1.5416) │ └─────────┘ ┌──────────────┐┌─────────┐ └──────────────┘└────────────┘ │ │ │ │ ┌─────────────┐ │ └──┬───┬───┘┌──┴────────┴──┐└─┬─┘└──┬───┬───┘ ┌──┴───┴───┐ └┬────────┤┌─┴─┐└─┬─┘├──────────┤└───┘└───────────┘ │ └─────────┘ │ │ └───┬───┬────┘ └┬─────────┬┘ └─────────────┘┌─┴─┐┌──────────┐┌───┐┌───────────┐ │ ┌─────────┐ │ \n", - "q_3 -> 3 ──┤ Rx(π/2) ├───────────────────────────────────────────────┼──────────────────────────┼──────────■───────┼──────────────────────────────────┼───────■──────┤ Ry(π/2) ├───┼───────────────────┼─────────■────────┤ Ry(1.1638) ├──┼─────────■─────────┤ Ry(-π/2) ├─┤ Rz(1.6333) ├┤ ├───┤ X ├─────┼──┤ Rz(2.6872) ├┤ Ry(-2.1999) ├──┼───────┤ X ├─────┤ Ry(2.1999) ├─┤ Rz(1.9627) ├───┼──┤1 ├──┼──────────────────────X──────┼───────────────────┼─────────┼────────────────────────┼───────────────────┼─────────────────┼────────┼───────────────────────────────────────┼────────────────┼───────────────────┤ X ├──────────────────────■───────────────────┤ Rxx(-0.94723) ├───────┼────────────────────────────■────────┤ Rz(π/4) ├───┼──────┤ X ├────┤ Rz(-π/4) ├────┤ X ├──────────┤ X ├───────┼───────────┤ Rz(-0.90092) ├────┤ X ├─────┤ Ry(-π/2) ├┤ Rz(-3.0109) ├─────■────────────┼─────────────────────────■──┤ Ry(-2.6323) ├┤ Rz(π/2) ├──┼─────────■───────┤ Rx(π) ├──┼──────────────────────┤ ├────────────────────────────────────■───────────────────────────────────────■──┤1 ├┤ Rz(π/4) ├─────────────────────────────────┼────────────────■────┼────────────────────■─────┤ Ry(0.14109) ├─────┼────────┤ X ├────┤ Ry(-0.14109) ├──┼─────┤ X ├──────┤ Ry(-π/2) ├──┤ Rz(-π) ├┤ X ├──┼──┤ Rz(-π/4) ├────────────────────┼────────────────┼────────┼───────────┤ X ├───────┤ Rz(π/4) ├─────────────────┤ X ├┤ Rz(-π/4) ├┤ X ├┤ Rz(-3π/4) ├──┼──┤ Ry(π/2) ├───┼──\n", - " └─────────┘ │ │ ┌─────────┐ │ │ │ └─────────┘ │ ┌─────────┐ │ ┌────────────┐ └────────────┘ │ ┌─────────────┐ ├──────────┤ └────────────┘│ │┌──┴───┴──┐ │ └────────────┘└─────────────┘ │ └───┘ └────────────┘ └────────────┘ │ └──────────────┘ │ ┌────────────┐ ┌───────┐ │ │ │ │ ┌──────────┐ │ ┌────────┐ │ ┌─┴─┐ ┌──────────┐ ┌────────┐ ┌─┴─┐┌──────────┐┌─┴─┐┌──────────┐ └─┬─┘ ┌───────┐ │ │ │ └─────────┘ │ └─┬─┘ ├─────────┬┘ └─┬─┘ ┌────┴───┴─────┐ │ └┬────────────┬┘┌───┴───┴────┐└──────────┘└─────────────┘ │ ┌──────────┐ └─────────────┘└─────────┘ │ ┌─┴─┐ └───────┘ │ │ │ │ │ │ Rxx(4.8296) │├─────────┴┐ ┌────────┐ ┌─┴─┐┌──────────┐ ┌─┴─┐┌───────────┐┌─────────┐└─────────────┘ ┌─┴─┐ └─┬─┘ └──────────────┘ │ └─┬─┘ └──────────┘ └────────┘└───┘ │ ├─────────┬┘ ┌─┴─┐┌──────────┐┌─┴─┐ ┌─┴─┐ └─┬─┘ └─────────┘ └───┘└──────────┘└─┬─┘└───────────┘ │ ├─────────┤ │ \n", - "q_4 -> 4 ────────────────────────────────────────────────────────────■──────────────────────────■─────┤ Rz(π/4) ├──┼──────────────────────────────────■───────┼────────────────────■────┤ Ry(π/2) ├────■───┤ Ry(2.8058) ├─────────────────■──┤ Rz(-2.0472) ├──┤ Ry(-π/2) ├───────────────┤1 ├┤ Rz(π/2) ├──┼─────────────────────────────────┼─────────────────────────────────────────────────┼────────────────────■───┤ Rz(1.4025) ├─┤ Ry(π) ├──┼───────────────────■─────────┼────────────────────────■────┤ Ry(-π/2) ├───┼────┤ Rz(-π) ├───┼──────┤ X ├───────┤ Ry(-π/2) ├────┤ Rz(-π) ├──┤ X ├┤ Rz(-π/4) ├┤ X ├┤ Rz(3π/4) ├───────■────────┤ Rx(π) ├───────────────────────────┤ ├───────■───────────────────────────────────────────────────■────────■──────┤ Rz(π/4) ├───────■───────┤ Rz(-0.44825) ├─┼────────────┤ Ry(3.1038) ├─┤ Rz(2.0726) ├─────────────────────────────────────────────■─────────┤ Rx(-π/2) ├───────────────────────────────────┼───────┤ X ├────────────────┼──────────────────────┤ ├────────────────────────────────────┼──────────────────────■────────────────┼──┤0 ├┤ Ry(-π/2) ├───┤ Rz(-π) ├─────────────────┤ X ├┤ Rz(-π/4) ├─────┤ X ├┤ Rz(-3π/4) ├┤ Ry(π/2) ├──────────────────┤ X ├────────┼────────────────────────■───────┼───────────────────────────────────────■──┤ Rz(π/4) ├───────────────────┤ X ├┤ Rz(-π/4) ├┤ X ├────┤ X ├───────────■────────────────────────────────────────────────────────■─────────────────■──┤ Rz(π/4) ├───■──\n", - " ┌─────────────┐┌───────────┐┌─────────────┐ └─────────┘┌─┴─┐ ┌──────────┐ ┌─────────┐ ┌─┴─┐ ┌──────────┐ └─────────┘ └────────────┘ └─────────────┘ └──────────┘ └──────────────┘└─────────┘ │ │ ┌──────────┐ ┌────────────┐ │ └────────────┘ └───────┘ │ ┌─────────────┐ │ └──────────┘ │ └────────┘ │ ┌────┴───┴────┐ └┬────────┬┘ └────────┘ └───┘└──────────┘└───┘└──────────┘ └───────┘ │ │┌─────────────┐┌────────────┐┌──────────────┐ └─────────┘ └──────────────┘ │ZZ(1.1107) ├────────────┤ ├────────────┤ └──────────┘ │ └───┘ │ ┌────────────┐ │ │ ┌──────────┐ ┌───────────┐ ┌─┴─┐ ┌──────────┐┌─┴─┐┌─────────┐ ┌─┴─┐└─┬──────────┬─┘└┬───────┬─┘ └────────┘ └───┘└──────────┘ └───┘└───────────┘└─────────┘ └───┘ │ │ ┌─────────────┐ └─────────┘ └───┘└──────────┘└───┘ └───┘ └─────────┘ \n", - "q_5 -> 5 ┤ Rz(-3.1159) ├┤ Ry(1.656) ├┤ Rz(0.58629) ├─────────────────────────────────────────────────────────────┤ X ├──┤ Ry(-π/2) ├───┤ Rz(π/2) ├──────────┤ X ├────┤ Rz(3π/4) ├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────■─────────────────────────────────■────┤ Rx(-π/2) ├─┤ Rz(1.7868) ├──────────────────■──────────────────────────────────────────────────■──┤ Rz(-2.4875) ├────────────■────────────────────────────────────────────■─────────────────X─┤ Ry(-1.4281) ├───┤ Rz(-π) ├───────────────────────────────────────────────────────────────────────────────────────────────────────┤0 ├┤ Rz(-1.4692) ├┤ Ry(1.3781) ├┤ Rz(-0.21319) ├─────────────────────────────────────────────────────────────────────────■────────────┤ Rx(2.6126) ├─┤ Rz(1.0897) ├──────────────────────────────────────────────────────────────────────────────────────────────────────■────────────────────────────■───┤ Rx(1.5416) ├─────┤1 ├──┤ Ry(-π/2) ├─┤ Rz(-3π/4) ├──────┤ X ├──────┤ Rz(-π/4) ├┤ X ├┤ Rz(π/4) ├─┤ X ├──┤ Rz(-π/4) ├───┤ Ry(π) ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────■────────────────────────────────■──────┤ Rx(-3.0231) ├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", - " └─────────────┘└───────────┘└─────────────┘ └───┘ └──────────┘ └─────────┘ └───┘ └──────────┘ └──────────┘ └────────────┘ └─────────────┘ └─────────────┘ └────────┘ └────────────────┘└─────────────┘└────────────┘└──────────────┘ └────────────┘ └────────────┘ └────────────┘ └───────────────┘ └──────────┘ └───────────┘ └───┘ └──────────┘└───┘└─────────┘ └───┘ └──────────┘ └───────┘ └─────────────┘ " - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "T : | 0 |1| 2 | 3 | 4 |5| 6 | 7 | 8 | 9 |10| 11 |12|13|14| 15 |16| 17 |18| 19 |20| 21 | 22 |23|24|25|26|27|28|29|30|31|32|\n", + " \n", + "q0 : -Rz(4.78)--S------------X-Ry(-3.07)-X-Si--------Rz(-4.78)-S--------H--------T--X---------Ti-H--Si-Rz(0.79)-C------------C-----------------------C-Rz(2.93)-------------------------------\n", + " | | | | | | \n", + "q1 : -Rz(0.98)--V-Rz(7.52)-V-|-Rz(8.45)--|------------------------------------------C---------H-----------------X--Rz(-0.79)-X--Rz(0.79)-H--Ry(2.23)-|-H--------X--Ti-X--T--X--Ti-X--T--H-----\n", + " | | | | | | | \n", + "q2 : -Ry(4.94)---------------|-----------|---------------------------------------C------------C--S--H--T--------X--Ti--------H--Si-------Si----------X-S--------|-----C-----|-----C--C--T--C--\n", + " | | | | | | | | | \n", + "q3 : -Rz(-1.57)-V-Rz(1.57)---C-Ry(-3.07)-C-Rz(-1.57)-Vi--------Rz(1.57)-Ry(2.02)-X--Ry(-2.02)-X-----------------C--Ti-------------------------------------------C-----------C--T-----X--Ti-X--\n", + "\n", + "T : | 0 |1| 2 | 3 | 4 |5| 6 | 7 | 8 | 9 |10| 11 |12|13|14| 15 |16| 17 |18| 19 |20| 21 | 22 |23|24|25|26|27|28|29|30|31|32|\n" + ] } ], "source": [ - "transpiled_circuit = transpile(circuit, backend=ionq_device, seed_transpiler=42)\n", - "transpiled_circuit.draw(idle_wires=False, fold=-1)" + "braket_random_circuit = to_braket(\n", + " qiskit_random_circuit, basis_gates=aria_supported_gates\n", + ")\n", + "print(braket_random_circuit)" ] }, { @@ -564,12 +465,12 @@ "id": "c698ffb1", "metadata": {}, "source": [ - "We can run our circuit and get job object back, which will store information about execution: job id, status of job and results when it will be available" + "We printed the Braket Circuit object that will be used to create the quantum task on the Aria-1 device. To submit the task, you do not have to create a Braket circuit, this is done internal when you submit the Qiskit circuit to the Backend." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "dfad043a", "metadata": { "slideshow": { @@ -578,8 +479,7 @@ }, "outputs": [], "source": [ - "ionq_job = ionq_device.run(transpiled_circuit, shots=10)\n", - "ionq_job.job_id()" + "aria_task = Aria_1.run(qiskit_random_circuit, shots=10)" ] }, { @@ -588,29 +488,18 @@ "id": "1c129b43", "metadata": {}, "source": [ - "If we do not want to wait for a job completion and return to it later, we can use `retrieve_job` method on device to get job object" + "If you do not want to wait for the task completion and return to it later, you can use `retrieve_job` method on device to get job object. For this, you will need to know the job_id (which is the task ARN that identifies the task in the AWS cloud)." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "34787aad", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "retrieved_job = ionq_device.retrieve_job(task_id=\"\")\n", - "retrieved_job" + "task_arn = aria_task.job_id()\n", + "retrieved_task = Aria_1.retrieve_job(task_id=task_arn)" ] }, { @@ -619,28 +508,28 @@ "id": "d28a2001", "metadata": {}, "source": [ - "Check status" + "From the task, you can check its status: " ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "764d4828", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "retrieved_job.status()" + "retrieved_task.status()" ] }, { @@ -649,287 +538,62 @@ "id": "6ce860f0", "metadata": {}, "source": [ - "And plot histogram of results" + "and get the results as done previously: " ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "4a8a8760", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plot_histogram(retrieved_job.result().get_counts())" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "939ec324", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Running algorithms\n", - "\n", - "Let's review an example of running algorithms using Qiskit on Braket devices.\n", - "\n", - "Qiskit provides a number of Algorithms and they are grouped by category according to the task they can perform. For instance Minimum Eigensolvers to find the smallest eigen value of an operator, for example ground state energy of a chemistry Hamiltonian or a solution to an optimization problem when expressed as an Ising Hamiltonian.\n", - "\n", - "Algorithms are configurable and often part of the configuration will be in the form of smaller building blocks, of which different instances of the building block type can be given. For instance with `VQE`, the Variational Quantum Eigensolver, it takes a trial wavefunction, in the form of a `QuantumCircuit` and a classical optimizer among other things.\n", - "\n", - "Let’s take a look at an example to construct a VQE instance. Here `TwoLocal` is the variational form (trial wavefunction), a parameterized circuit which can be varied, and SLSQP a classical optimizer. Then we pass hamiltonian to `compute_minimum_eigenvalue` method of `VQE` to get result.\n", - "\n", - "Full example and explanation of algorithm detail you can find [here](https://qiskit-community.github.io/qiskit-algorithms/tutorials/01_algorithms_introduction.html).\n", - "\n" + "random_circuit_results = retrieved_task.result()\n", + "plot_histogram(random_circuit_results.get_counts())" ] }, { "cell_type": "code", - "execution_count": 18, - "id": "02ad6d3e", + "execution_count": 19, + "id": "a16ab026", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{ 'aux_operators_evaluated': None,\n", - " 'cost_function_evals': 9,\n", - " 'eigenvalue': -1.4272080711283344,\n", - " 'optimal_circuit': ,\n", - " 'optimal_parameters': { ParameterVectorElement(θ[0]): 1.054197452954356,\n", - " ParameterVectorElement(θ[1]): 2.759415645946344,\n", - " ParameterVectorElement(θ[2]): -3.157245172580292,\n", - " ParameterVectorElement(θ[3]): -1.504397646177443,\n", - " ParameterVectorElement(θ[4]): -0.8460982537780612,\n", - " ParameterVectorElement(θ[5]): 3.3343214671170145,\n", - " ParameterVectorElement(θ[6]): 3.4110127659318756,\n", - " ParameterVectorElement(θ[7]): -5.015554393329303},\n", - " 'optimal_point': array([ 1.05419745, 2.75941565, -3.15724517, -1.50439765, -0.84609825,\n", - " 3.33432147, 3.41101277, -5.01555439]),\n", - " 'optimal_value': -1.4272080711283344,\n", - " 'optimizer_evals': None,\n", - " 'optimizer_result': ,\n", - " 'optimizer_time': 3.5380678176879883}\n" + "Quantum Task Summary\n", + "{'arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1': {'shots': 10, 'tasks': {'COMPLETED': 1}}}\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: 0.600 USD\n" ] } ], "source": [ - "H2_op = SparsePauliOp(\n", - " [\"II\", \"IZ\", \"ZI\", \"ZZ\", \"XX\"],\n", - " coeffs=[\n", - " -1.052373245772859,\n", - " 0.39793742484318045,\n", - " -0.39793742484318045,\n", - " -0.01128010425623538,\n", - " 0.18093119978423156,\n", - " ],\n", + "print(\"Quantum Task Summary\")\n", + "print(t.quantum_tasks_statistics())\n", + "print(\n", + " \"Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing \"\n", + " \"unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated \"\n", + " \"charges do not factor in any discounts or credits, and you may experience additional charges \"\n", + " \"based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\"\n", ")\n", - "\n", - "estimator = BackendEstimator(local_simulator, skip_transpilation=False)\n", - "ansatz = TwoLocal(rotation_blocks=\"ry\", entanglement_blocks=\"cz\")\n", - "slsqp = SLSQP(maxiter=1)\n", - "\n", - "vqe = VQE(estimator=estimator, ansatz=ansatz, optimizer=slsqp)\n", - "\n", - "result = vqe.compute_minimum_eigenvalue(H2_op)\n", - "print(result)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "86c36457", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "### Running Hybrid Jobs\n", - "\n", - "Amazon Braket Hybrid Jobs enables you to easily run hybrid quantum-classical algorithms, such as the Variational Quantum Eigensolver (VQE) and the Quantum Approximate Optimization Algorithm (QAOA), that combine classical compute resources with quantum computing devices to optimize the performance of today’s quantum systems. \n", - "\n", - "In order to run Hybrid Job we need to acomplish couple of step:\n", - "\n", - "1. Prepare script" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "5968d451", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\"\"\"Example of Hybrid Job payload with VQE.\"\"\"\n", - "from braket.jobs import save_job_result\n", - "from qiskit.quantum_info import SparsePauliOp\n", - "from qiskit.algorithms.minimum_eigensolvers import VQE\n", - "from qiskit.algorithms.optimizers import SLSQP\n", - "from qiskit.circuit.library import TwoLocal\n", - "from qiskit.primitives import BackendEstimator\n", - "\n", - "from qiskit_braket_provider import AWSBraketProvider\n", - "\n", - "\n", - "def main():\n", - " backend = AWSBraketProvider().get_backend(\"SV1\")\n", - "\n", - " h2_op = SparsePauliOp(\n", - " [\"II\", \"IZ\", \"ZI\", \"ZZ\", \"XX\"],\n", - " coeffs=[\n", - " -1.052373245772859,\n", - " 0.39793742484318045,\n", - " -0.39793742484318045,\n", - " -0.01128010425623538,\n", - " 0.18093119978423156,\n", - " ],\n", - " )\n", - "\n", - " estimator = BackendEstimator(\n", - " backend=backend,\n", - " options={\"seed_simulator\": 42, \"seed_transpiler\": 42, \"shots\": 10},\n", - " skip_transpilation=False,\n", - " )\n", - " ansatz = TwoLocal(rotation_blocks=\"ry\", entanglement_blocks=\"cz\")\n", - " slsqp = SLSQP(maxiter=1)\n", - "\n", - " vqe = VQE(estimator=estimator, ansatz=ansatz, optimizer=slsqp)\n", - "\n", - " vqe_result = vqe.compute_minimum_eigenvalue(h2_op)\n", - "\n", - " save_job_result(\n", - " {\n", - " \"VQE\": {\n", - " \"eigenvalue\": vqe_result.eigenvalue.real,\n", - " \"optimal_parameters\": list(vqe_result.optimal_parameters.values()),\n", - " \"optimal_point\": vqe_result.optimal_point.tolist(),\n", - " \"optimal_value\": vqe_result.optimal_value.real,\n", - " }\n", - " }\n", - " )\n" - ] - } - ], - "source": [ - "! cat ./data/2_hybrid_jobs/job_script.py" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "9b1aa5f7", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "2. Prepare image" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "646bfb43", - "metadata": { - "slideshow": { - "slide_type": "-" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "FROM 292282985366.dkr.ecr.us-west-2.amazonaws.com/amazon-braket-base-jobs:1.0-cpu-py37-ubuntu18.04\n", - "\n", - "RUN python3 -m pip install --upgrade pip\n", - "\n", - "RUN python3 -m pip install --no-cache --upgrade git+https://github.com/qiskit-community/qiskit-braket-provider\n" - ] - } - ], - "source": [ - "! cat ./data/2_hybrid_jobs/Dockerfile" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "1bcded1f", - "metadata": {}, - "source": [ - "3. Run Hybrid Job" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "55cd14e3", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [], - "source": [ - "image_uri = \".dkr.ecr..amazonaws.com/amazon-braket-qiskit-provider:latest\"\n", - "\n", - "job = AwsQuantumJob.create(\n", - " device=\"arn:aws:braket:::device/quantum-simulator/amazon/sv1\",\n", - " source_module=\"data/2_hybrid_jobs/job_script.py\",\n", - " entry_point=\"job_script:main\",\n", - " wait_until_complete=False,\n", - " job_name=\"qiskit-braket-vqe\",\n", - " image_uri=image_uri,\n", + "print(\n", + " f\"Estimated cost to run this example: {t.qpu_tasks_cost() + t.simulator_tasks_cost():.3f} USD\"\n", ")" ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "1ec1b936", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{}" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# print(job.result())\n", - "AwsQuantumJob(\"\").result()" - ] } ], "metadata": { @@ -948,7 +612,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.9.18" } }, "nbformat": 4, diff --git a/docs/tutorials/1_tutorial_vqe.ipynb b/docs/tutorials/1_tutorial_vqe.ipynb index f9e5af4b..dc429dbf 100644 --- a/docs/tutorials/1_tutorial_vqe.ipynb +++ b/docs/tutorials/1_tutorial_vqe.ipynb @@ -5,22 +5,39 @@ "id": "7f19aecc", "metadata": {}, "source": [ - "# Tutorial: Runing VQE on Braket backend" + "# Running VQE on an Amazon Braket backend" + ] + }, + { + "cell_type": "markdown", + "id": "55c313b7", + "metadata": {}, + "source": [ + "Let's review an example of running algorithms using Qiskit on Braket devices.\n", + "\n", + "Qiskit provides a number of Algorithms and they are grouped by category according to the task they can perform. For instance Minimum Eigensolvers to find the smallest eigen value of an operator, for example ground state energy of a chemistry Hamiltonian or a solution to an optimization problem when expressed as an Ising Hamiltonian.\n", + "\n", + "Algorithms are configurable and often part of the configuration will be in the form of smaller building blocks, of which different instances of the building block type can be given. For instance with `VQE`, the Variational Quantum Eigensolver, it takes a trial wavefunction, in the form of a `QuantumCircuit` and a classical optimizer among other things.\n", + "\n", + "Let’s take a look at an example to construct a VQE instance. Here `TwoLocal` is the variational form (trial wavefunction), a parameterized circuit which can be varied, and SLSQP a classical optimizer. Then we pass the Hamiltonian to `compute_minimum_eigenvalue` method of `VQE` to get result.\n", + "\n", + "Full example and explanation of algorithm detail you can find [here](https://qiskit-community.github.io/qiskit-algorithms/tutorials/01_algorithms_introduction.html).\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "ebac1b5c", "metadata": {}, "outputs": [], "source": [ - "from qiskit.algorithms.minimum_eigensolvers import VQE\n", - "from qiskit.quantum_info import SparsePauliOp\n", - "from qiskit.algorithms.optimizers import SLSQP\n", "from qiskit.circuit.library import TwoLocal\n", - "from qiskit.utils import algorithm_globals\n", "from qiskit.primitives import BackendEstimator\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit_algorithms.minimum_eigensolvers import VQE\n", + "from qiskit_algorithms.optimizers import SLSQP\n", + "from qiskit_algorithms.utils import algorithm_globals\n", "\n", "from qiskit_braket_provider import AWSBraketProvider, BraketLocalBackend\n", "\n", @@ -38,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "e94c63b1", "metadata": {}, "outputs": [ @@ -48,7 +65,7 @@ "BraketBackend[default]" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -59,34 +76,12 @@ "local_simulator" ] }, - { - "cell_type": "code", - "execution_count": 4, - "id": "b618fa9e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "BraketBackend[SV1]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "state_vector_simulator_backend = provider.get_backend(\"SV1\")\n", - "state_vector_simulator_backend" - ] - }, { "cell_type": "markdown", "id": "140737fe", "metadata": {}, "source": [ - "Running VQE\n", + "## Running VQE\n", "\n", "\n", "\n", @@ -95,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "9081f3b3", "metadata": {}, "outputs": [ @@ -105,22 +100,22 @@ "text": [ "{ 'aux_operators_evaluated': None,\n", " 'cost_function_evals': 9,\n", - " 'eigenvalue': -1.0778032163726936,\n", - " 'optimal_circuit': ,\n", - " 'optimal_parameters': { ParameterVectorElement(θ[0]): 3.611860069224077,\n", - " ParameterVectorElement(θ[1]): 4.19301252102391,\n", + " 'eigenvalue': -1.0522310440132328,\n", + " 'optimal_circuit': ,\n", + " 'optimal_parameters': { ParameterVectorElement(θ[1]): 4.19301252102391,\n", + " ParameterVectorElement(θ[0]): 3.611860069224077,\n", " ParameterVectorElement(θ[2]): 0.6019852007557844,\n", + " ParameterVectorElement(θ[6]): -5.466043598406607,\n", + " ParameterVectorElement(θ[7]): 0.6984088030463615,\n", " ParameterVectorElement(θ[3]): 5.949536809130025,\n", " ParameterVectorElement(θ[4]): -3.3070470445355764,\n", - " ParameterVectorElement(θ[5]): 1.8462931831829383,\n", - " ParameterVectorElement(θ[6]): -5.466043598406607,\n", - " ParameterVectorElement(θ[7]): 0.6984088030463615},\n", + " ParameterVectorElement(θ[5]): 1.8462931831829383},\n", " 'optimal_point': array([ 3.61186007, 4.19301252, 0.6019852 , 5.94953681, -3.30704704,\n", " 1.84629318, -5.4660436 , 0.6984088 ]),\n", - " 'optimal_value': -1.0778032163726936,\n", + " 'optimal_value': -1.0522310440132328,\n", " 'optimizer_evals': None,\n", - " 'optimizer_result': ,\n", - " 'optimizer_time': 4.060570001602173}\n" + " 'optimizer_result': ,\n", + " 'optimizer_time': 0.6713869571685791}\n" ] } ], @@ -167,7 +162,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.9.18" } }, "nbformat": 4, diff --git a/docs/tutorials/2_tutorial_hybrid_jobs.ipynb b/docs/tutorials/2_tutorial_hybrid_jobs.ipynb index 65a78c0f..9eb48d4f 100644 --- a/docs/tutorials/2_tutorial_hybrid_jobs.ipynb +++ b/docs/tutorials/2_tutorial_hybrid_jobs.ipynb @@ -5,15 +5,7 @@ "id": "adc318c6", "metadata": {}, "source": [ - "# Tutorial: Variational algorithms on Hybrid jobs" - ] - }, - { - "cell_type": "markdown", - "id": "8e36b315", - "metadata": {}, - "source": [ - "## Hybrid Jobs" + "# Running variational quantum algorithms with Amazon Braket Hybrid Jobs" ] }, { @@ -26,20 +18,12 @@ "Read more at https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs.html" ] }, - { - "cell_type": "markdown", - "id": "5f46c9fe", - "metadata": {}, - "source": [ - "## Prepare Files" - ] - }, { "cell_type": "markdown", "id": "3f2c43fc", "metadata": {}, "source": [ - "### Prepare Hybrid Job Script" + "## Prepare Hybrid Job script" ] }, { @@ -47,77 +31,75 @@ "id": "18a4937a", "metadata": {}, "source": [ - "The job script defines the specific quantum logic to be executed on the quantum processor and the classical processing that the output is saved to, in this case, setting up the device backend and saving the job results to the EC2 instance. To learn more about what the VQE is, see this example: https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_[…]lgorithms/VQE_Transverse_Ising/VQE_Transverse_Ising_Model.ipynb\n" + "The job script defines the specific quantum logic to be executed on the quantum processor and the classical processing that the output is saved to, in this case, setting up the device backend and saving the job results. To learn more about what the VQE is, see this example: https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_[…]lgorithms/VQE_Transverse_Ising/VQE_Transverse_Ising_Model.ipynb\n" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "b9184273", + "execution_count": 1, + "id": "fc89e59b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\"\"\"Example of Hybrid Job payload with VQE.\"\"\"\r\n", - "from braket.jobs import save_job_result\r\n", - "from qiskit.quantum_info import SparsePauliOp\r\n", - "from qiskit.algorithms.minimum_eigensolvers import VQE\r\n", - "from qiskit.algorithms.optimizers import SLSQP\r\n", - "from qiskit.circuit.library import TwoLocal\r\n", - "from qiskit.primitives import BackendEstimator\r\n", - "\r\n", - "from qiskit_braket_provider import AWSBraketProvider\r\n", - "\r\n", - "\r\n", - "def main():\r\n", - " # Sets up the \"SV1\" backend the quantum device, a default simulator provided by Amazon Braket.\r\n", - " backend = AWSBraketProvider().get_backend(\"SV1\")\r\n", - "\r\n", - " h2_op = SparsePauliOp(\r\n", - " [\"II\", \"IZ\", \"ZI\", \"ZZ\", \"XX\"],\r\n", - " coeffs=[\r\n", - " -1.052373245772859,\r\n", - " 0.39793742484318045,\r\n", - " -0.39793742484318045,\r\n", - " -0.01128010425623538,\r\n", - " 0.18093119978423156,\r\n", - " ],\r\n", - " )\r\n", - "\r\n", - " estimator = BackendEstimator(backend=backend, options={\"shots\": 10})\r\n", - " ansatz = TwoLocal(rotation_blocks=\"ry\", entanglement_blocks=\"cz\")\r\n", - " slsqp = SLSQP(maxiter=1)\r\n", - "\r\n", - " vqe = VQE(estimator=estimator, ansatz=ansatz, optimizer=slsqp)\r\n", - "\r\n", - " vqe_result = vqe.compute_minimum_eigenvalue(h2_op)\r\n", - "\r\n", - " # Save the results of the VQE computation to the EC2 instance.\r\n", - " save_job_result(\r\n", - " {\r\n", - " \"VQE\": {\r\n", - " \"eigenvalue\": vqe_result.eigenvalue.real,\r\n", - " \"optimal_parameters\": list(vqe_result.optimal_parameters.values()),\r\n", - " \"optimal_point\": vqe_result.optimal_point.tolist(),\r\n", - " \"optimal_value\": vqe_result.optimal_value.real,\r\n", - " }\r\n", - " }\r\n", - " )\r\n" - ] - } - ], + "outputs": [], "source": [ - "! cat ./data/2_hybrid_jobs/job_script.py" + "from pprint import pprint\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from braket.aws import AwsDevice\n", + "from braket.devices import Devices\n", + "from braket.jobs import hybrid_job, save_job_result\n", + "from qiskit.circuit.library import TwoLocal\n", + "from qiskit.primitives import BackendEstimator\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit_algorithms.minimum_eigensolvers import VQE\n", + "from qiskit_algorithms.optimizers import SLSQP\n", + "\n", + "from qiskit_braket_provider import AWSBraketProvider\n", + "\n", + "sv1 = AwsDevice(Devices.Amazon.SV1)" ] }, { - "cell_type": "markdown", - "id": "f840ef07", + "cell_type": "code", + "execution_count": 2, + "id": "b9184273", "metadata": {}, + "outputs": [], "source": [ - "In summary, this script sets up the hybrid job script that executes a VQE computation using a the Amazon Braket SV1 default simulator as the quantum backend and then saves the results of the computation to the EC2 instance the hybrid job is running on." + "@hybrid_job(device=sv1.arn, include_modules=\"qiskit_algorithms\")\n", + "def main():\n", + " \"\"\"Decorated function that will be run in the docker container.\"\"\"\n", + " backend = AWSBraketProvider().get_backend(\"SV1\")\n", + "\n", + " h2_op = SparsePauliOp(\n", + " [\"II\", \"IZ\", \"ZI\", \"ZZ\", \"XX\"],\n", + " coeffs=[\n", + " -1.052373245772859,\n", + " 0.39793742484318045,\n", + " -0.39793742484318045,\n", + " -0.01128010425623538,\n", + " 0.18093119978423156,\n", + " ],\n", + " )\n", + "\n", + " estimator = BackendEstimator(backend=backend, options={\"shots\": 10})\n", + " ansatz = TwoLocal(rotation_blocks=\"ry\", entanglement_blocks=\"cz\")\n", + " slsqp = SLSQP(maxiter=1)\n", + "\n", + " vqe = VQE(estimator=estimator, ansatz=ansatz, optimizer=slsqp)\n", + "\n", + " vqe_result = vqe.compute_minimum_eigenvalue(h2_op)\n", + "\n", + " # Save the results of the VQE computation.\n", + " save_job_result(\n", + " {\n", + " \"VQE\": {\n", + " \"eigenvalue\": vqe_result.eigenvalue.real,\n", + " \"optimal_parameters\": list(vqe_result.optimal_parameters.values()),\n", + " \"optimal_point\": vqe_result.optimal_point.tolist(),\n", + " \"optimal_value\": vqe_result.optimal_value.real,\n", + " }\n", + " }\n", + " )" ] }, { @@ -126,35 +108,22 @@ "metadata": {}, "source": [ "## Running your job\n", - "Amazon Braket provides a container for Hybrid Jobs that has the Qiskit-Braket provider and associated dependencies installed. To use the base container, call `retrieve_image(Framework.BASE, AwsSession().region)` as demonstrated below:" + "Amazon Braket provides a container for Hybrid Jobs with the Qiskit-Braket provider preinstalled. We can start your hybrid job by executing the decorated function `main`." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "5e644a0f", "metadata": {}, "outputs": [], "source": [ - "import time\n", - "from pprint import pprint\n", - "from braket.aws import AwsQuantumJob, AwsSession\n", - "from braket.jobs.image_uris import Framework, retrieve_image\n", - "import matplotlib.pyplot as plt\n", - "\n", - "job = AwsQuantumJob.create(\n", - " device=\"arn:aws:braket:::device/quantum-simulator/amazon/sv1\",\n", - " source_module=\"data/2_hybrid_jobs/job_script.py\",\n", - " entry_point=\"job_script:main\",\n", - " wait_until_complete=False,\n", - " job_name=\"qiskit-braket-vqe-\" + str(int(time.time())),\n", - " image_uri=retrieve_image(Framework.BASE, AwsSession().region),\n", - ")" + "job = main()" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "23e007d1", "metadata": {}, "outputs": [ @@ -162,24 +131,24 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'VQE': {'eigenvalue': -0.49570779349360855,\n", - " 'optimal_parameters': [0.2196102979045742,\n", - " -3.634974011510415,\n", - " -3.8951343453580307,\n", - " 4.911202213644824,\n", - " 2.372597182173905,\n", - " -1.903856255621255,\n", - " -0.7605074501419118,\n", - " -4.839353619669662],\n", - " 'optimal_point': [0.2196102979045742,\n", - " -3.634974011510415,\n", - " -3.8951343453580307,\n", - " 4.911202213644824,\n", - " 2.372597182173905,\n", - " -1.903856255621255,\n", - " -0.7605074501419118,\n", - " -4.839353619669662],\n", - " 'optimal_value': -0.49570779349360855}}\n" + "{'VQE': {'eigenvalue': -0.644964795023488,\n", + " 'optimal_parameters': [4.1404100559572345,\n", + " 2.429160127975507,\n", + " -2.2387955544001814,\n", + " -3.3773914956176405,\n", + " -2.0835781442626446,\n", + " -0.684829663754746,\n", + " 1.513976624453238,\n", + " -3.7320799934099953],\n", + " 'optimal_point': [4.1404100559572345,\n", + " 2.429160127975507,\n", + " -2.2387955544001814,\n", + " -3.3773914956176405,\n", + " -2.0835781442626446,\n", + " -0.684829663754746,\n", + " 1.513976624453238,\n", + " -3.7320799934099953],\n", + " 'optimal_value': -0.644964795023488}}\n" ] } ], @@ -190,13 +159,13 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 5, "id": "3692cb45", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -251,7 +220,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/docs/tutorials/3_tutorial_minimum_eigen_optimizer.ipynb b/docs/tutorials/3_tutorial_minimum_eigen_optimizer.ipynb index cb8f2136..3f7532e6 100644 --- a/docs/tutorials/3_tutorial_minimum_eigen_optimizer.ipynb +++ b/docs/tutorials/3_tutorial_minimum_eigen_optimizer.ipynb @@ -3,86 +3,125 @@ { "attachments": {}, "cell_type": "markdown", - "id": "d58530d2", "metadata": {}, "source": [ - "# Tutorial: Minimum Eigen Optimizer\n", - "\n", - "For original tutorial refer to https://qiskit-community.github.io/qiskit-optimization/tutorials/03_minimum_eigen_optimizer.html#" + "# Minimum Eigen Optimizer\n" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "704bfb64", + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "! pip install qiskit_optimization" + "## About this notebook and the adaptation to Amazon Braket backend\n", + "The original version of this notebook is accessible at [docs/tutorials/03_minimum_eigen_optimizer.ipynb](https://github.com/qiskit-community/qiskit-optimization/blob/stable/0.6/docs/tutorials/03_minimum_eigen_optimizer.ipynb). The only changes made to the original notebook are contained in the first cell and in cell #6 where we pass the `BackendSampler` object to execute the tasks on Amazon Braket SV1 simulator." ] }, { "cell_type": "code", - "execution_count": 23, - "id": "2c692b55", + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "from typing import List, Tuple\n", + "from qiskit.primitives import BackendSampler\n", + "from qiskit_braket_provider import AWSBraketProvider\n", + "\n", + "sampler = BackendSampler(\n", + " backend=AWSBraketProvider().get_backend(\"SV1\"),\n", + " options={\"shots\": 1000},\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An interesting class of optimization problems to be addressed by quantum computing are Quadratic Unconstrained Binary Optimization (QUBO) problems.\n", + "Finding the solution to a QUBO is equivalent to finding the ground state of a corresponding Ising Hamiltonian, which is an important problem not only in optimization, but also in quantum chemistry and physics. For this translation, the binary variables taking values in $\\{0, 1\\}$ are replaced by spin variables taking values in $\\{-1, +1\\}$, which allows one to replace the resulting spin variables by Pauli Z matrices, and thus, an Ising Hamiltonian. For more details on this mapping we refer to [1].\n", "\n", - "import numpy as np\n", + "Qiskit optimization provides automatic conversion from a suitable `QuadraticProgram` to an Ising Hamiltonian, which then allows leveraging all the `SamplingMinimumEigensolver` implementations, such as\n", "\n", - "from qiskit.utils import algorithm_globals\n", - "from qiskit.primitives import BackendSampler\n", - "from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver\n", - "from qiskit.algorithms.optimizers import COBYLA\n", - "from qiskit.visualization import plot_histogram\n", - "from qiskit_optimization.algorithms import (\n", - " MinimumEigenOptimizer,\n", - " RecursiveMinimumEigenOptimizer,\n", - " SolutionSample,\n", - " OptimizationResultStatus,\n", - ")\n", - "from qiskit_optimization import QuadraticProgram\n", + "- `SamplingVQE`,\n", + "- `QAOA`, or\n", + "- `NumpyMinimumEigensolver` (classical exact method).\n", "\n", - "from qiskit_braket_provider import AWSBraketProvider" + "Note 1: `MinimumEigenOptimizer` does not support `qiskit_algorithms.VQE`. But `qiskit_algorithms.SamplingVQE`\n", + "can be used instead.\n", + "\n", + "Note 2: `MinimumEigenOptimizer` can use `NumpyMinimumEigensolver` as an exception case though it inherits `MinimumEigensolver` (not `SamplingMinimumEigensolver`).\n", + "\n", + "Qiskit optimization provides a the `MinimumEigenOptimizer` class, which wraps the translation to an Ising Hamiltonian (in Qiskit Terra also called `SparsePauliOp`), the call to a `MinimumEigensolver`, and the translation of the results back to an `OptimizationResult`.\n", + "\n", + "In the following we first illustrate the conversion from a `QuadraticProgram` to a `SparsePauliOp` and then show how to use the `MinimumEigenOptimizer` with different `MinimumEigensolver`s to solve a given `QuadraticProgram`.\n", + "The algorithms in Qiskit optimization automatically try to convert a given problem to the supported problem class if possible, for instance, the `MinimumEigenOptimizer` will automatically translate integer variables to binary variables or add linear equality constraints as a quadratic penalty term to the objective. It should be mentioned that a `QiskitOptimizationError` will be thrown if conversion of a quadratic program with integer variables is attempted.\n", + "\n", + "The circuit depth of `QAOA` potentially has to be increased with the problem size, which might be prohibitive for near-term quantum devices.\n", + "A possible workaround is Recursive QAOA, as introduced in [2].\n", + "Qiskit optimization generalizes this concept to the `RecursiveMinimumEigenOptimizer`, which is introduced at the end of this tutorial.\n", + "\n", + "### References\n", + "[1] [A. Lucas, *Ising formulations of many NP problems,* Front. Phys., 12 (2014).](https://arxiv.org/abs/1302.5843)\n", + "\n", + "[2] [S. Bravyi, A. Kliesch, R. Koenig, E. Tang, *Obstacles to State Preparation and Variational Optimization from Symmetry Protection,* arXiv preprint arXiv:1910.08980 (2019).](https://arxiv.org/abs/1910.08980)" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "bd534390", "metadata": {}, "source": [ - "### Converting a QUBO to an Operator" + "## Converting a QUBO to a SparsePauliOp" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "f55baa58", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_algorithms.utils import algorithm_globals\n", + "from qiskit_algorithms import QAOA, NumPyMinimumEigensolver\n", + "from qiskit_algorithms.optimizers import COBYLA\n", + "from qiskit.primitives import Sampler\n", + "from qiskit_optimization.algorithms import (\n", + " MinimumEigenOptimizer,\n", + " RecursiveMinimumEigenOptimizer,\n", + " SolutionSample,\n", + " OptimizationResultStatus,\n", + ")\n", + "from qiskit_optimization import QuadraticProgram\n", + "from qiskit.visualization import plot_histogram\n", + "from typing import List, Tuple\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\\ This file has been generated by DOcplex\n", - "\\ ENCODING=ISO-8859-1\n", - "\\Problem name: CPLEX\n", + "Problem name: \n", "\n", "Minimize\n", - " obj: x - 2 y + 3 z + [ 2 x*y - 2 x*z + 4 y*z ]/2\n", - "Subject To\n", + " x*y - x*z + 2*y*z + x - 2*y + 3*z\n", "\n", - "Bounds\n", - " 0 <= x <= 1\n", - " 0 <= y <= 1\n", - " 0 <= z <= 1\n", + "Subject to\n", + " No constraints\n", "\n", - "Binaries\n", - " x y z\n", - "End\n", + " Binary variables (3)\n", + " x y z\n", "\n" ] } @@ -96,13 +135,20 @@ "qubo.minimize(\n", " linear=[1, -2, 3], quadratic={(\"x\", \"y\"): 1, (\"x\", \"z\"): -1, (\"y\", \"z\"): 2}\n", ")\n", - "print(qubo.export_as_lp_string())" + "print(qubo.prettyprint())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we translate this QUBO into an Ising operator. This results not only in a `SparsePauliOp` but also in a constant offset to be taken into account to shift the resulting value." ] }, { "cell_type": "code", - "execution_count": 9, - "id": "eae79719", + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -111,48 +157,45 @@ "text": [ "offset: 1.5\n", "operator:\n", - "-0.5 * IIZ\n", - "+ 0.25 * IZI\n", - "- 1.75 * ZII\n", - "+ 0.25 * IZZ\n", - "- 0.25 * ZIZ\n", - "+ 0.5 * ZZI\n" + "SparsePauliOp(['IIZ', 'IZI', 'ZII', 'IZZ', 'ZIZ', 'ZZI'],\n", + " coeffs=[-0.5 +0.j, 0.25+0.j, -1.75+0.j, 0.25+0.j, -0.25+0.j, 0.5 +0.j])\n" ] } ], "source": [ "op, offset = qubo.to_ising()\n", - "print(f\"offset: {offset}\")\n", + "print(\"offset: {}\".format(offset))\n", "print(\"operator:\")\n", "print(op)" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sometimes a `QuadraticProgram` might also directly be given in the form of a `SparsePauliOp`. For such cases, Qiskit optimization also provides a translator from a `SparsePauliOp` back to a `QuadraticProgram`, which we illustrate in the following." + ] + }, { "cell_type": "code", - "execution_count": 10, - "id": "ec6b4990", + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\\ This file has been generated by DOcplex\n", - "\\ ENCODING=ISO-8859-1\n", - "\\Problem name: CPLEX\n", + "Problem name: \n", "\n", "Minimize\n", - " obj: x0 - 2 x1 + 3 x2 + [ 2 x0*x1 - 2 x0*x2 + 4 x1*x2 ]/2\n", - "Subject To\n", + " x0*x1 - x0*x2 + 2*x1*x2 + x0 - 2*x1 + 3*x2\n", "\n", - "Bounds\n", - " 0 <= x0 <= 1\n", - " 0 <= x1 <= 1\n", - " 0 <= x2 <= 1\n", + "Subject to\n", + " No constraints\n", "\n", - "Binaries\n", - " x0 x1 x2\n", - "End\n", + " Binary variables (3)\n", + " x0 x1 x2\n", "\n" ] } @@ -160,43 +203,54 @@ "source": [ "qp = QuadraticProgram()\n", "qp.from_ising(op, offset, linear=True)\n", - "print(qp.export_as_lp_string())" + "print(qp.prettyprint())" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "dd5b2f10", "metadata": {}, "source": [ - "### Solving a QUBO with the MinimumEigenOptimizer\n" + "This translator allows, for instance, one to translate a `SparsePauliOp` to a `QuadraticProgram` and then solve the problem with other algorithms that are not based on the Ising Hamiltonian representation, such as the `GroverOptimizer`." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solving a QUBO with the MinimumEigenOptimizer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by initializing the `MinimumEigensolver` we want to use." ] }, { "cell_type": "code", - "execution_count": 24, - "id": "e17f6bc4", + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "algorithm_globals.random_seed = 10598\n", - "\n", - "sampler = BackendSampler(\n", - " backend=AWSBraketProvider().backends(local=True)[0],\n", - " options={\n", - " \"seed_simulator\": algorithm_globals.random_seed,\n", - " \"seed_transpiler\": algorithm_globals.random_seed,\n", - " },\n", - " skip_transpilation=False,\n", - ")\n", "qaoa_mes = QAOA(sampler=sampler, optimizer=COBYLA(), initial_point=[0.0, 0.0])\n", "exact_mes = NumPyMinimumEigensolver()" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we use the `MinimumEigensolver` to create `MinimumEigenOptimizer`." + ] + }, { "cell_type": "code", - "execution_count": 25, - "id": "9e3248ad", + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -206,57 +260,76 @@ ") # using the exact classical numpy minimum eigen solver" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first use the `MinimumEigenOptimizer` based on the classical exact `NumPyMinimumEigensolver` to get the optimal benchmark solution for this small example." + ] + }, { "cell_type": "code", - "execution_count": 26, - "id": "81d2e400", + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "fval=-2.0, x=0.0, y=1.0, z=0.0, status=SUCCESS\n" + "objective function value: -2.0\n", + "variable values: x=0.0, y=1.0, z=0.0\n", + "status: SUCCESS\n" ] } ], "source": [ "exact_result = exact.solve(qubo)\n", - "print(exact_result)" + "print(exact_result.prettyprint())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we apply the `MinimumEigenOptimizer` based on `QAOA` to the same problem." ] }, { "cell_type": "code", - "execution_count": 27, - "id": "59e7a201", + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "fval=-2.0, x=0.0, y=1.0, z=0.0, status=SUCCESS\n" + "objective function value: -2.0\n", + "variable values: x=0.0, y=1.0, z=0.0\n", + "status: SUCCESS\n" ] } ], "source": [ "qaoa_result = qaoa.solve(qubo)\n", - "print(qaoa_result)" + "print(qaoa_result.prettyprint())" ] }, { "attachments": {}, "cell_type": "markdown", - "id": "c345243c", "metadata": {}, "source": [ - "### Analysis of Samples" + "### Analysis of Samples\n", + "`OptimizationResult` provides useful information in the form of `SolutionSample`s (here denoted as *samples*). Each `SolutionSample` contains\n", + "information about the input values (`x`), the corresponding objective function value (`fval`), the fraction of samples corresponding to that input (`probability`),\n", + "and the solution `status` (`SUCCESS`, `FAILURE`, `INFEASIBLE`). Multiple samples corresponding to the same input are consolidated into a single `SolutionSample` (with its `probability` attribute being the aggregate fraction of samples represented by that `SolutionSample`)." ] }, { "cell_type": "code", - "execution_count": 28, - "id": "c54be53e", + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -264,27 +337,34 @@ "output_type": "stream", "text": [ "variable order: ['x', 'y', 'z']\n", - "SolutionSample(x=array([0., 1., 0.]), fval=-2.0, probability=0.4013671875, status=)\n", - "SolutionSample(x=array([1., 1., 0.]), fval=0.0, probability=0.162109375, status=)\n", - "SolutionSample(x=array([0., 0., 0.]), fval=0.0, probability=0.2216796875, status=)\n", - "SolutionSample(x=array([1., 0., 0.]), fval=1.0, probability=0.1376953125, status=)\n", - "SolutionSample(x=array([0., 1., 1.]), fval=3.0, probability=0.0146484375, status=)\n", - "SolutionSample(x=array([1., 0., 1.]), fval=3.0, probability=0.0322265625, status=)\n", - "SolutionSample(x=array([0., 0., 1.]), fval=3.0, probability=0.0283203125, status=)\n", - "SolutionSample(x=array([1., 1., 1.]), fval=4.0, probability=0.001953125, status=)\n" + "SolutionSample(x=array([0., 1., 0.]), fval=-2.0, probability=0.457, status=)\n", + "SolutionSample(x=array([1., 1., 0.]), fval=0.0, probability=0.128, status=)\n", + "SolutionSample(x=array([0., 0., 0.]), fval=0.0, probability=0.172, status=)\n", + "SolutionSample(x=array([1., 0., 0.]), fval=1.0, probability=0.136, status=)\n", + "SolutionSample(x=array([0., 0., 1.]), fval=3.0, probability=0.039, status=)\n", + "SolutionSample(x=array([1., 0., 1.]), fval=3.0, probability=0.05, status=)\n", + "SolutionSample(x=array([0., 1., 1.]), fval=3.0, probability=0.013, status=)\n", + "SolutionSample(x=array([1., 1., 1.]), fval=4.0, probability=0.005, status=)\n" ] } ], "source": [ "print(\"variable order:\", [var.name for var in qaoa_result.variables])\n", - "for smpl in qaoa_result.samples:\n", - " print(smpl)" + "for s in qaoa_result.samples:\n", + " print(s)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We may also want to filter samples according to their status or probabilities." ] }, { "cell_type": "code", - "execution_count": 29, - "id": "651b9550", + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -295,32 +375,30 @@ " OptimizationResultStatus.SUCCESS,\n", " ),\n", "):\n", - " \"\"\"Returns filtered samples.\"\"\"\n", " res = []\n", - " for sample in samples:\n", - " if sample.status in allowed_status and sample.probability > threshold:\n", - " res.append(sample)\n", + " for s in samples:\n", + " if s.status in allowed_status and s.probability > threshold:\n", + " res.append(s)\n", "\n", " return res" ] }, { "cell_type": "code", - "execution_count": 30, - "id": "224a2a4a", + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "SolutionSample(x=array([0., 1., 0.]), fval=-2.0, probability=0.4013671875, status=)\n", - "SolutionSample(x=array([1., 1., 0.]), fval=0.0, probability=0.162109375, status=)\n", - "SolutionSample(x=array([0., 0., 0.]), fval=0.0, probability=0.2216796875, status=)\n", - "SolutionSample(x=array([1., 0., 0.]), fval=1.0, probability=0.1376953125, status=)\n", - "SolutionSample(x=array([0., 1., 1.]), fval=3.0, probability=0.0146484375, status=)\n", - "SolutionSample(x=array([1., 0., 1.]), fval=3.0, probability=0.0322265625, status=)\n", - "SolutionSample(x=array([0., 0., 1.]), fval=3.0, probability=0.0283203125, status=)\n" + "SolutionSample(x=array([0., 1., 0.]), fval=-2.0, probability=0.457, status=)\n", + "SolutionSample(x=array([1., 1., 0.]), fval=0.0, probability=0.128, status=)\n", + "SolutionSample(x=array([0., 0., 0.]), fval=0.0, probability=0.172, status=)\n", + "SolutionSample(x=array([1., 0., 0.]), fval=1.0, probability=0.136, status=)\n", + "SolutionSample(x=array([0., 0., 1.]), fval=3.0, probability=0.039, status=)\n", + "SolutionSample(x=array([1., 0., 1.]), fval=3.0, probability=0.05, status=)\n", + "SolutionSample(x=array([0., 1., 1.]), fval=3.0, probability=0.013, status=)\n" ] } ], @@ -334,10 +412,19 @@ " print(s)" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to obtain a better perspective of the results, statistics is very helpful, both with respect to\n", + "the objective function values and their respective probabilities. Thus, mean and standard deviation are the very\n", + "basics for understanding the results." + ] + }, { "cell_type": "code", - "execution_count": 31, - "id": "9da37a65", + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -347,8 +434,7 @@ }, { "cell_type": "code", - "execution_count": 32, - "id": "3768185e", + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -357,7 +443,7 @@ "1.5" ] }, - "execution_count": 32, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -368,8 +454,7 @@ }, { "cell_type": "code", - "execution_count": 33, - "id": "63c14a9b", + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -378,7 +463,7 @@ "1.9364916731037085" ] }, - "execution_count": 33, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -387,25 +472,32 @@ "np.std(fvals)" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, despite all the number-crunching, visualization is usually the best early-analysis approach." + ] + }, { "cell_type": "code", - "execution_count": 34, - "id": "e4c4baac", + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'x=0 y=1 z=0': 0.4013671875,\n", - " 'x=1 y=1 z=0': 0.162109375,\n", - " 'x=0 y=0 z=0': 0.2216796875,\n", - " 'x=1 y=0 z=0': 0.1376953125,\n", - " 'x=0 y=1 z=1': 0.0146484375,\n", - " 'x=1 y=0 z=1': 0.0322265625,\n", - " 'x=0 y=0 z=1': 0.0283203125}" + "{'x=0 y=1 z=0': 0.457,\n", + " 'x=1 y=1 z=0': 0.128,\n", + " 'x=0 y=0 z=0': 0.172,\n", + " 'x=1 y=0 z=0': 0.136,\n", + " 'x=0 y=0 z=1': 0.039,\n", + " 'x=1 y=0 z=1': 0.05,\n", + " 'x=0 y=1 z=1': 0.013}" ] }, - "execution_count": 34, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -413,27 +505,26 @@ "source": [ "samples_for_plot = {\n", " \" \".join(\n", - " f\"{qaoa_result.variables[i].name}={int(v)}\" for i, v in enumerate(smpl.x)\n", - " ): smpl.probability\n", - " for smpl in filtered_samples\n", + " f\"{qaoa_result.variables[i].name}={int(v)}\" for i, v in enumerate(s.x)\n", + " ): s.probability\n", + " for s in filtered_samples\n", "}\n", "samples_for_plot" ] }, { "cell_type": "code", - "execution_count": 35, - "id": "d101a797", + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 35, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -445,16 +536,33 @@ { "attachments": {}, "cell_type": "markdown", - "id": "08aa7318", "metadata": {}, "source": [ - "### RecursiveMinimumEigenOptimizer" + "## RecursiveMinimumEigenOptimizer" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `RecursiveMinimumEigenOptimizer` takes a `MinimumEigenOptimizer` as input and applies the recursive optimization scheme to reduce the size of the problem one variable at a time.\n", + "Once the size of the generated intermediate problem is below a given threshold (`min_num_vars`), the `RecursiveMinimumEigenOptimizer` uses another solver (`min_num_vars_optimizer`), e.g., an exact classical solver such as CPLEX or the `MinimumEigenOptimizer` based on the `NumPyMinimumEigensolver`.\n", + "\n", + "In the following, we show how to use the `RecursiveMinimumEigenOptimizer` using the two `MinimumEigenOptimizer`s introduced before." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we construct the `RecursiveMinimumEigenOptimizer` such that it reduces the problem size from 3 variables to 1 variable and then uses the exact solver for the last variable. Then we call `solve` to optimize the considered problem." ] }, { "cell_type": "code", - "execution_count": 36, - "id": "cca567a1", + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -465,27 +573,27 @@ }, { "cell_type": "code", - "execution_count": 37, - "id": "4eaa9994", + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "fval=-2.0, x=0.0, y=1.0, z=0.0, status=SUCCESS\n" + "objective function value: -2.0\n", + "variable values: x=0.0, y=1.0, z=0.0\n", + "status: SUCCESS\n" ] } ], "source": [ "rqaoa_result = rqaoa.solve(qubo)\n", - "print(rqaoa_result)" + "print(rqaoa_result.prettyprint())" ] }, { "cell_type": "code", - "execution_count": 38, - "id": "0772b179", + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -498,8 +606,7 @@ }, { "cell_type": "code", - "execution_count": 39, - "id": "96a34ccb", + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -508,7 +615,7 @@ "{'x=0 y=1 z=0': 1.0}" ] }, - "execution_count": 39, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -525,18 +632,17 @@ }, { "cell_type": "code", - "execution_count": 40, - "id": "d3a65a6b", + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 40, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -544,11 +650,48 @@ "source": [ "plot_histogram(samples_for_plot)" ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Version Information

SoftwareVersion
qiskit0.45.2
qiskit_ibm_provider0.8.0
qiskit_optimization0.6.0
qiskit_aer0.13.2
qiskit_algorithms0.2.2
qiskit_ionq0.4.7
qiskit_ibm_runtime0.17.0
System information
Python version3.10.13
Python compilerClang 15.0.0 (clang-1500.1.0.2.5)
Python buildmain, Aug 24 2023 12:59:26
OSDarwin
CPUs8
Memory (Gb)16.0
Tue Feb 13 17:28:51 2024 EST
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

This code is a part of Qiskit

© Copyright IBM 2017, 2024.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import qiskit.tools.jupyter\n", + "\n", + "%qiskit_version_table\n", + "%qiskit_copyright" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "cqt-rl-pulse", "language": "python", "name": "python3" }, @@ -562,9 +705,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.10.13" } }, "nbformat": 4, - "nbformat_minor": 5 + "nbformat_minor": 4 } diff --git a/docs/tutorials/data/2_hybrid_jobs/Dockerfile b/docs/tutorials/data/2_hybrid_jobs/Dockerfile deleted file mode 100644 index 60dbb8b7..00000000 --- a/docs/tutorials/data/2_hybrid_jobs/Dockerfile +++ /dev/null @@ -1,5 +0,0 @@ -FROM 292282985366.dkr.ecr.us-west-2.amazonaws.com/amazon-braket-base-jobs:1.0-cpu-py37-ubuntu18.04 - -RUN python3 -m pip install --upgrade pip - -RUN python3 -m pip install --no-cache --upgrade git+https://github.com/qiskit-community/qiskit-braket-provider diff --git a/docs/tutorials/data/2_hybrid_jobs/job_script.py b/docs/tutorials/data/2_hybrid_jobs/job_script.py deleted file mode 100644 index 7a43d32d..00000000 --- a/docs/tutorials/data/2_hybrid_jobs/job_script.py +++ /dev/null @@ -1,45 +0,0 @@ -"""Example of Hybrid Job payload with VQE.""" -from braket.jobs import save_job_result -from qiskit.algorithms.minimum_eigensolvers import VQE -from qiskit.algorithms.optimizers import SLSQP -from qiskit.circuit.library import TwoLocal -from qiskit.primitives import BackendEstimator -from qiskit.quantum_info import SparsePauliOp - -from qiskit_braket_provider import AWSBraketProvider - - -def main(): - # Sets up the "SV1" backend the quantum device, a default simulator provided by Amazon Braket. - backend = AWSBraketProvider().get_backend("SV1") - - h2_op = SparsePauliOp( - ["II", "IZ", "ZI", "ZZ", "XX"], - coeffs=[ - -1.052373245772859, - 0.39793742484318045, - -0.39793742484318045, - -0.01128010425623538, - 0.18093119978423156, - ], - ) - - estimator = BackendEstimator(backend=backend, options={"shots": 10}) - ansatz = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz") - slsqp = SLSQP(maxiter=1) - - vqe = VQE(estimator=estimator, ansatz=ansatz, optimizer=slsqp) - - vqe_result = vqe.compute_minimum_eigenvalue(h2_op) - - # Save the results of the VQE computation to the EC2 instance. - save_job_result( - { - "VQE": { - "eigenvalue": vqe_result.eigenvalue.real, - "optimal_parameters": list(vqe_result.optimal_parameters.values()), - "optimal_point": vqe_result.optimal_point.tolist(), - "optimal_value": vqe_result.optimal_value.real, - } - } - ) diff --git a/tox.ini b/tox.ini index 1e82321f..5f5690ae 100644 --- a/tox.ini +++ b/tox.ini @@ -22,7 +22,7 @@ commands = isort . -c {posargs} black --check {posargs} . pylint -rn qiskit_braket_provider tests - nbqa pylint docs/ --disable=pointless-statement,missing-module-docstring,invalid-name,expression-not-assigned,duplicate-code,import-error + nbqa pylint docs --nbqa-exclude=^docs/tutorials/3_tutorial_ --disable=pointless-statement,missing-module-docstring,invalid-name,expression-not-assigned,duplicate-code,import-error mypy --install-types --non-interactive --exclude build . [testenv:black]