qiskit/evaluators/expval_demoday.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "21e62c44",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# New expectation value design PoC\n",
    "\n",
    "[Qiskit Demoday Sep 16](https://github.com/qiskit-community/feedback/wiki/DemoDay#sep-16-2021)\n",
    "\n",
    "Takashi Imamichi and Ikko Hamamura (IBM Research - Tokyo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a02345fd",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Motivation\n",
    "\n",
    "We propose a simple and generic interface for expectation values and their gradients.\n",
    "The current workflow with opflow to get an expectation value is as follows.\n",
    "```python\n",
    "state = StateFn(...) # can be a circuit-based state or defined via a statevector or dictionary\n",
    "operator = ... # some opflow operator, e.g. PauliSumOp\n",
    "expectation = StateFn(operator, is_measurement=True) @ state\n",
    "expectation_converter = PauliExpectation # method to evaluate the expected value, e.g. PauliExpectation, CVaRExpectation, AerPauliExpectation, ...\n",
    "circuit_sampler = CircuitSampler(backend)\n",
    "converted = expectation_converter.convert(expectation) \n",
    "sampled = circuit_sampler.convert(converted, parameters)\n",
    "result = sampled.eval()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa82e846",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We propose a new design of the expectation value to make it generic and simple.\n",
    "Essentially, we aim at the following workflow.\n",
    "\n",
    "```python\n",
    "operator = ... # some opflow operator, e.g. PauliSumOp\n",
    "state = ... # a parametrized quantum circuit (or ansatz)\n",
    "backend = ... # AerBackend or IBMQBackend\n",
    "expval = PauliExpectationValue(state, operator, backend)\n",
    "result = expval.evaluate(parameters).value\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b78a5565",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Outline of the new design\n",
    "\n",
    "We propose an abstract class for expectation value and gradient.\n",
    "An instance will be initialized with the following objects:\n",
    "\n",
    "- `state` $\\psi(\\theta)$: a (parametrized) quantum circuit or a state vector to be converted into a quantum circuit.\n",
    "- `observable` $H$: we allow opflow `PauliSumOp` (primitive is `SparsePauliOp`) or quantum_info operator `BaseOperator` that is compatible with `SparsePauliOp` for simplicity.\n",
    "- `backend`: Either `IBMQBackend` or `AerSimulator`. We don't support legacy simulator backends and BasicAer.\n",
    "- (optional) `expval`: take an expectation value object as an input (e.g., gradient)\n",
    "\n",
    "Users use `ExpectationValue.evaluate(parameters)` to obtain the expectation value.\n",
    "\n",
    "Instances of our expectation value classes are immutable.\n",
    "Users need to invoke the constructor to evaluate the expectation value of different states or observables."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63eaef98",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The internal workflow consists of phases:\n",
    "\n",
    "1. `ExpectationValue._preprocessing` generates quantum circuits corresponding to the pair of quantum state and observable. The circuits maybe left parametrized. This will be invoked on demand to avoid overhead of the constructor.\n",
    "2. `ExpectationValue.evaluate(parameters)` transpiles quantum circuits (if necessary), puts parameter values to the transpiled circuits, and executes them on the backend.\n",
    "3. `ExpectationValue._postprocessing` interprets the results of the backend into an expectation value and other information as `ExpectationValueResult`.\n",
    "\n",
    "Note: we allow `ExpectationValue.evaluate(parameters)` to process a set of parameters and the output will be `ExpectationValueArrayResult`. See an example later.\n",
    "\n",
    "`ExpectationValueGradient` may have the same interface and/or it may take `ExpectationValue` object as an input of the constructor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8765e853",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Demo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "05da73c4",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fc97bb99",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6104c3e9",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observable\n",
      "-1.052373245772859 * II\n",
      "+ 0.39793742484318045 * IZ\n",
      "- 0.39793742484318045 * ZI\n",
      "- 0.01128010425623538 * ZZ\n",
      "+ 0.18093119978423156 * XX\n",
      "\n",
      "ansatz\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 387.452x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.circuit.library import RealAmplitudes\n",
    "from qiskit.opflow import PauliSumOp\n",
    "\n",
    "observable = PauliSumOp.from_list(\n",
    "    [\n",
    "        (\"II\", -1.052373245772859),\n",
    "        (\"IZ\", 0.39793742484318045),\n",
    "        (\"ZI\", -0.39793742484318045),\n",
    "        (\"ZZ\", -0.01128010425623538),\n",
    "        (\"XX\", 0.18093119978423156),\n",
    "    ]\n",
    ")\n",
    "print(\"observable\")\n",
    "print(observable)\n",
    "\n",
    "ansatz = RealAmplitudes(num_qubits=2, reps=2)\n",
    "print(\"\\nansatz\")\n",
    "ansatz.decompose().draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e5bc903",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ExpectationValue class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2dd0c134",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.evaluators import PauliExpectationValue"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01eba673",
   "metadata": {},
   "source": [
    "### PauliExpectationValue\n",
    "\n",
    "Evaluate the expectation value by sampling. This supports both AerSimulator and IBMQ backends."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "578ae95d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.providers.aer import AerSimulator\n",
    "\n",
    "backend = AerSimulator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "624c2fc9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ExpectationValueResult(value=-1.3045851234732189, variance=0.2985086690184938, confidence_interval=(-1.3335981061414726, -1.2755721408049652))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expval = PauliExpectationValue(ansatz, observable, backend=backend)\n",
    "expval.evaluate([0, 1, 1, 2, 3, 5], shots=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "18535167",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ExpectationValueArrayResult(values=array([-1.28753097, -1.32096817]), variances=array([0.30054645, 0.24197059]), confidence_intervals=array([[-1.30433766, -1.27072428],\n",
       "       [-1.33568567, -1.30625067]]))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multi prameters\n",
    "expval = PauliExpectationValue(ansatz, observable, backend=backend)\n",
    "expval.evaluate([[0, 1, 1, 2, 3, 5], [1, 1, 2, 3, 5, 8]], shots=3000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "257787d2",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exact simulation by SaveExpectationValueVariance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e602573e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.evaluators import ExactExpectationValue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a795bd78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ExpectationValueResult(value=-1.2843665118617325, variance=0.26528532962023577, confidence_interval=None)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expval = ExactExpectationValue(ansatz, observable, backend=backend)\n",
    "expval.evaluate([0, 1, 1, 2, 3, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "60687fe8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ExpectationValueArrayResult(values=array([-1.28436651, -1.31875263]), variances=array([0.26528533, 0.42691205]), confidence_intervals=array([None, None], dtype=object))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expval = ExactExpectationValue(ansatz, observable, backend=backend)\n",
    "expval.evaluate(np.array([[0, 1, 1, 2, 3, 5], [1, 1, 2, 3, 5, 8]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c94c403",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Transpiled Circuits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3e1a8842",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ExpectationValueResult(value=-1.2270449811062014, variance=0.3261140003605256, confidence_interval=(-1.2569617757694307, -1.1971281864429721))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1142.53x385.28 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.test.mock import FakeBogota\n",
    "\n",
    "backend = AerSimulator.from_backend(FakeBogota())\n",
    "\n",
    "expval = PauliExpectationValue(ansatz, observable, backend=backend)\n",
    "expval.set_transpile_options(initial_layout=[3, 2])\n",
    "print(expval.evaluate([0, 1, 1, 2, 3, 5]))\n",
    "expval.transpiled_circuits[0].draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9185b9ae",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Large number of shots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "620b76bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_shots 8192\n",
      "Number of shots specified: 10000 exceeds max_shots property of the backend: 8192.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    from qiskit import QuantumCircuit, QiskitError\n",
    "    qc = QuantumCircuit(1, 1)\n",
    "    qc.h(0)\n",
    "    qc.measure(0, 0)\n",
    "    from qiskit import IBMQ\n",
    "    prov = IBMQ.load_account()\n",
    "    ibmq_qasm_sim = prov.get_backend('ibmq_qasm_simulator')\n",
    "    print(f\"max_shots {backend.configuration().max_shots}\")\n",
    "    ibmq_qasm_sim.run(qc, shots=10000).result().get_counts()\n",
    "except QiskitError as ex:\n",
    "    print(ex.message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9cb73555",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ExpectationValueResult(value=-1.28629134229759, variance=0.3013702509749989, confidence_interval=(-1.2955064759928994, -1.2770762086022804))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expval = PauliExpectationValue(ansatz, observable, backend=ibmq_qasm_sim)\n",
    "expval.evaluate([0, 1, 1, 2, 3, 5], shots=10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88234028",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Readout error mitigation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c992bb1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w/o mitigation shots=4000, result=ExpectationValueResult(value=-1.2595981522160702, variance=0.3167834517853961, confidence_interval=(-1.2745298670322645, -1.244666437399876))\n",
      "w/ tensored mitigation shots=4000, result=ExpectationValueResult(value=-1.2774601799810748, variance=0.3030202762495204, confidence_interval=(-1.292072288559631, -1.2628480714025185))\n",
      "w/ M3 mitigation shots=4000, result=ExpectationValueResult(value=-1.274027046504209, variance=0.3045704741174017, confidence_interval=(-1.2886772367653694, -1.2593768562430485))\n"
     ]
    }
   ],
   "source": [
    "from qiskit.evaluators.backends import ReadoutErrorMitigation\n",
    "\n",
    "backend = AerSimulator.from_backend(FakeBogota())\n",
    "mit_tensored = ReadoutErrorMitigation(\n",
    "    backend, mitigation=\"tensored\", refresh=600, shots=2000, mit_pattern=[[0], [1]]\n",
    ")\n",
    "mit_mthree = ReadoutErrorMitigation(\n",
    "    backend, mitigation=\"mthree\", refresh=600, shots=2000, qubits=[0, 1]\n",
    ")\n",
    "expval_raw = PauliExpectationValue(ansatz, observable, backend=backend)\n",
    "expval_tensored = PauliExpectationValue(ansatz, observable, backend=mit_tensored)\n",
    "expval_mthree = PauliExpectationValue(ansatz, observable, backend=mit_mthree)\n",
    "shots = 4000\n",
    "print(f\"w/o mitigation shots={shots}, result={expval_raw.evaluate([0, 1, 1, 2, 3, 5], shots=shots)}\")\n",
    "print(f\"w/ tensored mitigation shots={shots}, result={expval_tensored.evaluate([0, 1, 1, 2, 3, 5], shots=shots)}\")\n",
    "print(f\"w/ M3 mitigation shots={shots}, result={expval_mthree.evaluate([0, 1, 1, 2, 3, 5], shots=shots)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce3810ee",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Gradient of expectation value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3070586b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.evaluators.expectation_value.expectation_value_gradient import (\n",
    "    FiniteDiffGradient,\n",
    "    ParameterShiftGradient,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "06c9d4ac",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fin diff of exact [ 0.28213347  0.42656751  0.20442583  0.42656749 -0.17291453  0.0589814 ]\n",
      "param shift of exact [ 0.28213349  0.42656754  0.20442588  0.42656754 -0.17291452  0.05898141]\n",
      "fin diff w/o mit [ 0.16262713  0.4314544   0.34752583  0.24589932 -0.12426491  0.28484219]\n",
      "param shift w/o mit [ 0.24911042  0.3794629   0.17450169  0.38138296 -0.14381146  0.05720959]\n",
      "fin diff w/  mit [ 0.47428411  0.28015226  0.39108048  0.59261647 -0.07708405  0.07528248]\n",
      "param shift w/  mit [ 0.27310091  0.40288055  0.20674927  0.41180033 -0.16378474  0.05274286]\n"
     ]
    }
   ],
   "source": [
    "parameters = [0, 1, 1, 2, 3, 5]\n",
    "\n",
    "exact_expval = ExactExpectationValue(ansatz, observable, backend=AerSimulator())\n",
    "exact_findiff = FiniteDiffGradient(exact_expval, 1e-8)\n",
    "print(f\"fin diff of exact {exact_findiff.evaluate(parameters).values}\")\n",
    "\n",
    "exact_expval = ExactExpectationValue(ansatz, observable, backend=AerSimulator())\n",
    "exact_findiff = ParameterShiftGradient(exact_expval)\n",
    "print(f\"param shift of exact {exact_findiff.evaluate([0, 1, 1, 2, 3, 5]).values}\")\n",
    "\n",
    "shots = 2000\n",
    "findiff = FiniteDiffGradient(expval_raw, 1e-1)\n",
    "paramshift = ParameterShiftGradient(expval_raw)\n",
    "print(f\"fin diff w/o mit {findiff.evaluate(parameters, shots=shots).values}\")\n",
    "print(f\"param shift w/o mit {paramshift.evaluate(parameters, shots=shots).values}\")\n",
    "\n",
    "findiff = FiniteDiffGradient(expval_mthree, 1e-1)\n",
    "paramshift = ParameterShiftGradient(expval_mthree)\n",
    "print(f\"fin diff w/  mit {findiff.evaluate([0, 1, 1, 2, 3, 5], shots=shots).values}\")\n",
    "print(f\"param shift w/  mit {paramshift.evaluate(parameters, shots=shots).values}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ced77786",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### VQE by Scipy optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7dd56dfc",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      fun: -1.847151931688854\n",
      " hess_inv: array([[ 1.81424069e+00, -7.89703086e-01, -5.73244156e-01,\n",
      "        -2.21914037e-01,  5.87909808e-01,  4.22230305e-01],\n",
      "       [-7.89703086e-01,  1.55393010e+00,  1.62068458e-01,\n",
      "         6.68346234e-02, -6.46365845e-01, -6.41520197e-01],\n",
      "       [-5.73244156e-01,  1.62068458e-01,  1.89981547e+00,\n",
      "        -1.39292826e-03, -7.06428492e-01, -1.19853898e-01],\n",
      "       [-2.21914037e-01,  6.68346234e-02, -1.39292826e-03,\n",
      "         8.57102253e-01, -1.72732718e-01, -1.63459541e-01],\n",
      "       [ 5.87909808e-01, -6.46365845e-01, -7.06428492e-01,\n",
      "        -1.72732718e-01,  1.49153981e+00,  4.65053775e-01],\n",
      "       [ 4.22230305e-01, -6.41520197e-01, -1.19853898e-01,\n",
      "        -1.63459541e-01,  4.65053775e-01,  1.12790465e+00]])\n",
      "      jac: array([-0.02623533,  0.01379811, -0.00251373,  0.02619514,  0.01860486,\n",
      "       -0.01356285])\n",
      "  message: 'Desired error not necessarily achieved due to precision loss.'\n",
      "     nfev: 69\n",
      "      nit: 9\n",
      "     njev: 57\n",
      "   status: 2\n",
      "  success: False\n",
      "        x: array([-0.83416504,  1.17090196, -1.50548417,  0.83722648, -0.88745376,\n",
      "       -1.0932899 ])\n"
     ]
    }
   ],
   "source": [
    "from scipy.optimize import minimize\n",
    "\n",
    "shots = 1000\n",
    "expval = PauliExpectationValue(ansatz, observable, backend=AerSimulator(), append=True)\n",
    "paramshift = ParameterShiftGradient(expval)\n",
    "# this may take a long time...\n",
    "result = minimize(\n",
    "    lambda x: expval.evaluate(x, shots=shots, seed_simulator=123).value,\n",
    "    np.zeros(6),\n",
    "    jac=lambda x: paramshift.evaluate(x, shots=shots, seed_simulator=123).values,\n",
    ")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "71a0aed0",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtkAAAHgCAYAAABw0HFmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxzklEQVR4nO3de3ydVZ3v8e+vSZuWprZcUtpCSVqUdDC1oUQUtfaGHmAUho5YPXM97cjrvIaZ0RwZX/bMQTZUWz1H7cy5jHM6tspchAoDZQZQhHApooJpC3aXUh2B0nIpUYQ2tDS9/M4fa+cQ2p1kJ3mevfbl8369ntez91orO78+bpMvT9Zey9xdAAAAAJIzKnYBAAAAQKUhZAMAAAAJI2QDAAAACSNkAwAAAAkjZAMAAAAJI2QDAAAACauNXUAaTjvtNG9qaopdBgAAACrY5s2bf+XuDfn6KjJkNzU1qbOzM3YZAAAAqGBmtqu/PqaLAAAAAAkjZAMAAAAJI2QDAAAACSNkAwAAAAkjZAMAAAAJI2QDAAAACSNkAwAAAAkjZAMAAAAJI2QDAAAACSNkAwAAAAkjZAMAAAAJI2QDAAAACSNkAwAAAAkjZAMAAAAJI2QDAAAACSNkAwAAAAkjZI9Qd7e0cqXU1CTV1ITzypWhHQAAANWJkD0C3d3S4sVSNitt3CgdOhTO27aFdoI2AABAdSJkD1MmI02aJJ1+unTzzVJrq1RbG84bNkiTJ4f+TCZmlQAAAIjB3D12DYlra2vzzs7O1L9PU1O4c93aemLf1q3SkiXSM8+kXgYAAAAiMLPN7t6Wr4872SOwe7fU0pK/r6Ul9AMAAKD6ELJHYPr0MB87n2w29AMAAKD6ELJHYPlyadUq6fgZN+7S6tXSsmVx6gIAAEBchOxhymSkL3xBuusu6bLLwhzsw4fD+bLLQvsXvsAHHwEAAKoRIXuYMplwx3rvXumCC8KHHMeNCwH7+9+XPvax0E/IBgAAqD6E7BGqr5euvTasInLkSPiw4zXXSP/wD9L3vhe7OgAAAMRAyE5BJiO9853Sn/yJ9JvfxK4GAAAAxUbITkFdnfTtb4epJO3tsasBAABAsRGyU9LWJq1YId14o/Rv/xa7GgAAABQTIbsILrtMMuv/4MORAAAAlYWQnaKVK6UtW6SamrD1+qRJIVQ3Nko33CDt388KJAAAAJWIkJ2yd7wj7Pw4fbr0wANST4+0caO0bZu0eLHU3R27QgAAACSNkJ2yNWvCOtp33BHuZtfWhvOGDeGO9po1sSsEAABA0gjZKVu3LnwA0uyt7Wahff36OHUBAAAgPYTslO3eLbW05O9raQn9AAAAqCyE7JRNny5ls/n7stnQDwAAgMpCyE7Z8uXSqlVhFZG+3KXVq6Vly+LUBQAAgPQQslPW3i7t2iUtXSpt3SodPhzOS5eGdnaEBAAAqDxRQraZXWlm283smJm1DTBuvZm9bGb9TLgoffX1UkeHNHu2tGhR2HL9kkvC846O0A8AAIDKEutOdlbSEkmbBhn3bUkXp15NSjKZsIrIhAnSF74gvfpqmCayd294PmECOz4CAABUotoY39Tdd0iSHb+u3YnjNplZUzFqSkMmc2KAft/7wt3sBx6IUREAAACKoWLmZJvZVWbWaWadXV1dscvpV3OztHNn7CoAAACQptRCtpndZ2bZPMflaXw/d1/r7m3u3tbQ0JDGt0hEc7P04ovSvn2xKwEAAEBaUpsu4u4XpfXa5ay5OZx37pTe/e64tQAAACAdFTNdpFzMmhXOTBkBAACoXLGW8LvCzPZIulDSXWZ2T659mpnd3WfcTZJ+LKnZzPaY2fIY9Sbp7LOlmhpCNgAAQCWLtbrI7ZJuz9P+gqRL+zz/ZDHrKoYxY6QZMwjZAAAAlYzpIhE0N0tPPRW7CgAAAKSFkB3BrFnSL34hHTsWuxIAAACkgZAdQXOz9MYb0nPPxa4EAAAAaSBkR9B3GT8AAABUHkJ2BL0hm3nZAAAAlYmQHcHkydLEidzJBgAAqFSE7AjMwocfCdkAAACViZAdSXMzIRsAAKBSEbIjaW6Wnn9e2r8/diUAAABIGiE7kt4PP/7853HrAAAAQPII2ZHMmhXOTBkBAACoPITsSN7+dmnUKEI2AABAJSJkR1JXJzU1sVY2AABAJSJkR8QKIwAAAJWJkB3RrFnhg4/HjsWuBAAAAEkiZEfU3CwdPCjt2RO7EgAAACSJkB1R7zJ+zMsGAACoLITsiHpDNvOyAQAAKgshO6IpU6S3vY2QDQAAUGkI2RGZscIIAABAJSJkR9bczJxsAACASkPIjqy5Oawu8vrrsSsBAABAUgjZkfV++PHnP49bBwAAAJJDyI5s1qxwZl42AABA5SBkR/b2t4cPQDIvGwAAoHIQsiMbN05qbORONgAAQCUhZJcAlvEDAACoLITsEjBrVgjZx47FrgQAAABJIGSXgOZm6cAB6fnnY1cCAACAJBCyS0DvMn5MGQEAAKgMhOwSQMgGAACoLITsEjBtmlRfT8gGAACoFITsEmAW7mazVjYAAEBlIGSXCJbxAwAAqByE7MgymXAn+zvfkZ57LjzOd2QysSsFAABAoQjZkWUykru0YUN4fv750vz5oa3vQcgGAAAoH4TsEtG7wsiBA3HrAAAAwMgRskvEO94RzoRsAACA8kfILhEnnSSddZZ08GDsSgAAADBShOwS0ru9OgAAAMpblJBtZlea2XYzO2Zmbf2MmW5mD5jZk7mxny52ncU2a1a4k+0euxIAAACMRKw72VlJSyRtGmDMEUmfdfdzJb1X0tVmdm4xiouhu1t65hmprk56+GGpqUlauTK0AwAAoLxECdnuvsPdB9x6xd1fdPctucf7Je2QdEYx6iu27m5p8WJp7FjpkUeknh5p40Zp27bQTtAGAAAoL2UxJ9vMmiSdJ+nRAcZcZWadZtbZ1dVVtNqSsGZNuHP93e9Kra1SbW04b9ggNTaGfgAAAJSP1EK2md1nZtk8x+VDfJ16Sf8i6TPuvq+/ce6+1t3b3L2toaFhpOUX1bp10ooVYWfHvsxC+/r1ceoCAADA8NSm9cLuftFIX8PMRisE7H9299tGXlVp2r1bamnJ39fSEvoBAABQPkp2uoiZmaR1kna4+9dj15Om6dOlbDZ/XzYb+gEAAFA+Yi3hd4WZ7ZF0oaS7zOyeXPs0M7s7N+z9kv5A0iIzezx3XBqj3rQtXy6tWnXi0n3u0urV0rJlceoCAADA8JhX4KLMbW1t3tnZGbuMgvWuLtLYGOZgt7SEO9hf/KK0Z4/U0SHV18euEgAAAH2Z2WZ3z7vnS2pzslG4+voQpNeskRYtkvbtC20TJ0rbtxOwAQAAyk3JzsmuNvX10rXXSnPmSPPmSV/7WvjA449/HLsyAAAADBUhu0T9wR9IZ5wR5moDAACgvBCyS1RdnXTNNdJDD4UPPpoNfmQysasGAACAxJzskvapT0lf+pK0d+9bVx5ZsCCcH3wwRlUAAAAYDHeyS9j48dJnPiPdfbf0+OOxqwEAAEChCNkl7uqrpQkTwnrZAAAAKA+E7BI3aVII2rfcIv3857GrAQAAQCGYkx1ZJiNdf/2J7WZvfV5TI335y9L69UUpCwAAACPAnezIMpnwocbBjj/9U+kf/1F67rnYFQMAAGAwhOwycc014fzVr8atAwAAAINjukiZOOss6ROfkNaulcaODVuvNzVJy5dL7e1svQ4AAFBKuJNdJrq7pW3bpA9/OKyP3dMjbdwY2hYvDv0AAAAoDYTsMrFmjdTcLN1xh9TaKtXWhvOGDVJjY+gHAABAaSBkl4l166QVK05cdcQstLPqCAAAQOkgZJeJ3bullpb8fS0toR8AAAClgZBdJqZPl7LZ/H3ZbOgHAABAaSBkl4nly6VVq8Ka2X25hy3Xly2LUxcAAABORMguE+3t0q5d0tKl0tat0uHD4bx0aWhvb49dIQAAAHoRsstEfb3U0SHNni0tWhTWyl60KDzv6GCdbAAAgFJCyC4j9fXStddKc+ZI06ZJBw5In/0sARsAAKDUELLL1KRJYUOan/wkdiUAAAA4HiG7TE2cKI0aJT30UOxKAAAAcDxCdpmqrZXOO4+QDQAAUIoI2WVs/vwwXeSNN2JXAgAAgL4I2WVswQLp0CHp0UdjVwIAAIC+CNllbN48yYwpIwAAAKWGkF0GMpkQpnuPhx4Kx8knhx0fr7sutGcysSsFAACARMguC5lMCNP5jk9/Who3LszLJmQDAACUBkJ2mVuwQDp4UPrpT2NXAgAAgF6E7DI3b144My8bAACgdBCyy9ypp0qzZxOyAQAASgkhuwLMny898oh0+HDsSgAAACARsivCggXSgQNSZ2fsSgAAACARsivCBz8YzkwZAQAAKA2E7ArQ0CCdey4hGwAAoFQQsivE/PnSD38oHTkSuxIAAAAQsivEggVSd7e0ZUvsSgAAAEDIrhCPPRbO73nPW7dgP/5gV0gAAID01cYuAMn46lelO++U3v72cF6wILQ/+GDMqgAAAKpTlDvZZnalmW03s2Nm1tbPmLFm9piZPZEbe32x6yw38+dLDz8sHT0auxIAAIDqFmu6SFbSEkmbBhhzSNIid58jqVXSxWb23iLUVrYWLJD27ZMefzx2JQAAANUtynQRd98hSWY20BiX1J17Ojp3eOrFlbH588OZpfwAAADiKukPPppZjZk9LullSfe6+6MDjL3KzDrNrLOrq6toNZaSadPCnGxCNgAAQFyphWwzu8/MsnmOywt9DXc/6u6tks6UdIGZtQwwdq27t7l7W0NDQwL/gvI0f760aZPk3PMHAACIJrXpIu5+UYKv9aqZPSDpYoX53OjHggXSunXS669L9fWxqwEAAKhOJTtdxMwazGxS7vE4SR+S9FTUospA77zsV1+NWgYAAEBVi7WE3xVmtkfShZLuMrN7cu3TzOzu3LCpkh4ws59J+qnCnOw7Y9RbTk4+WTr1VGnv3jBtpKlJWrky7AYJAACA4ogSst39dnc/093r3P10d/8PufYX3P3S3OOfuft57v4ud29x9xti1FpOurulxYulefPCetk9PdLGjdK2baGdoA0AAFAcJTtdBEO3Zk24c33bbVJrq1RbG84bNkiNjaEfAAAA6SNkV5B166QVK6Tjlx83C+3r18epCwAAoNoQsivI7t1SSz+LHLa0hH4AAACkj5BdQaZPl7L9LHCYzYZ+AAAApI+QXUGWL5dWrTpxIxp3afVqadmyOHUBAABUG0J2BWlvl3btkpYulbZulQ4fDuelS0N7e3vsCgEAAKoDIbuC1NdLHR3S7NnSwoVSXZ10ySXheUcHO0ACAAAUCyG7wtTXS9deK82ZE5bwu/ji8JyADQAAUDyE7AplJk2YIG3ZErsSAACA6kPIrmD19dKTT0oHD8auBAAAoLoQsivYhAnS0aPSz34WuxIAAIDqQsiuYL3zsJkyAgAAUFyE7ApWVyedcgohGwAAoNgI2RXMTDr/fEI2AABAsRGyK9zcudK2bVJPT+xKAAAAqgchu0JkMuHOde/x0EPh+MpXws6PdXWhPZOJXSkAAEDlI2RXiExGcj/x+MUvQv/f/314TsgGAABIHyG7wp19tjRxIvOyAQAAiomQXeHMpPPOI2QDAAAUEyG7CsydKz3xhHTkSOxKAAAAqgMhuwrMnSu98Ya0Y0fsSgAAAKoDIbsKzJ0bzkwZAQAAKA5CdhU45xxp/HhCNgAAQLEQsqtATY3U2krIBgAAKBZCdpWYO1faulU6ejR2JQAAAJWPkF0l5s6VXn/9zc1pAAAAkB5CdpXgw48AAADFQ8iuEueeK40dS8gGAAAoBkJ2laitld71LkI2AABAMRCyq8jcuSFku8euBAAAoLIRsqvI3LnSa69JTz8duxIAAIDKRsiuInz4EQAAoDgI2VWkpUUaPZqQDQAAkDZCdhWpqwtBe/Pm2JUAAABUNkJ2Fclkwq6P994rmfV/ZDKxKwUAAChvtbELQPFkMtLkydLVV0u7dkl/+Ieh/cEHY1YFAABQebiTXWX48CMAAED6CNlVZs4cqaaGkA0AAJAmQnaVGTdO+q3f4sOPAAAAaSJkV6HenR8BAACQjigh28yuNLPtZnbMzNoGGVtjZlvN7M5i1Vfp5s6VXnpJOnQodiUAAACVKdad7KykJZI2FTD205J2pFtOden98GN3d9w6AAAAKlWUkO3uO9x952DjzOxMSb8t6ZvpV1U9WlvDetiEbAAAgHSU+pzsv5b0OUnHBhtoZleZWaeZdXZ1daVeWDmbMEE65xxp//7YlQAAAFSm1EK2md1nZtk8x+UFfv1HJL3s7gWtg+Hua929zd3bGhoaRlR7pevulsaOld54Q9q0SWpqklau5M42AABAUlIL2e5+kbu35DnuKPAl3i/pMjN7VtLNkhaZ2T+lVW+16O6WFi+Wzj5b+uEPpZ4eaeNGadu20E7QBgAAGLmSnS7i7ivc/Ux3b5L0CUn3u/vvRy6r7K1ZE+5c33prmJtdWxvOGzZIjY2hHwAAACMTawm/K8xsj6QLJd1lZvfk2qeZ2d0xaqoW69ZJK1aEDz72ZRba16+PUxcAAEAlMXePXUPi2travLOzM3YZJammJqyPXVt7Yt/hw2FHyCNHil8XAABAuTGzze6ed8+Xkp0ugnRMny5ls/n7stnQDwAAgJEhZFeZ5culVauk4/+A4S6tXi0tWxanLgAAgEpCyK4y7e3Srl3S0qXS1q1hisjWreH5rl2hHwAAACNDyK4y9fVSR4c0e7a0aJFUVxfOs2eH9vr62BUCAACUP0J2Faqvl669VpozR5o2LWxK87nPEbABAACSQsiucpMmhZD9k5/ErgQAAKByFBSyzexrZvbOtItB8U2cGNbIfuCB2JUAAABUjkLvZO+QtNbMHjWz/2xmE9MsCsUzerQ0dy4hGwAAIEkFhWx3/6a7v1/SH0pqkvQzM/uOmS1MszgUx8KFYbrIwYOxKwEAAKgMBc/JNrMaSbNyx68kPSHpv5jZzSnVhiJZuFDq6ZF+9KPYlQAAAFSGQudkr5G0U9Klkla5+/nu/hV3/6ik89IsEOmbNy9st37//bErAQAAqAy1BY77maT/5u6v5+m7IMF6EMGECVJbG/OyAQAAklJoyH5CUrOZ9W17TdIud38t8aqQikxGuv76E9v7/s9qJl13XRgLAACA4Sl0TvbfSvqJpLWS/l7SjyXdImmnmX04pdqQsExGcs9//OAHYcz3vkfABgAAGKlCQ/YLks5z9zZ3P19hHvbTkj4k6b+nVRyK5/3vD8v5MWUEAABg5AoN2ee4+/beJ+7+pKRZ7v50OmWh2E46SXrPewjZAAAASSg0ZD9pZt8ws/m5429zbXWSDqdYH4po4UJp82bpNWbZAwAAjEihIfuPJP27pM/kjqcl/bFCwGZDmgqxcKF07Ji0aVPsSgAAAMrboKuL5DahudvdF0r6Wp4h3YlXhSguvFCqqwtTRj760djVAAAAlK9B72S7+1FJx8xsYhHqQURjx0rvex/zsgEAAEaq0HWyuyVtM7N7Jf3/DWnc/S9SqQrRLFwY1sl+5RXplFNiVwMAAFCeCp2TfZukayVtkrS5z4EKs3BhWDf7oYdiVwIAAFC+CrqT7e43mtk4SWe5+86Ua0JE99wTzkuWDDyOXSEBAAD6V1DINrOPSvqqpDGSZphZq6Qb3P2yFGtDBCtXSo89Jj3/vJTNSgsWhPYHH4xZFQAAQHkpdLpIRtIFkl6VJHd/XNLMVCpCdAsXStu3Sy+/HLsSAACA8lRoyD7s7sdvUXIs6WJQGhbmVj7n7jUAAMDwFLq6yHYz+4+SaszsHZL+QtKP0isLMZ1/vjRhAkv5AQAADFehd7L/XNI7JR2SdJOkfQo7P6IC1dZK8+ZJ998fuxIAAIDyVOjqIgck/VXuQBVYuFC6++6wVnZdXexqAAAAykuhq4ucI+kaSU19v8bdF6VTFmJblPtf9tVXpdNPj1oKAABA2Sl0TvYtkv5O0jclHU2vHJSKs8+Wxo+X9uyRdu6Umpqk5cul9napvj52dQAAAKWt0DnZR9z9G+7+mLtv7j1SrQzRdHdLH/6w9KEPSQ8/LPX0SBs3Stu2SYsXh34AAAD0r9CQ/W9m9qdmNtXMTuk9Uq0M0axZE+5c33ab1NoaPgjZ2ipt2CA1NoZ+AAAA9M/cffBBZs/kaXZ3L8kNadra2ryzszN2GWWrqSncuW5tPbFv69aw5foz+d4RAAAAVcTMNrt7W76+QlcXmZFsSShlu3dLLS35+1paQj8AAAD6N+B0ETP7XJ/HVx7XtyqtohDX9OlSNpu/L5sN/QAAAOjfYHOyP9Hn8Yrj+i5OuBaUiOXLpVWrpONnErlLq1dLy5bFqQsAAKBcDBayrZ/H+Z6jQrS3S7t2SUuXhjnYhw+H89Klob29PXaFAAAApW2wkO39PM73HBWivl7q6JBmz5YWLAg7Pl5xRXje0cE62QAAAIMZcHURMzsq6XWFu9bjJB3o7ZI01t1Hp17hMLC6SHJaWqTt26XHHpPe/e7Y1QAAAJSOgVYXGfBOtrvXuPvb3H2Cu9fmHvc+H3bANrMrzWy7mR0zs7yF5cY9a2bbzOxxMyM1RzBuXDg//XTcOgAAAMpJoduqJy0raYmk/1vA2IXu/quU60E/xo4NZ0I2AABA4aKEbHffIUlmfHay1NXUSKNHE7IBAACGotBt1WNxST8ws81mdtVAA83sKjPrNLPOrq6uIpVXHcaOJWQDAAAMRWp3ss3sPklT8nT9lbvfUeDLfMDdnzezyZLuNbOn3H1TvoHuvlbSWil88HFYRSOvcePYRh0AAGAoUgvZ7n5RAq/xfO78spndLukCSXlDNtIzdqz03HNhvezRJbmeDAAAQGkp2ekiZjbezCb0Ppb0YYUPTCJFmYxk9ubx0EMhYB89Ko0Z82Z7JhO7UgAAgNIVJWSb2RVmtkfShZLuMrN7cu3TzOzu3LDTJf3QzJ6Q9Jiku9z9+zHqrSaZTNg+ve/x4IOh795732wjZAMAAPQv1uoit0u6PU/7C5IuzT1+WtKcIpeGPGbODGc+/AgAAFCYkp0ugtIxbVqYKkLIBgAAKAwhG4OqqZGamgjZAAAAhSJkoyAzZhCyAQAACkXIRkFmziRkAwAAFIqQjYLMnCn95jfSq6/GrgQAAKD0EbJRkN4VRtj5EQAAYHCEbBSEZfwAAAAKR8hGQWbMCGdCNgAAwOAI2SjIxInSqacSsgEAAApByEbBWGEEAACgMIRsFIyQDQAAUBhCNgo2c6b07LPS0aOxKwEAAChthGwUbMYM6cgRac+e2JUAAACUNkI2CsZa2QAAAIUhZKNgrJUNAABQGEI2CjZ9ulRTQ8gGAAAYDCEbBautlRobCdkAAACDIWRjSFjGDwAAYHCEbAwJIRsAAGBwhGwMycyZUleXtH9/7EoAAABKFyEbQ8IyfgAAAIMjZGNIWMYPAABgcIRsDMmMGeFMyAYAAOgfIRtDcvLJ0sSJTBcBAAAYCCEbQ2LGCiMAAACDIWRjyAjZAAAAAyNkY8hmzgzTRY4di10JAABAaSJkY8hmzpQOHZJefDF2JQAAAKWJkI0hYxk/AACAgRGyMWSEbAAAgIERsjFkZ50ljRpFyAYAAOgPIRtDNmaMdOaZhGwAAID+ELIxLL0rjAAAAOBEhGwMC2tlAwAA9I+QjWGZOTMs4XfgQOxKAAAASg8hG8PSu8LIs89GLQMAAKAkEbIxLCzjBwAA0D9CNoaFkA0AANA/QjaG5bTTpPp6QjYAAEA+hGwMixkrjAAAAPQnSsg2syvNbLuZHTOztgHGTTKzW83sKTPbYWYXFrNODIyQDQAAkF+sO9lZSUskbRpk3N9I+r67z5I0R9KOtAtD4WbMCBvSuMeuBAAAoLRECdnuvsPddw40xswmSvqgpHW5r+lx91eLUB4GkcmE6SJr1oR1skeNCs+PPzKZ2JUCAADEUcpzsmdI6pL0LTPbambfNLPx/Q02s6vMrNPMOru6uopXZRXKZMLd67vuCs9bW6X580Nb34OQDQAAqlVqIdvM7jOzbJ7j8gJfolbSXEnfcPfzJL0u6fP9DXb3te7e5u5tDQ0NCfwLMJjeZfzeeCNuHQAAAKWmNq0XdveLRvgSeyTtcfdHc89v1QAhG8XX1BTOhGwAAIC3KtnpIu7+kqTdZtaca1os6cmIJeE4Y8dKZ5whHTwYuxIAAIDSEmsJvyvMbI+kCyXdZWb35NqnmdndfYb+uaR/NrOfSWqVtKroxWJAM2dyJxsAAOB4qU0XGYi73y7p9jztL0i6tM/zxyX1u4424ps5U3rssdhVAAAAlJaSnS6C0tfdLe3ZI9XUSJs2hTnaK1eGdgAAgGpGyMawdHdLixdLkyZJjzwi9fRIGzdK27aFdoI2AACoZoRsDMuaNeHO9S23hHWya2vDecMGqbEx9AMAAFQrQjaGZd06acWKsLNjX2ahff36OHUBAACUAkI2hmX3bqmlJX9fS0voBwAAqFaEbAzL9OlSNpu/L5sN/QAAANWKkI1hWb5cWrVKcn9ru7u0erW0bFmcugAAAEoBIRvD0t4u7dolLV0qbd0qHT4czkuXhvb29tgVAgAAxEPIxrDU10sdHdLs2dL8+VJdnbRkSXje0RH6AQAAqpX58X/vrwBtbW3e2dkZu4yq0dgoPfecdORI2JgGAACgGpjZZnfPuzs5d7IxYmPGhHNXV9w6AAAASgUhGyPWG7JfeiluHQAAAKWCkI0R6w3ZL74Ytw4AAIBSQcjGiNXVhTMhGwAAICBkY8gymbB9eu/x6KOhffnyt7ZnMjGrBAAAiIeQjSHLZMKmM32PSZOkP/uzt7YRsgEAQLUiZCMRU6cyXQQAAKAXIRuJmDKF1UUAAAB6EbKRCO5kAwAAvImQjUT0huwK3EAUAABgyAjZSMSUKdLBg9L+/bErAQAAiI+QjURMnRrOTBkBAAAgZCMhhGwAAIA3EbKRCEI2AADAmwjZSMSUKeHMMn4AAACEbCRk0iSpro472QAAABIhGwkxY61sAACAXoRsJIZdHwEAAAJCNhLDnWwAAICAkI3EELIBAAACQjYSM2WK9Mor0qFDsSsBAACIi5CNxPSulb13b9w6AAAAYiNkIzFsSAMAABAQspEYNqQBAAAICNlIDHeyAQAAAkI2EjN5ctiUhpANAACqHSEbiamtDUGbkA0AAKodIRuJYtdHAAAAQjYSxoY0AAAAhGwkjJANAAAQKWSb2ZVmtt3MjplZWz9jms3s8T7HPjP7TJFLxRBNmRI2ozl2LHYlAAAA8cS6k52VtETSpv4GuPtOd29191ZJ50s6IOn24pSH4Zo6VTpyRPr1r2NXAgAAEE+UkO3uO9x95xC+ZLGkX7r7rrRqQjJYKxsAAKB85mR/QtJNAw0ws6vMrNPMOru6uopUFo7Hro8AAAAphmwzu8/MsnmOy4f4OmMkXSbploHGuftad29z97aGhoaRlI4R4E42AACAVJvWC7v7RQm91CWStrj73oReDynqvZNNyAYAANWsHKaLfFKDTBVB6Rg/XpowgZANAACqW6wl/K4wsz2SLpR0l5ndk2ufZmZ39xk3XtKHJN0Wo04Mz9SpzMkGAADVLbXpIgNx99uVZzk+d39B0qV9nr8u6dQiloYEsCENAACoduUwXQRlZsoUQjYAAKhuhGwkjukiAACg2hGykbipU6Xu7nAAAABUI0I2Esda2QAAoNoRspE4dn0EAADVjpCNxHEnGwAAVDtCNhJHyAYAANWOkI3EnXKKNHo000UAAED1ImQjcWaslQ0AAKobIRupYNdHAABQzQjZSAV3sgEAQDUjZCMV7PoIAACqGSEbqZg6Verqkg4fjl0JAABA8RGykYreDWn27o1bBwAAQAyEbKSid61spowAAIBqRMhGKtiQBgAAVDNCNlJByAYAANWMkI1UTJ4czkwXAQAA1YiQjVSMGSOddhp3sgEAQHUiZCM17PoIAACqFSEbqZkyhekiAACgOhGykRruZAMAgGpFyEZqerdWd49dCQAAQHERspGaKVOknh7plVdiVwIAAFBchGykhl0fAQBAtSJkIzVsSAMAAKoVIRupmTIlnAnZAACg2hCykRqmiwAAgGpFyEZqJkyQxo/nTjYAAKg+hGykasoUQjYAAKg+hGykqnetbAAAgGpCyEaq2PURAABUI0I2UkXIBgAA1YiQjVRNmSLt2ycdOBC7EgAAgOIhZCNVLOMHAACqESEbqWLXRwAAUI0I2UgVuz4CAIBqRMhGqpguAgAAqhEhG6k67TSppoY72QAAoLoQspGqUaOk008nZAMAgOoSJWSb2ZVmtt3MjplZ2wDj2nPjsmZ2k5mNLWadGL5MRjILxwsvSN/61pvP+x6ZTOxKAQAAkhfrTnZW0hJJm/obYGZnSPoLSW3u3iKpRtInilMeRiqTkdzD8ZGPSPX10vz5b7b1HoRsAABQiWpjfFN33yFJZjbY0FpJ48zssKSTJL2QcmlIwZQp0qFDsasAAAAonpKdk+3uz0v6qqTnJL0o6TV3/0F/483sKjPrNLPOrq6uYpWJQXR3S7/8pTR6tLRpk9TUJK1cGdoBAAAqVWoh28zuy82lPv64vMCvP1nS5ZJmSJomabyZ/X5/4919rbu3uXtbQ0NDMv8IjEh3t7R4sXTyydIjj0g9PdLGjdK2baGdoA0AACpVaiHb3S9y95Y8xx0FvsRFkp5x9y53PyzpNknvS6teJG/NmnDn+tZbpdZWqbY2nDdskBobQz8AAEAlKtnpIgrTRN5rZidZmLy9WNKOyDVhCNatk1asCKuI9GUW2tevj1MXAABA2mIt4XeFme2RdKGku8zsnlz7NDO7W5Lc/VFJt0raImlbrta1MerF8OzeLbW05O9raQn9AAAAlSjW6iK3S7o9T/sLki7t8/w6SdcVsTQkaPp0KZsNU0SOl82GfgAAgEpUytNFUOaWL5dWrQrrYfflLq1eLS1bFqcuAACAtBGykZr2dmnXLmnpUmnrVunw4XD+2MdCe3t77AoBAADSEWW6CKpDfb3U0RFWEVm0SNq3L7SNHSvt2BEeAwAAVCLuZCNV9fXStddKc+ZI8+ZJN90kvfyydOONsSsDAABIDyEbRXXppdIll0jXXx/CNgAAQCUiZKPovv516fXXwx1uAACASsScbKQikwl3q4/Xd2OatWvD87/7u6KVBQAAUBTcyUYqMpmwVF9/xyuvSKedFj4AefwSfwAAAOWOkI0oTj5Z+uIXpU2bpFtvjV0NAABAsgjZiOb558P54x8P00b6OzKZqGUCAAAMGSEb0dxwg/TAA+Hx4sXSpEkhVDc2hr79+8NUEkI2AAAoN4RsRNXWJk2dKp10UgjcPT3Sxo3Stm0heHd3j/x7ZDID3ykfykHgBwCkrdDfW/xOKm3mFfips7a2Nu/s7IxdBgqwcmUI1Bs2vHXlEfewHfuvfy3df//Iv8911735w2jBgnB+8MH+x+cb09+KKQAAJG2w31v8Thpc32uYFjPb7O5teTvdveKO888/31EeGhvdt27N37dli3tTU3i8f7/7DTe4T5rkbha+7oYbQnsh/YxhTCWNKaVaGMMY3u+MKeUxaZPU6f3kUaaLIKrdu6WWlvx9LS2hv7s7TB3JZvNPKXnppYH7u7sHfw3GMKZcxvB+Z0w1jeH9zpiRjImN6SKIqqkp/J+itfXEvq1bpXnzpLPPls45R/rud/NPKXnlFenUU6Wbb87fP3t2eJ7NMoYx5T+G9ztjqmkM73fGjGRMMXaWZroIStYNN7hfeaX7sWNvbT92zP13f9f9wgvd6+sHnlIyWP8pp4Q/JQ00ZuLEwcc0NIRjoDGnn+4+eTJjGJPemMHe76VWL2MYM5Ix5fZ+nzx58N8TDQ3up502+O+tk08eeMypp4ajVP7tpTamd7pp2jTAdBHuZCOq3j/3NDZKK1aEKSLZrLR6tbRrl9TRIU2cKB06JNXWnvj1hw9LdXXhz0T99Y8dG/7LdqRj6urCY8YwJvaYUqqFMYxJe0wp1VKsMfzeGvmYceOkI0dO7EvaQHeymZONqOrrQ5CePVtatCj80FiyJDzv6Aj906eH4J1PNhvGDNR/1lnhGOmYxsbCXmewehnDmJGMKeT9Xkr1MoYxIxlTbu/3Qn5PFPq7JKkxpXR9ijlm+vT8fcXEnWxEU+jyQ4sWhTl5/S3z98or0imn9N/fO3droKUCGcOYchnD+50x1TSG9ztjRjKGOdnMycYg9u93v+CCMHd7yxb3np5wvvLK0P7iiwP3798/+GswhjHlMob3O2OqaQzvd8aMZEwxaIA52dEDcRoHIbvy9F0Lc9So8IGG/tZRzdfPGMZU0phSqoUxjOH9zphSHpO2gUI200VQVgbbrXEku2IlsSskYxhTzDGlVAtjGMP7nTGlPCYtA00XyfOZTKB09BeQ+86/yuf4/sG2Vu39Psd/r8G+D2MYUwpjSqkWxjAm7TGlVAtjSntMMbZVHwh3sgEAAIBhYAk/AAAAoIgI2QAAAEDCCNkAAABAwgjZAAAAQMII2QAAAEDCCNkAAABAwgjZAAAAQMII2QAAAEDCCNkAAABAwgjZAAAAQMII2QAAAEDCCNkAAABAwgjZAAAAQMII2QAAAEDCCNkAAABAwgjZAAAAQMII2QAAAEDCCNkAAABAwszdY9eQODPrkrQrwrc+TdKvInzfasN1Th/XuDi4zunjGhcH1zl9XOPiGOp1bnT3hnwdFRmyYzGzTndvi11HpeM6p49rXBxc5/RxjYuD65w+rnFxJHmdmS4CAAAAJIyQDQAAACSMkJ2stbELqBJc5/RxjYuD65w+rnFxcJ3TxzUujsSuM3OyAQAAgIRxJxsAAABIGCE7IWZ2sZntNLN/N7PPx66nEpjZejN72cyyfdpOMbN7zewXufPJMWssd2Y23cweMLMnzWy7mX061851TpCZjTWzx8zsidx1vj7XPsPMHs393NhgZmNi11ruzKzGzLaa2Z2551zjhJnZs2a2zcweN7POXBs/MxJmZpPM7FYze8rMdpjZhVzn5JhZc+493HvsM7PPJHmNCdkJMLMaSf9H0iWSzpX0STM7N25VFeHbki4+ru3zkjrc/R2SOnLPMXxHJH3W3c+V9F5JV+feu1znZB2StMjd50hqlXSxmb1X0lckrXH3t0v6jaTl8UqsGJ+WtKPPc65xOha6e2ufpc74mZG8v5H0fXefJWmOwvua65wQd9+Zew+3Sjpf0gFJtyvBa0zITsYFkv7d3Z929x5JN0u6PHJNZc/dN0l65bjmyyXdmHt8o6TfKWZNlcbdX3T3LbnH+xV+iJ8hrnOiPOjOPR2dO1zSIkm35tq5ziNkZmdK+m1J38w9N3GNi4WfGQkys4mSPihpnSS5e4+7vyquc1oWS/qlu+9SgteYkJ2MMyTt7vN8T64NyTvd3V/MPX5J0ukxi6kkZtYk6TxJj4rrnLjcNIbHJb0s6V5Jv5T0qrsfyQ3h58bI/bWkz0k6lnt+qrjGaXBJPzCzzWZ2Va6NnxnJmiGpS9K3ctOfvmlm48V1TssnJN2Ue5zYNSZko2x5WBqH5XESYGb1kv5F0mfcfV/fPq5zMtz9aO7Pkmcq/PVrVtyKKouZfUTSy+6+OXYtVeAD7j5XYYrk1Wb2wb6d/MxIRK2kuZK+4e7nSXpdx01b4DonI/c5jcsk3XJ830ivMSE7Gc9Lmt7n+Zm5NiRvr5lNlaTc+eXI9ZQ9MxutELD/2d1vyzVznVOS+5PvA5IulDTJzGpzXfzcGJn3S7rMzJ5VmLK3SGFOK9c4Ye7+fO78ssIc1gvEz4yk7ZG0x90fzT2/VSF0c52Td4mkLe6+N/c8sWtMyE7GTyW9I/cp9jEKf3b418g1Vap/lfRHucd/JOmOiLWUvdyc1XWSdrj71/t0cZ0TZGYNZjYp93icpA8pzH9/QNLHcsO4ziPg7ivc/Ux3b1L4GXy/u/+euMaJMrPxZjah97GkD0vKip8ZiXL3lyTtNrPmXNNiSU+K65yGT+rNqSJSgteYzWgSYmaXKswHrJG03t2/FLei8mdmN0laIOk0SXslXSdpo6TvSjpL0i5JH3f34z8ciQKZ2QckPSxpm96cx/pfFeZlc50TYmbvUvgATY3CzY3vuvsNZjZT4a7rKZK2Svp9dz8Ur9LKYGYLJF3j7h/hGicrdz1vzz2tlfQdd/+SmZ0qfmYkysxaFT7EO0bS05L+k3I/P8R1TkTuPxSfkzTT3V/LtSX2XiZkAwAAAAljuggAAACQMEI2AAAAkDBCNgAAAJAwQjYAAACQMEI2AAAAkDBCNgCUODM7amaP9zk+P/hX5X2dB82sLen6Cvi+v2Nm5xb7+wJATLWDDwEARHYwtyV7ufodSXcqbKYBAFWBO9kAUIbM7GIzu6XP8wVmdmfu8TfMrNPMtpvZ9QW81rvN7Edm9oSZPWZmE8xsrJl9y8y2mdlWM1uYG/vHZva/+3ztnbnNX2Rm3Wb2pdzr/MTMTjez90m6TNL/yN2FPzvZKwEApYmQDQClb9xx00WWSrpP0ntyO5ZJ0lKFnQ0l6a/cvU3SuyTNz+04mZeZjZG0QdKn3X2OpIskHZR0tSR399kK2w7faGZjB6lzvKSf5F5nk6RPufuPFLYp/kt3b3X3Xw7j3w8AZYeQDQCl72AuoPYeG9z9iKTvS/qomdVK+m1Jd+TGf9zMtihsI/5OSQPNh26W9KK7/1SS3H1f7rU/IOmfcm1PKWwvfM4gdfYoTAuRpM2Smob47wSAisGcbAAoXzdL+jNJr0jqdPf9ZjZD0jWS3u3uvzGzb0sa7A70UBzRW2/Q9H3tw+7uucdHxe8YAFWMO9kAUL4ekjRX0qf05lSRt0l6XdJrZna6pEsGeY2dkqaa2bslKTcfu1bSw5J+L9d2jqSzcmOfldRqZqPMbLqkCwqoc7+kCUP4dwFA2SNkA0DpO35O9pclyd2PKkzPuCR3lrs/oTBN5ClJ35H0yEAv7O49CvO5/5eZPSHpXoW7038raZSZbVOYs/3H7n4o93rPKKwU8j8lbSmg/psl/WXuA5R88BFAVbA3/7IHAAAAIAncyQYAAAASRsgGAAAAEkbIBgAAABJGyAYAAAASRsgGAAAAEkbIBgAAABJGyAYAAAASRsgGAAAAEvb/AF5Ik39UbnAaAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from qiskit.evaluators.results import ExpectationValueResult\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "y = [h.value for h in expval.history if isinstance(h, ExpectationValueResult)]\n",
    "x = list(range(len(y)))\n",
    "yerr = np.array(\n",
    "    [tuple(abs(c - h.value) for c in h.confidence_interval) for h in expval.history if isinstance(h, ExpectationValueResult)]\n",
    ").transpose()\n",
    "plt.plot(y, color=\"blue\")\n",
    "plt.errorbar(x, y, yerr=yerr, capsize=5, fmt=\"o\", markersize=8, ecolor=\"blue\", markeredgecolor=\"blue\", color=\"w\")\n",
    "plt.xlabel(\"Eval count\")\n",
    "plt.ylabel(\"Energy\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d35b5d6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Current status\n",
    "\n",
    "The following classes and features have been implemented.\n",
    "\n",
    "Expectation value classes\n",
    "- `PauliExpectationValue`: expectation value for shot-based backends (both AerBackend and IBMQBackend) \n",
    "- `ExactExpectationValue`: exact expectation value with `SaveExpectationValueVariance` instruction supported only by Aer\n",
    "\n",
    "Gradient of expectation value classes\n",
    "- `FiniteDiffGradient`: finite difference gradient\n",
    "- `ParameterShiftGradient`: parameter shift rule for the simple cases (parameters appears only once and they have coefficient 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2691314",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Features\n",
    "- Separate transpilation of ansatz and Pauli strings\n",
    "  - A parameterized circuit corresponding to an ansatz is usually shared by Pauli strings that comprise the observable. This technique reduces the duplicate transpile of the shared part.\n",
    "- Take a history of evaluations so that users can make a plot of optimization\n",
    "  - Optimization algorithms e.g., [Scipy.optimize.minimize](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html), should take care of the history. But, [OptimizeResult](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.OptimizeResult.html#scipy.optimize.OptimizeResult) is not enough to include variance and confidence interval of expectation values.\n",
    "- Backend wrapper\n",
    "  - Retry of job submission in case of cancel and/or network error\n",
    "  - Split circuits if the size is larger than `max_experiments`\n",
    "  - Copy circutis to realize users-set `shots` that is more than `max_shots`\n",
    "  - Readout error mitigation (tensored, complete, M3)\n",
    "    - Periodical calibration, e.g., calibration every 30 minutes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a9eb6c2",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Questions\n",
    "- Why does expval take care of backend as backend wrapper?\n",
    "  - `QuantumInstance` of terra and `IBMQJobManager` (ManagedJob) of IBMQ provider can take care of only the split of circuits to satisfy `max_experiments`. But, as far as we know, there is no feature to realize `shots` more than `max_shots`. If this feature is implemented as part of IBMQ provider, it cannot be used for other backends, e.g., AQT and IonQ. Should it be part of terra?\n",
    "  - We experimentally }implemented preemptive readout error mitigation calibration, i.e., we put the calibration job between a set of jobs generated by the split or copy of circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a4a436b",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "TODOs\n",
    "- Finalize the interface of the design\n",
    "- Make a PR of the first release of the expectation value\n",
    "\n",
    "Ultimate goals (not necessarily inclueded as part of the first PR)\n",
    "- Grouping algorithms of operators, AbelienGrouper (tensor product basis grouper) and grouper with entanglement measurements\n",
    "- Better gradient support (maybe based on Opflow gradient)\n",
    "- Qiskit Runtime support\n",
    "- Gate error mitigation, e.g., zero noise extrapolation\n",
    "- Classical shadow\n",
    "- Entanglement forging\n",
    "- On-chip parallelization\n",
    "- Bootstrap (sampling from probability distribution obtained from backend)\n",
    "- Merge shots (execute the same circuits again and merge the shots to realize a larger number of shots)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "interpreter": {
   "hash": "55198b233f406dc59b712acd847cdd7a571fa057c585d106ba05aad0d31ffb93"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}