qiskit/advanced/aer/3_building_noise_models.ipynb

{
 "cells": [
  {
   "attachments": {
    "qiskit_header.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![qiskit_header.png](attachment:qiskit_header.png)"
   ]
  },
  {
   "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: ['u1', 'u2', 'u3']\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: ['u1', 'u2', 'u3']\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: ['u1', 'u2', 'u3']\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 will 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 resetting a qubit reset to 1 instead of 0 with probability `p_reset`.\n",
    "* When measuring a qubit, flip the state of the qubit 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: ['cx', 'measure', 'u2', 'u1', 'reset', 'u3']\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": "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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 is 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 times 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: ['cx', 'measure', 'u2', 'reset', 'u3']\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": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAFOCAYAAADkYUZrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3de3wU5dn/8c9lIicBBSrHoIBB5KBgDEVsCthHS6WVPir1UFtPqPVcpf3p4+PZPlVr1Xpqq7Wtx1Y81Aq1FWltAdEIBhQLWIgVFCKHClhAESRevz/uCV2WBGZDdjKQ7/v12leyM7Oz391N9pq55557zN0RERGRHdujsQOIiIjsKlQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYkp8aJpZheY2SIz+8TMZpnZF3ewfDMzuzF6zEYze8/MLsla5gQzmx/Nn29mx+X3VYiISFOUaNE0s5OAu4CbgEOBV4DnzWy/7TzsceArwLlAH+AbwJsZ6xwKPAH8BhgU/XzKzIbk4zWIiEjTZUmOCGRmM4A33f2cjGmVwNPufmUty38ZeAo4wN0/qGOdTwDt3f3ojGl/Af7l7qdsL8/nPvc579GjR71ei4iI7J5mzZr1gbvvW9u8wqRCmFkz4DDgtqxZk4Ej6njYfwOvAePM7DRgA/A88L/uvj5aZihwT9bjXgAu2lGmHj16UFFREe8FiIhIk2Bm79Y1L7GiCXwOKABWZE1fARxVx2N6AWXARuAEYB9CgewKjImW6VzHOjvXtkIzO5fQ1EvXrl2ZMmVKeKJevWjTpg1z5swBoEOHDvTv359p06YBUFhYSFlZGbNnz2bt2rUAlJaWsmLFCpYsWQJA7969ad68OXPnzgWgY8eOHHjggUyfPh2A5s2bM3ToUCoqKli/PtT8IUOGsHTpUqqqqgDo06cPBQUFzJ8/P7y4zp3p2bMn5eXlALRs2ZIhQ4YwY8YMNmzYAMDQoUNZtGgRy5cvB6Bfv35UV1ezYMECALp160ZRUREzZswAoHXr1pSWllJeXs7GjRsBKCsrY+HChaxcuRKAAQMGsHHjRiorKwHo3r07nTp12rKR0bZtW0pKSpg+fTqbN28GYNiwYcybN49Vq1YBMHDgQNatW8c777wDhI2U9u3bM3v2bADatWvHwIEDmTp1Ku6OmTF8+HDmzJnDmjVrACgpKWH16tUsXrxYn5M+J31O+pwS+Zy2J7HmWTPrClQBw9z9pYzp1wGnuPtBtTxmMvBFoLO7/zua9mXCnmRnd19hZpuAse7+aMbjTgfud/cW28tUWlrq2tMUEZFMZjbL3Utrm5dkR6APgGq23QPsyLZ7ijWWAVU1BTPyVvSzpvPQ8hzXKSIiUi+JFU133wTMAo7OmnU0oRdtbV4GuppZ64xpB0Y/a9qcy3Ncp4iISL0kfZ7mHcAZZna2mfU1s7sIxyfvAzCzR8zskYzlfwusAh40s/5m9gXCKStPu/vKaJm7gC+Z2ZVmdpCZXQkcCdyZ1IsSEZGmIcmOQLj7E2bWAbga6ALMBUa5e81e435Zy683s6MInX9eA9YAzwL/k7HMK2Z2MvB/wA3AP4GT3H1Gvl+PiIg0LYmep5k26ggkIiLZ0tIRSEREZJemoikiIhKTiqaIiEhMKpoiIiIxqWiKiIjEpKIpIiISk4qmiIhITCqaIiIiMaloioiIxKSiKSIiEpOKpoiISEwqmiIiIjGpaIqIiMSkoikiIhKTiqaIiEhMKpoiIiIxqWjW06RJk+jTpw/FxcXccsst28x/6KGH2HfffRk0aBCDBg3il7/85ZZ5Dz/8ML1796Z37948/PDD2zx29OjRDBgwIK/5RUQkd4WNHWBXVF1dzYUXXsif//xnioqKGDx4MKNHj6Zfv35bLXfSSSdx7733bjVt9erV3HDDDVRUVGBmHHbYYYwePZp27doB8Mwzz9C6devEXouIiMSnPc16mDlzJsXFxfTq1YtmzZpx8sknM2HChFiPfeGFFzj66KNp37497dq14+ijj2bSpEkArF+/njvuuIOrr746n/FFRKSeVDTroaqqiu7du2+5X1RURFVV1TbL/e53v+OQQw5hzJgxLFmyZIePveaaa/je975Hq1at8vwKRESkPlQ068Hdt5lmZlvdP/bYY1m8eDFvvvkmRx11FKeffvp2H/vGG2/w9ttvc9xxx+UntIiI7DQVzXooKirasucIsHTpUrp27brVMh06dKB58+YAnHPOOcyaNWu7jy0vL2fWrFn06NGDsrIyFi5cyIgRI/L/YkREJDYVzXoYPHgwlZWVLFq0iE2bNjF+/HhGjx691TLLli3b8vvEiRPp27cvACNHjmTy5MmsWbOGNWvWMHnyZEaOHMn555/P+++/z+LFi5k+fToHHnggU6ZMSfJliYjIDqj3bD0UFhZy7733MnLkSKqrqznrrLPo378/1157LaWlpYwePZq7776biRMnUlhYSPv27XnooYcAaN++Pddccw2DBw8G4Nprr6V9+/aN+GpERCQuq+0YW1NRWlrqFRUVjR1DRERSxMxmuXtpbfPUPCsiIhKTiqaIiEhMKpoiIiIxqWiKiIjEpKIpIiISk4qmiIhITCqaIiIiMaloioiIxKSiKSIiEpOKpoiISEwqmiIiIjFpwPYGcM6dDbeuBy5tuHWJiEjD0p6miIhITCqaIiIiMaloioiIxKSiKSIiEpOKpoiISEwqmiIiIjGpaIqIiMSkoikiIomaNGkSffr0obi4mFtuuaXO5Z5++mnMjIqKiq2mv/fee7Ru3Zrbbrttq+nV1dUceuihfO1rX8tLblDRFBGRBFVXV3PhhRfy/PPPM3/+fB5//HHmz5+/zXLr1q3j7rvvZsiQIdvMu+yyyzjmmGO2mX7XXXfRt2/fvOSuoaIpIiKJmTlzJsXFxfTq1YtmzZpx8sknM2HChG2Wu+aaa7j88stp0aLFVtOfffZZevXqRf/+/beavnTpUv74xz9y9tln5zW/iqaIiCSmqqqK7t27b7lfVFREVVXVVsu8/vrrLFmyZJtm1o8++ogf/ehHXHfdddus99JLL+XWW29ljz3yW9ZUNEVEJDHuvs00M9vy+2effcZll13G7bffvs1y1113HZdddhmtW7feavpzzz1Hx44dOeywwxo+cBYN2C4iIokpKipiyZIlW+4vXbqUrl27brm/bt065s6dy4gRIwBYvnw5o0ePZuLEicyYMYOnn36ayy+/nA8//JA99tiDFi1aUFVVxcSJE/nTn/7EJ598wtq1a/nWt77FY4891uD5VTRFRCQxgwcPprKykkWLFtGtWzfGjx/Pb3/72y3z9957bz744IMt90eMGMFtt91GaWkpL7300pbp119/Pa1bt+aiiy4C4OabbwZgypQp3HbbbXkpmKDmWRERSVBhYSH33nsvI0eOpG/fvpx44on079+fa6+9lokTJzZ2vB2y2tqXm4rS0lLPPv+nPnQ9TRGR3YeZzXL30trmaU9TREQkJhVNERGRmFQ0RUREYlLRFBERiSnxomlmF5jZIjP7xMxmmdkXYz6uzMw2m9ncrOlnmJnXcmtR17pERETqI9GiaWYnAXcBNwGHAq8Az5vZfjt4XDvgEeDFOhb5GOiSeXP3Txoqt4iICCS/pzkOeMjdH3D3t9z9YmAZcP4OHvcr4GGgvI757u7LM28NmFlERARIcEQgM2sGHAbcljVrMnDEdh53AdAZ+AZwTR2LtTSzd4EC4A3gGnd/vY71nQucC9C1a1emTJkCQK9evWjTpg1z5swBoEOHDvTv359p06YB4YTcsrIyZs+ezdq1awEoLS1lxYoVwAHbf/E5WLZsGQUFBVsuldO5c2d69uxJeXnYXmjZsiVDhgxhxowZbNiwAYChQ4eyaNEili8P2wr9+vWjurqaBQsWANCtWzeKioqYMWMGAK1bt6a0tJTy8nI2btwIQFlZGQsXLmTlypUADBgwgI0bN1JZWQlA9+7d6dSp05br2rVt25aSkhKmT5/O5s2bARg2bBjz5s1j1apVAAwcOJB169bxzjvvANCjRw/at2/P7NmzAWjXrh0DBw5k6tSpuDtmxvDhw5kzZw5r1qwBoKSkhNWrV7N48WJg5z6nmqG7evfuTfPmzZk7N7T0d+zYkQMPPJDp06cD0Lx5c4YOHUpFRQXr168HYMiQISxdunTLwNJ9+vTR56TPSZ/Tbvo5bU9igxuYWVegChju7tMypl8LnOrufWp5zMHAX4DD3X2RmV0PjHH3ARnLDAUOBOYAbYDvAqOAge5eub1MGtxARESybW9wg8YYeza7Slst0zCz5sB44PvuvqjOlbmXk9Fsa2avEPY2LwYuaYjAIiIikGzR/ACoJjS1ZuoIrKhl+S5AP+BBM3swmrYHYGa2GRjl7pOzH+Tu1WZWAfRusOQiIpIXu1pLXWIdgdx9EzALODpr1tGEXrTZqoCDgUEZt/uAt6Pfa3sMFi7Mdgihg5GIiEiDSbp59g7gUTObCbwMnAd0JRRDzOwRAHc/zd0/BbLPyVwJbHT3uRnTrgNeBSqBtoQm2UPYcY9cERGRnCRaNN39CTPrAFxNaH6dS2hmfTdaZLvna9ZhH+AXhGbffwOvA8PcfWYDRBYREdki8Y5A7v4z4Gd1zBuxg8deD1yfNe0y4LKGSSciIlI3jT0rIiISk4qmiIhITCqaIiIiMaloioiIxKSiKSIiEpOKpoiISEwqmiIiIjGpaIqIiMSkoikiIhKTiqaIiEhMKpoiIiIxqWiKiIjEpKIpIiISk4qmiIhITCqaIiIiMaloioiIxKSiKSIiEpOKpoiISEwqmiIiIjGpaIqIiMSUU9E0sxPN7MsZ9681s6Vm9oKZdWn4eCIiIumR657m9TW/mFkJ8L/A3cCewO0NF0tERCR9CnNcfn9gQfT7ccCz7n6rmU0GXmjQZCIiIimT657mJ0Cb6Pf/Av4S/f7vjOkiIiK7pVz3NF8Cbjez6UApMCaafiCwpCGDiYiIpE2ue5oXAZsIxfI8d38/mn4Map4VEZHdXE57mu6+FDi2lumXNlgiERGRlMr5PE0za2FmY8zsCjPbJ5p2gJm1b/h4IiIi6ZHTnqaZFRM6/7QG9gGeAj4Ezo/un93QAUVERNIi1z3NO4HJQCdgQ8b0icCRDRVKREQkjXLtPXsEcLi7V5tZ5vT3gK4NlkpERCSF6jP27J61TNuPcK6miIjIbivXojkZGJdx382sLXAD8McGSyUiIpJCuTbPjgP+ZmYLgBbAE0AxsAI4sYGziYiIpEqu52m+b2aDgFOAEsKe6i+A37j7hu0+WEREZBeX654mUXH8dXQTERFpMnZYNM3seOAP7v5p9Hud3P2ZBksmIiKSMnH2NJ8GOgMro9/r4kBBQ4QSERFJox0WTXffo7bfRUREmpqciqCZDTOzbQqtmRWY2bCGiyUiIpI+ue45/g2obWD2faJ5IiIiu61ci6YRjl1m6wB8tPNxRERE0ivWKSdmNjH61YHHzGxjxuwCYADwSgNnExERSZW452muin4asIatr3CyCZgOPNCAuURERFInVtF09zMBzGwxcJu7qylWRESanFyH0bshX0FERETSLs6IQG8Cw919jZn9ndo7AgHg7oc0ZDgREZE0ibOn+TugpuPP9kYEEhER2a3FGRHohtp+FxERaWo0LJ6IiEhMcY5pbvc4ZiYd0xQRkd1Z3KuciIiINHk5HdMUERFpynRMU0REJCadpykiIhKTztMUERGJKfHzNM3sAuD/AV2AecCl7v5SHcsOB24G+gCtgHeBX7r7bVnLnQD8ADgA+Cdwlbv/fmezioiIZKrXMU0zO8DMvhbdDsjhcScBdwE3AYcSLif2vJntV8dD1gN3A8OAfsD/ATdEhbdmnUOBJ4DfAIOin0+Z2ZDcX5mIiEjdciqaZtbBzJ4FKoFno9tCM5tgZh1irGIc8JC7P+Dub7n7xcAy4PzaFnb3We4+3t3nufsid38MeAH4YsZilwJ/c/cfRuv8ITAlmi4iItJgct3T/CVQTChaLaLbMKAnO7ieppk1Aw4DJmfNmgwcEefJzezQaNmpGZOH1rLOF+KuU0REJK6cLg0GjAT+y93LM6a9bGbfAf6yg8d+DigAVmRNXwEctb0HmtlSYF9C3hvc/b6M2Z3rWGfnOtZ1LnAuQNeuXZkyZQoAvXr1ok2bNsyZMweADh060L9/f6ZNmwZAYWEhZWVlzJ49m7Vr1wJQWlrKihUrCIdSG8ayZcsoKChg/vz54cV17kzPnj0pLw9vecuWLRkyZAgzZsxgw4ZwLfChQ4eyaNEili9fDkC/fv2orq5mwYIFAHTr1o2ioiJmzJgBQOvWrSktLaW8vJyNG0Mfr7KyMhYuXMjKlSsBGDBgABs3bqSyshKA7t2706lTJyoqKgBo27YtJSUlTJ8+nc2bNwMwbNgw5s2bx6pV4ZrlAwcOZN26dbzzzjsA9OjRg/bt2zN79mwA2rVrx8CBA5k6dSrujpkxfPhw5syZw5o1awAoKSlh9erVLF68GNi5z2nJkiUA9O7dm+bNmzN37lwAOnbsyIEHHsj06dMBaN68OUOHDqWiooL169cDMGTIEJYuXUpVVRUAffr00eekz0mfU4N8TiNoKMuWLWuQz2l7zD3WCHlhYbN3gWPd/c2s6QOBP7h7XccmMbOuQBUwLLPjj5ldB5zi7gdt57E9gdbA4cCPgO+6+6PRvE3A2Jr70bTTgfvdvcX2Xk9paanX/NHujHPu3OlVbPGAGpVFpAlJ4/enmc1y99La5uW6p3kjcKeZfdvdq6KVdwNuj+ZtzwdANdvuAXZk2z3Frbj7oujXv5tZJ+B6oKZILq/POkVERHJVnwHbewKLzawqut8N+IRQqH5Z13rcfZOZzQKOBp7KmHU04VzQuPYAmmfcL4/W8eOsdb6SwzpFRER2KOkB2+8AHjWzmcDLwHlAV+A+ADN7BMDdT4vuXwwsAhZEjx8GfB/4WcY67wKmmdmVwO+B44AjgbIGzC0iIpLsgO3u/kR0asrVhMEN5gKj3P3daJHsY6IFhGOYPYDNhIEL/oeoyEbrfMXMTiY6hzNa5iR3n9FQuUVERCD3Y5o7zd1/xtZ7ipnzRmTdvxPY4WFid38aDfEnIiJ5luvgBs3M7AYzW2hmn5hZdeYtXyFFRETSINfBDX4AnE7oLfsZYQzZnwKrgAu28zgREZFdXq5F80TgPHe/n3D6yAR3vwS4jtBjVUREZLeVa9HsBMyPfl8P7BP9Pgn4ckOFEhERSaNci+Z7hFNEAN4mDKsHYfzXDQ0VSkREJI1yLZq/B/4r+v0uwmW6FgEPsZ2BDURERHYHOZ1y4u5XZvz+dDSQ+hHAQnd/rqHDiYiIpMlOnafp7q8CrzZQFhERkVTLtXkWMysxs0fMrCK6PWpmJfkIJyIikia5Dm5wKvAaYQi8P0W3TsBMM/tWw8cTERFJj1ybZ38IXOPuN2VOjAZL/z/gsYYKJiIikja5Ns/uCzxZy/SnCJcGExER2W3lWjT/BoyoZfoIYOrOhhEREUmzOBehPj7j7vPAzWZWyn96zR4OHA9c3+DpREREUqS+F6E+N7pluoc6LvklIiKyO4hzEeqcT0sRERHZHakgioiIxFSfwQ2+ambTzOwDM/uXmU01s1H5CCciIpImuQ5ucDZh0PZ/AlcA/wMsAn5vZmc1fDwREZH0yHVwgyuAce5+b8a0X5nZLEIB/XWDJRMREUmZXJtn9yNccDrb88D+Ox9HREQkvepzEeqja5n+ZeDdnY8jIiKSXrk2z94G3BNd1eQVwIEy4NvAxQ2cTUREJFVyvQj1/Wa2EvgeYRQggLeAE919QkOHExERSZPYRdPMCgnNsNPc/ff5iyQiIpJOsY9puvtm4BmgTf7iiIiIpFeuHYHmAMX5CCIiIpJ2uRbN64Hbzey/zay7mbXPvOUhn4iISGrk2nv2j9HPZwg9Z2tYdL+gIUKJiIikUa5F88i8pBAREdkFxCqaZtYK+DHw38CewF+AS9z9gzxmExERSZW4xzRvAM4gNM8+ThgV6Od5yiQiIpJKcZtnjwfGuvt4ADP7DfCymRW4e3Xe0omIiKRI3D3N7sBLNXfcfSawGeiaj1AiIiJpFLdoFgCbsqZtJveORCIiIrusuEXPgMfMbGPGtBbAA2b2cc0Edx/dkOFERETSJG7RfLiWaY81ZBAREZG0i1U03f3MfAcRERFJu1yH0RMREWmyVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYkq8aJrZBWa2yMw+MbNZZvbF7Szbxcx+a2b/MLNqM3uolmXOMDOv5dYiry9ERESanESLppmdBNwF3AQcCrwCPG9m+9XxkObAB8AtwIztrPpjoEvmzd0/aajcIiIikPye5jjgIXd/wN3fcveLgWXA+bUt7O6L3f0Sd38IWL2d9bq7L8+8NXx0ERFp6hIrmmbWDDgMmJw1azJwxE6uvqWZvWtmS83sOTM7dCfXJyIiso3CBJ/rc0ABsCJr+grgqJ1Y7wLgLGAO0Ab4LvCymQ1098rshc3sXOBcgK5duzJlyhQAevXqRZs2bZgzZw4AHTp0oH///kybNg2AwsJCysrKmD17NmvXrgWgtLSUFStWAAfsRPytLVu2jIKCAubPnw9A586d6dmzJ+Xl5QC0bNmSIUOGMGPGDDZs2ADA0KFDWbRoEcuXhx3sfv36UV1dzYIFCwDo1q0bRUVFzJgRWrhbt25NaWkp5eXlbNy4EYCysjIWLlzIypUrARgwYAAbN26ksjK8hd27d6dTp05UVFQA0LZtW0pKSpg+fTqbN28GYNiwYcybN49Vq1YBMHDgQNatW8c777wDQI8ePWjfvj2zZ88GoF27dgwcOJCpU6fi7pgZw4cPZ86cOaxZswaAkpISVq9ezeLFi4Gd+5yWLFkCQO/evWnevDlz584FoGPHjhx44IFMnz4dgObNmzN06FAqKipYv349AEOGDGHp0qVUVVUB0KdPH31O+pz0OTXI5zSChrJs2bIG+Zy2x9y9wQJv94nMugJVwDB3fylj+nXAKe5+0A4e/xzwgbufsYPlCoA3gL+5+yXbW7a0tNRr/mh3xjl37vQqtnjg0oZbl4hI2qXx+9PMZrl7aW3zkjym+QFQDXTOmt6Rbfc+683dq4EKoHdDrVNERAQSLJruvgmYBRydNetoQi/aBmFmBhxC6GAkIiLSYJI8pglwB/Comc0EXgbOA7oC9wGY2SMA7n5azQPMbFD0a1vgs+j+JnefH82/DngVqIyWuYRQNGvtkSsiIlJfiRZNd3/CzDoAVxPOp5wLjHL3d6NFajtf8/Ws+8cC7wI9ovv7AL8gNPv+O1p+mLvPbNj0IiLS1CW9p4m7/wz4WR3zRtQyzXawvsuAyxoknIiIyHZo7FkREZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVSYtKkSfTp04fi4mJuueWWbeZv3LiRk046ieLiYoYMGcLixYsBWLVqFUceeSStW7fmoosu2uoxX/nKVxg4cCD9+/fnvPPOo7q6OomXIrLbUtEUSYHq6mouvPBCnn/+eebPn8/jjz/O/Pnzt1rmV7/6Fe3atePtt9/msssu44orrgCgRYsW/OAHP+C2227bZr1PPvkkc+bMYe7cufzrX//iqaeeSuT15Fs+NjCuuuoqunfvTuvWrZN4CbKLUtEUSYGZM2dSXFxMr169aNasGSeffDITJkzYapkJEyZw+umnAzBmzBhefPFF3J299tqLsrIyWrRosc1627ZtC8DmzZvZtGkTZpb/F5Nn+drAOPbYY5k5c2a9c+WjkM+aNYuDDz6Y4uJiLrnkEty93vmkYahoiqRAVVUV3bt333K/qKiIqqqqOpcpLCxk7733ZtWqVTtc98iRI+nYsSNt2rRhzJgxDRu8EeRrA+Pwww+nS5cu9cqUr0J+/vnn84tf/ILKykoqKyuZNGlSztnqW8wBbr75ZoqLi+nTpw8vvPACAAsWLGDQoEFbbm3btuXOO+/MOdeuSkVzN9LQ/xwAH374IWPGjOGggw6ib9++lJeXJ/FSmpza9iCy9wrjLFObF154gWXLlrFx40b++te/1j9kSuRzA6O+8lHIly1bxtq1axk6dChmxmmnncazzz6bU66dKebz589n/PjxzJs3j0mTJnHBBRdQXV1Nnz59eOONN3jjjTeYNWsWrVq14rjjjsv1LdtlqWjuJvLxzwHw3e9+l6985Sv84x//YM6cOfTt2zenXA1dyJcsWcKRRx5J37596d+/P3fddVdOedKaq6ioiCVLlmy5v3TpUrp27VrnMps3b+bf//437du3j7X+Fi1aMHr06G2+yONI23uVzw2M+spHIa+qqqKoqGi769yRnSnmEyZM4OSTT6Z58+b07NmT4uLibZqvX3zxRQ444AD233//nHLtylQ0dxP5+OdYu3Yt06ZNY+zYsQA0a9aMffbZJ3amfBTywsJCbr/9dt566y1effVVfvrTn26zzl0x1+DBg6msrGTRokVs2rSJ8ePHM3r06K2WGT16NA8//DAATz/9NF/60pe2WwjWr1/PsmXLgFBk//SnP3HQQQfFzgTpfK/yvYFRH/ko5A1R+HemmMd57Pjx4znllFNyyrSrU9HcTeTjn+Odd95h33335RnsulYAABf2SURBVMwzz+TQQw/l7LPP5qOPPoqdKR+FvEuXLpSUlADQpk0b+vbtm4qt753NVVhYyL333svIkSPp27cvJ554Iv379+faa69l4sSJAIwdO5ZVq1ZRXFzMHXfcsdVeX48ePRg3bhwPPfQQRUVFzJ8/n48++ojRo0dzyCGHMHDgQDp27Mh55523y79X+djA2Fn5KORFRUUsXbp0u+vckZ0p5jt67KZNm5g4cSLf+MY3csq0q1PR3E3k459j8+bNzJ49m/PPP5/XX3+dvfbaq9bmubrkeyt38eLFvP766wwZMiR2pjTnGjVqFAsXLuSf//wnV111FQA33njjloLQokULnnrqKd5++21mzpxJr169tnrO1atXs379epYuXUq/fv3o1KkTr732Gm+++Sbz5s3jnnvuobCwMKdMaXyv8rGBAXD55ZdTVFTExx9/TFFREddff33sTPko5F26dKFNmza8+uqruDuPPPIIX//612Nngp0r5jt67PPPP09JSQmdOnXKKdOuLrf/IEmtXP45ioqKYv1zFBUVUVRUtOULbcyYMTkVzXxu5a5fv54TTjiBO++8c8tpFbt6rjRK63s1atQoRo0atdW0G2+8ccvvNRsYtck85prp1ltv5dZbb80pR43MQl5dXc1ZZ521pZCXlpYyevRoxo4dy7e//W2Ki4tp374948eP3/L4Hj16sHbtWjZt2sSzzz7L5MmT6devHz//+c8544wz2LBhA8cccwzHHHNMTrkyi3m3bt0YP348v/3tb7dapqaYDx06dKtiPnr0aL75zW8ybtw43n//fSorK/n85z+/5XGPP/54k2uaBRXN3UY+/jkKCgro3r07CxYsoE+fPrz44ov069cvdqZ8FHKATz/9lBNOOIFTTz2V448/Puf3Kq25Mp3TgD34H7i0/o/dFd6rtMhHIS8tLWXu3Ln1zrQzxbx///6ceOKJ9OvXj8LCQn76059SUFAAwMcff8yf//xn7r///npn21WpaO4m8vXPcc8993DqqaeyadMmevXqxYMPPhg7Uz4KubszduxY+vbty7hx4+r1XqU1VxrtCu9VWjYwsjVUrp3NtDPF/KqrrtpyqCBTq1at8noKT5olXjTN7ALg/wFdgHnApe7+0naWHw7cAfQH3gdudff7dmadu6t8/HMMGjSIioqKeuXJRyGfPn06jz76KAcffDCDBg0C4Kabbtrmde+KudJI75XI1izJYZnM7CTgMeACYHr080ygn7u/V8vyPYG5wK+BnwFl0c+T3f139VlnptLSUq9vQciUxi3dNGaS+PT5xZfW9yote5qZ0vhepTGTmc1y99La5iXde3Yc8JC7P+Dub7n7xcAy4Pw6lj8PeN/dL46WfwB4GPj+TqxTRESkXhJrnjWzZsBhQPYAi5OBI+p42NBofqYXgNPNbE/A6rFOaUTa+t616b2Spi6x5lkz6wpUAcPdfVrG9GuBU929Ty2PWQg85u43ZkwbBkwFuhKKZq7rPBc4N7rbB1jQAC8vjs8BHyT0XLlIYy5lii+NudKYCdKZS5niSzLX/u6+b20zGqP3bHaVtlqm7Wj5mum2nWVqXae7/wL4xY5jNiwzq6irjbwxpTGXMsWXxlxpzATpzKVM8aUlV5JF8wOgGuicNb0jsKKOxyyvY/nNwCpCccx1nSIiIvWSWEcgd98EzAKOzpp1NPBKHQ8rB46qZfkKd/+0nusUERGpl6SbZ+8AHjWzmcDLhN6xXYH7AMzsEQB3Py1a/j7gIjO7E7gf+AJwBnBK3HWmSOJNwjGlMZcyxZfGXGnMBOnMpUzxpSJXoudpwpaBCC4nDEQwF7isphOPmU0BcPcRGcsPB37CfwY3+FEdgxvUuk4REZGGknjRFBER2VXp0mAiIiIxqWiKiIjEpKKZEMu4kKCZ6X3fxegzExFQ0UyMu3s0lCDu/lnN9MximrS0FgIzK2jsDNnc/TMz6wRgZi3MrNEvq2dmBY359yPSFKkjUALMrDMwBighDN33KvCUu7/aqMEi0RevZRbzzHneSH8kNUW9sXOZ2SDgNGAUYSCNCuDPwF+AN9y9OgXvk7l7dWM8fzYzK0hLlkxpzJXGTABm1gVoA2wACoDl7v5J46ZKBxXNBJjZH4Fi4C3CaTNHAAOAt4FbgEeT/scxswsJ1x6d4e4bMqbvQdgxbqwC8ENgNjDZ3ddlTC8APmuMXGY2C1gH/IEw0tRXo1s18BBwtbt/lHAhf5Cw8fWku6/JmF5IeJ+22dBIWl0bPTV7x434N1YQPX2jv0c10pQpOoXvLMJ31KeEAWTKgb8C09x9Y2NsJJpZobtvTvI5a+XuuuXxBnwJ+BdQFN1vAexNGKjhAeAdYFzCmcqAz4BphGuRXgIMzFqmOXAN0KURcr0OvES4es3wrGVaAncD+yWUaUT0+bWoZd5Y4F3geaBNI7xPC4H3gKeAr9fyPv2acF3ZpHIdTLje7VFAYda8AqKN9KRvQCnwHKG1Z8+seYWNkSuNmaLnHkG4CMaPgL7AMdH3VGU0/YfZn20jZCwAChrr+bWnmWdmdj0wzN2/VMu8tsDFwJXRMrMTyvQTYAihebEE6ASsJ3wJv0wopp0IW5dt3X19QrluBQYDTxC2cgcA+xD27qYQ9vRaEfaw9vaMPdE8ZjqPMMrUSHdfYWbNCXsEm6L5w4EngfPd/Zl854me8/8I79PPgN6EL7oBwCZCs/GjhL3gGST0PkW5HgZOJAww8m/CReEnZv5dm9lQwqhe53lCXz5RrlOAxYQv3L8RWnemZixzBGHj8VRPoNUnjZmi5/wtsN7dz82avidhI/FG4A/uPjaJPNFzf4Hwt34P8EjN/140r5CwAelAO2BNvv+uVDTzzMzKgN8D33b3SbXMLwT+BDzv7j9JKNOjhD+uS6LOSV8ijNd7KOE4xgrgIGCRu2eP65vPXL8mFKSxUdNeCeGaqoMJxaEA6Am85u6jEspURNh4+Im735ExfUtzsZk9CVS5+2UJZfoJ4QvibHffbGY9CUVzKGEvdD+gG6GJ+6tJZIpyzQYmAUsJe1J9CBs57xGucfsHwgbicHfvl2Cu8ihXBfB5YBjhcMkaYCJhI+OSKNeAppopyvUQsBfh++oTM2sBbPaoWdTMxgL/DzjB3ecllOlh4FvASmBfwsb+ve7+XMYyXyC0jH3N892E25i72U3hRmgme4Rw/PJKQiHYK2P+PoQvmeMTzDQAOKaW6R0JW78PEbbeRiX8XnUGRtQyfW/gSMJWbmK5+M9G5RWEPfG/EI71dMlYphewBPhGgu9Ta+DwOv7W+gFnJ/35ETZqpgJnRffbAF+M3rsngZmEAvEZWU3Jec7Vg9AMen50vwWhmJ8I3AW8Fn1+nwGjm2qmjGwjCVekOjFremH0s2YjaHiCmaZG350HE/Z2JxE6KK0FfgUMJOyFvplEHu1pJsDMuhM+9KMIW5IzCXtz1YS9gz5eywWz85yp0MNeyh6EU4+2dB4xs2MJF//eO8lMtWTcqlNSlOtxd2/dCFmOA04l7Ol+Rmh+XEbYO1/t7sOSzpSRbatOGWY2mtBBqEXCOYqBPdx9Ydb0ToSNxe8QNor2SThXJ8KG6jtZ09sQNnouAE5KMldKMxmhL8NNhMNGswgb0E+5+yoz+xwwGrjT3dsmlKkrYWP5NXe/P2rhaUvYK/8v4ATgEGBPwsbYH/KeSUUzOWZ2CKGZ4QjCwf59CE1/d7j73xszG/zn1BPgacKxzOzLsjWaqID+DGjv7ic2UobuhObP/oTmzyLCVu+j7r6yMTJliz7DG4BO7v6dRsxR0/Fnc8a0Z4GP3P3UxsoV5cjeyHgW2OjuJzVSnrreq8bM9DXgm8Ag/nN94s2EovpLd78twSwdgFbuviRreiHhMMXFwCVJbWCoaOZJ1GHkEOB4wukKbxKuA7o8mt+H0Algkyf0IWRkOo6wpzSP0Gz8nrt/bGZ7eDiJv5DQgWRVErky8m232300v427f5hgpkJCqM1Z05u7+8akctSSqc7TSqINjL08oQ5AOxLlaUdoYTnN3V9u5EhbmNk+wDPAFe7+WsLP3Sb7M4req7aNmGnLBkV0rmY/wjHynoRm5AeBhZ6ic0ujDYxqdz8hkedT0cwPM7ubUDCXAe0JxzGWA88Ct7r7uynItD/hvNHfA3dlNxUlmOswd5+VNa3RzsuMnr/M3adnTWtGKOqfRvcTPW+sjkxbFdCaDZ+kMkXP2Z1wrHcw8E9gAaEH7d/dfU3NF7GZtfbkemJnfvnvaCOjlbt/nFCuvsA4QrP+24Tjg28AL2XuSZlZS884fzpJjXEOZn2ZWWvC8cy73P2NRJ40iQOnTe1G2DpbC3wZ6BBN2xf4H2AR4SD2d0jwXKyYmc4lNM8mmas34RjhXMIFxQ/Nmm+E4xWfB5ollOmgKNM6YDzwhaz5exCaqY4lNIOmIZMBzZLMFD1vT8JgFG8BD0e/LyW0rPwUOCA7Z0K59mXbc3yNrHMgic73SyIXcABhg2IacDNhY7U8es+eBL7cSO9VJ+DbhEMfmdNrRpqC0HO9eVJ/VznmTzRXo7/g3fEG/C9h5Iya+9knet8E/APo2pQzRc97LeHE6Z8ArxBOoH6VcFHx7tEy3aKCUZTge/U6ofPWS4RjOcsJgy0cEC3TMcrUvalmip7zPsKpJJ0zpu1H2Bh7lzAwRGK9ZTMy/DR6L5ZHv/fLmr9HlPMb2f8Lecz08+i9apMxrRNwZlRIPwLGNsJ7dU/0Xq0mDJQxKrsQRe/V95MqUHUV8lqWaxH9TGxDP5UDdu8G3gK6RL0J8dBLtTA65wnCCBsfE/5hm3ImCF3t/0QYgeQcQnGYS+gwVW5mfwDuB95y96UJZepGGOThfuDrhPNYf00YOq/SzN4k7O295VmdE5pYJgidoqa5+3Iz2zNqsn7P3W9x9/0Jp+mcZ2Z7RJ2UkjKYUNB/Tui8NdfM3jaz/zWz9h6aak8HfuTJNbHvD8x293UWBtsvcPcV7v6gh97X9wHnmFmrhPLUKCX8/32PcOz598AiM7vHzEqiZc4hDEiR1HH8qwktF2+b2VNmNirqk7GFme0HXBT1L0iuOTnprZqmcAM6EIrUPwjnXm2zdQbMAb7TxDMVEnroXZk1vT3hVJyLCM1Wn5HQFjihGWoUcEHW9GaEre2vETYwPgPObKqZMjJcTzgml7n3tCfQMvq9jHCcc5vzSvOYaX/gBcLIQ3sQNjhGEvY434vep5cJe1aXJZjru9HzH5T1GTaLfu9HOFRyZIKZuhL2Ls+N7hcSDgVcEX2u1cDfCXvB300wVzmhCftMwobXRkL/i3uAkmiZHwBvJ5VpS7akn7Cp3KI/xieA+YTRUH5A2Ds4kHAC87/IGOSgqWbKyrdnLdOOj77kWjVSpj1qmTZSmbY872HRl9lsajkRn9CS8EmSuQi9T0+n9nGLDyBsNE4hNHG3TDBXT0IT+yKiQSCy5tcMhZjke7UX4Tj4kFrmtSL0JXgyyfcqrYW85qbes3kUnV/0VULnm16EL5B2hBEu7nf38U05U109PaPejtXu7mZ2G1Dq7iMSylTnZdIylrkeGOruI5tqpppc0WdUDNwKHE4YTWY6YRD7foSTzxd7451ba4TOPtmnDP0G6JbU31XG87Yh7EGdStgjn0zYkxpA2Ct/w91PSzJTVr5tes5aGFrvAHf/YkIZ9iJszK909xlZ81oR3qvvEzao23jCvYxVNBuYhbFKi6O7HxH26jYQClRrwnHDD9x9dVPOlJXLCHtJCzw6jzWab4Tjd1We8Plq22NmI4B/eUJjb8bR2JmiY+NHRbchhGOdqwjDnD3qjXCKVaaa4knYS2lJ1IPV3X+X4PPv4eHaqy0IQ8INIxSHEsLe52PAM5n/Awnk2u6lAM2sJTAB+Lm7/z6pXFkZGr2Qb/XcKpoNx8zOJ5yvNpBQiN4hjCE5BXjak+2gkdpMteT6iHDO2lLCsYwJ7r6gETI12rlxdUljJtjyZft1wqkdLQnHLae5+9qoKDhhL+CDRszVitAbe6pnjNgUdSg5yt3/mGS2bLb1oP97u/u/GzNPbSxc3aTU3csTfM5UF3IVzQYSNXu+DdxO6LG3L2Gr+0hCM1UVYain+UmdPJzGTDFyHRTlujTKlciV7c2sHaEj1B8JW/yv1LwfWSfK9wWWeQKjEqUxU/R8bQh7kEcSWgiqCK0FHxGaGn/j7pXRsokNtlBLrqWE4r2BcPjhMXf/RxJZMjLtSTiW+a7X0vO0sQYS2FGuNGuMQr6VpA+i7q43wviHM+qYV0Y4t+4d4HNNOVNac0WZNhKGeqsm7DndSBhMv2aZ7oSOHL2aaqboOa8iFPPB0f2DCKcI3UcY5PsPwL5J/k3FyPUa4ZJbieYCLiVsTDxI6HDTmawLKBM6Lh1DLR3hUpDrqyQ3qMiehE6JqRxEYUvOxg6wu9wII/zMBwZE95tn/rERTg2YD3yzKWdKay7CKRv3EQYIOITQWaMyKlavEkZLupJwgd4mmynK9RIwrpbpBYTjdJXApCQzpTUX4XDD36Js1YRjl3cQNg73jpY5D3i1qedKYyGv7abBDRrO04QmoUstDMS80d03Re3zuPt7wIeEK2M05UypyxUd45oPLHH3le7+prtfSTjpe2Q073rgh4STwJtkpihXIWHwiRPMbN9oWs2J+tXuPo3wZVtkZgObcq4ox6fAAx46rOxPaD7+GqEj0l/N7ApCsZhR54qaSC7gJEKrSjFhjO5y4MdmVmZmNZcp/CZwjbtvSjDX1hqrWu9ON6LxWoH/Jgwdto7wR3gY/xmu61vR9B5NNVPKczUnGgqOsGeyR9b8ESQ4lF9aM0XPezihqfhH1DLOLaHJeD3hlI4mmwvoAlwGjKxl3qGEwRZWRZ9hYu9VGnMR+jVMI2pdImwwXw0sjHLMIpyn+Q/C4OyJ/V1l39QRqAFZuMzQfoTrZR4HfCGatZxQEB5x9+ubeqa05co437AX4XqPK2qZdy1whrv3aqqZoueuuWj5mYTxigsJLQdPEHplH0JoWuvr7oOVy1oSeoJ+Ep12AtGEaP4PgVHufmhSmdKYy8JlyE4G5rv7C1nzDgXOjua3I4ytXJVErtqoaO4kM+tIGFj4e4QTuzcQmhZfIjRt7EkYheQFoNITeMPTmCmtuTIyjQNWEkY+WUYYkeQZd/8o+lI5B3jf3Z9ripnqyLkPYai6mosVr+M/HZdu9qwT05tqrrp6yEYn6s8GHnT3xJrY05orbYW8LiqaOyk6ybY/ocfgasK4qQcTeoGtBK5uhH/S1GVKa646Mh1K6Hm5FPixu09u6pmiXG2BdZlftNEeXgvCIBkDCHvFSX+GqctVW6ZalmlBOI73uCd0jC6tuTKeO1WFvDYqmjsh2hpaR9j6mZYxbT/C8ZWxhFF3TnT32U01U1pzbSdTd8KoNucQOkmc0pQzZWS7n7C3NpNwft/aWpZp5xkXnm6quWJm2scTOrc2zbnSXsi3ke+DprvzjbA38HfquIIDoSNHBaFJqMlmSmuuGJmaKdOW5z2F0CHjQ8I5tPcTxv4s5j9XNGlN6PV4cFPOVUem4wiHHmoy1YxqM6CR36s05LqfsNF8MNC2jmX2SSrPjm7a09wJURv8c4Thuk4D/ulZo5+Y2cWEy1oNaqqZ0ppLmXLK9QDhfL5bCUXpdMKX7QLC9VBfJAz+f5e7N2vKudKYKa25zOwU4DfAWsKhiD8Dk4A3CcfrN0T/E+OBq9x9bhK5tquxq/aufiM0Lb5BOKfoDEIz2l7RvFaEHnyPNfVMac2lTLHyFBIuDn5L1vT+wJ2E46wfEDos/aop50pjppTnqhnAoxfhyiV/J4yR/TrhHOQvAecDm5LKtMPMjR1gd7gROho8QegN+gGhA8evCRecnUGCzVVpzpTWXMoUK087oosnE5qILWv+SYSmv0FNPVcaM6UxV1oL+Y5uap5tQNGpAl8lnLj/CWGEkqc84UGi054prbmUKTdRD1XzcLmrcwjNeq2Ua9fIlIZcFi5K0Mnd/2FmzYBPPaMomdlJwONAibu/kVSu7VHRzBNL8OoOcaUxE6QzlzLlxszGEcYJ/XFjZ8mUxlxpzATpydXYhXxHVDRFZKdZuFxTddqKehpzpTETpDNXWgp5JhVNERFJpVQWchVNERGReHRpMBERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGY/j+4bfOnyfgudAAAAABJRU5ErkJggg==\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": 18,
   "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>0.14.0</td></tr><tr><td>Terra</td><td>0.11.0</td></tr><tr><td>Aer</td><td>0.3.4</td></tr><tr><td>Ignis</td><td>0.2.0</td></tr><tr><td>Aqua</td><td>0.6.1</td></tr><tr><td>IBM Q Provider</td><td>0.4.4</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.7.4 (default, Aug  9 2019, 18:34:13) [MSC v.1915 64 bit (AMD64)]</td></tr><tr><td>OS</td><td>Windows</td></tr><tr><td>CPUs</td><td>2</td></tr><tr><td>Memory (Gb)</td><td>7.9987335205078125</td></tr><tr><td colspan='2'>Tue Dec 10 15:53:38 2019 Eastern Standard Time</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.4"
  },
  "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
}