samples/getting-started/azure-quantum/qiskit/Getting-started-with-Qiskit-and-IonQ-on-Azure-Quantum.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Getting started with Qiskit and IonQ on Azure Quantum\n",
    "\n",
    "This notebook shows how to send a basic quantum circuit expressed using the [Qiskit library](https://github.com/QISKit/qiskit-terra) to an IonQ target via the Azure Quantum service."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "First, install `azure-quantum` with the `qiskit` dependencies, and `matplotlib` for plotting:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "# To install the Azure Quantum client package with support for\n",
    "# Qiskit, uncomment and run the line below:\n",
    "#\n",
    "# !pip install azure-quantum[qiskit]==0.19.2109.165653 --quiet\n",
    "#\n",
    "# We also recommend installing matplotlib, if you don't have it installed already:\n",
    "# !pip install matplotlib --quiet"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "And import the required packages for this sample:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "from qiskit import QuantumCircuit\n",
    "from qiskit.visualization import plot_histogram\n",
    "from qiskit.tools.monitor import job_monitor\n",
    "from azure.quantum.qiskit import AzureQuantumProvider"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Connecting to the Azure Quantum service\n",
    "\n",
    "To connect to the Azure Quantum service, find the resource ID and location of your Workspace from the Azure portal here: https://portal.azure.com. Navigate to your Azure Quantum workspace and copy the values from the header.\n",
    "\n",
    "<img src=\"../azure-quantum-resource-id.png\" alt=\"How to retrieve the resource ID and location from an Azure Quantum workspace\">"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Paste the values into the following `AzureQuantumProvider` constructor to create a `provider` object that connects to your Azure Quantum workspace."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "provider = AzureQuantumProvider(\n",
    "  resource_id=\"\",\n",
    "  location=\"\"\n",
    ")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Use `provider.backends` to see what targets are currently available. Running this method will trigger authentication to your Microsoft account, if you're not already logged in."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "print([backend.name() for backend in provider.backends()])"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "['ionq.qpu', 'ionq.simulator', 'quantinuum.qpu.h1-1', 'quantinuum.sim.h1-1sc', 'quantinuum.sim.h1-1e']\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Run a simple circuit\n",
    "\n",
    "Let's create a simple Qiskit circuit to run.\n",
    "\n",
    "This notebook assumes some familiarity with Qiskit. To read more about Qiskit, review the [Qiskit documentation](https://qiskit.org/documentation/intro_tutorial1.html)."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "# Create a Quantum Circuit acting on the q register\n",
    "circuit = QuantumCircuit(3, 3)\n",
    "circuit.name = \"Qiskit Sample - 3-qubit GHZ circuit\"\n",
    "circuit.h(0)\n",
    "circuit.cx(0, 1)\n",
    "circuit.cx(1, 2)\n",
    "circuit.measure([0,1,2], [0, 1, 2])\n",
    "\n",
    "# Print out the circuit\n",
    "circuit.draw()"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "     ┌───┐          ┌─┐      \n",
       "q_0: ┤ H ├──■───────┤M├──────\n",
       "     └───┘┌─┴─┐     └╥┘┌─┐   \n",
       "q_1: ─────┤ X ├──■───╫─┤M├───\n",
       "          └───┘┌─┴─┐ ║ └╥┘┌─┐\n",
       "q_2: ──────────┤ X ├─╫──╫─┤M├\n",
       "               └───┘ ║  ║ └╥┘\n",
       "c: 3/════════════════╩══╩══╩═\n",
       "                     0  1  2 "
      ],
      "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_0: ┤ H ├──■───────┤M├──────\n",
       "     └───┘┌─┴─┐     └╥┘┌─┐   \n",
       "q_1: ─────┤ X ├──■───╫─┤M├───\n",
       "          └───┘┌─┴─┐ ║ └╥┘┌─┐\n",
       "q_2: ──────────┤ X ├─╫──╫─┤M├\n",
       "               └───┘ ║  ║ └╥┘\n",
       "c: 3/════════════════╩══╩══╩═\n",
       "                     0  1  2 </pre>"
      ]
     },
     "metadata": {},
     "execution_count": 5
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "To get a result back quickly, use `provider.get_backend` to create a `Backend` object to connect to the IonQ Simulator back-end:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "simulator_backend = provider.get_backend(\"ionq.simulator\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "You can now run the program via the Azure Quantum service and get the result. The following cell will submit a job that runs the circuit with 100 shots:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "job = simulator_backend.run(circuit, shots=100)\n",
    "job_id = job.id()\n",
    "print(\"Job id\", job_id)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Job id 6255e7ce-1ca0-11ec-9d4c-00155dd132ce\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "To monitor job progress, we can use the Qiskit `job_monitor` we imported earlier to keep track of the Job's status. Note that this call will block until the job completes:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "job_monitor(job)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Job Status: job has successfully run\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "To wait until the job is completed and return the results, run:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "result = job.result()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "This returns a `qiskit.Result` object."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "type(result)"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "qiskit.result.result.Result"
      ]
     },
     "metadata": {},
     "execution_count": 10
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "print(result)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='6255e7ce-1ca0-11ec-9d4c-00155dd132ce', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 50, '111': 50}, probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(meas_map='[0, 1, 2]', name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Because this is an object native to the Qiskit package, we can use Qiskit's `result.get_counts` and `plot_histogram` to visualize the results. The results can return a sparse dictionary so to make sure all possible bitstring lables are represented we add them to `counts`."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "# The histogram returned by the results can be sparse, so here we add any of the missing bitstring labels.\n",
    "counts = {format(n, \"03b\"): 0 for n in range(8)}\n",
    "counts.update(result.get_counts(circuit))\n",
    "print(counts)\n",
    "plot_histogram(counts);"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Run on IonQ QPU\n",
    "\n",
    "To connect to real hardware (Quantum Processing Unit or QPU), simply provide the name of the target `\"ionq.qpu\"` to the `provider.get_backend` method:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "qpu_backend = provider.get_backend(\"ionq.qpu\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Submit the circuit to run on Azure Quantum. Note that depending on queue times this may take a while to run!\n",
    "\n",
    "Here we will again use the `job_monitor` to keep track of the job status, and `plot_histogram` to plot the results."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "# Submit the circuit to run on Azure Quantum\n",
    "qpu_job = qpu_backend.run(circuit, shots=1024)\n",
    "job_id = qpu_job.id()\n",
    "print(\"Job id\", job_id)\n",
    "\n",
    "# Monitor job progress and wait until complete:\n",
    "job_monitor(qpu_job)\n",
    "\n",
    "# Get the job results (this method also waits for the Job to complete):\n",
    "result = qpu_job.result()\n",
    "print(result)\n",
    "counts = {format(n, \"03b\"): 0 for n in range(8)}\n",
    "counts.update(result.get_counts(circuit))\n",
    "print(counts)\n",
    "plot_histogram(counts)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Job id 614da722-fa72-11eb-9e14-00155df1914a\n",
      "Job Status: job has successfully run\n",
      "Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='614da722-fa72-11eb-9e14-00155df1914a', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])\n",
      "{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "# Print package versions used in this notebook\n",
    "import qiskit\n",
    "print('\\n'.join(f'{m.__name__}=={m.__version__}' for m in globals().values() if getattr(m, '__version__', None)))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "qiskit==0.18.0\n"
     ]
    }
   ],
   "metadata": {
    "scrolled": true
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [],
   "outputs": [],
   "metadata": {}
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}