qiskit/advanced/aer/4_custom_gate_noise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../../images/qiskit_header.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" align=\"middle\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Qiskit Aer: Applying noise to custom unitary gates\n",
    "\n",
    "The latest version of this notebook is available on https://github.com/Qiskit/qiskit-tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "This notebook shows how to add custom unitary gates to a quantum circuit, and use them for noise simulations in Qiskit Aer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:09:18.154548Z",
     "start_time": "2019-08-19T17:09:15.909907Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import execute, QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "from qiskit.quantum_info.operators import Operator\n",
    "from qiskit.quantum_info import process_fidelity\n",
    "from qiskit.providers.aer import QasmSimulator\n",
    "from qiskit.providers.aer.noise import NoiseModel, errors\n",
    "\n",
    "from qiskit.tools.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating matrix operators\n",
    "\n",
    "We can use the `Operator` class in `qiskit.quantum_info.operators` to represent arbitrary matrix operators. If the operator is unitary it can then be added to a quantum circuit and used for simulation on Qiskit Aer.\n",
    "\n",
    "Lets create two operators below for a CNOT gate, and an iSWAP gates:\n",
    "\n",
    "$$\\mbox{CNOT} = \\left(\\begin{array} \n",
    "& 1 & 0 & 0 & 0 \\\\ \n",
    "0 & 0 & 0 & 1 \\\\ \n",
    "0 & 0 & 1 & 0 \\\\ \n",
    "0 & 1 & 0 & 0\n",
    "\\end{array}\\right), \\quad\n",
    "\\mbox{iSWAP} = \\left(\\begin{array} \n",
    "& 1 & 0 & 0 & 0 \\\\ \n",
    "0 & 0 & i & 0 \\\\ \n",
    "0 & i & 0 & 0 \\\\ \n",
    "0 & 0 & 0 & 1\n",
    "\\end{array}\\right)$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:09:18.170527Z",
     "start_time": "2019-08-19T17:09:18.166252Z"
    }
   },
   "outputs": [],
   "source": [
    "# CNOT matrix operator with qubit-0 as control and qubit-1 as target\n",
    "cx_op = Operator([[1, 0, 0, 0],\n",
    "                  [0, 0, 0, 1],\n",
    "                  [0, 0, 1, 0],\n",
    "                  [0, 1, 0, 0]])\n",
    "\n",
    "# iSWAP matrix operator\n",
    "iswap_op = Operator([[1, 0, 0, 0],\n",
    "                     [0, 0, 1j, 0],\n",
    "                     [0, 1j, 0, 0],\n",
    "                     [0, 0, 0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** The matrix is specified with respect to the tensor product $U_{b}\\otimes U_{a}$ for qubits specified by list `[a, b]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using operators in circuits\n",
    "\n",
    "Let us demonstrate how these can be used in a circuit. We will consider an example of implementing a CNOT gate decomposed in terms of single-qubit gates and the iSWAP gate as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:09:55.343221Z",
     "start_time": "2019-08-19T17:09:55.332156Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        ┌─────┐     ┌──────────┐┌─────┐┌───┐┌─────┐┌──────────┐     \n",
      "q_0: |0>┤ Sdg ├─────┤0         ├┤ Sdg ├┤ H ├┤ Sdg ├┤0         ├─────\n",
      "        ├─────┤┌───┐│  unitary │└─────┘└───┘└─────┘│  unitary │┌───┐\n",
      "q_1: |0>┤ Sdg ├┤ H ├┤1         ├───────────────────┤1         ├┤ S ├\n",
      "        └─────┘└───┘└──────────┘                   └──────────┘└───┘\n"
     ]
    }
   ],
   "source": [
    "# CNOT in terms of iSWAP and single-qubit gates\n",
    "cx_circ = QuantumCircuit(2)\n",
    "\n",
    "# Add gates\n",
    "cx_circ.sdg(1)\n",
    "cx_circ.h(1)\n",
    "cx_circ.sdg(0)\n",
    "cx_circ.unitary(iswap_op, [0, 1], label='iswap')\n",
    "cx_circ.sdg(0)\n",
    "cx_circ.h(0)\n",
    "cx_circ.sdg(0)\n",
    "cx_circ.unitary(iswap_op, [0, 1], label='iswap')\n",
    "cx_circ.s(1)\n",
    "\n",
    "print(cx_circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we have assigned an optional *label* of `\"iswap\"` to the unitary when it is inserted. This allows us to identify this unitary in a Qiskit Aer `NoiseModel` so that we can add errors to these custom unitary gates in noisy circuit simulations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can confirm this circuit returns the correct using the `Operator` class as a simulator for the circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:09:58.954826Z",
     "start_time": "2019-08-19T17:09:58.948275Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Operator([[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",
      " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]], input_dims=(2, 2), output_dims=(2, 2))\n"
     ]
    }
   ],
   "source": [
    "# Simulate the unitary for the circuit using Operator:\n",
    "unitary = Operator(cx_circ)\n",
    "print(unitary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And to confirm the output is corrct we can compute the process fidelity:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:01.198369Z",
     "start_time": "2019-08-19T17:10:01.184222Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process Fidelity =  (0.9999999999999996+0j)\n"
     ]
    }
   ],
   "source": [
    "fpro = process_fidelity(cx_op, unitary)\n",
    "print(\"Process Fidelity = \", fpro)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a custom unitary in a noise model\n",
    "\n",
    "The Qiskit Aer QasmSimulator supports simulation of arbitrary unitary operators directly as specified by the `\"unitary\"` in the basis gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:03.174651Z",
     "start_time": "2019-08-19T17:10:03.168643Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'unitary' in QasmSimulator().configuration().basis_gates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This allows us to add noise models to arbitrary unitaries in our simulation when we identity them using the optional `label` argument of `QuantumCircuit.unitary`.\n",
    "\n",
    "We will now do this by creating a `NoiseModel` that includes a quantum error channel on our custom iSWAP gate. For our example we will create an 2-qubit error consisting of two single-qubit amplitude damping channels with different damping parameters. For now we will assume all the other circuit instructions are ideal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:05.585654Z",
     "start_time": "2019-08-19T17:10:05.574669Z"
    }
   },
   "outputs": [],
   "source": [
    "# Error parameters\n",
    "param_q0 = 0.05  # damping parameter for qubit-0\n",
    "param_q1 = 0.1   # damping parameter for qubit-1\n",
    "\n",
    "# Construct the error\n",
    "qerror_q0 = errors.amplitude_damping_error(param_q0)\n",
    "qerror_q1 = errors.amplitude_damping_error(param_q1)\n",
    "iswap_error = qerror_q1.tensor(qerror_q0)\n",
    "\n",
    "# Build the noise model by adding the error to the \"iswap\" gate\n",
    "noise_model = NoiseModel()\n",
    "noise_model.add_all_qubit_quantum_error(iswap_error, 'iswap')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that when we add an error to a custom label such as `\"iswap\"` the `NoiseModel` does not know what gate this label is supposed to apply to, so we must manually add the desired gate string to the noise model `basis_gates`. This ensure that the compiler will unroll to the correct basis gates for the noise model simulation. This can done using the `NoiseModel.add_basis_gates` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:06.301854Z",
     "start_time": "2019-08-19T17:10:06.298595Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cx', 'id', 'u3', 'unitary']\n"
     ]
    }
   ],
   "source": [
    "noise_model.add_basis_gates(['unitary'])\n",
    "print(noise_model.basis_gates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default the basis gates of a noise model are `['cx','id','u3']` plus any standard QasmSimulator basis gates that are added to the noise model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulating a custom unitary noise model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first take our previous CX circuit and add an initial Hadamard gate and final measurement to create a Bell-state preparation circuit that we may simulator on the `QasmSimulator` both for the ideal and noisy case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:26.234163Z",
     "start_time": "2019-08-19T17:10:26.224218Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         ┌───┐ ┌─────┐┌──────────┐┌─────┐┌───┐┌─────┐┌──────────┐┌─┐        \n",
      "q_0: |0>─┤ H ├─┤ Sdg ├┤0         ├┤ Sdg ├┤ H ├┤ Sdg ├┤0         ├┤M├────────\n",
      "        ┌┴───┴┐└┬───┬┘│  unitary │└─────┘└───┘└─────┘│  unitary │└╥┘┌───┐┌─┐\n",
      "q_1: |0>┤ Sdg ├─┤ H ├─┤1         ├───────────────────┤1         ├─╫─┤ S ├┤M├\n",
      "        └─────┘ └───┘ └──────────┘                   └──────────┘ ║ └───┘└╥┘\n",
      " c_0: 0 ══════════════════════════════════════════════════════════╩═══════╬═\n",
      "                                                                          ║ \n",
      " c_1: 0 ══════════════════════════════════════════════════════════════════╩═\n",
      "                                                                            \n"
     ]
    }
   ],
   "source": [
    "# Bell state circuit where iSWAPS should be inserted at barrier locations\n",
    "bell_circ = QuantumCircuit(2, 2, name='bell')\n",
    "bell_circ.h(0)\n",
    "bell_circ = bell_circ + cx_circ \n",
    "bell_circ.measure([0,1], [0,1])\n",
    "print(bell_circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ideal output\n",
    "\n",
    "Lets first see the ideal output. Since this generates a Bell-state we expect two peaks for 00 and 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:28.605669Z",
     "start_time": "2019-08-19T17:10:28.467516Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Execute on the simulator without noise\n",
    "job = execute(bell_circ, QasmSimulator(),\n",
    "              basis_gates=noise_model.basis_gates)\n",
    "ideal_result = job.result()\n",
    "ideal_counts = ideal_result.get_counts(bell_circ)\n",
    "plot_histogram(ideal_counts, title='Ideal output for iSWAP bell-state preparation')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Noisy circuit execution\n",
    "\n",
    "Finally lets now simulate it with our custom noise model. Since there is a small amplitude damping error on the two qubit gates we expect small additional peaks for the 01 and 10 outcome probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:31.078094Z",
     "start_time": "2019-08-19T17:10:30.946144Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Execute on the simulator without noise\n",
    "job = execute(bell_circ, QasmSimulator(),\n",
    "              basis_gates=noise_model.basis_gates,\n",
    "              noise_model=noise_model)\n",
    "noise_result = job.result()\n",
    "noise_counts = noise_result.get_counts(bell_circ)\n",
    "plot_histogram(noise_counts, title='Noisy output for iSWAP bell-state preparation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:53.298595Z",
     "start_time": "2019-08-19T17:10:53.290949Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>None</td></tr><tr><td>Terra</td><td>0.9.0</td></tr><tr><td>Aer</td><td>0.3.0</td></tr><tr><td>Ignis</td><td>0.2.0</td></tr><tr><td>Aqua</td><td>0.5.6</td></tr><tr><td>IBM Q Provider</td><td>0.3.2rc1</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.7.3 (default, Mar 27 2019, 16:54:48) \n",
       "[Clang 4.0.1 (tags/RELEASE_401/final)]</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>4</td></tr><tr><td>Memory (Gb)</td><td>16.0</td></tr><tr><td colspan='2'>Mon Aug 19 13:10:53 2019 EDT</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2019.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}