ibmq_tutorial.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IBMQ Usage Tutorial\n",
    "\n",
    "A course material for **計算物理導論 Introduction to Computational Physics**\n",
    "Course No.782025001\n",
    "\n",
    "**This course material was made in 2023/04 for Qiskit Version < 1.0. There are some features has been deprecated.**\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment Setup"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For google colab setup\n",
    "\n",
    "If you are using google colab, you will need to run the following part to setup enviroment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install qiskit qiskit_aer qiskit_ibm_provider"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to create a quantum circuit\n",
    "\n",
    "### 1. Importing the necessary packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Importing the necessary packages\n",
    "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n",
    "from numpy import pi\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Create a quantum circuit like this:\n",
    "```txt\n",
    "     ┌───┐┌───┐        ┌─┐\n",
    "q_0: ┤ X ├┤ H ├──■─────┤M├\n",
    "     ├───┤└───┘┌─┴─┐┌─┐└╥┘\n",
    "q_1: ┤ X ├─────┤ X ├┤M├─╫─\n",
    "     └───┘     └───┘└╥┘ ║ \n",
    "c: 2/════════════════╩══╩═\n",
    "                     1  0 \n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ┌───┐┌───┐        ┌─┐\n",
      "q_0: ┤ X ├┤ H ├──■─────┤M├\n",
      "     ├───┤└───┘┌─┴─┐┌─┐└╥┘\n",
      "q_1: ┤ X ├─────┤ X ├┤M├─╫─\n",
      "     └───┘     └───┘└╥┘ ║ \n",
      "c: 2/════════════════╩══╩═\n",
      "                     1  0 \n"
     ]
    }
   ],
   "source": [
    "qreg_q = QuantumRegister(2, 'q')\n",
    "creg_c = ClassicalRegister(2, 'c')\n",
    "circuit = QuantumCircuit(qreg_q, creg_c)\n",
    "\n",
    "circuit.name = \"Intracell State\"\n",
    "# you can name the circuit by this.\n",
    "\n",
    "circuit.x(qreg_q[0])\n",
    "circuit.x(qreg_q[1])\n",
    "circuit.h(qreg_q[0])\n",
    "circuit.cx(qreg_q[0], qreg_q[1])\n",
    "circuit.measure(qreg_q[1], creg_c[1])\n",
    "circuit.measure(qreg_q[0], creg_c[0])\n",
    "\n",
    "print(circuit)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the quantum circuit on a simulator\n",
    "\n",
    "### 1. Prepare the backend\n",
    "\n",
    "At first we need to import the backend simulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from qiskit_aer import AerSimulator, AerProvider"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A basic backend can be created with the following command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "basicBackend = AerSimulator()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, there is more in `AerProvider` can be accessed, but we won't use them for this basic tutorial.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[AerSimulator('aer_simulator'),\n",
       " AerSimulator('aer_simulator_statevector'),\n",
       " AerSimulator('aer_simulator_statevector_gpu'),\n",
       " AerSimulator('aer_simulator_density_matrix'),\n",
       " AerSimulator('aer_simulator_density_matrix_gpu'),\n",
       " AerSimulator('aer_simulator_stabilizer'),\n",
       " AerSimulator('aer_simulator_matrix_product_state'),\n",
       " AerSimulator('aer_simulator_extended_stabilizer'),\n",
       " AerSimulator('aer_simulator_unitary'),\n",
       " AerSimulator('aer_simulator_unitary_gpu'),\n",
       " AerSimulator('aer_simulator_superop'),\n",
       " QasmSimulator('qasm_simulator'),\n",
       " StatevectorSimulator('statevector_simulator'),\n",
       " UnitarySimulator('unitary_simulator'),\n",
       " PulseSimulator('pulse_simulator')]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AerProvider().backends()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Make a job\n",
    "\n",
    "And then we can make a job with the circuit we created before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit_aer.jobs.aerjob.AerJob at 0x7f6f4fb45940>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job01 = basicBackend.run(circuit)\n",
    "job01"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After running the job, we can get the result by using `result.get_counts()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result(backend_name='aer_simulator', backend_version='0.11.2', qobj_id='0c896ab7-3f64-4256-8a87-8059c9a67729', job_id='7b2effc5-ccf4-4a78-b7e2-f0aa22c9326a', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0x2': 500, '0x1': 524}), header=QobjExperimentHeader(clbit_labels=[['c', 0], ['c', 1]], creg_sizes=[['c', 2]], global_phase=0.0, memory_slots=2, metadata={}, n_qubits=2, name='Intracell State', qreg_sizes=[['q', 2]], qubit_labels=[['q', 0], ['q', 1]]), status=DONE, seed_simulator=3396607744, metadata={'parallel_state_update': 16, 'sample_measure_time': 0.000238847, 'noise': 'ideal', 'batched_shots_optimization': False, 'measure_sampling': True, 'device': 'CPU', 'num_qubits': 2, 'parallel_shots': 1, 'remapped_qubits': False, 'method': 'stabilizer', 'active_input_qubits': [0, 1], 'num_clbits': 2, 'input_qubit_map': [[1, 1], [0, 0]], 'fusion': {'enabled': False}}, time_taken=0.001358976)], date=2023-04-26T04:18:54.786023, status=COMPLETED, header=QobjHeader(backend_name='aer_simulator', backend_version='0.11.2'), metadata={'time_taken': 0.001498151, 'time_taken_execute': 0.00137838, 'mpi_rank': 0, 'parallel_experiments': 1, 'omp_enabled': True, 'max_gpu_memory_mb': 10001, 'num_processes_per_experiments': 1, 'num_mpi_processes': 1, 'time_taken_load_qobj': 8.0343e-05, 'max_memory_mb': 128555}, time_taken=0.0016393661499023438)\n"
     ]
    }
   ],
   "source": [
    "result01 = job01.result()\n",
    "print(result01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'10': 500, '01': 524}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result01.get_counts()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And this will return a dictionary with the result of the measurement.\n",
    "\n",
    "The result show that the measurement of our bits are `10` and `01`.\n",
    "\n",
    "The probability of getting `10` is $\\sim 0.5$ and `01` is $\\sim 0.5$.\n",
    "\n",
    "It can be calculated by dividing the number of getting `10` or `01` by the total number of shots, \n",
    "\n",
    "for the default number in local simulator is $1024$."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Futher usage"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### a. We can also use `plot_histogram` to plot the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(result01.get_counts())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### b. Or change the number of shots by using `job backend.run(circuit, shots=4096)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| The counts are:  {'10': 2036, '01': 2060}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job02 = basicBackend.run(circuit, shots=4096)\n",
    "result02 = job02.result()\n",
    "# print(result01)\n",
    "print(\"| The counts are: \", result02.get_counts())\n",
    "plot_histogram(result02.get_counts())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### c. Run multiple circuits at once\n",
    "\n",
    "You can run multiple circuits at once by passing a list of circuits to `backend.run()`.\n",
    "And you can put different circuits in the list.\n",
    "\n",
    "We introduce some new circuit here for example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        ┌───┐                ░ ┌─┐         \n",
      "   q_0: ┤ H ├──■─────────────░─┤M├─────────\n",
      "        └───┘┌─┴─┐           ░ └╥┘┌─┐      \n",
      "   q_1: ─────┤ X ├──■────────░──╫─┤M├──────\n",
      "             └───┘┌─┴─┐      ░  ║ └╥┘┌─┐   \n",
      "   q_2: ──────────┤ X ├──■───░──╫──╫─┤M├───\n",
      "                  └───┘┌─┴─┐ ░  ║  ║ └╥┘┌─┐\n",
      "   q_3: ───────────────┤ X ├─░──╫──╫──╫─┤M├\n",
      "                       └───┘ ░  ║  ║  ║ └╥┘\n",
      "meas: 4/════════════════════════╩══╩══╩══╩═\n",
      "                                0  1  2  3 \n"
     ]
    }
   ],
   "source": [
    "qreg_q_cat = QuantumRegister(4, 'q')\n",
    "circuit_cat = QuantumCircuit(qreg_q_cat)\n",
    "\n",
    "circuit_cat.name = \"GHZ State\"\n",
    "\n",
    "circuit_cat.h(qreg_q_cat[0])\n",
    "circuit_cat.cx(qreg_q_cat[0], qreg_q_cat[1])\n",
    "circuit_cat.cx(qreg_q_cat[1], qreg_q_cat[2])\n",
    "circuit_cat.cx(qreg_q_cat[2], qreg_q_cat[3])\n",
    "\n",
    "circuit_cat.measure_all()\n",
    "# using the measure_all() method to measure all the qubits\n",
    "# and it will add classical registers automatically,\n",
    "# so you don't need to add classical registers manually.'\n",
    "\n",
    "print(circuit_cat)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a circuit list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Intracell State', 'GHZ State', 'GHZ State', 'GHZ State', 'Intracell State']\n"
     ]
    }
   ],
   "source": [
    "multiple_circs = [\n",
    "    circuit, circuit_cat, circuit_cat, circuit_cat, circuit\n",
    "]\n",
    "print([qc.name for qc in multiple_circs])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then run it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| The counts are: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'10': 1996, '01': 2100},\n",
       " {'1111': 2070, '0000': 2026},\n",
       " {'0000': 2041, '1111': 2055},\n",
       " {'0000': 2018, '1111': 2078},\n",
       " {'01': 2063, '10': 2033}]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job03 = basicBackend.run(multiple_circs, shots=4096)\n",
    "result03 = job03.result()\n",
    "# print(result01)\n",
    "print(\"| The counts are: \")\n",
    "result03.get_counts()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rnning the quantum circuit on IBMQ and a real quantum computer\n",
    "\n",
    "At first we need to have an account of [IBM Quantum](https://quantum-computing.ibm.com/).\n",
    "\n",
    "When you have an account of [IBM Quantum](https://quantum-computing.ibm.com/), you can get your API token in the [home page](https://quantum-computing.ibm.com/) after login.\n",
    "\n",
    "![home_page](./home_page.png)\n",
    "\n",
    "Copy the token and paste it on `IBMProvider.save_account`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_ibm_provider import IBMProvider"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IBMProvider.save_account('API_TOKEN') # paste your API_TOKEN here"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After that, you can access the backends on **IBM Quantum** to load your account.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "theIBMProvider = IBMProvider()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The followings are the backends on **IBM Quantum** you can access.\n",
    "It's including the simulator and the real quantum computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMBackend('simulator_extended_stabilizer')>,\n",
       " <IBMBackend('ibm_hanoi')>,\n",
       " <IBMBackend('ibmq_kolkata')>,\n",
       " <IBMBackend('ibm_cairo')>,\n",
       " <IBMBackend('ibm_washington')>,\n",
       " <IBMBackend('ibmq_guadalupe')>,\n",
       " <IBMBackend('simulator_stabilizer')>,\n",
       " <IBMBackend('ibm_lagos')>,\n",
       " <IBMBackend('ibmq_mumbai')>,\n",
       " <IBMBackend('ibm_auckland')>,\n",
       " <IBMBackend('ibm_perth')>,\n",
       " <IBMBackend('ibm_sherbrooke')>,\n",
       " <IBMBackend('ibmq_qasm_simulator')>,\n",
       " <IBMBackend('simulator_mps')>,\n",
       " <IBMBackend('simulator_statevector')>,\n",
       " <IBMBackend('ibmq_jakarta')>,\n",
       " <IBMBackend('ibm_geneva')>,\n",
       " <IBMBackend('ibmq_quito')>,\n",
       " <IBMBackend('ibm_nairobi')>,\n",
       " <IBMBackend('ibmq_lima')>,\n",
       " <IBMBackend('ibmq_belem')>,\n",
       " <IBMBackend('ibmq_manila')>,\n",
       " <IBMBackend('ibm_oslo')>]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theIBMProvider.backends()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `simulator=False` we can show the of only real machine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMBackend('ibm_hanoi')>,\n",
       " <IBMBackend('ibmq_kolkata')>,\n",
       " <IBMBackend('ibm_cairo')>,\n",
       " <IBMBackend('ibm_washington')>,\n",
       " <IBMBackend('ibmq_guadalupe')>,\n",
       " <IBMBackend('ibm_lagos')>,\n",
       " <IBMBackend('ibmq_mumbai')>,\n",
       " <IBMBackend('ibm_auckland')>,\n",
       " <IBMBackend('ibm_perth')>,\n",
       " <IBMBackend('ibm_sherbrooke')>,\n",
       " <IBMBackend('ibmq_jakarta')>,\n",
       " <IBMBackend('ibm_geneva')>,\n",
       " <IBMBackend('ibmq_quito')>,\n",
       " <IBMBackend('ibm_nairobi')>,\n",
       " <IBMBackend('ibmq_lima')>,\n",
       " <IBMBackend('ibmq_belem')>,\n",
       " <IBMBackend('ibmq_manila')>,\n",
       " <IBMBackend('ibm_oslo')>]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theIBMProvider.backends(simulator=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Make a job on IBMQ\n",
    "\n",
    "Pick a backend and run the job.\n",
    "We use the circuit list we created before for example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ibmq_qasm_simulator'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ibmqQASM = theIBMProvider.get_backend('ibmq_qasm_simulator')\n",
    "ibmqQASM.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| The counts are: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'10': 2013, '01': 2083},\n",
       " {'0000': 2021, '1111': 2075},\n",
       " {'1111': 2036, '0000': 2060},\n",
       " {'1111': 2026, '0000': 2070},\n",
       " {'10': 2050, '01': 2046}]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job11 = ibmqQASM.run(multiple_circs, shots=4096)\n",
    "result11 = job11.result()\n",
    "# print(result11)\n",
    "print(\"| The counts are: \")\n",
    "result11.get_counts()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Pending a job to real quantum computer\n",
    "1. We need to pick a quantum computer to run the job."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_ibm_provider import least_busy"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`least_busy` can tell us which quantum computer is the least busy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<IBMBackend('ibm_hanoi')>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theLeastBusy = least_busy(theIBMProvider.backends(simulator=False))\n",
    "theLeastBusy"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, we pick the `ibmq_quito` to run the job.\n",
    "It's a 5-qubit quantum computer.\n",
    "You can use the following method to access it as backend."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. by using `provider.get_backend('ibmq_quito')`, recommend this method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<IBMBackend('ibmq_quito')>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theRealDevice = theIBMProvider.get_backend('ibmq_quito')\n",
    "theRealDevice"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. by the attribute of `provider.backends.ibmq_quito`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<IBMBackend('ibmq_quito')>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theRealDevice = theIBMProvider.backend.ibmq_quito\n",
    "theRealDevice"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before pending, we need to transpile the circuit list to the backend we picked.\n",
    "\n",
    "Due to every quantum computer has different gate set and qubits layout, we need to transpile the circuit, then it can be runnable on the real machine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import transpile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Before: \n",
      "     ┌───┐┌───┐        ┌─┐\n",
      "q_0: ┤ X ├┤ H ├──■─────┤M├\n",
      "     ├───┤└───┘┌─┴─┐┌─┐└╥┘\n",
      "q_1: ┤ X ├─────┤ X ├┤M├─╫─\n",
      "     └───┘     └───┘└╥┘ ║ \n",
      "c: 2/════════════════╩══╩═\n",
      "                     1  0 \n",
      "------------------------------divider------------------------------\n",
      "| After: \n",
      "global phase: 7π/4\n",
      "               ┌─────────┐┌────┐┌──────────┐     ┌─┐   \n",
      "      q_0 -> 0 ┤ Rz(π/2) ├┤ √X ├┤ Rz(-π/2) ├──■──┤M├───\n",
      "               └──┬───┬──┘└────┘└──────────┘┌─┴─┐└╥┘┌─┐\n",
      "      q_1 -> 1 ───┤ X ├─────────────────────┤ X ├─╫─┤M├\n",
      "                  └───┘                     └───┘ ║ └╥┘\n",
      "ancilla_0 -> 2 ───────────────────────────────────╫──╫─\n",
      "                                                  ║  ║ \n",
      "ancilla_1 -> 3 ───────────────────────────────────╫──╫─\n",
      "                                                  ║  ║ \n",
      "ancilla_2 -> 4 ───────────────────────────────────╫──╫─\n",
      "                                                  ║  ║ \n",
      "          c: 2/═══════════════════════════════════╩══╩═\n",
      "                                                  0  1 \n"
     ]
    }
   ],
   "source": [
    "transpiled_list = transpile(multiple_circs, backend=theRealDevice)\n",
    "print(\"| Before: \")\n",
    "print(multiple_circs[0])\n",
    "print(\"-\"*30+\"divider\"+\"-\"*30)\n",
    "print(\"| After: \")\n",
    "print(transpiled_list[0])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For `ibmq_quito` is a 5-qubit quantum computer, transpiler will redistribute the qubits and add ancilla to feet the layout of `ibmq_quito`.\n",
    "\n",
    "Further explain can be found in [Qiskit Compiler and the Look-Ahead Swap Mapper](https://youtu.be/hidQGlKl_-E).\n",
    "\n",
    "Then we can pending the job to `ibmq_quito`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<JobStatus.QUEUED: 'job is queued'>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job12 = theRealDevice.run(transpiled_list, shots=4096)\n",
    "job12.status()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are successfully pending the job on `ibmq_quito`.\n",
    "\n",
    "And you can check the status of the job by using `job.status()`.\n",
    "\n",
    "Remenmber to use `job.job_id()` to get the job id for retrieving the job when it's finished."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ch43bo2ccl2b15otr7k0'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job12_id = job12.job_id()\n",
    "job12_id"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Retrieving the job"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At [Jobs](https://quantum-computing.ibm.com/jobs) page, you can see the status of the job.\n",
    "\n",
    "![./jobs.png](./jobs.png)\n",
    "\n",
    "![./job_info.png](./job_info.png)\n",
    "\n",
    "When the jobs are finished, you can retrieve the job by using `provider.retrieve_job(job_id='the job id')`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "retrieve_job12 = theIBMProvider.retrieve_job(job_id=job12_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'00': 355, '01': 1820, '10': 1833, '11': 88},\n",
       " {'0000': 1802,\n",
       "  '0001': 129,\n",
       "  '0010': 40,\n",
       "  '0011': 42,\n",
       "  '0100': 20,\n",
       "  '0101': 8,\n",
       "  '0110': 6,\n",
       "  '0111': 89,\n",
       "  '1000': 42,\n",
       "  '1001': 2,\n",
       "  '1010': 8,\n",
       "  '1011': 75,\n",
       "  '1100': 51,\n",
       "  '1101': 115,\n",
       "  '1110': 170,\n",
       "  '1111': 1497},\n",
       " {'0000': 1774,\n",
       "  '0001': 119,\n",
       "  '0010': 45,\n",
       "  '0011': 61,\n",
       "  '0100': 27,\n",
       "  '0101': 9,\n",
       "  '0110': 12,\n",
       "  '0111': 107,\n",
       "  '1000': 69,\n",
       "  '1001': 9,\n",
       "  '1010': 8,\n",
       "  '1011': 81,\n",
       "  '1100': 54,\n",
       "  '1101': 114,\n",
       "  '1110': 186,\n",
       "  '1111': 1421},\n",
       " {'0000': 1741,\n",
       "  '0001': 125,\n",
       "  '0010': 46,\n",
       "  '0011': 54,\n",
       "  '0100': 14,\n",
       "  '0101': 12,\n",
       "  '0110': 11,\n",
       "  '0111': 104,\n",
       "  '1000': 60,\n",
       "  '1001': 11,\n",
       "  '1010': 10,\n",
       "  '1011': 61,\n",
       "  '1100': 62,\n",
       "  '1101': 110,\n",
       "  '1110': 154,\n",
       "  '1111': 1521},\n",
       " {'00': 313, '01': 1825, '10': 1859, '11': 99}]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "retrieve_job12.result().get_counts()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every job which run on IBM Quantum can be retrieved by using `provider.retrieve_job()`, just need to provide the job id."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'10': 2013, '01': 2083},\n",
       " {'0000': 2021, '1111': 2075},\n",
       " {'1111': 2036, '0000': 2060},\n",
       " {'1111': 2026, '0000': 2070},\n",
       " {'10': 2050, '01': 2046}]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "retrieve_job11 = theIBMProvider.retrieve_job(job_id=job11.job_id())\n",
    "retrieve_job11.result().get_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'10': 2013, '01': 2083},\n",
       " {'0000': 2021, '1111': 2075},\n",
       " {'1111': 2036, '0000': 2060},\n",
       " {'1111': 2026, '0000': 2070},\n",
       " {'10': 2050, '01': 2046}]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result11.get_counts()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More References\n",
    "\n",
    "1. [Qiskit Documentation](https://qiskit.org/documentation/)\n",
    "2. [Qiskit Aer Documentation](https://qiskit.org/documentation/tutorials/simulators/1_aer_provider.html)\n",
    "3. [Qiskit IBM Provider Documentation - IBM Quantum Account](https://qiskit.org/ecosystem/ibm-provider/tutorials/1_the_ibm_quantum_account.html)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "quantumsphere12",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "2bdd9fc75eb04bcd8468aa71a8eaea8d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "b8c215d382134388b2c5c062975861ed": {
      "model_module": "@quantum/lab-widgets",
      "model_module_version": "4.0.17",
      "model_name": "CircuitComposerModel",
      "state": {
       "circuit": "\"OPENQASM 2.0;\\ninclude \\\"qelib1.inc\\\";\\nqreg q[2];\\ncreg c[2];\\nx q[0];\\nx q[1];\\nh q[0];\\ncx q[0],q[1];\\nmeasure q[1] -> c[1];\\nmeasure q[0] -> c[0];\\n\"",
       "editable": true,
       "layout": "IPY_MODEL_2bdd9fc75eb04bcd8468aa71a8eaea8d",
       "qiskit_code_cell_index": -1
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}