qiskit/aer/building_noise_models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"../../images/qiskit-heading.gif\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Qiskit Aer: Building Noise Models\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 introduces how to use the Qiskit Aer `noise` module to build custom noise models for noisy simulations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit import execute, QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "from qiskit.quantum_info.operators import Kraus, SuperOp\n",
    "from qiskit.providers.aer import QasmSimulator\n",
    "from qiskit.tools.visualization import plot_histogram\n",
    "\n",
    "# Qiskit Aer noise module imports\n",
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "from qiskit.providers.aer.noise.errors import QuantumError, ReadoutError\n",
    "from qiskit.providers.aer.noise.errors import pauli_error\n",
    "from qiskit.providers.aer.noise.errors import depolarizing_error\n",
    "from qiskit.providers.aer.noise.errors import thermal_relaxation_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Qiskit Aer Noise Module\n",
    "\n",
    "The `aer.noise` module contains Python classes to build customized noise models for simulation. There are three key classes:\n",
    "\n",
    "1. The `NoiseModel` class which stores a noise model used for noisy simulation \n",
    "2. The `QuantumError` class which describes CPTP gate errors. These can be applied\n",
    "    * After *gate* or *reset* instructions\n",
    "    * Before *measure* instructions.\n",
    "\n",
    "3. The `ReadoutError` class which describes classical readout errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Errors\n",
    "\n",
    "Rather than deal with the `QuantumError` object directly, many helper functions exist to automatically generate a specific type of parameterized quantum error. These are contained in the `noise.errors` submodule and include functions for many common errors types used in quantum computing research. The function names and the type of error they return are:\n",
    "\n",
    "| Standard error function | Details |\n",
    "| --- | --- |\n",
    "| `kraus_error` | a general n-qubit CPTP error channel given as a list of Kraus matrices $[K_0, ...]$. |\n",
    "| `mixed_unitary_error` | an n-qubit mixed unitary error given as a list of unitary matrices and probabilities $[(U_0, p_0),...]$. |\n",
    "| `coherent_unitary_error` | an n-qubit coherent unitary error given as a single unitary matrix $U$. |\n",
    "| `pauli_error` | an n-qubit Pauli error channel (mixed unitary) given as a list of Pauli's and probabilities $[(P_0, p_0),...]$ |\n",
    "| `depolarizing_error` | an n-qubit depolarizing error channel parameterized by a depolarization probability $p$. |\n",
    "| `reset_error` | a single-qubit reset error parameterized by a probabilities $p_0, p_1$ of reseting to the $|0\\rangle$, $|1\\rangle$ state.|\n",
    "| `thermal_relaxation_error` | a single qubit thermal relaxation channel parameterized by relaxation time constants $T_1$, $T_2$, gate time $t$, and excited state thermal population $p_1$. |\n",
    "| `phase_amplitude_damping_error` | A single-qubit generalized combined phase and amplitude damping error channel given by an amplitude damping parameter $\\lambda$, a phase damping parameter $\\gamma$, and an excited state thermal population $p_1$. |\n",
    "| `amplitude_damping_error` |  A single-qubit generalized amplitude damping error channel given by an amplitude damping parameter $\\lambda$, and an excited state thermal population $p_1$. |\n",
    "| `phase_damping_error` |  A single-qubit phase damping error channel given by a phase damping parameter $\\gamma$ |\n",
    "\n",
    "### Combining quantum errors\n",
    "\n",
    "`QuantumError` instances can be combined by using composition, tensor product, and tensor expansion (reversed order tensor product) to produce new `QuantumErrors` as:\n",
    "\n",
    " * Composition: $\\cal{E}(\\rho)=\\cal{E_2}(\\cal{E_1}(\\rho))$ as `error = error1.compose(error2)`\n",
    " * Tensor product: $\\cal{E}(\\rho) =(\\cal{E_1}\\otimes\\cal{E_2})(\\rho)$ as `error error1.tensor(error2)`\n",
    " * Expand product: $\\cal{E}(\\rho) =(\\cal{E_2}\\otimes\\cal{E_1})(\\rho)$ as `error error1.expand(error2)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "For example to construct a 5% single-qubit Bit-flip error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QuantumError on 1 qubits. Noise circuits:\n",
      "  P(0) = 0.05, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]\n",
      "  P(1) = 0.95, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]\n",
      "QuantumError on 1 qubits. Noise circuits:\n",
      "  P(0) = 0.05, QasmQobjInstructions = [[{'name': 'z', 'qubits': [0]}]\n",
      "  P(1) = 0.95, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]\n"
     ]
    }
   ],
   "source": [
    "# Construct a 1-qubit bit-flip and phase-flip errors\n",
    "p_error = 0.05\n",
    "bit_flip = pauli_error([('X', p_error), ('I', 1 - p_error)])\n",
    "phase_flip = pauli_error([('Z', p_error), ('I', 1 - p_error)])\n",
    "print(bit_flip)\n",
    "print(phase_flip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QuantumError on 1 qubits. Noise circuits:\n",
      "  P(0) = 0.0025000000000000005, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}, {'name': 'z', 'qubits': [0]}]\n",
      "  P(1) = 0.0475, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]\n",
      "  P(2) = 0.0475, QasmQobjInstructions = [[{'name': 'z', 'qubits': [0]}]\n",
      "  P(3) = 0.9025, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]\n"
     ]
    }
   ],
   "source": [
    "# Compose two bit-flip and phase-flip errors\n",
    "bitphase_flip = bit_flip.compose(phase_flip)\n",
    "print(bitphase_flip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QuantumError on 2 qubits. Noise circuits:\n",
      "  P(0) = 0.0025000000000000005, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}, {'name': 'z', 'qubits': [1]}]\n",
      "  P(1) = 0.0475, QasmQobjInstructions = [[{'name': 'z', 'qubits': [1]}]\n",
      "  P(2) = 0.0475, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]\n",
      "  P(3) = 0.9025, QasmQobjInstructions = [[{'name': 'id', 'qubits': [1]}]\n"
     ]
    }
   ],
   "source": [
    "# Tensor product two bit-flip and phase-flip errors with\n",
    "# bit-flip on qubit-0, phase-flip on qubit-1\n",
    "error2 = phase_flip.tensor(bit_flip)\n",
    "print(error2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting to and from QuantumChannel operators\n",
    " \n",
    " We can also convert back and forth between `QuantumError` objects in Qiskit-Aer and `QuantumChannel` objects in Qiskit-Terra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kraus([array([[ 0.00000000e+00+0.j,  2.23606798e-01+0.j],\n",
      "       [ 2.23606798e-01+0.j, -7.02166694e-17+0.j]]), array([[0.97467943+0.j, 0.        +0.j],\n",
      "       [0.        +0.j, 0.97467943+0.j]])], input_dims=(2,), output_dims=(2,))\n"
     ]
    }
   ],
   "source": [
    "# Convert to Kraus operator\n",
    "bit_flip_kraus = Kraus(bit_flip)\n",
    "print(bit_flip_kraus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SuperOp([[1. +0.j 0. +0.j 0. +0.j 0. +0.j]\n",
      " [0. +0.j 0.9+0.j 0. +0.j 0. +0.j]\n",
      " [0. +0.j 0. +0.j 0.9+0.j 0. +0.j]\n",
      " [0. +0.j 0. +0.j 0. +0.j 1. +0.j]], input_dims=(2,), output_dims=(2,))\n"
     ]
    }
   ],
   "source": [
    "# Convert to Superoperator\n",
    "phase_flip_sop = SuperOp(phase_flip)\n",
    "print(phase_flip_sop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QuantumError on 1 qubits. Noise circuits:\n",
      "  P(0) = 0.049999999999999996, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]\n",
      "  P(1) = 0.9500000000000001, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert back to a quantum error\n",
    "print(QuantumError(bit_flip_kraus))\n",
    "\n",
    "# Check conversion is equivalent to original error\n",
    "QuantumError(bit_flip_kraus) == bit_flip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Readout Error\n",
    "\n",
    "Classical readout errors are specified by a list of assignment probabilities vectors $P(A|B)$:\n",
    "\n",
    "  * $A$ is the *recorded* classical bit value\n",
    "  * $B$ is the *true* bit value returned from the measurement \n",
    " \n",
    "E.g. for 1 qubits: $ P(A|B) = [P(A|0), P(A|1)]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ReadoutError([[0.95 0.05]\n",
       " [0.1  0.9 ]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Measurement miss-assignement probabilities\n",
    "p0given1 = 0.1\n",
    "p1given0 = 0.05\n",
    "\n",
    "\n",
    "ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Readout errors may also be combined using `compose`, `tensor` and `expand` like with quantum errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding errors to a Noise Model\n",
    "\n",
    "When adding a quantum error to a noise model we must specify the type of *instruction* that it acts on, and what qubits to apply it to. There are three cases for Quantum Errors:\n",
    " \n",
    " 1. All-qubit quantum error\n",
    " 2. Specific qubit quantum error\n",
    " 3. Non-local quantum error\n",
    " \n",
    "### All-qubit quantum error\n",
    "\n",
    "This applies the same error to any occurrence of an instruction, regardless of which qubits it acts on.\n",
    "\n",
    "It is added as `noise_model.add_all_qubit_quantum_error(error, instructions)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']\n",
      "  Instructions with noise: ['u3', 'u2', 'u1']\n",
      "  All-qubits errors: ['u1', 'u2', 'u3']\n"
     ]
    }
   ],
   "source": [
    "# Create an empty noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "# Add depolarizing error to all single qubit u1, u2, u3 gates\n",
    "error = depolarizing_error(0.05, 1)\n",
    "noise_model.add_all_qubit_quantum_error(error, ['u1', 'u2', 'u3'])\n",
    "\n",
    "# Print noise model info\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specific qubit quantum error\n",
    "\n",
    "This applies the error to any occurrence of an instruction acting on a specified list of qubits. Note that the order of the qubit matters: For a 2-qubit gate an error applied to qubits [0, 1] is different to one applied to qubits [1, 0] for example.\n",
    "\n",
    "It is added as `noise_model.add_quantum_error(error, instructions, qubits)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']\n",
      "  Instructions with noise: ['u3', 'u2', 'u1']\n",
      "  Qubits with noise: [0]\n",
      "  Specific qubit errors: [('u1', [0]), ('u2', [0]), ('u3', [0])]\n"
     ]
    }
   ],
   "source": [
    "# Create an empty noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "# Add depolarizing error to all single qubit u1, u2, u3 gates on qubit 0 only\n",
    "error = depolarizing_error(0.05, 1)\n",
    "noise_model.add_quantum_error(error, ['u1', 'u2', 'u3'], [0])\n",
    "\n",
    "# Print noise model info\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Non-local qubit quantum error\n",
    "\n",
    "This applies an error to a specific set of noise qubits after any occurrence of an instruction acting on a specific of gate qubits.\n",
    "\n",
    "It is added as `noise_model.add_quantum_error(error, instructions, instr_qubits, error_qubits)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']\n",
      "  Instructions with noise: ['u3', 'u2', 'u1']\n",
      "  Qubits with noise: [0, 2]\n",
      "  Non-local specific qubit errors: [('u1', [0], [2]), ('u2', [0], [2]), ('u3', [0], [2])]\n"
     ]
    }
   ],
   "source": [
    "# Create an empty noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "# Add depolarizing error on qubit 2 forall single qubit u1, u2, u3 gates on qubit 0 \n",
    "error = depolarizing_error(0.05, 1)\n",
    "noise_model.add_nonlocal_quantum_error(error, ['u1', 'u2', 'u3'], [0], [2])\n",
    "\n",
    "# Print noise model info\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Executing a noisy simulation with a noise model\n",
    "\n",
    "* To execute a noisy simulation we pass the noise model object to `QasmSimulator.run` or `execute` using the `noise_model` kwarg.\n",
    "* Eg: `qiskit.execute(circuits, QasmSimulator(), noise_model=noise)`\n",
    "\n",
    "**Important:** *When running a noisy simulation make sure you compile your qobj to the same basis gates as the noise model!*\n",
    "\n",
    "This can be done using `NoiseModel.basis_gates`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Noise Model Examples\n",
    "\n",
    "We will now give some examples of noise models For our demonstrations we wil use a simple test circuit generating a n-qubit GHZ state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         ┌───┐          ┌─┐              \n",
      "q0_0: |0>┤ H ├──■───────┤M├──────────────\n",
      "         └───┘┌─┴─┐     └╥┘     ┌─┐      \n",
      "q0_1: |0>─────┤ X ├──■───╫──────┤M├──────\n",
      "              └───┘┌─┴─┐ ║      └╥┘┌─┐   \n",
      "q0_2: |0>──────────┤ X ├─╫───■───╫─┤M├───\n",
      "                   └───┘ ║ ┌─┴─┐ ║ └╥┘┌─┐\n",
      "q0_3: |0>────────────────╫─┤ X ├─╫──╫─┤M├\n",
      "                         ║ └───┘ ║  ║ └╥┘\n",
      " c0_0: 0 ════════════════╩═══════╬══╬══╬═\n",
      "                                 ║  ║  ║ \n",
      " c0_1: 0 ════════════════════════╩══╬══╬═\n",
      "                                    ║  ║ \n",
      " c0_2: 0 ═══════════════════════════╩══╬═\n",
      "                                       ║ \n",
      " c0_3: 0 ══════════════════════════════╩═\n",
      "                                         \n"
     ]
    }
   ],
   "source": [
    "# Simulator\n",
    "simulator = QasmSimulator()\n",
    "\n",
    "# System Specification\n",
    "n_qubits = 4\n",
    "qr = QuantumRegister(n_qubits)\n",
    "cr = ClassicalRegister(n_qubits)\n",
    "circ = QuantumCircuit(qr, cr)\n",
    "\n",
    "# Test Circuit\n",
    "circ.h(qr[0])\n",
    "for qubit in range(n_qubits - 1):\n",
    "    circ.cx(qr[qubit], qr[qubit + 1])\n",
    "circ.measure(qr, cr)\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ideal Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ideal execution\n",
    "job = execute(circ, simulator)\n",
    "result_ideal = job.result()\n",
    "plot_histogram(result_ideal.get_counts(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Noise Example 1: Basic bit-flip error noise model\n",
    "\n",
    "Lets consider a simple toy noise model example common in quantum information theory research:\n",
    "\n",
    "* When applying a single qubit gate, flip the state of the qubit with probability `p_gate1`.\n",
    "* When applying a 2-qubit gate apply single-qubit errors to each qubit.\n",
    "* When reseting a qubit reset to 1 instead of 0 with probability `p_reset`\n",
    "* When measuring a qubit, flip the state of the qubit before with probability `p_meas`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']\n",
      "  Instructions with noise: ['cx', 'u3', 'u2', 'reset', 'measure', 'u1']\n",
      "  All-qubits errors: ['reset', 'measure', 'u1', 'u2', 'u3', 'cx']\n"
     ]
    }
   ],
   "source": [
    "# Example error probabilities\n",
    "p_reset = 0.03\n",
    "p_meas = 0.1\n",
    "p_gate1 = 0.05\n",
    "\n",
    "# QuantumError objects\n",
    "error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])\n",
    "error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])\n",
    "error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])\n",
    "error_gate2 = error_gate1.tensor(error_gate1)\n",
    "\n",
    "# Add errors to noise model\n",
    "noise_bit_flip = NoiseModel()\n",
    "noise_bit_flip.add_all_qubit_quantum_error(error_reset, \"reset\")\n",
    "noise_bit_flip.add_all_qubit_quantum_error(error_meas, \"measure\")\n",
    "noise_bit_flip.add_all_qubit_quantum_error(error_gate1, [\"u1\", \"u2\", \"u3\"])\n",
    "noise_bit_flip.add_all_qubit_quantum_error(error_gate2, [\"cx\"])\n",
    "\n",
    "print(noise_bit_flip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Executing the noisy simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the noisy simulation\n",
    "job = execute(circ, simulator,\n",
    "              basis_gates=noise_bit_flip.basis_gates,\n",
    "              noise_model=noise_bit_flip)\n",
    "result_bit_flip = job.result()\n",
    "counts_bit_flip = result_bit_flip.get_counts(0)\n",
    "\n",
    "# Plot noisy output\n",
    "plot_histogram(counts_bit_flip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2: T1/T2 thermal relaxation\n",
    "\n",
    "* Now consider a more realistic error model based on thermal relaxation with the qubit environment\n",
    "* Each qubit parameterized by a thermal relaxation time constant $T_1$ and a dephasing time constant $T_2$.\n",
    "* Note that we must have $T_2 \\le 2 T_1$\n",
    "* Error rates on instructions are determined by gate time and qubit $T_1$, $T_2$ values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u2', 'u3']\n",
      "  Instructions with noise: ['cx', 'u3', 'u2', 'measure', 'reset']\n",
      "  Qubits with noise: [0, 1, 2, 3]\n",
      "  Specific qubit errors: [('reset', [0]), ('reset', [1]), ('reset', [2]), ('reset', [3]), ('measure', [0]), ('measure', [1]), ('measure', [2]), ('measure', [3]), ('u2', [0]), ('u2', [1]), ('u2', [2]), ('u2', [3]), ('u3', [0]), ('u3', [1]), ('u3', [2]), ('u3', [3]), ('cx', [0, 0]), ('cx', [0, 1]), ('cx', [0, 2]), ('cx', [0, 3]), ('cx', [1, 0]), ('cx', [1, 1]), ('cx', [1, 2]), ('cx', [1, 3]), ('cx', [2, 0]), ('cx', [2, 1]), ('cx', [2, 2]), ('cx', [2, 3]), ('cx', [3, 0]), ('cx', [3, 1]), ('cx', [3, 2]), ('cx', [3, 3])]\n"
     ]
    }
   ],
   "source": [
    "# T1 and T2 values for qubits 0-3\n",
    "T1s = np.random.normal(50e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec\n",
    "T2s = np.random.normal(70e3, 10e3, 4)  # Sampled from normal distribution mean 50 microsec\n",
    "\n",
    "# Truncate random T2s <= T1s\n",
    "T2s = np.array([min(T2s[j], 2 * T1s[j]) for j in range(4)])\n",
    "\n",
    "# Instruction times (in nanoseconds)\n",
    "time_u1 = 0   # virtual gate\n",
    "time_u2 = 50  # (single X90 pulse)\n",
    "time_u3 = 100 # (two X90 pulses)\n",
    "time_cx = 300\n",
    "time_reset = 1000  # 1 microsecond\n",
    "time_measure = 1000 # 1 microsecond\n",
    "\n",
    "# QuantumError objects\n",
    "errors_reset = [thermal_relaxation_error(t1, t2, time_reset)\n",
    "                for t1, t2 in zip(T1s, T2s)]\n",
    "errors_measure = [thermal_relaxation_error(t1, t2, time_measure)\n",
    "                  for t1, t2 in zip(T1s, T2s)]\n",
    "errors_u1  = [thermal_relaxation_error(t1, t2, time_u1)\n",
    "              for t1, t2 in zip(T1s, T2s)]\n",
    "errors_u2  = [thermal_relaxation_error(t1, t2, time_u2)\n",
    "              for t1, t2 in zip(T1s, T2s)]\n",
    "errors_u3  = [thermal_relaxation_error(t1, t2, time_u3)\n",
    "              for t1, t2 in zip(T1s, T2s)]\n",
    "errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(\n",
    "             thermal_relaxation_error(t1b, t2b, time_cx))\n",
    "              for t1a, t2a in zip(T1s, T2s)]\n",
    "               for t1b, t2b in zip(T1s, T2s)]\n",
    "\n",
    "# Add errors to noise model\n",
    "noise_thermal = NoiseModel()\n",
    "for j in range(4):\n",
    "    noise_thermal.add_quantum_error(errors_reset[j], \"reset\", [j])\n",
    "    noise_thermal.add_quantum_error(errors_measure[j], \"measure\", [j])\n",
    "    noise_thermal.add_quantum_error(errors_u1[j], \"u1\", [j])\n",
    "    noise_thermal.add_quantum_error(errors_u2[j], \"u2\", [j])\n",
    "    noise_thermal.add_quantum_error(errors_u3[j], \"u3\", [j])\n",
    "    for k in range(4):\n",
    "        noise_thermal.add_quantum_error(errors_cx[j][k], \"cx\", [j, k])\n",
    "\n",
    "print(noise_thermal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Executing the noisy simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the noisy simulation\n",
    "job = execute(circ, simulator,\n",
    "              basis_gates=noise_thermal.basis_gates,\n",
    "              noise_model=noise_thermal)\n",
    "result_thermal = job.result()\n",
    "counts_thermal = result_thermal.get_counts(0)\n",
    "\n",
    "# Plot noisy output\n",
    "plot_histogram(counts_thermal)"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}