Part1/Task3_QrngQiskitQuantinuum.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Task 3: Run Quantum Random Number Generator on Quantinuum Emulator\n",
        "\n",
        "*In this task, you are already given all the code you’ll need! You need to set up the Azure Quantum connection information and use it to run this code on the Quantinuum emulator target.*\n",
        "\n",
        "*To submit this task, update this notebook with the saved results of code cells execution and commit it in your challenge repository.*"
      ],
      "metadata": {},
      "id": "f1017805-47c5-44d8-85d4-ce753a32dba1"
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Submit a simple job to Quantinuum using Azure Quantum\n",
        "Azure Quantum provides several ways to express quantum programs. In this example we are using [Qiskit](https://qiskit.org/), but note that Q# and Cirq are also supported. All code in this example will be written in Python.\n",
        "\n",
        "Let's begin. When you see a code block, hover over it and click the triangle play-button to execute it. To avoid any compilation issues, this should be done in order from top to bottom."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "ec77154e-03ff-474c-861a-0dda205ccdeb"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1. Connect to the Azure Quantum workspace\n",
        "\n",
        "To connect to the Azure Quantum service, construct an instance of the `AzureQuantumProvider`. Note that it's imported from `azure.quantum.qiskit`.\n",
        "\n",
        "You need to substitute `<subscriptionId>`, `<resourceGroupId>`, `<workspaceId>`, and `<location>` in the connection string below with the parameter values from your own quantum workspace.\n",
        "You can learn how to create an Azure Quantum workspace in [this Microsoft Learn module](https://docs.microsoft.com/learn/modules/get-started-azure-quantum/3-create-quantum-workspace).\n",
        "(Executing this cell will open a new tab with a login prompt; return to the notebook once you log in.)"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "4126f938-b366-45b6-ab83-b7c695b01b6d"
    },
    {
      "cell_type": "code",
      "source": [
        "from azure.quantum.qiskit import AzureQuantumProvider\n",
        "provider = AzureQuantumProvider (\n",
        "    resource_id = \"/subscriptions/b0c3bbe3-7123-4ba4-9aa2-57d9845f4a1d/resourceGroups/AzureQuantum/providers/Microsoft.Quantum/Workspaces/qchack-2022-b\",\n",
        "    location = \"eastus\"\n",
        ")"
      ],
      "outputs": [],
      "execution_count": 1,
      "metadata": {},
      "id": "b37d1d86-aa21-4498-b88d-a2d69bd797e5"
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's see what providers and targets are enabled in this workspace with the following command:"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "66b82358-b8a6-4bbd-b55b-5aeb0f832ee0"
    },
    {
      "cell_type": "code",
      "source": [
        "from qiskit import QuantumCircuit\n",
        "from qiskit.visualization import plot_histogram\n",
        "from qiskit.tools.monitor import job_monitor\n",
        "\n",
        "print(\"This workspace's targets:\")\n",
        "for backend in provider.backends():\n",
        "    print(\"- \" + backend.name())"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "This workspace's targets:\n- ionq.qpu\n- ionq.simulator\n- quantinuum.hqs-lt-s1\n- quantinuum.hqs-lt-s1-apival\n- quantinuum.hqs-lt-s2\n- quantinuum.hqs-lt-s2-apival\n- quantinuum.hqs-lt-s1-sim\n- quantinuum.hqs-lt-s2-sim\n"
        }
      ],
      "execution_count": 2,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "f3fcafea-b8d8-47db-bcaa-d8235026d429"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ❕ Do you see `quantinuum.hqs-lt-s2-apival` in your list of targets? If so, you're ready to keep going.\n",
        "\n",
        "## Quantinuum: The quantum provider\n",
        "Azure Quantum partners with third-party companies to deliver solutions to quantum jobs. These company offerings are called *providers*. Each provider can offer multiple *targets* with different capabilities. See the table below for Quantinuum's H1-2 device targets.\n",
        "\n",
        "| Target name | Target ID | Number of qubits | Description|\n",
        "| --- | ---| ---|---|\n",
        "H1-2 API Validator | `quantinuum.hqs-lt-s2-apival` | 12 | Quantinuum's H1-2 Syntax Checker. Use this to validate quantum programs before submitting to hardware or emulation on Quantinuum's platform and check a quantum circuit's cost in H-Series Quantum Credits (HQCs). Free of cost. |\n",
        "H1-2 Emulator | `quantinuum.hqs-lt-s2-sim` | 12 | Quantinuum's H1-2 emulator. Uses a realistic physical model and noise model that is consistent with the Quantinuum H1 hardware offering. |\n",
        "H1-2 | `quantinuum.hqs-lt-s2` | 12 | Quantinuum's H1-2 trapped ion device. |\n",
        "\n",
        "To start, we will use `quantinuum.hqs-lt-s2-apival` to avoid any costs or credit usage. To learn more about Quantinuum's targets, check out our [documentation](https://aka.ms/AQ/Quantinuum/Documentation)."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "ab8f0d8c-9826-4156-b282-49c10e673e79"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2. Build the quantum program\n",
        "\n",
        "Let's create a simple Qiskit circuit to run."
      ],
      "metadata": {},
      "id": "5e9a8ce5-2f89-4a9d-96f2-2b73495aa6f4"
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a quantum circuit acting on a single qubit\n",
        "circuit = QuantumCircuit(1,1)\n",
        "circuit.name = \"Single qubit random\"\n",
        "circuit.h(0)\n",
        "circuit.measure(0, 0)\n",
        "\n",
        "# Print out the circuit\n",
        "circuit.draw()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 3,
          "data": {
            "text/plain": "     ┌───┐┌─┐\n  q: ┤ H ├┤M├\n     └───┘└╥┘\nc: 1/══════╩═\n           0 ",
            "text/html": "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌───┐┌─┐\n  q: ┤ H ├┤M├\n     └───┘└╥┘\nc: 1/══════╩═\n           0 </pre>"
          },
          "metadata": {}
        }
      ],
      "execution_count": 3,
      "metadata": {},
      "id": "5cdc21b5-a92e-45cf-bacf-2bf5baf11526"
    },
    {
      "cell_type": "markdown",
      "source": [
        "The circuit you built is a simple quantum random bit generator. With Quantinuum's API validator, we will be able to confirm that the circuit is able to be run on the Quantinuum H1-2 emulator and hardware."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "cc64ce44-ae1f-4a7d-9fa9-aeaf713555ea"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3. Submit the quantum program to Quantinuum"
      ],
      "metadata": {},
      "id": "d3b7b048-0c31-433a-8244-4959e1cf60d9"
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an object that represents Quantinuum's API validator target, \"quantinuum.hqs-lt-s2-apival\".\n",
        "#   Note that any target you have enabled in this workspace can\n",
        "#   be used here. Azure Quantum makes it extremely easy to submit\n",
        "#   the same quantum program to different providers. \n",
        "quantinuum_api_val_backend = provider.get_backend(\"quantinuum.hqs-lt-s2-apival\")\n",
        "\n",
        "# Using the Quantinuum target, call \"run\" to submit the job. We'll\n",
        "# use a count of 100 (simulated runs).\n",
        "job_api_val = quantinuum_api_val_backend.run(circuit, count=100)\n",
        "print(\"Job id:\", job_api_val.id())"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Job id: a347320e-b81a-11ec-9242-00155dd52124\n"
        }
      ],
      "execution_count": 4,
      "metadata": {},
      "id": "7909acc6-219d-41e8-9b16-38f67d69a7fd"
    },
    {
      "cell_type": "markdown",
      "source": [
        "The job ID can be used to retrieve the results later using the [get_details function](https://docs.microsoft.com/en-us/azure/quantum/optimization-job-reference#jobdetails) or by viewing it under the **Job management** section of the portal."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "6d6f0a75-57f4-4175-89e2-c350f77a77d2"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4. Obtain the job results\n",
        "You can monitor the job status with Qiskit's `job_monitor` function.\n",
        "\n",
        "This may take a minute or so ⏳. Your job will be packaged and sent to Quantinuum, where it will wait its turn to be run. You'll see your job go through these stages: \"job is queued\" &rarr; \"job is actively running\" &rarr; \"job has successfully run.\""
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "d77a830f-65b7-4f41-8e2f-9baba03993de"
    },
    {
      "cell_type": "code",
      "source": [
        "job_monitor(job_api_val)\n",
        "\n",
        "result_api_val = job_api_val.result()\n",
        "\n",
        "# The result object is native to the Qiskit package, so we can use Qiskit's tools to print the result as a histogram.\n",
        "# For API validation, we expect to see all zeroes.\n",
        "plot_histogram(result_api_val.get_counts(circuit), title=\"Result\", number_to_keep=2)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "\rJob Status: job has successfully run\n"
        },
        {
          "output_type": "execute_result",
          "execution_count": 5,
          "data": {
            "text/plain": "<Figure size 504x360 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 5,
      "metadata": {},
      "id": "e8b82e7f-22b7-4664-8f5f-3e1f30fc411c"
    },
    {
      "cell_type": "markdown",
      "source": [
        "**See the histogram above? Congratulations, you've submitted a job with Azure Quantum! 👏**\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "e1af032f-6e76-420e-9684-61c7e6f960e9"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5. Estimate costs\n",
        "\n",
        "To estimate the costs of running this program on the emulator, you can use the `backend.estimate_cost` method."
      ],
      "metadata": {},
      "id": "07bb083d-c191-4b21-9e68-f1421c9490e2"
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an object that represents Quantinuum's API emulator target, \"quantinuum.hqs-lt-s2-sim\".\n",
        "quantinuum_sim_backend = provider.get_backend(\"quantinuum.hqs-lt-s2-sim\")\n",
        "cost = quantinuum_sim_backend.estimate_cost(circuit, shots=100)\n",
        "print(f\"Estimated cost: {cost.estimated_total} {cost.currency_code}\")"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Estimated cost: 5.12 EHQC\n"
        }
      ],
      "execution_count": 6,
      "metadata": {},
      "id": "d8ba9998-61a4-450f-a375-3f3d5420a462"
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6. Submit the job to the emulator\n",
        "\n",
        "Next, run the same program on Quantinuum's H1-2 emulation targets. Just replace `quantinuum.hqs-lt-s2-apival` with `quantinuum.hqs-lt-s2-sim`.\n",
        "\n",
        "To learn more about submitting Qiskit circuits to Azure Quantum, review [this documentation](https://docs.microsoft.com/azure/quantum/quickstart-microsoft-qiskit?pivots=platform-quantinuum)."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "id": "b71ac1c7-1fe9-4080-8010-9907538c8860"
    },
    {
      "cell_type": "code",
      "source": [
        "# Using the Quantinuum target target, call \"run\" to submit the job. We'll\n",
        "# use a count of 100 (simulated runs).\n",
        "job_sim = quantinuum_sim_backend.run(circuit, count=100)\n",
        "print(\"Job id:\", job_sim.id())"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Job id: d9668cea-b81a-11ec-9242-00155dd52124\n"
        }
      ],
      "execution_count": 9,
      "metadata": {},
      "id": "48312bbd-ea91-4906-b9cb-044df8b68b5d"
    },
    {
      "cell_type": "code",
      "source": [
        "job_monitor(job_sim)\n",
        "\n",
        "result_sim = job_sim.result()\n",
        "\n",
        "# The result object is native to the Qiskit package, so we can use Qiskit's tools to print the result as a histogram.\n",
        "# For running on an emulator, we expect to see random bits generated.\n",
        "plot_histogram(result_sim.get_counts(circuit), title=\"Result\")"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Job Status: job has successfully run\n"
        },
        {
          "output_type": "execute_result",
          "execution_count": 10,
          "data": {
            "text/plain": "<Figure size 504x360 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 10,
      "metadata": {},
      "id": "120270fb-59bf-4e8a-800b-383b83154a35"
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "kernelspec": {
      "name": "python3",
      "language": "python",
      "display_name": "Python 3 (ipykernel)"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.13",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}