ibmq-qsim-sup-mat.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "852ab4ac-e501-4694-bf67-90cd4122140e",
   "metadata": {},
   "source": [
    "# Open Science Prize: Supplementary Material\n",
    "\n",
    "This notebook is meant to provide a little more information about the Open Science Prize, but mostly, this notebook is a launching point from which the motivated learner can find open access sources with even more detailed information."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c764af20-017f-4209-9483-4f89f10cb562",
   "metadata": {},
   "source": [
    "## 1 The Heisenberg Spin Model\n",
    "In the open prize notebook, the Hamiltonian you are simulating is defined as the [Heisenberg XXX model](https://en.wikipedia.org/wiki/Quantum_Heisenberg_model#XXX_model) for 3 spins in a line:\n",
    "$$\n",
    "H_{\\text{Heis3}} = \\sigma_x^{(0)}\\sigma_x^{(1)} + \\sigma_x^{(1)}\\sigma_x^{(2)} + \\sigma_y^{(0)}\\sigma_y^{(1)} + \\sigma_y^{(1)}\\sigma_y^{(2)} + \\sigma_z^{(0)}\\sigma_z^{(1)} + \\sigma_z^{(1)}\\sigma_z^{(2)}.\n",
    "$$\n",
    "\n",
    "### 1-1 Why call it XXX?\n",
    "The XXX model is one of a family of spin models known as [Heisenberg spin models](https://en.wikipedia.org/wiki/Quantum_Heisenberg_model). In some sense, the most general form of Heisenberg model is often refered to as the XYZ model. The name 'XYZ' is used because the three pair-wise operators $\\sigma_x\\sigma_x$, $\\sigma_y\\sigma_y$, and $\\sigma_z \\sigma_z$ in the Hamitlonian have different coefficients $J_x$, $J_y$, and $J_z$ respectively. In the case where $J_x = J_y = J_z$, the model is labeled the 'XXX' model.\n",
    "\n",
    "### 1-2 Numerically computing the matrix representation\n",
    "To compute the matrix representation of $H_{\\text{Heis3}}$, we are actually missing some pieces namely the identity operator $I$ and the [tensor product](https://en.wikipedia.org/wiki/Tensor_product#Tensor_product_of_linear_maps) $\\otimes$ symbol. They are both often left out in when writing a Hamiltonian, but they are implied to be there. Writing out the full $H_{\\text{Heis3}}$ including the identity operators and tensor product symbols\n",
    "$$\n",
    "H_{\\text{Heis3}} = \\sigma_x^{(0)}\\otimes\\sigma_x^{(1)}\\otimes I^{(2)} + I^{(0)} \\otimes\\sigma_x^{(1)}\\otimes\\sigma_x^{(2)} + \\sigma_y^{(0)}\\otimes\\sigma_y^{(1)}\\otimes I^{(2)} + I^{(0)} \\otimes \\sigma_y^{(1)}\\otimes\\sigma_y^{(2)} + I^{(0)} \\otimes\\sigma_z^{(0)}\\otimes\\sigma_z^{(1)} + I^{(0)}\\otimes\\sigma_z^{(1)}\\otimes\\sigma_z^{(2)}.\n",
    "$$\n",
    "You can see why physicists don't write that all out all the time.\n",
    "\n",
    "#### 1-2.1 Tensor product vs Kronecker product\n",
    "\n",
    "A point of clarity about jargon. To numerically compute the [tensor product](https://en.wikipedia.org/wiki/Tensor_product#Tensor_product_of_linear_maps) of $\\sigma_x\\otimes\\sigma_x$, as an example, we often have already chosen to be working with the matrix representation of the operators at hand ($\\sigma_x = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}$ in this example). Because a computer works in the matrix representation, what a computer does is actually called a [Kronecker product](https://en.wikipedia.org/wiki/Kronecker_product#Examples). When doing numerically computations, Kronecker product is the name you would look up for the given software package you're using such as [Mathematica](https://reference.wolfram.com/language/ref/KroneckerProduct.html), [numpy](https://numpy.org/doc/stable/reference/generated/numpy.kron.html), or [Qiskit](https://qiskit.org/documentation/tutorials/operators/01_operator_flow.html#Pauli-operators,-sums,-compositions,-and-tensor-products). \n",
    "\n",
    "Below is an example in Qiskit and numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6e8a2e34-0eaf-4e95-b9fa-753cd35f611a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams.update({'font.size': 16})  # enlarge matplotlib fonts\n",
    "\n",
    "# Import Qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)\n",
    "from qiskit.opflow import Zero, One, I, X, Y, Z\n",
    "\n",
    "# Suppress warnings\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6a7b4f61-08ea-40ad-b595-581632eb53a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Qiskit Kronecker product:\n",
      " [[0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      " [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]]\n",
      "----------------\n",
      "Numpy Kronecker product:\n",
      " [[0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      " [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "# Compute a kronecker product in qiskit\n",
    "# Qiskit already knows what I and X are (the identity and Pauli-X operators), so to compute the kronecker product it's very simple: ^\n",
    "IX_qiskit = (I^X)\n",
    "print('Qiskit Kronecker product:\\n', IX_qiskit.to_matrix())\n",
    "\n",
    "print(\"----------------\")\n",
    "\n",
    "# Compute a kronecker product in numpy\n",
    "X_numpy = np.array([[0,1],[1,0]], dtype=complex)\n",
    "I_numpy = np.eye(2, dtype=complex)\n",
    "\n",
    "IX_numpy = np.kron(I_numpy, X_numpy)\n",
    "print('Numpy Kronecker product:\\n', IX_numpy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2482ca28-5d74-4313-8e1f-cdbb18c7c121",
   "metadata": {},
   "source": [
    "## 2 Using OpFlow\n",
    "Qiskit offers [functionality for mathematically working with quantum states and operators](https://qiskit.org/documentation/apidoc/opflow.html) called ```opflow``` with tutorials found [here](https://qiskit.org/documentation/tutorials/operators/index.html). Opflow is especially convenient when dealing with large numbers of qubits as tensor products can become unweildy when using numpy both in size and syntax. For example, to define $H_{\\text{Heis3}}$, we could use ```numpy```'s ```numpy.kron(...)``` function to compute the tensor product as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b664ad3b-cc82-41fd-b72b-b59140cafa33",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns matrix representation of the XXX Heisenberg model for 3 spin-1/2 particles in a line (uses np.kron())\n",
    "def H_heis3_np_kron():\n",
    "    #iden is the identity matrix; sig_x, sig_y, and sig_z are Pauli matrices\n",
    "    iden = np.eye(2,2)\n",
    "    sig_x = np.array([[0,1],[1,0]])\n",
    "    sig_y = np.array([[0,-1j],[1j,0]])\n",
    "    sig_z = np.array([[0,1],[0,-1]])\n",
    "    \n",
    "    # Interactions (np.kron(A,B) is the tensor product of A and B)\n",
    "    XXs = np.kron(iden, np.kron(sig_x, sig_x)) + np.kron(sig_x, np.kron(sig_x, iden))\n",
    "    YYs = np.kron(iden, np.kron(sig_y, sig_y)) + np.kron(sig_y, np.kron(sig_y, iden))\n",
    "    ZZs = np.kron(iden, np.kron(sig_z, sig_z)) + np.kron(sig_z, np.kron(sig_z, iden))\n",
    "    \n",
    "    # Sum interactions\n",
    "    H = XXs + YYs + ZZs\n",
    "    \n",
    "    # Return Hamiltonian\n",
    "    return H\n",
    "\n",
    "# Returns matrix representation of the XXX Heisenberg model for 3 spin-1/2 particles in a line (uses opflow)\n",
    "def H_heis3_opflow():\n",
    "    \n",
    "    # Interactions (I is the identity matrix; X, Y, and Z are Pauli matricies; ^ is a tensor product)\n",
    "    XXs = (I^X^X) + (X^X^I)\n",
    "    YYs = (I^Y^Y) + (Y^Y^I)\n",
    "    ZZs = (I^Z^Z) + (Z^Z^I)\n",
    "    \n",
    "    # Sum interactions\n",
    "    H = XXs + YYs + ZZs\n",
    "    \n",
    "    # Return Hamiltonian\n",
    "    return H"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "199e6d25-b57a-4a7b-ac11-4b48d2e29efa",
   "metadata": {},
   "source": [
    "Using opflow, however, the math is much easier to read and does not require recursive function calls, which can be confusing when generalizing a Hamiltonian to many qubits. Also, the operators do not need to be explicity computed in opflow saving memory. In opflow, the carrot symbol ```^``` denotes a tensor product. Important note, paranetheses are often needed to clarify the order of operations especially if doing other math operations such as ```+```. See below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fc4e4da7-292d-46fe-972e-4f9c7f32ebce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matrix dimensions of op: (8, 8)\n"
     ]
    }
   ],
   "source": [
    "# Example of incorrectly adding two PauliOp objects.\n",
    "op = X^X + Z^Z\n",
    "print('matrix dimensions of op:', op.to_matrix().shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbb4bb92-2fc8-439c-8d05-0eb086367098",
   "metadata": {},
   "source": [
    "The shape of ```op``` should be (4,4) since $X$ and $Z$ are 2x2, but without parentheses, the order of operations is not correct. Shown below is the correct way of adding the two tensored Pauli operators in opflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9de48874-6287-4721-9d7e-d9037994e216",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matrix dimensions of op: (4, 4)\n"
     ]
    }
   ],
   "source": [
    "# Example of correctly adding two PauliOp objects.\n",
    "op = (X^X) + (Z^Z)\n",
    "print('matrix dimensions of op:', op.to_matrix().shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d780ee45-42a2-4b8f-b7ec-0e08da813b71",
   "metadata": {},
   "source": [
    "## 3 Solution to the Time-Independent Schrödinger Equation\n",
    "\n",
    "The [Schrödinger equation](https://en.wikipedia.org/wiki/Schrödinger_equation) is a foundational pillar of quantum mechanics. It relates how a quantum state $|\\psi(t)\\rangle$ changes in time given what the state was initially $|\\psi(0)\\rangle$. It's solution is relatively simple (more on how it's not simple in the next section) when the Hamiltonian $H$ that governs the state evolvution does not depend on time. Treating Schrödinger equation as the differential equation it is, we can use separation of variables to solve it\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "i \\hbar \\frac{d |\\psi(t)\\rangle}{dt} &= H|\\psi(t)\\rangle \\\\\n",
    "|\\psi(t)\\rangle &= e^{-iHt / \\hbar} |\\psi(0)\\rangle.\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4ded8ca-3fad-4518-aa09-4c21386a06e7",
   "metadata": {},
   "source": [
    "## 4 Exponential of a Matrix\n",
    "The solution to the [Schrödinger equation](https://en.wikipedia.org/wiki/Schrödinger_equation) for a Hamiltonian $H$ that does not depend on time (and $\\hbar = 1$) is\n",
    "$$\n",
    "|\\psi(t)\\rangle = e^{-iHt}|\\psi(0)\\rangle.\n",
    "$$\n",
    "But, what does it mean to take $e$ to the power of an operator $H$? Let's briefly address this topic and give references where you can learn more.\n",
    "\n",
    "Working with the the matrix representation of $H$, the time evolution $U_H(t) = e^{-iHt}$ can be numerically and algebraically evaluated using a [taylor series expansion](https://en.wikipedia.org/wiki/Taylor_series#Exponential_function) ($e^x = 1 + x + x^2/2! + x^3/3! + ... $) . This is often where computers step in. Although, single Pauli operators (e.g. $H=\\sigma_x$) have a nice algebraic result. On a computer, many different software packages have methods for computing $e^A$ where $A$ is a matrix (see scipy's [expm](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.expm.html) or opflow's [.exp_i()](https://qiskit.org/documentation/tutorials/operators/01_operator_flow.html#Evolutions,-exp_i(),-and-the-EvolvedOp)).\n",
    "\n",
    "We do need to be careful when the matrix that is being exponentiated is a sum of operators that do not commute ($[A,B] = AB - BA \\neq 0$). For example, if $H = \\sigma_x + \\sigma_z$, we need to take care in working with $e^{it(\\sigma_x + \\sigma_z)}$ since the Pauli operatos $\\sigma_x$ and $\\sigma_z$ do not commute $[\\sigma_x, \\sigma_z] = \\sigma_x \\sigma_z - \\sigma_z \\sigma_x = -2i\\sigma_y \\neq0$. If we want to apply $e^{it(\\sigma_x + \\sigma_z)}$ on a quantum computer, however, we will want to decompose the sum in the exponential into a product of exponentials. Each product can then be implemented on the quantum computer as a single or two-qubit gate. Continuing the example, $\\sigma_x$ and $\\sigma_z$ do not commute ($[\\sigma_x, \\sigma_z] \\neq 0$), so we cannot simply decompose the exponential into a product of exponentials $e^{-it(\\sigma_x + \\sigma_z)} \\neq e^{-it\\sigma_x}e^{-it\\sigma_z}$. This is where approximation methods come in such as Trotterization (more on that in the next section)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "959cf31a-b738-4ab4-bc2b-825b1bc7cf87",
   "metadata": {},
   "source": [
    "## 5 Trotterization\n",
    "\n",
    "The Open Science Prize notebook ends the decomposition of the unitary time evolution $U_{\\text{Heis3}}(t)$ calculation with\n",
    "$$\n",
    "U_{\\text{Heis3}}(t) \\approx \\left[XX^{(0,1)}(t/n) YY^{(0,1)}(t/n) ZZ^{(0,1)}(t/n) XX^{(1,2)}(t/n) YY^{(1,2)}(t/n) ZZ^{(1,2)}(t/n) \\right]^{n}\n",
    "$$\n",
    "where $t$ is time and $n$ is the number of Trotter steps. (Remember, this is not the only possible Trotterization.)\n",
    "\n",
    "The physical implementation of the two-qubit gates $XX(t)$, $YY(t)$, and $ZZ(t)$ are outlined in the Open Science Prize notebook, though without explanation. Here we provide a brief explanation with references where you can learn more.\n",
    "\n",
    "Qiskit has a library of circuits that include such gates called the [circuit library](https://qiskit.org/documentation/apidoc/circuit_library.html), but not every gate in the library is native to a physical device. Nonnative gates (such as $XX$, $YY$, $ZZ$, or $ZX$) need to be decomposed into gates that are [native to the physical device](https://qiskit.org/documentation/tutorials/circuits_advanced/08_gathering_system_information.html#Configuration). You may even come across three-qubit gates like XXY or XYZ in some models. These interactions can be decomposition into native gates, or you may find it effective go further and [engineer a typically nonnative interaction](https://qiskit.org/textbook/ch-quantum-hardware/hamiltonian-tomography.html) using Pulse.\n",
    "\n",
    "Assuming you want to only use native gates and not pulses, this review article is a useful starting point: F. Tacchino, et. al., *Quantum Computers as Universal Quantum Simulators: State-of-the-Art and Perspectives*, [Adv. Quantum Technol. *3* 3 (2020)](https://doi.org/10.1002/qute.201900052) \\[[free arxiv version](https://arxiv.org/abs/1907.03505)\\]\n",
    "\n",
    "\n",
    "In this notebook, let's start with the [ZZ gate](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RZZGate.html)\n",
    "$$\n",
    "\\begin{align}\n",
    "ZZ(2t) &= e^{-it\\sigma_z \\otimes \\sigma_z} \\\\\n",
    "ZZ(2t) &= \\begin{bmatrix} e^{-it} & 0 & 0 & 0 \\\\ 0 & e^{it} & 0 & 0 \\\\ 0 & 0 & e^{it} & 0 \\\\ 0 & 0 & 0 & e^{-it} \\\\ \\end{bmatrix}\n",
    "\\end{align}.\n",
    "$$\n",
    "This can be implemented in terms of two-qubit [CNOT gates](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CXGate.html#qiskit.circuit.library.CXGate) sandwiching a single qubit rotation [$R_z(2t)$ rotation](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RZGate.html) as shown below. (Note that $R_z$ is evaluated at the angle $2t$ instead of the typical $t$ to simplify writing the exponential terms.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4b52e0cf-8c7f-4d85-a5a5-21937352f236",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.circuit import Parameter\n",
    "from qiskit import QuantumCircuit, QuantumRegister, execute\n",
    "\n",
    "t = Parameter('t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7899531d-1294-4bfc-94d6-4a97b755b427",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 267.052x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ZZ in two and single qubit gates\n",
    "qc = QuantumCircuit(2)\n",
    "qc.cnot(0,1)\n",
    "qc.rz(2 * t, 1)\n",
    "qc.cnot(0,1)\n",
    "\n",
    "qc.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b281b10f-69ec-4dfe-a5b2-797569a0d56d",
   "metadata": {},
   "source": [
    "For fun, let's check this mathematically by evaluating the circuit library ZZ gate and decomposed circuit at various time values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dc7629c2-f881-4505-b904-bb56173cb30f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.circuit.library import RXXGate, RYYGate, RZZGate, CXGate\n",
    "from qiskit.quantum_info.operators import Operator\n",
    "\n",
    "import qiskit.quantum_info as qi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c84f1be2-930c-4545-98d4-36dc6396eda8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# time \n",
    "time = np.pi/2  # try different time values as a check that the decomposition of ZZ into native gates is accurate\n",
    "\n",
    "# Qiskit circuit library ZZ gate\n",
    "qc = QuantumCircuit(2)\n",
    "qc.append(RZZGate(time), [0,1])\n",
    "qc_ZZ_matrix = qi.Operator(qc)\n",
    "\n",
    "# Decomposed ZZ gate\n",
    "CNOT = Operator(np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]))\n",
    "Rz = Operator(np.array([[np.exp(-1j*time/2),0], [0,np.exp(1j*time/2)]]))\n",
    "I_Rz = (Operator(I)^Rz)\n",
    "np_ZZ_matrix = CNOT@I_Rz@CNOT\n",
    "\n",
    "# Confirm matrices are the same at time t\n",
    "np.array_equal(qc_ZZ_matrix, np_ZZ_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da817ff1-df52-43ec-af83-6e17030d355d",
   "metadata": {},
   "source": [
    "The $ZZ(t)$ gate can be rotated to the $XX(t)$ gate by adding single qubit rotations. Single qubit rotations such as $R_y(\\pi/2) \\sigma_z R_y(-\\pi/2) = \\sigma_x$ can transform $\\sigma_z$ to $\\sigma_x$. Consider computing the calculation yourself. Remember that Pauli matrices can be decomposed from an exponential form like so $R_z(2\\theta)= \\exp\\left(-i\\theta\\sigma_z\\right) = \\cos(\\theta)I - i \\sin(\\theta)\\sigma_z$. Below is an abbreviated calculation to guide your own. Note that most tensor products with the identity have been omitted (e.g. $\\sigma_z^{(0)} = \\sigma_z^{(0)} \\otimes I^{(1)}$), and for extra clarity, each operator has the qubit it acts on indexed in the superscript, so $\\sigma_z^{(0)}$ would be the $\\sigma_z$ operator acting on qubit $0$.\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\left(R_y^{(0)}(\\pi/2) \\otimes R_Y^{(1)}(\\pi/2)\\right) ZZ(t)^{(0,1)}\\left( R_y^{(0)}(-\\pi/2) \\otimes R_Y^{(1)}(-\\pi/2)\\right) &= \\\\\n",
    "\\exp\\left[\\frac{-i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] \\exp\\left[\\frac{-it}{2} \\sigma_z^{(0)} \\otimes \\sigma_z^{(1)}\\right] \\exp\\left[\\frac{i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] &= \\\\\n",
    "\\exp\\left[\\frac{-i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] \\left[\\cos(t/2)(I^{(0)} \\otimes I^{(1)}) -i\\sin(t/2)(\\sigma_z^{(0)} \\otimes \\sigma_z^{(1)}) \\right] \\exp\\left[\\frac{i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] &= \\\\\n",
    "\\cos(t/2) \\exp\\left[\\frac{-i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] (I^{(0)} \\otimes I^{(1)}) \\exp\\left[\\frac{i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] - i \\exp\\left[\\frac{-i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right] \\sin(t/2)(\\sigma_z \\otimes \\sigma_z) \\exp\\left[\\frac{i\\pi}{4}(\\sigma_y^{(0)} + \\sigma_y^{(1)})\\right]  &= \\\\\n",
    "\\cos(t/2) (I^{(0)} \\otimes I^{(1)}) - \\frac{i \\sin(t/2)}{4} \\left[\\left(I^{(0)} - i \\sigma_y^{(0)}\\right) \\sigma_z^{(0)} \\left(I^{(0)} + i \\sigma_y^{(0)}\\right)\\right] \\otimes \\left[\\left(I^{(1)} - i \\sigma_y^{(1)}\\right) \\sigma_z^{(1)} \\left(I^{(1)} + i \\sigma_y^{(1)}\\right)\\right]  &= \\\\\n",
    "\\cos(t/2) (I^{(0)} \\otimes I^{(1)}) - i \\sin(t/2) (\\sigma_x^{(0)} \\otimes \\sigma_x^{(1)})  &= \\\\\n",
    "\\exp\\left[\\frac{-it}{2} \\sigma_x^{(0)} \\otimes \\sigma_x^{(1)}\\right] &=  \\\\\n",
    "&= XX(t) \\\\\n",
    "\\end{align}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c18e249f-58ce-43d6-9f49-c5680b1b19c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 387.452x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# XX(t)\n",
    "qc = QuantumCircuit(2)\n",
    "qc.ry(np.pi/2,[0,1])\n",
    "qc.cnot(0,1)\n",
    "qc.rz(2 * t, 1)\n",
    "qc.cnot(0,1)\n",
    "qc.ry(-np.pi/2,[0,1])\n",
    "\n",
    "qc.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4614a7cc-813b-4d5f-87eb-d509b4534447",
   "metadata": {},
   "source": [
    "Let's check for fun again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1401b27f-be6d-4eaf-af29-80fea03bc190",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# time \n",
    "time = np.pi/6  # try different time values as a check that the decomposition of XX into native gates is accurate\n",
    "\n",
    "# Qiskit circuit library XX gate\n",
    "qc = QuantumCircuit(2)\n",
    "qc.append(RXXGate(time), [0,1])\n",
    "qc_XX_matrix = qi.Operator(qc).data\n",
    "\n",
    "# Decomposed XX gate\n",
    "Rz = Operator(np.array([[np.exp(-1j*time/2),0], [0,np.exp(1j*time/2)]]))\n",
    "Ry = Operator(np.array([[np.cos(np.pi/4), -np.sin(np.pi/4)],[np.sin(np.pi/4), np.cos(np.pi/4)]]))\n",
    "Ry_minus = Operator(np.array([[np.cos(-np.pi/4), -np.sin(-np.pi/4)],[np.sin(-np.pi/4), np.cos(-np.pi/4)]]))\n",
    "I_Rz = (Operator(I)^Rz)\n",
    "\n",
    "np_XX_matrix = (Ry^Ry)@CNOT@I_Rz@CNOT@(Ry_minus^Ry_minus)\n",
    "\n",
    "# Confirm matrices are the same at time t\n",
    "np.array_equal(np.round(qc_XX_matrix, 6), np.round(np_XX_matrix, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41154af6-1176-40f4-a799-4e49b5467451",
   "metadata": {},
   "source": [
    "The $ZZ(t)$ gate can be rotated to the $YY(t)$ gate by adding single qubit rotations $R_x(\\pi/2) \\sigma_z R_x(-\\pi/2) = -\\sigma_y$ around the $ZZ$ gate just as was done with the $XX$ gate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9e0fa136-3964-4614-9be6-0aece7c37872",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 387.452x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# YY(t)\n",
    "qc = QuantumCircuit(2)\n",
    "qc.rx(np.pi/2,[0,1])\n",
    "qc.cnot(0,1)\n",
    "qc.rz(2 * t, 1)\n",
    "qc.cnot(0,1)\n",
    "qc.rx(-np.pi/2,[0,1])\n",
    "\n",
    "qc.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4d484c88-5494-4adb-9e4a-deb8b009a4c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# time \n",
    "time = np.pi/6  # try different time values as a check that the decomposition of YY into native gates is accurate\n",
    "\n",
    "# Qiskit circuit library YY gate\n",
    "qc = QuantumCircuit(2)\n",
    "qc.append(RYYGate(time), [0,1])\n",
    "qc_YY_matrix = qi.Operator(qc).data\n",
    "\n",
    "# Decomposed YY gate\n",
    "Rz = Operator(np.array([[np.exp(-1j*time/2),0], [0,np.exp(1j*time/2)]]))\n",
    "Rx = Operator(np.array([[np.cos(np.pi/4), -1j*np.sin(np.pi/4)],[-1j*np.sin(np.pi/4), np.cos(np.pi/4)]]))\n",
    "Rx_minus = Operator(np.array([[np.cos(-np.pi/4), -1j*np.sin(-np.pi/4)],[-1j*np.sin(-np.pi/4), np.cos(-np.pi/4)]]))\n",
    "I_Rz = (Operator(I)^Rz)\n",
    "\n",
    "np_YY_matrix = (Rx^Rx)@CNOT@I_Rz@CNOT@(Rx_minus^Rx_minus)\n",
    "\n",
    "# Confirm matrices are the same at time t\n",
    "np.array_equal(np.round(qc_YY_matrix, 6), np.round(np_YY_matrix, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fcf11bd-7678-4627-9fbc-a090fba9d674",
   "metadata": {},
   "source": [
    "## 6 State Tomography\n",
    "[State tomography](https://qiskit.org/documentation/tutorials/noise/8_tomography.html) is a method for determining the quantum state of a qubit, or qubits, even if the state is in a superposition or entangled. Repeatedly measuring a prepared quantum state may not be enough to determine the full state. For example, what if you want to know if the result of a quantum calculation is the state $|0\\rangle -i|1\\rangle$?\n",
    "\n",
    "Repeated measurements in the $Z$-basis would return $|0\\rangle$ 50% of the time and $|1\\rangle$ 50% of the time. However, there are other states that give the same measurement result, such as $|0\\rangle + |1\\rangle$, $|0\\rangle - |1\\rangle$, and $|0\\rangle + i|1\\rangle$. How could you determine the state you have has the $-i$ phase you're looking for? This requires measurements in [different bases](https://qiskit.org/textbook/ch-states/single-qubit-gates.html#measuring). In state tomography, a quantum circuit is repeated with measurements done in different bases to exhaustively determine the full quantum state (including any phase information). The Open Science Prize this year is using this technique to determine the full quantum state after the quantum simulation. That state is then compared to the exact expected result to compute a fidelity. Although this fidelity only gives information on how well the quantum simulation produces one particular state, it's a more lightweight approach than a full [process tomography](https://qiskit.org/documentation/tutorials/noise/8_tomography.html) caluclation. In short, a high fidelity measured by state tomography doesn't gaurentee a high fidelity quantum simulation, but a low fidelity state tomography does imply a low fidelity quantum simulation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f54d9f18-0385-4b0a-9568-5f1e8efdafb4",
   "metadata": {},
   "source": [
    "# 7 Two-Qubit Gate with Pulse\n",
    "[Qiskit Pulse](https://qiskit.org/documentation/apidoc/pulse.html) offers low-level control of a device's qubits. Pulse allows users to program the physical interactions happening on the superconducting chip. This can be a powerful tool for streamlining circuits \\[1-4\\], crafting new types of gates \\[1-4\\], getting [higher fidelity readout](https://www.youtube.com/watch?v=_1XTChcvbOs), and more. Of course, the increased level of control requires more understanding of [the physics of the qubit and how gates are physically generated on chip](https://qiskit.org/textbook/ch-quantum-hardware/transmon-physics.html). For someone new to Pulse, this may seem intimidating. However, there are great tutorials, and the [qiskit textbook](https://qiskit.org/textbook/ch-quantum-hardware/index-pulses.html) can slowly introduce you to these ideas with real and practically useful examples. For those more experienced with Pulse, it may be time to review papers such as this [general overview](https://arxiv.org/pdf/2004.06755.pdf). There will be other papers you find useful for this competition. Below, there is a small--and far from exhaustive--list to get you started \\[1-4\\].\n",
    "\n",
    "To aid your efforts, we've provided a simple example of implementing a pulse-efficient [$R_{ZX}$ gate](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RZXGate.html#qiskit.circuit.library.RZXGate) as outlined in paper [3](https://arxiv.org/pdf/2105.01063.pdf). Note that although the example below is interesting, it is not the only way to make a \"pulse-efficient\" two-qubit rotation gate.\n",
    "\n",
    "\\[1\\] T. Alexander, et al., *Qiskit Pulse: Programming Quantum Computers Through the Cloud with Pulses*, [Quantum Sci. and Technol. **5** 044006 (2020)](https://arxiv.org/pdf/2004.06755.pdf)\n",
    "\n",
    "\n",
    "\\[2\\] J. Stenger, et al., *Simulating the dynamics of braiding of Majorana zero modes using an IBM quantum computer*, [Phys. Rev. Research **3**, 033171 (2021)](https://arxiv.org/pdf/2012.11660.pdf)\n",
    "\n",
    "\\[3\\] N. Earnest, et al., *Pulse-efficient circuit transpilation for quantum applications on cross-resonance-based hardware*, [arXiv:2105.01063 \\[quant-ph\\] (2021)](https://arxiv.org/pdf/2105.01063.pdf)\n",
    "\n",
    "\\[4\\] S. Oomura, et al., *Design and application of high-speed and high-precision CV gate on IBM Q OpenPulse system*, [arXiv:2102.06117 \\[quant-ph\\] (2021)](https://arxiv.org/pdf/2102.06117.pdf)\n",
    "\n",
    "[qiskit experiments repo](https://github.com/Qiskit/qiskit-experiments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "bcf02aae-a24a-478b-9651-fc25f8dad0d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import qiskit packages\n",
    "from qiskit import IBMQ\n",
    "from qiskit import schedule, transpile\n",
    "from qiskit.tools.monitor import job_monitor\n",
    "\n",
    "# load IBMQ Account data\n",
    "# IBMQ.save_account(TOKEN)\n",
    "provider = IBMQ.load_account()\n",
    "\n",
    "provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')\n",
    "backend = provider.get_backend('ibmq_jakarta')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a057968d-c6d1-4ea0-a773-3d9fae612066",
   "metadata": {},
   "source": [
    "## 7.1 The [$R_{ZX}$ Gate](https://qiskit.org/documentation/stubs/qiskit.circuit.library.RZXGate.html#qiskit.circuit.library.RZXGate)\n",
    "It's now time for an example of implementing a rotational two-qubit gate and how you might go about using Pulse to implement it as efficiently as possible. Remembering the dicussion in sections 4 and 5, we can write out the form of the $R_{ZX}(\\theta)$ gate:\n",
    "\n",
    "$$\n",
    "R_{ZX}(2\\theta) = \\exp\\left(-i \\theta \\sigma_z^{(0)} \\otimes \\sigma_x^{(1)}\\right) = \\cos(\\theta)(I^{(0)}\\otimes I^{(1)}) -i \\sin(\\theta)(\\sigma_z^{(0)} \\otimes \\sigma_x^{(1)})\n",
    "$$\n",
    "\n",
    "Let's follow paper [\\[3\\]](https://arxiv.org/pdf/2105.01063.pdf)'s same line of reasoning. First, implement an $R_{ZX}$ using native circuit gates. Second, compare that circuit's performance to an $R_{ZX}$ gate contrusted from native pulses. Since the competition focuses on Jakarta's qubits 1, 3, and 5, let's just consider an $R_{ZX}$ gate between 1 and 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bc34997b-9248-4521-9c60-6cc6e34bcffc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                    \n",
      "q0_0: ──────────────────────────────────────────────\n",
      "                                                    \n",
      "q0_1: ──────────────■─────────────────■─────────────\n",
      "                    │                 │             \n",
      "q0_2: ──────────────┼─────────────────┼─────────────\n",
      "      ┌──────────┐┌─┴─┐┌───────────┐┌─┴─┐┌─────────┐\n",
      "q0_3: ┤ Ry(-π/2) ├┤ X ├┤ Rz(3π/11) ├┤ X ├┤ Ry(π/2) ├\n",
      "      └──────────┘└───┘└───────────┘└───┘└─────────┘\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x648 with 1 Axes>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# RZX gate circuit (see section 5 for details on why this is the circuit for RZX)\n",
    "theta = 3*np.pi/11 # pick arbitrary rotation angle theta\n",
    "\n",
    "qrs = QuantumRegister(4)\n",
    "qc = QuantumCircuit(qrs)\n",
    "qc.ry(-np.pi/2, 3)\n",
    "qc.cx(1, 3)\n",
    "qc.rz(theta, 3)\n",
    "qc.cx(1, 3)\n",
    "qc.ry(np.pi/2, 3)\n",
    "print(qc.draw())\n",
    "\n",
    "qct = transpile(qc, backend)  # display the typical circuit diagram\n",
    "schedule(qct, backend).draw()  # display what the pulse schedule looks like for the circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "087e3714-4129-47a2-b1e6-c1b26a31ff8e",
   "metadata": {},
   "source": [
    "Now that we have an $R_{ZX}$ circuit implementation (shown above in circuit and pulse schedule forms), let's make the \"pulse-efficient\" version of $R_{ZX}$. (Spoiler: it's only two pulses!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7785e505-f8c3-457f-9d17-7cf5f1c411ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The PassManager helps decide how a circuit should be optimized\n",
    "# (https://qiskit.org/documentation/tutorials/circuits_advanced/04_transpiler_passes_and_passmanager.html)\n",
    "from qiskit.transpiler import PassManager\n",
    "\n",
    "# This function will pull pulse-level calibration values to build RZX gates and tell the PassManager to leave RZX gates alone\n",
    "from qiskit.transpiler.passes import RZXCalibrationBuilderNoEcho"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f96a9cdc-578a-4e23-8ee3-9d4d8867d22d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x550.8 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equivalent circuit in terms of cross-resonance gates (https://qiskit.org/textbook/ch-quantum-hardware/cQED-JC-SW.html#6.-The-Cross-Resonance-Entangling-Gate)\n",
    "qrs_pe = QuantumRegister(4)\n",
    "qc_pe = QuantumCircuit(qrs_pe)\n",
    "qc_pe.rzx(theta/2, 1, 3)\n",
    "qc_pe.x(1)\n",
    "qc_pe.rzx(-theta/2, 1, 3)\n",
    "qc_pe.x(1)\n",
    "\n",
    "# Add the pulse-level calibrations\n",
    "pm = PassManager([RZXCalibrationBuilderNoEcho(backend)])\n",
    "qc_pulse_efficient = pm.run(qc_pe)\n",
    "\n",
    "schedule(qc_pulse_efficient, backend).draw()  # show pulse schedule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "93da1619-2bac-45df-8724-ca33e6616cf1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Duration of standard CNOT-based circuit:\n",
      "3776\n",
      "Duration of pulse-efficient circuit:\n",
      "1184\n"
     ]
    }
   ],
   "source": [
    "# Compare the schedule durations\n",
    "print('Duration of standard CNOT-based circuit:')\n",
    "print(schedule(qct, backend).duration)\n",
    "print('Duration of pulse-efficient circuit:')\n",
    "print(schedule(qc_pulse_efficient, backend).duration)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b9966af-636f-4a75-8e13-60a053e4c525",
   "metadata": {},
   "source": [
    "You've just optimized an $R_{ZX}$ gate using pulse-level control! The shorter circuit time for the pulse-efficient circuit is great news! The shorter the circuit, the less likely the qubit will decohere. This time savings, and fewer pulses to the qubits, will reduce errors. Let's quantify this reduction by measuring the [process fidelity](https://qiskit.org/documentation/tutorials/noise/8_tomography.html) of the two circuits. If we wanted to be thorough, we should do a [randomized benchmarking](https://qiskit.org/textbook/ch-quantum-hardware/randomized-benchmarking.html) as shown in Fig. 1 of paper [\\[3\\]](https://arxiv.org/pdf/2105.01063.pdf)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1122b4a4-aba3-45cf-aa4c-3c8358c3e987",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Process tomography functions\n",
    "from qiskit.ignis.verification.tomography import process_tomography_circuits, ProcessTomographyFitter\n",
    "\n",
    "# Get exact gate for comparison in process tomography\n",
    "from qiskit.circuit.library import RZXGate\n",
    "\n",
    "# Get the ideal unitary operator to compare to circuit output\n",
    "target_unitary = qi.Operator(RZXGate(theta).to_matrix())\n",
    "\n",
    "# Generate process tomography circuits and run\n",
    "qpt_qcs = process_tomography_circuits(qc, [qrs[1], qrs[3]])\n",
    "job = execute(qpt_qcs, backend, shots=8192)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ff05476f-831f-4feb-8e20-82436c74074b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n"
     ]
    }
   ],
   "source": [
    "job_monitor(job)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "11371910-5166-4470-87f0-a94bb00e6ff9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average gate fidelity: F = 0.91322\n"
     ]
    }
   ],
   "source": [
    "# Extract tomography data\n",
    "qpt_tomo = ProcessTomographyFitter(job.result(), qpt_qcs)\n",
    "\n",
    "# Tomographic reconstruction\n",
    "choi_fit_lstsq = qpt_tomo.fit(method='lstsq')\n",
    "print('Average gate fidelity: F = {:.5f}'.format(qi.average_gate_fidelity(choi_fit_lstsq, target=target_unitary)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a738714-545b-4ebe-b381-2fcc610e4f7f",
   "metadata": {},
   "source": [
    "Now for the pulse-efficient gate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ec7d0533-fbf3-468e-bd43-469a477e4a4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate process tomography circuits and run\n",
    "qpt_qcs = process_tomography_circuits(qc_pulse_efficient, [qrs_pe[1], qrs_pe[3]])\n",
    "job = execute(qpt_qcs, backend, shots=8192)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e3274b60-f0c2-4a42-96d7-664c3cd4af26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n"
     ]
    }
   ],
   "source": [
    "job_monitor(job)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "97fca98c-f492-4643-95da-42d9f24678f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average gate fidelity: F = 0.92471\n"
     ]
    }
   ],
   "source": [
    "# Extract tomography data so that counts are indexed by measurement configuration\n",
    "qpt_tomo = ProcessTomographyFitter(job.result(), qpt_qcs)\n",
    "\n",
    "# Tomographic reconstruction\n",
    "choi_fit_lstsq = qpt_tomo.fit(method='lstsq')\n",
    "print('Average gate fidelity: F = {:.5f}'.format(qi.average_gate_fidelity(choi_fit_lstsq, target=target_unitary)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f387262-d130-4c2c-91af-bdcf8ff9019e",
   "metadata": {},
   "source": [
    "This is just one example of how Pulse could be used. Read [tutorials](https://qiskit.org/documentation/tutorials/circuits_advanced/05_pulse_gates.html), papers, and the [Qiskit youtube channel](https://www.youtube.com/c/qiskit) for more ideas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3442d831-379c-420d-8aa5-3d300220d796",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.18.3</td></tr><tr><td><code>qiskit-aer</code></td><td>0.9.1</td></tr><tr><td><code>qiskit-ignis</code></td><td>0.6.0</td></tr><tr><td><code>qiskit-ibmq-provider</code></td><td>0.18.0</td></tr><tr><td><code>qiskit-aqua</code></td><td>0.9.5</td></tr><tr><td><code>qiskit</code></td><td>0.32.0</td></tr><tr><td><code>qiskit-nature</code></td><td>0.1.3</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.8.8 (default, Apr 13 2021, 12:59:45) \n",
       "[Clang 10.0.0 ]</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>64.0</td></tr><tr><td colspan='2'>Mon Nov 29 09:01:00 2021 EST</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}