qiskit/advanced/aer/3_building_noise_models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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": {
    "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.403378Z",
     "start_time": "2019-08-19T17:00:41.139269Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.420358Z",
     "start_time": "2019-08-19T17:00:43.416062Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.435843Z",
     "start_time": "2019-08-19T17:00:43.432211Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.460191Z",
     "start_time": "2019-08-19T17:00:43.456782Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.482424Z",
     "start_time": "2019-08-19T17:00:43.473779Z"
    }
   },
   "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,  5.99336762e-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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.509521Z",
     "start_time": "2019-08-19T17:00:43.503976Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.794037Z",
     "start_time": "2019-08-19T17:00:43.778223Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:44.659598Z",
     "start_time": "2019-08-19T17:00:44.654818Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:45.882254Z",
     "start_time": "2019-08-19T17:00:45.877630Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:46.615959Z",
     "start_time": "2019-08-19T17:00:46.612055Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:47.444879Z",
     "start_time": "2019-08-19T17:00:47.440612Z"
    }
   },
   "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:48.817405Z",
     "start_time": "2019-08-19T17:00:48.806966Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        ┌───┐          ┌─┐              \n",
      "q_0: |0>┤ H ├──■───────┤M├──────────────\n",
      "        └───┘┌─┴─┐     └╥┘     ┌─┐      \n",
      "q_1: |0>─────┤ X ├──■───╫──────┤M├──────\n",
      "             └───┘┌─┴─┐ ║      └╥┘┌─┐   \n",
      "q_2: |0>──────────┤ X ├─╫───■───╫─┤M├───\n",
      "                  └───┘ ║ ┌─┴─┐ ║ └╥┘┌─┐\n",
      "q_3: |0>────────────────╫─┤ X ├─╫──╫─┤M├\n",
      "                        ║ └───┘ ║  ║ └╥┘\n",
      " c_0: 0 ════════════════╩═══════╬══╬══╬═\n",
      "                                ║  ║  ║ \n",
      " c_1: 0 ════════════════════════╩══╬══╬═\n",
      "                                   ║  ║ \n",
      " c_2: 0 ═══════════════════════════╩══╬═\n",
      "                                      ║ \n",
      " c_3: 0 ══════════════════════════════╩═\n",
      "                                        \n"
     ]
    }
   ],
   "source": [
    "# Simulator\n",
    "simulator = QasmSimulator()\n",
    "\n",
    "# System Specification\n",
    "n_qubits = 4\n",
    "circ = QuantumCircuit(n_qubits, n_qubits)\n",
    "\n",
    "# Test Circuit\n",
    "circ.h(0)\n",
    "for qubit in range(n_qubits - 1):\n",
    "    circ.cx(qubit, qubit + 1)\n",
    "circ.measure(range(4), range(4))\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ideal Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:50.560988Z",
     "start_time": "2019-08-19T17:00:50.415545Z"
    },
    "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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:51.543615Z",
     "start_time": "2019-08-19T17:00:51.536564Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']\n",
      "  Instructions with noise: ['measure', 'u3', 'u1', 'reset', 'u2', 'cx']\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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:52.951874Z",
     "start_time": "2019-08-19T17:00:52.687440Z"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAFLCAYAAAC0rNfYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXxU1f3/8deHsCPIKiQCAkW2IBhwYUcEXKpSyhf3vT8XcKtFC4XWAlWpWtdalYpaq9YqCO7aKkXFBbeAkU3UsglEGxYBQZaE8/vj3MRJmOCdLUzI+/l4zIOZe+985sxMmM89557FnHOIiIjIj6u2vwsgIiJSWShpioiIhKSkKSIiEpKSpoiISEhKmiIiIiEpaYqIiIRUfX8XYH9q0qSJa9269f4uhoiIpJFPPvlkvXOuWbR9VTpptm7dmjlz5uzvYoiISBpp3LjxqvL2qXlWREQkJCVNERGRkJQ0RUREQlLSFBERCUlJU0REJCQlTRERkZCUNEVEREJS0hQREQlJSVNERCQkJU0REZGQlDRFRERCUtIUEREJSUlTREQkJCVNERGRkJQ0RUREQlLSFBERCUlJU0REJCQlTRERkZCUNEVEREJS0hQREQlJSVNERCQkJU0REZGQlDRDmj17Nscccww9e/bk7rvv3mv/fffdR69evejXrx/Dhw/nq6++KtnXtGlTBgwYwIABAzjnnHNKtl922WUcc8wx9OnTh6uuuordu3dXyHsREZH4KGmGUFRUxNixY5k+fTrz5s1j5syZfPbZZ6WO6datG3PmzOGdd95h2LBhTJw4sWRfnTp1mDt3LnPnzuXJJ58s2X766afzwQcf8O6777Jjxw4ef/zxCntPIiISOyXNEHJzc2nbti1t2rShZs2ajBgxgldffbXUMf3796du3boAHHXUUaxbt+5H4w4dOhQzw8zo0aNHqOeIiMj+o6QZQn5+PoceemjJ46ysLPLz88s9/oknnmDIkCElj3fs2MHxxx/P0KFDefnll/c6fvfu3UyfPp3Bgwcnt+AiIpVAIpe/ALZs2UJ2djZjx44t2TZr1iz69etH7969S7X8JUpJMwTn3F7bzCzqsdOnT2fBggVcffXVJds+/fRT5syZw7Rp05gwYQIrVqwo9Zzrr7+e3r1707t37+QWXEQkzSV6+QtgypQp9OnTp+Txxo0bmThxIs899xzz5s2joKCAt956KynlVdIMISsri7Vr15Y8XrduHS1atNjruDfffJM77riDJ598klq1apVsz8zMBKBNmzb069ePTz/9tGTfrbfeyoYNG7j55ptT+A5ERNJTope/PvnkEwoKChg0aFDJtpUrV9K+fXuaNm0KwMCBA3nxxReTUl4lzRB69OjB8uXLWbVqFbt27WLWrFmcdNJJpY759NNPGTNmDE8++STNmjUr2f7tt9+yc+dOADZs2MAHH3xAx44dAXjsscdKaqDVqumrEJGqJ5HLX3v27OGGG25g8uTJpY5p164dn3/+OatXr6awsJCXX365VMUnEdWTEuUAV716dW677TZGjhxJUVER5557Lp07d2bKlCnk5ORw8sknM3HiRLZt28bFF18MQMuWLXnyySdZtmwZY8aMoVq1auzZs4df/vKXdOrUCYDrrruOVq1aceKJJwJw6qmnlmqTFxE50MVz+eull14C4OGHH2bo0KG0bNmy1HENGzbkjjvu4Be/+AXVqlXjmGOOYdWqVUkpr5JmSEOHDmXo0KGltk2YMKHk/rPPPhv1ecceeyzvvvtu1H0FBQXJK6CISCUU6+Wvl156qeTy10cffcS8efN4+OGH2bZtG7t27aJevXpMnDiRk046qaRF8NFHHyUjIyMp5VXSFBGR/Sby8ldmZiazZs3iwQcfLHVM8eWvGTNmlLr8FXnck08+ySeffFLSSaigoIBmzZrx7bff8sgjj/DII48kpbxKmiIist8kcvlrX8aPH8+iRYsA+PWvf0379u2TUl6L1p5cVeTk5Lg5c+bs72KIiEgaady4ca5z7qho+9RlU0REJCQlTRERkZCUNEVEREJS0hQREQlJSVNERCQkJU0REZGQlDRFRERCUtIUEREJSUlTREQkJE2jlwRj/94o9LG3XbgphSUREZFUUk1TREQkJCVNERGRkNQ8KyIiaSvdLn+ppikiIhKSkqaIiEhISpoiIiIhVXjSNLMrzGyFme0ws1wz67+PY0eY2WtmVmBmW83sAzMbto/jzzYzZ2Yvpab0IiJSlVVo0jSzM4F7gClADvAe8KqZtS7nKQOBOcApwfGvAM9GS7Rm1g74E/B2CoouIiJS4TXNMcCjzrlpzrmlzrmrgXxgdLSDnXO/dM7d4pz70Dn3pXNuMpALDI88zsxqAP8EfgssT+1bEBGRqqrCkqaZ1QR6Aq+V2fUa0CeGUPWBsv2KbwZWOuf+Hn8JRURE9q0ix2k2BTKAb8ps/wYYEiaAmV0JtAQej9h2AnAmcGTIGJcBlwFkZmYyf/58ALKysqhbty5ffvklAAcffDDt2rVjwYIFAGRkZNC9e3eWLVvGtm3bAOjcuTMbN24Ewo8jAli6dCnff/89AF26dKGgoICCggIADjvsMMyMlStXAtCkSRMyMzNZtGgRALVq1SI7O5vFixezc+dOALp27Up+fj4bNmwAoE2bNjjnWLVqFQDNmjWjWbNmLFmyBIA6derQuXNnFi5cyO7duwHo3r07q1evZtMmfz7Srl07du3axZo1awBo3rw5jRs3ZunSpQDUq1ePjh07kpeXR1FREQA5OTksX76czZs3A9C+fXu2b9/OunXrKP68GzRowLJlywCoX78+hx9+OAsWLMA5h5mRk5PDF198wdatWwHo2LEjW7ZsIT8/P+Hv6Ztv/J9ey5YtqVmzJsuX+0aJRo0a0bp1a/Ly8gCoUaMGRxxxhL4nfU/6ntLiexpMWBs2bEjK97Qv5pwLXaBEmFkWsBYY4Jx7O2L7ROBs51ynH3n+/+GT5VnOuReCbU2BT4FznHNvBtseBZo65079sTLl5OS4OXPmxPeGIqTb4FsRkQPF/vh9bdy4ca5z7qho+yqyprkeKAJalNl+CHvXPkuJSJgXFCfMQFcgE5htZsXbqgXPKQSynXPLEi+6iIhIBV7TdM7twnfiGVpm11B8L9qozOwM4AngIufcM2V2fwQcgW+aLb69gO9BeySwIimFFxERoeLnnr0TeNzMPgTeBUYBWcBUADN7DMA5d0Hw+Cx8DfN6YK6ZFddSdznnNjrntgGLIl/AzL4FqjvnSm0XERFJVIUmTefc02bWBPgdvll1EfBT59yq4JCy4zVH4ct4d3Ar9hZwXGpLKyIiUlqFr3LinLsfuL+cfcft63HI+BfFUy4REZEfo7lnRUREQlLSFBERCUlJU0REJCQlTRERkZCUNEVEREJS0hQREQlJSVNERCQkJU0REZGQlDRFRERCUtIUEREJSUlTREQkJCVNERGRkJQ0RUREQlLSFBERCUlJU0REJCQlTRERkZCUNEVEREJS0hQREQlJSVNERCQkJU0REZGQlDRFRERCUtIUEREJSUlTREQkJCVNERGRkJQ0RUREQlLSFBERCUlJU0REJCQlTRERkZCUNEVEREJS0hQREQlJSVNERCQkJU0REZGQlDRFRERCiilpmtkZZnZCxOPfm9kaM/u3mWUmv3giIiLpI9aa5qTiO2bWA5gA/BmoAdyRvGKJiIikn+oxHn8YsCy4/3PgOefcbWb2GvDvpJZMREQkzcRa09wB1A/uDwZmB/c3R2wXERE5IMVa03wbuMPM3gGOAkYG2zsAXyWzYCIiIukm1prmVcAufLIc5ZxbF2w/GTXPiojIAS6mmqZzbg1wWpTt1yatRCIiImkq5nGaZlbbzEaa2Tgzaxhs+4mZNU5+8URERNJHTDVNM2uP7/xzENAQmAF8C4wOHl+S7AKKiIiki1hrmncDrwHNge8jtr8ADEpWoURERNJRrL1n+wC9nHNFZha5fTWQlbRSiYiIpKF45p6tEWVba/xYTRERkQNWrEnzNWBMxGNnZg2AycDLSSuViIhIGoq1eXYM8IaZLQNqA08D7YFvgDOSXDYREZG0Eus4zXVmdiRwNtADX1N9EPiHc+77fT5ZRESkkou1pkmQHB8JbiIiIlXGjyZNMxsBvOic2x3cL5dzblbSSiYiIpJmwtQ0nwFaAP8L7pfHARnJKJSIiEg6+tGk6ZyrFu2+iIhIVRNTEjSzAWa2V6I1swwzG5C8YomIiKSfWGuObwDRJmZvGOwTERE5YMWaNA1/7bKsJsC2xIsjIiKSvkINOTGzF4K7DnjCzHZG7M4AugLvJblsIiIiaSXsOM0Nwb8GbKL0Cie7gHeAaUksl4iISNoJlTSdcxcDmNlK4HbnnJpiRUSkyol1Gr3JqSqIiIhIugszI9CnwEDn3CYzW0j0jkAAOOe6JbNwIiIi6SRMTXMmUNzxZ18zAomIiBzQwswINDna/XiZ2RXAr4FMYDFwrXPu7XKOzQTuwK+ocjjwuHPuoijHNQBuAkbih798BUxwzk1PtLwiIiLFKnRaPDM7E7gHmALk4IepvGpmrct5Si1gPXAL8EE5MWvgF8c+HL+mZ0fgImBFMssuIiIS5prmPq9jRgpxTXMM8Khzrnh4ytVmdhIwGhgfJd5K4JqgHCPLiXkxcAgwwDm3K9i2Mkx5RUREYhF2lZOEmVlNoCdwe5ldrwF9Egg9HHgXuNfMfgZsBKYDNzvndicQV0REpJSYrmkmqCl+9qBvymz/BhiSQNx2wPHAk8ApQBvgPuAg4PqyB5vZZcBlAJmZmcyfPx+ArKws6taty5dffgnAwQcfTLt27ViwYAEAGRkZdO/enWXLlrFtmx+m2rlzZzZu3Ag0iqnAS5cu5fvv/fwQXbp0oaCggIKCAgAOO+wwzIyVK1cC0KRJEzIzM1m0aBEAtWrVIjs7m8WLF7Nzp++f1bVrV/Lz89mwwc9B0aZNG5xzrFq1CoBmzZrRrFkzlixZAkCdOnXo3LkzCxcuZPduf17RvXt3Vq9ezaZNm/yH2q4du3btYs2aNQA0b96cxo0bs3TpUgDq1atHx44dycvLo6ioCICcnByWL1/O5s2bAWjfvj3bt29n3bp1FH/eDRo0YNmyZQDUr1+fww8/nAULFuCcw8zIycnhiy++YOvWrQB07NiRLVu2kJ+fn/D39M03/k+vZcuW1KxZk+XLlwPQqFEjWrduTV5eHgA1atTgiCOO0Pek70nfU1p8T4MJa8OGDUn5nvbFnAvV8powM8sC1uKbUd+O2D4RONs51+lHnv8SsL5sRyAz+xyoDbR1zhUF2y4D7gIOcvt4gzk5OW7OnDlxvqMfjP17+KR524WbEn49EZGqYn/8vjZu3DjXOXdUtH0VOU5zPVCEX9A60iHsXfuMRT6wuzhhBpYCdfG124IEYouIiJSosHGazrldZpYLDAVmROwaGrxGvN4FzjGzas65PcG2DsB2fKIWERFJiooep3kn8LiZfYhPdqOALGAqgJk9FrzOBcVPMLMjg7sNgD3B413OuSXB9geAq4B7zOwv+Guak4H799U0KyIiEquY5p4tZmY/AToHD5c65/4b5nnOuafNrAnwO/zkBouAnzrnVgWHRBuvuaDM49OAVfjkiHPuKzM7AZ+QPwG+Bh7BT3YgIiKSNDElzSDhPQwMA/b8sNleAn7hnNtQ7pMDzrn7gfvL2XdclG0WIub7JDZsRURE5EfFOiPQQ0B7oD++x2ptYADQFq2nKSIiB7hYm2dPBAY75+ZFbHvXzC4HZievWCIiIukn1ppmARBtAertwI82zYqIiFRmsSbNPwB3m9mhxRuC+3cE+0RERA5Y8UzY3hZYaWZrg8eHAjvwkxQ8lPQSioiIpIkKm7BdRESksqvICdtFREQqtQpdhFpERKQyiylpmllNM5tsZp+b2Q4zK4q8paqQIiIi6SDWmuaNwIX43rJ7gF/j167cAFyR3KKJiIikl1iT5hnAKOfcX/HLfD3vnLsGmIhfrUREROSAFWvSbA4Ury7yHdAwuP8v4IRkFUpERCQdxZo0V+OX8gL4Ej+tHkBv4PtkFUpERCQdxZo0nwUGB/fvASab2QrgUTSxgYiIHOBimrDdOTc+4v4zZrYGvyTX5865l5JdOBERkXQS1yLUxYJ1LN9PUllERETSWsyTG5hZDzN7zMw+Dm6Pm1mPVBROREQkncQ6ucG5wEdAJvBKcGsOfGhm5yW/eCIiIukj1ubZm4EbnHNTIjea2XjgJuCJZBVMREQk3cTaPNsMmB5l+wz80mAiIiIHrFiT5hvAcVG2Hwe8lWhhRERE0lmYRahHRDx8FfijmR3FD71mewEjgElJL52IiEgaiXcR6suCW6R7gfsTLpGIiEiaCrMItdbcFBERQYtQi4iIhBbP5AanmNlcM1tvZgVm9paZ/TQVhRMREUknsU5ucAl+0vb/AuOA3wArgGfN7BfJL56IiEj6iHVyg3HAGOfcXyK2PWxmufgE+kjSSiYiIpJmYm2ebY1fcLqsV4HDEi+OiIhI+opnEeqhUbafAKxKvDgiIiLpK9bm2duBe4NVTd4DHNAPOB+4OsllExERSSuxLkL9VzP7H3AdfhYggKXAGc6555NdOBERkXQSOmmaWXV8M+xc59yzqSuSiIhIegp9TdM5VwjMAuqnrjgiIiLpK9aOQHlA+1QUREREJN3FmjQnAXeY2XAza2VmjSNvKSifiIhI2oi19+zLwb+z8D1ni1nwOCMZhRIREUlHsSbNQSkphYiISCUQKmmaWV3gT8BwoAYwG7jGObc+hWUTERFJK2GvaU4GLsI3z/4TPyvQAykqk4iISFoK2zw7Avh/zrmnAMzsH8C7ZpbhnCtKWelERETSSNiaZivg7eIHzrkPgUIgKxWFEhERSUdhk2YGsKvMtkJi70gkIiJSaYVNegY8YWY7I7bVBqaZ2fbiDc65YcksnIiISDoJmzT/HmXbE8ksiIiISLoLlTSdcxenuiAiIiLpLtZp9ERERKosJU0REZGQlDRFRERCUtIUEREJSUlTREQkJCVNERGRkJQ0RUREQlLSFBERCUlJU0REJCQlTRERkZCUNEVEREJS0hQREQlJSVNERCQkJU0REZGQlDRFRERCqvCkaWZXmNkKM9thZrlm1v9Hjh8YHLfDzJab2agy+zPM7MaImCvM7CYzC7vAtoiISCgVmjTN7EzgHmAKkAO8B7xqZq3LOb4t8EpwXA7wR+BeM/u/iMPGAVcC1wCdgF8Gj8en6G0k3ezZsznmmGPo2bMnd9999177d+7cyS9+8Qt69uzJkCFDWL16dcm+xYsXc8IJJ9C7d2/69u3Ljh07AJg5cyZ9+/alX79+jBw5kg0bNlTY+xEROVBVdE1zDPCoc26ac26pc+5qIB8YXc7xo4B1zrmrg+OnAX8Hro84pg/wonPuRefcSufcC8ALwLEpfB9JU1RUxNixY5k+fTrz5s1j5syZfPbZZ6WOeeKJJ2jYsCG5ubmMHj2aSZMmAVBYWMjll1/OnXfeybx583jxxRepUaMGhYWFjB8/nhdeeIF33nmH7Oxspk2bth/enYgcKJJ9cr9161YGDBhQcmvfvj3jx6d/XafCkqaZ1QR6Aq+V2fUaPvFF0zvK8f8GjjKzGsHjd4BBZtYpeJ0uwPH4Gmray83NpW3btrRp04aaNWsyYsQIXn311VLHvPLKK5x11lkA/OxnP2Pu3Lk453jjjTfIzs6ma9euADRu3JiMjAycczjn2L59O845tm7dSosWLSr8vYnIgSEVJ/f169dn7ty5JbdWrVpx2mmn7Yd3F5uKvO7XFMgAvimz/RtgSDnPaQHMjnJ89SBePnArUB9YYmZFwb6bnXP3RwtoZpcBlwFkZmYyf/58ALKysqhbty5ffvklAAcffDDt2rVjwYIFAGRkZNC9e3eWLVvGtm3bAOjcuTMbN24EGoX6AIotXbqU77//HoDVq1fTsGHDknI0aNCAvLy8ksdNmjRh3bp1bNq0ifnz51OrVi0aNGjAe++9x5tvvsmmTZsYMWIEX3/9Nf379+fMM8+kTZs2TJw4kd69e1O7dm3atGnDjTfeWBKzTp06dO7cmYULF7J7924AunfvzurVq9m0aRMA7dq1Y9euXaxZswaA5s2b07hxY5YuXQpAvXr16NixI3l5eRQVFQGQk5PD8uXL2bx5MwDt27dn+/btrFu3juLPu0GDBixbtgyA+vXrc/jhh7NgwQKcc5gZOTk5fPHFF2zduhWAjh07smXLFvLz8xP+nr75xv/ptWzZkpo1a7J8+XIAGjVqROvWrcnLywOgRo0aHHHEEaW+py5dulBQUEBBQQEAhx12GGbGypUrS76nzMxMFi1aBECtWrXIzs5m8eLF7Ny5E4CuXbuSn59f0lTepk0bnHOsWrUKgGbNmtGsWTOWLFmi70nfU1p9T88++yxNmjRh48aNNG/enCFDhvDQQw9xzjnnlHxPTz31FBdeeCErVqzg1FNP5brrriM3N5f58+eTnZ1NRkZGyW9Qly5dWLduXcn35Jzjm2++oVatWsyfP7/M9zSYsDZs2JCU72lfzDkXukCJMLMsYC0wwDn3dsT2icDZzrlOUZ7zOfC4c+7GiG0DgTeBTOfc12Z2FvAn4NfAYuBI/HXTXzvnHt5XmXJyctycOXMSfm9j/x4+ad524aZSj5977jnmzJnDn//8ZwCefvpp5s+fz6233lpyTO/evXnmmWc49NBDAejRowezZ8/mH//4Bw8//DD/+c9/qFOnDsOHD+e3v/0tffr04fTTT+euu+6iTZs2jBs3jkMOOYTrr78eEZFYPf/88/znP/8p9TuVm5vLbbfdVnJMnz59mDFjRqnfqddff53p06eTl5dHQUEBGzZsYMSIEVxzzTWl4t92221s3bqVG2+8kbIS+X2NV+PGjXOdc0dF21eRNc31QBG+9hjpEPaufRb7upzjC4Hini1/Am53zj0VPF5oZofhOwLtM2mmg6ysLNauXVvyeN26dXs1pRYfc+ihh1JYWMiWLVto1KgRWVlZ9O3blyZNmgAwdOhQ8vLyqF+/PgBt27YFYPjw4VGvQYiIhBGtcmVmoY4pLCzk/fffL3Vy3717dwYOHFhy3KxZs5g6dWryC54CFXZN0zm3C8gFhpbZNRTfOzaaeezddDsU+Ng5tzt4XBefjCMVUUnGoPbo0YPly5ezatUqdu3axaxZszjppJNKHXPyySfz1FP+nOD555+nf//+mBmDBw9m8eLFbN++ncLCQt577z06depEZmYmy5YtY/369QC88cYbdOjQocLfm4gcGGI5uQfKPbmvW7duycl9sUWLFlFUVMSRRx5ZMW8mQRWdWO4ELjKzS8yss5ndA2QBUwHM7DEzeyzi+KlASzO7Ozj+EuAi4PaIY14EfmNmp5hZGzP7Ob6X7rMV8YYSVb16dW677TZGjhxJr169GD58OJ07d2bKlCklHYLOO+88Nm7cSM+ePXnggQeYOHEiAA0bNuSKK65g8ODBDBgwgG7dunHCCSeQmZnJ2LFjOeWUU+jXrx+LFi1izJgx+/NtikglloqT+2IzZ85kxIgRFfp+ElFh1zRLXtDsCmAskAksAn7lnJsb7HsTwDl3XMTxA4G7gGxgHXCrc25qxP76wI3Az/FNt/nAU8AfnHM79lWWdLimKSJSGbz++utMmDCBoqIizj33XK677jqmTJlCTk4OJ598Mjt27GDUqFEsXLiQRo0a8dBDD9GmTRsApk+fzl133YWZMXToUCZPnlwSNycnh6effrrc1rB0u6ZZ4UkznShpioikt3RLmpXiup+IiEg6UNIUEREJSUlTREQkJK0EkuZ0vVREJH0oaYqISEKq0sm9mmdFRERCUtIUEREJSUlT0lK8a/etXr2arKyskjX6ImdCuummm+jatSutWrWqsPchIgcWJU1JO4ms3Qd+KafiNfruvPPOku0nnngis2eXXWlORCQ8JU1JO4kszL0vRx99tBbjFpGEKGke4OJt5iy2Zs0aWrVqxb333luy7f7776d379706dOHSy65hB079jnFb8zy8/NL1uQDv3pC8aK50Y6pXr06DRo0CBYE9020AwcO5NRTT2XevHlJLZuIVG1KmgewRJs5ASZMmMDgwT+snL5u3ToefPBB5syZw3vvvUdRURGzZs1KarkTWbuvefPmfPrpp7z11lvcdNNNXHrppWzZsiWp5RORqktJ8wCWaDPnyy+/TJs2bUot4wN+rbwdO3ZQWFjI999/n/Qmz0TW7qtVqxaNGzcG4Mgjj6Rt27b897//TWr5RKTqUtI8gCXSzLlt2zbuuecexo4dW+r4rKwsrrrqKrp160bnzp1p0KABxx9/fFLLncjafevXr6eoyK9JvnLlSpYvX16yPJGISKKUNA9giTRz3nLLLYwePZqDDjqo1L5vv/2WV199lQULFrBkyRK2b9/O9OnTk1ruRBbmfu+99+jXrx/9+/fnoosu4o477qBRIz9bycSJE8nOzmb79u1kZ2dzyy23JLXcInLg0zR6B7BYmjkPPfTQUs2cubm5vPDCC0yaNInNmzdTrVo1ateuTbNmzWjdujVNmzYF4NRTT+XDDz/kjDPOSGrZhw4dytChQ0ttmzBhQsn92rVr8+ijj+71vGHDhjFs2LCoMSdPnlxq8VsRkVippnkAS6SZ85VXXiEvL4+8vDxGjRrFr371Ky699FJatmzJxx9/zPbt23HOMXfu3HJXXJfkSUUv6KuuuooOHTrQp0+flJdf5EChpHkAS6SZszxHHXUUw4YNY9CgQfTt25c9e/Zw4YUXVsTbqbJS0Qsa4JxzzmHGjBmpLr7IAUXNswe4eJs5I/3mN78p9Xj8+PGMHz8+aWWUfYvsBQ2U9IKO7NX8yiuvMG7cOMD3gh43bhzOOcyspBd03bp1S8Xt06fPXjVSEdk3JU2pdKrSMkQQvRd0bm5uucdE9oKuXbs299xzD7NmzeIvf/lLhZa7Mps9ezYTJkygqKiI888/n2uvvbbU/p07dzJ69Gjy8vJo1KgRjzzyCK1btyY3N5df/epXgO9kN27cOE499VTATwry+OOPY2Z06dKFvxAD7NUAACAASURBVPzlL9SuXVvlrmTUPCuS5lLRC1rKl0hzeOfOnZkzZw5z585lxowZjBkzhsLCwgqZFKSylruyUdIUSXOJTPaQm5vLpEmT6N69O1OnTuWuu+5i2rRpFVr+yiaRSUHq1q1L9eq+AW/nzp2lTm5SPSlIZS13ZaPm2SqsqjVzVlaRvaAzMzOZNWsWDz74YKljintBH3PMMXv1gi52yy23UK9ePS699NKKfguVSiLN4U2aNOHjjz/m6quvZs2aNTzwwANUr1691KQgtWvXZtCgQUmfFKSylruyUU1T4hbvMIjc3NyS9S779+/PSy+9VOp5RUVFDBw4sOSMuKpLRS9ogEsuuYQTTzyRL7/8kuzsbB5//PFUv5VKIZHmcPA9zOfNm8fs2bO5++672bFjR4VMClJZy13ZqKYpcSm+fjJr1iyysrIYPHgwJ510UqkenZHXT2bOnMmkSZN45JFHSq6fVK9ena+//poBAwZw0kknlTQPTZ06lQ4dOrB169b99fbSTip6QT/00ENJK9+BJJFJQSJ17NiRunXrsnTpUlatWpXySUEqa7krG9U0JS6pun6ydu1aXn/9dc4///yKezNVXLJbDNasWcOwYcM49thj6d27N1OnTq3Q95OoRCYFWbVqFYWFhQB89dVXfPnll7Ru3bpCJgWprOWubFTTlLik4voJ+NrTpEmT+O677yruzVRhqWoxuPHGG+nevTtbt27l+OOP57jjjttrtZx0FdkcXlRUxLnnnlvSHJ6Tk8PJJ5/Meeedx6hRo+jZsyeNGjUqqbW///773H333dSoUYNq1arxpz/9iSZNmtCkSZOSSUEyMjLo1q1b0icFqazlrmyUNCUuybp+smzZMq688kqGDBnCW2+9RbNmzTjyyCN55513UlNwKSWRiRMiJ0uIbDFo0aJFSbNg/fr16dChA/n5+ZUmaUL8zeFnnnkmZ555ZtSYFTEpSGUtd2WipClxScX1kw8++IBXX32V119/nZ07d7J161Yuv/xy/vrXv1bIe6qsYukFDaV7QqeqxaDY6tWr+fTTT+nZs2esb0skLemapsQlFddPfv/737N48WLy8vJ46KGH6N+/vxJmiqWix2Wx7777jgsvvJApU6bQoEGDJJdcZP9QTVPikorrJ1LxUtFikJOTw+7du7nwwgsZOXIkp512WoW8l4pSWcc3V9ZypxslTYlbKq6fFOvXrx/9+vVLSjmlfIlMnLBq1SoOPfRQqlevXqrFwDnHNddcQ4cOHbjyyiv30zsTSQ0lTZEqLBUtBu+//z5PP/00Xbp0YcCAAQDccMMNe51giVRGSpoiVVyyWwx69erFxo0bk15OkXSgpCkpoesnInIgUu9ZEZEKFO8MTG+88QaDBg2ib9++DBo0iLlz55Y856abbqJr1660atWqwt5HVaWapoiUK5ExoLK3RGZgatKkCU8++SSZmZksWbKE008/ncWLFwNw4okncskll3D00Ufvr7dWZaimKSIpk4pa1SeffELfvn3p2bMnv/nNb6KOI01XiczZ3K1bNzIzMwG/aPSOHTvYuXMnAEcffXSVX+eyoihpikhKFNeqpk+fzrx585g5cyafffZZqWMia1WjR49m0qRJACW1qnfffZf77ruP0aNHlzzn+uuv56677uLWW2/liSeeoEuXLjEl5I0bNzJs2DBatWrF2LFjSz1n5syZ9O3bl379+jFy5Eg2bNiQ1M8k2gxM+fn55R4TOQNTpBdeeIFu3bpRq1atpJZPfpySpoikRCpqVV9//TVbt26lZ8+ejB07lt/97ncMHTo0poRcq1YtJkyYwB/+8IdSxxcWFjJ+/HheeOEF3nnnHbKzs5k2bVpSP5NEZ2ACWLp0KZMnT+bOO+9MatkkHCVNEUmJVNSq8vPzS+bHbdu2Ld27d+d///tfTAm5Xr169OrVa69amnMO51zJMlhbt25NepNnLDMwAXvNwLR27VouuOAC7r//ftq2bZvUskk4SpoikhKpqFUVHx+ZbM0s7oQcqUaNGtx+++307duXLl26sGzZsqSv65rInM2bN2/mrLPO4oYbbqBXr15JLZeEp6QpIimRilpVVlYW69atK0mekTFjTchl7d69m7/97W+89dZbLFmyhOzsbO66665Y3/Y+Rc7A1KtXL4YPH14yA1NxTfm8885j48aN9OzZkwceeICJEycCMG3aNFasWMHtt99esvh3QUEBABMnTiQ7O5vt27eTnZ3NLbfcktRyyw805EREUiKReW3Lq1W1aNGCgw46iM2bN7N27VqeeuopLrvsMhYtWhTXRPORFi5cCFCSoIcPHx61g1Gi4p2B6frrr+f666+PGnPy5MlMnjw5qeWU6FTTFEmieIdYlNejc/v27Zx55pkce+yx9O7du1L9MKaqVnX77bczdepU3n77bZo2bcqAAQNiauYsT2ZmJsuWLWP9+vWAH/bSoUOHpH8uUrmppilVzuzZs5kwYQJFRUWcf/75XHvttaX279y5k9GjR5OXl0ejRo145JFHaN26NRs3buSiiy5iwYIFnH322dx2220lz7npppv45z//yddff01ubm7MA9eLe3QuXbqUpUuXlirPVVddRf/+/dm1axfDhw/n9ddfrzSTn6eiVpWTk8O8efN4/fXXmTBhAr17945ponmA7t27s3XrVnbv3s3LL7/MzJkz6dSpE2PHjuWUU06hRo0atGrVivvuuy85H0RImn4y/SlpSpWSyIws+0psJ554IkcddRTnn38+bdq0ASjp0RkZ+5VXXmHcuHGA79E5bty4Uj06ly9fXipu3bp16d+/PwA1a9akW7durFu3LhUfTaUTb0IGyMvLi7r94osv5uKLL05aGeXAo6QpVUrk2EFITmIDPyPL888/X6r5r3hoRKTyenSGWYR78+bN/Pvf/2bUqFExv+90pCn6pDLSNU2pUpI1djCaZAyxKE9hYSGXXHIJl112WUnCF5GKp5qmVCmpTGxZWVmlnruvIRZhe3QWu/baa/nJT35Sajo5KZ9qsZIqqmlKlZLo2MF96dGjB3v27Ilr4Pq+3HzzzWzZsoUpU6aEeo8ikjqqaUqVksjYwR9TvXp1atasyciRIykqKkpKj8769etzxx13cPjhh3PccccBcMkll3DBBRck9XMRkXCUNKVKiRw7mKzE1qlTJyZOnMgzzzzDrl272L59O+effz7XXXcdkHiPzjDXU0WkYihpSpWTiqEKmpFFpGpQ0hSpAOqYInJgUNIUiaAZWURkX9R7VkREJCQlTRERkZCUNEVEREJS0hQREQmpwpOmmV1hZivMbIeZ5ZpZ/x85fmBw3A4zW25me81WHWtMERGReFRo0jSzM4F7gClADvAe8KqZtS7n+LbAK8FxOcAfgXvN7P/ijSkiIhKviq5pjgEedc5Nc84tdc5dDeQD5c1CPQpY55y7Ojh+GvB3IHJ12lhjioiIxKXCkqaZ1QR6Aq+V2fUa0Kecp/WOcvy/gaPMrEacMUVEROJSkTXNpkAG8E2Z7d8ALfY+HILt0Y6vHsSLJ6aIiEhcLNragSl5IbMsYC0wwDn3dsT2icDZzrlOUZ7zOfC4c+7GiG0DgTeBTHzSjzXmZcBlwcOOwLLE3125mgLrFTvlcRVbsRU7/WJXxjIXO8w51yzajoqcRm89UMTeNcBD2LumWOzrco4vBDYAFmtM59yDwIPR9iWbmX3snDtKsVMbV7EVW7HTL3ZlLHMYFdY865zbBeQCQ8vsGorv8RrNPGBIlOM/ds7tjjOmiIhIXCp6wvY7gcfN7EPgXXzv2CxgKoCZPQbgnCteYXcqcJWZ3Q38FegLXAScHTamiIhIslRo0nTOPW1mTYDf4a9JLgJ+6pxbFRzSuszxK8zsp8Bd+CEk64BrnHMzY4i5P6WyGbgyxq6MZVZsxVbs9Iqb6tj7VGEdgURERCo7zT0rIiISkpKmiIhISEqaIiIiISlppoiZWcT9SvM5lym37evYdFKJy11p/jZEREkzZZxzLpgbF+fcnuLtyfhBT+UPbVDuBsX3kxnbzDKSGS9SJS73HjNrHrxObTNLWo92M8tI1QlEcdzKdIIikgzqPZsCZtYCGAn0wE/V9z4wwzn3fpJfx/Df4Z5o+2JNHmbWHj8GdhDQBj+5xIvAHOfc/+KNG+V1qkHpk4kqWu4jgQuAn+JntfoYeB2YDXzinCtKYrnNOVeUSJwyMasD9Zxzm5MVMyJ2RjLLWiZ2faAe8D+gLrA92vcZZ2yVe+/YmUB94Hv8POFfO+d2JCl2dedcYTJixfS6SprJZ2YvA+2BpfixpX2ArsCXwC34+XTj+iM1syuBxcAHzrnvI7ZXw1ey4v5Czewt/B/42/hpCI8H+uGnLLwHuCPeH3IzuxmYD7zmnNsasT0D2FNFy50LbMUn+G+AU4JbEfAo8Dvn3LY4y/03/MnadOfcpojt1YNyx/2Da2YnAb8AugE1gf8AzwFvOOe2xxs3yutEPUkprt3G8ZmcA1yMP5kFf3L1CvAf59yy4thJOEnJCIqXrKRWWct9Bf7vpCuwGz972zxgDjDXObczieUmVYl/L8453ZJ4w/9gFwAtg8e1gYPxsxlNA5YDY+KM3Q/YA8wFngCuAbqXOaYWcAOQGWPsQUG5G5bZfigwET8x/v1ARgLlXoBPbLcDA8scUwf4M9C6ipT7uKDctaPs+3/AKuBVoH4C5f4cWA3MAH4WpdyPAF3iiL0Mv/zeFcHf2gf4RL8IOD2ev+0g9hHBdzUEqF5mXwbBSX6csQcAK4HHgJOBC4PPdyfwFXBlArGPAl7Cty7VKLOvehUt93HB/71bgc5B2acBXwTbby77HccQuy+QB1wC1IxS7mr4eckbJ/Ieyn39ZAes6jdgEr5ZMNq+BsBvge+AHnHEvgs/p+4fgj/2j4A38FMMXoBvmjw2+ME8KMbY1+NrJnWCxxlAtYj95wGbgePjKPdtQTlHAX/Br1LzCX5t1PH4M9FjgnLHlCQqcblHBbGaB49rRf4AAAPxtc8RcZT7pqCMPws+n5fwP7yfA/cBvYCj4yz3M8C0KNs742dpWQtcEOf/nb/jm/E+wjdRTyr7/wS/xu5fY/0xBKYDD0bZXjd4nQ3ADQmUe1fw+f4XeIi9T676AE8R48lbJS73k+WUu0bwt/8/4OEEyl0E5OMX7/gXcGqZY/oG2+NKzPu6VfTcs1XBbOBKMzvJOfevyB3OuS1mdiv+B3EgvtkvFk3xk9X/PuhkdDx+cvocfNPNGUAnfLPNdzHGfgUYB4wA/uGCpo7i5hPn3BNmdnpQ7jlxlHu5c25q0OTWA//jdzQwDPg50Bb4l4toAj3Ay/0S/gTqXOBO59zOoNzFzb5vBc3O/YFZMcauh/9Bedk5V2hmM/EJvje+pvgUvib+ahzlboy/7EBQ3upAkXNuqZldg/9RvNbM/uWC68kxOAJ/YrgGXwsaCvzMzFbja7Yv4k8O+7vglzEGNfE/tMXlroX/nLcDk4Im37PM7Ann3IoYY3fA15w+xp9EDQCeMLNNwAvA4/jvuauLvQmxspZ7F9DIzGo753aYWW2g0Dm3G5hqZruBX5tZtnNucYyx2+CnTX0pKPfpwIwg5gx8y89ZQJZLxTXPZGfhqn7DN3s9hr9+OR7/Q1svYn9D/I9CPDWIrsDJUbYfgu8I8yi+9vDTOGJnAHfgz1wfxHdOaRyxvwW+OWhkHLFbAMdF2X4wvnn1D0ko98bKUm5+6EswDt/qMBt/7Scz4ph2Qbljbu4EDgJ6lfO32QXfrBXv530Nfsm+DuW8p1bB335MLSnA4cBbwC+Cx/XxJwzj8LWtD/E/7nso09QcMv65wd92n7J/P8G/jfG18d4xxm2D//EeHTyuje/8dwb+evpHwfe4BxhWhcp9In45yDPKbK8e/FsXf+lgYIxxs/A14suLPwegEf5E9jdBuXcG5T4t1nKHuakjUAqYWSt8whwCbML/h/8Gf8bYG+jonOsYZ+zqztcequHb7ks6dZjZacATzrmD44xdC7gaX4uqjU/um/DNm8fim0B7lB8h9OuU6rQUlPufzrmD4oxXFz+h/8/xiWE1PonGXe6yHRQiPu+iZJU7iPFz/A9jW/x/9M34WmIOsNE5NyDe2BGvUfa9DMN3EKodR6xm+Ka3dvga67+BBS6osZrZCODvzrn6ccRuj29a/7zM9ub4k8/L8ScxDWOMa/ja9zTgJPw1wZn4Fplvg+/2THxzYjzlbo4/MV5eZnt9/Od0BXBmguU+Gd+qUlnKXQuYgv89ycWf0M9wzm0ws6b435i7nXMN4ih3E6Cuc+6rMtur4xPo1fiFPWIqd+jXV9JMHTPrhr+m1gd/gbohvvfYnc65hUl8HcNf+H4GaOCcK7sGaazxOgGnAkfiz2Rb4GtDD7jYm4B+7LWq4Tt/NHbOnZFgrNbAafhrdk2B5qSg3BGfd7LK3QrfbJqNbzZtib8e87iLvYnzx17LgMn4a6mXxxmjPf4HdSC+V+RaYDv+B74T8JJzbmyC5Szu+FMYse05YJtz7tw4Y9bHLy14Cr51xuFPUjLwfytPOecmJVLu4HXKnqQ8B+x0zp0ZZ7x6+N6zPwvKXZjscu/j84673EGMU4Fz8L8lh+ArD4X4pPqQc+72RMpdzms+hz+5/b9kxwYlzaQJamnd8NfWtgKf4q8/fh3s74hvRtnlYvzQI2L/HP+fZTG+CWy1c267mVVzfpB8deBg59yGOMpf3IFmd5ntzZxzBbHGixLbuXK6sgf76zvnvo0h5kH4azBnA9/ie3TmEixQnki5y8TeiO/x9zmw0DmXn0i5I55bHcCVueZiZrVccH0zXj82rCQ4UannYr+eWTZOF/xJShf8yVUd/DXJN1zyh540wrfYXOCcezfBeB3xLT5t8ScotfEdvXKdX9g+acysIf6a9Djn3Edxxqjl/PCMFvi/y2x8M3gtEiy3mdUv+3cQfN4NEil35ImD+bGaXfBLP7bFf95/Az53SR4mEvzfvRe4xzn3STJjl7yGkmZymNmf8QkzH/8D0gZ/7ec54DaXwPqeUWIfhh//+Sz+j2P5Pp7+Y7F7Oudyy2yriU9yu8t5WiKxEx7fGMT5O/4H5Av8Z9IS2ILvkXqfc+6tJMY+FJ+YF+B7jr6RQOx+zrl3ymwr9XlbnIO2y4ldKoEWn2DFEbsV/rrrMcAK/Inbu865T4PvtI6LvfNZ2dhH43txLsMPX1nonNtU/ANsZgfF8hplfrj3OkmJ97MoJ/a+TlLqxnoSYWadgTH4Zvrl+M/8XeAtl+CEEmVif4m/nPEJ8HZkk6eZ1XERY8HjeJ2Ex2DG+boJn3juk0vBhdKqdsOfRW0BTgCaBNua4S9Mr8B3o7+cOMYMhYx9Gb65MNZu+Ifjr6MtAu4EcsrsN3zvvWMoMx4qSbFrxBm7C74234sfOkQcDFyKr40U4bvjxzy2L2TsiZQZ2hIydqfgM9mKvx7Yt8z+avjaw2kEQ1GSGLv4u4wndlt8T++l+O7+8/FNskuAqUDbBP7vRIu9Bt9Scx/wk7LvI4bYzdh7CEXxZ1zcIcWIbwxvtNhGmfGNEX9DsZT7J/gTh7nAH/Enx+/jxyY+AwxJ4POOFnte8LlPB05I4PNuDpxPREe8iM+8uIKWAdSKo9xRY0c5rnas5Y65LKkKXJVuwAT8DBfFj8sOzJ4CfIbvAp1OsX+Pr00Vj/9cG/znHAu0Co45NPgxbplGsa/F13KKH5cd4DwK3/OvQyxxKyD2BHxtdTx+soRCfGvE7QTJAX/dZ0/xZ5Qmsafih3u0iNjWGn/itgrfSzLmHq0hYxckEPu+4P1+HdzvUmZ/RvBapxP7OMQfi10tInZMYwWBB4LPpH7Etub465pz8deP/1+cn8mPxd6WQOx7g89kI37ox08pkyCDz+T6stv3Z+yY32cqg1eVG/5a4xdA+4ht1fnhrKf4bPqXaRb7H/ju5S3w10kuxHfn/hR/tv8ivlv64jSLPQifuAaX+UyKJzhoArwDTEyz2Pfhr0E1Dm4D8Cc9S4MfhE/xY0nj+UxSGftt4NfB/RrsfeL2T3yP1JIaRZrE/hDfWWsivpa2B98cOYGgxoKf0Wh5HJ9JKmO/AkwO7mdQJqHjh1i9j+9Bmk6x5+FrrxfjO+DtxF9GupdgCBJwI/BlOsWOuSypfoGqcAt+SJfia3xnEOVMJ/iPdXm6xMYngnOA8WW2N8Z3krgK31yzhxjPPFMZO4hTGz+xeT6+5lcnyjGfEMcUY6mKHfxA/RS4osz2mvgz5FPxQwv2ABenS+wgzqTgPUfWTmrww4lEP/y1yL3Ghu6v2Pjr/v/G95athm/VOBF/crE6+CzexddcfpUusYP4vwzidCrzXdYM7nfBX5oZlC6x8eMnZwCXBY+r4y8ZjAu+3yJgIb4mG9MJfipjx3NLafCqdAu+2Kfx13lew5/1HI+fdeMefDNTvXSLHfEaNaJsGxH8AMR81pnq2PiemncGPwDL8NfDRuCv/f4TX1tMu9gRr7HX9dDghzcZn3dSYwM98Wf184ky0B0/KH5HOsXG9/68kOhzBf8EfwL6Jr4Ze68To/0VO4jTFt/UvoJgsocy+7viZ9yJ5/NOSWz8cKPTgGOj7KuL77swPc7PO2Wx47mp92wSBYNuT8H/uLbD/4dvhJ/p5K/OuafSJXZ5PQfth2nRnJndDhzlnDsuXWIHcTKcX7XkIHxNpD9+EoOj8Gf+s/FjwF5Jl9jFYzujfS4Rx0zCz+xyYjrFDr6v9vi5eHvhr2G+g2827QL8H7DSxTheNZWxy74Ovhmy7PCefwCHxvM3mOrYwZjSP+InvqiBP1mejU9q/fBLx12QbrEjXmOvnrNm9ij++nr/dI0d6vWVNBNjZi3xy4CBbx5Ygu/R2g4/ndl2YL1zbmOaxjZ8DWSZC8aUBvsNP5h6rYtxnFYqY5fzejXxvRm/xzevbnbObUs0bqpjR3mt44ACF/tcnBUS2/z8oUOC27H4a9UbgIfxEzEkMqwqZbEjXsPwTdlF+FrhXOCPzrmZ6RI7iFMtOHGrjZ+PdwC+ZakHvob4BDAr8v9UGsTe59KEZlYHeB4/0ciz6RI7HkqaCTCz0fjxZd3xCWw5vunuTeAZV2aapzSNvQ3fgWEN/mL78y5Yoy8NY5caN/Zj/5nSNXYypTh2NfzJTTN8Ivgvvif3luBH1+GvRa5P49h18T2333IRsyuZnzBkiHPu5XSJvY/XLBnbbGYHuyQu/J3K2GVepwa+ZWleZYod9fWUNOMTNJd+ie9t9gD+P9EQfO/LLvj/TNc455bEOsh3P8buFMS+Nogd04ruKY7dCN/h6WX82fB7xe87MsEFA7fXuBhmu9mPsSMHyHcG8l1ssyKlMnZ9fC1vEL61YC2+5WAbvinvH865L4JjY5okoIJjr8En4O/xlzKecM59FjZeBcaugb/euMpFGZifyEQB+zN2IlIZOyEuxRdND9QbflLgD8rZ1w/flX450FSxkxZ7Jz9MMPBf/CojHSOOaYXv5NBOsROO/Vt8Qj46eNwJP4/yVPx0hS8CzWL9Hvdz7I/wS16lY+xr8ScNf8N3emnB3sNBGuAnbt+rY10liH0KsU9ikrLYidwq5EUOxBt+hp8l+LXmYO9FhFsH+89R7KTEnhb8OB2Cn4f3j/jxq0X4cWWX4Qf2f6fYSYn9NjAmyvYMfphi8F9x/t9R7L1jzMMveP528P2twPfg7oefTxr8EKj3FTvx2IncKuyFDrQbfvzkIvyA/cgxZtUi7r8HjFXsxGLjk++vgN+W2X4wvvn3EfywhT3EuIq9YkeNXR3fvP4uQc2JMgPhgcHBd91dsROO3Qzfceic4HFL/CLLnwffXy5+TOJn+LmmFTuB2IneKuyFDqQbwTyvwHD8VF9b8dc6evLD9FnnBdvbKHZisYP4tQimWiPKvK/AccQxJZ9ilxu7F76591aizFWLb/b9Dj+sQrETiA1k4k+AToyyLwc/acKG4LtU7ARjJ3qrsBc6EG/49TG74ZsI/h38h/kO3xlmOTBJsROPzQ8d1tqV/bGK2Pd74puyTLH3jl0NX7O6FD9xxiZ8U/AQ/Pjg04HHgI8UO/HYQfw6REw2XnyL2H8zfrFvxU5C7ERu6j0bIzM7BD/b/nX4gdjf45eNehv4AD9Y+Cf4hPGFi+EDVux9xh4D/A8/60c+flqtWc65bcH4s0uBdc65lxQ7/thRXqshfrq44oWEt/JD56M/Ouc+UOzkxC6vF6uZ1cXPmPQ359ytip2c2PFS0oxRMPNENr6H30b8fKpH4Ke0+x/wuwT+0yh2uNg5+J6La4A/OedeU+ykxW4AbI38oQqG3dTGT6jRFdgWz/ep2OFiRzmmNnAm8E8Xw2LTip0iFV21rcw3fPPAd8CAMtsOC77A1/DNkD0UO6Wxi5dceg0/N6xiJyF2EOuvwP/Dn/Q0KOeYRsWvq9gVErthCr/LKhU7Gbf98qKV9YY/u19IOSsu4DtmfIxvolHs1MeuqdhJjX02vmPFt/jrz3/FT1Tfnh9WHTkIeA44QrFTEvvn+EsZxbGLp4jrqtiJxU7WrcJfsDLfgi/rP/jxQ4cTfTWJq/ETHiu2Yle22MXjPtvhF/NdiJ/CcQG+08XxwGhgl2IrdmWLnazbfnnRynzDdzv/JPjRugjfzbxesK8u8Ax+Oi3FVuxKExvfM3QCcEuZ7dnA3fhrpevxnY4eVmzFrkyxk3nbLy9a2W/4C/9P43uJrsd3yHgEv/7iB8TYTKPYip0OsfFLzXUK7tekzPU5/DXqPcCRiq3YlS12sm7qPZuAoOv/KfgB/Tvws4HMcHFO2qzYip1OsYP41fA/XEVmdil+9pW6iq3YB0LsuMqjpJkcsa7GoNiKXZliB/HH4KeN+5NiK/aBFjt0GZQ0RSSMYKmmolQkZsVW7P0dO3QZlDRFRETCqba/CyAiIlJZKGmKiIiEpKQp2lq+nQAAAB1JREFUIiISkpKmiIhISEqaIiIiISlpioiIhPT/AXzErT0qOKpBAAAAAElFTkSuQmCC\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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:54.577456Z",
     "start_time": "2019-08-19T17:00:54.491018Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u2', 'u3']\n",
      "  Instructions with noise: ['measure', 'u3', 'reset', 'u2', 'cx']\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": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:55.689241Z",
     "start_time": "2019-08-19T17:00:55.515394Z"
    }
   },
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:01:16.716582Z",
     "start_time": "2019-08-19T17:01:16.709462Z"
    }
   },
   "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:01:16 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
}