{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mirror circuit benchmarks\n",
    "This notebook shows how to generate and analyze experiments that are similar to those performed in \"Measuring the Capabilities of Quantum Computers\" arXiv:2008.11294. For more details, see arXiv:2008.11294"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pygsti\n",
    "from pygsti.processors import QubitProcessorSpec, CliffordCompilationRules\n",
    "from pygsti.protocols import MirrorRBDesign as RMCDesign\n",
    "from pygsti.protocols import PeriodicMirrorCircuitDesign as PMCDesign\n",
    "from pygsti.protocols import ByDepthSummaryStatistics as SummaryStats\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_qubits = 4\n",
    "qubit_labels = ['Q'+str(i) for i in range(n_qubits)] \n",
    "gate_names = ['Gcnot'] + ['Gc{}'.format(i) for i in range(24)] \n",
    "availability = {'Gcnot':[('Q'+str(i),'Q'+str((i+1) % n_qubits)) for i in range(n_qubits)]}\n",
    "pspec = QubitProcessorSpec(n_qubits, gate_names, availability=availability, qubit_labels=qubit_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "clifford_compilations = {'absolute': pygsti.processors.CliffordCompilationRules.create_standard(pspec, verbosity=0)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This cell is utility code for deciding how long the longest circuits should be. You\n",
    "# may want to choose this by hand instead.\n",
    "\n",
    "# A guess at the rough per-qubit error rate for picking the maximum depth\n",
    "# to go to at each width. Change as appropriate. Putting this too low will\n",
    "# just mean you run longer and more circuits than necessary.\n",
    "estimated_qubit_error_rate = 0.005\n",
    "\n",
    "# Heuristic for removing depths that are so long that you'll get no\n",
    "# useful data for w-qubit circuits. You could do this another way.\n",
    "def trim_depths(depths, w):\n",
    "    target_polarization = 0.01 \n",
    "    maxdepth = np.log(target_polarization)/(w * np.log(1 - estimated_qubit_error_rate))\n",
    "    trimmed_depths = [d for d in depths if d < maxdepth]\n",
    "    numdepths = len(trimmed_depths)\n",
    "    if numdepths < len(depths) and trimmed_depths[-1] < maxdepth:\n",
    "        trimmed_depths.append(depths[numdepths])\n",
    "    return trimmed_depths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 [0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] [('Q0',)]\n",
      "2 [0, 2, 4, 8, 16, 32, 64, 128, 256, 512] [('Q0', 'Q1')]\n",
      "3 [0, 2, 4, 8, 16, 32, 64, 128, 256, 512] [('Q0', 'Q1', 'Q2')]\n",
      "4 [0, 2, 4, 8, 16, 32, 64, 128, 256] [('Q0', 'Q1', 'Q2', 'Q3')]\n"
     ]
    }
   ],
   "source": [
    "# This cell sets the circuit sampling parameters. These parameters are chosen\n",
    "# so as to replicate the experiments shown in Figs. 2 and 3 of arXiv:2008.11294.\n",
    "\n",
    "# The number of circuits per circuit shape (width and depth). Set this to 40\n",
    "# to replicate the experiments in arXiv:2008.11294. A smaller number might\n",
    "# be a good idea for a fast test run.\n",
    "circuits_per_shape = 10\n",
    "\n",
    "# The circuit widths to include in the benchmark.\n",
    "widths = [i for i in range(1, n_qubits + 1)]\n",
    "\n",
    "# The circuit depths to include, as a function of width.\n",
    "base_depths = [0,] +  [int(d) for d in 2**np.arange(1, 15)]\n",
    "depths = {w:trim_depths(base_depths,w) for w in widths}\n",
    "\n",
    "# The one-or-more qubit subsets to test for each width. You might want\n",
    "# to choose them more intelligently than here (in arXiv:2008.11294 we used the\n",
    "# qubits that were \"best\" according to their RB calibration data, although\n",
    "# there's nothing special about that strategy).\n",
    "qubit_lists = {w:[tuple([q for q in qubit_labels[:w]])] for w in widths}\n",
    "\n",
    "for w in widths:\n",
    "    print(w, depths[w], qubit_lists[w])\n",
    "    \n",
    "# Sets the two-qubit gate density in the circuits (where \"density\" refers\n",
    "# to the number of circuit locations occupied by a CNOT, with each CNOT\n",
    "# occupying two locations).\n",
    "xi = 1/8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ('Q0',)\n",
      "- Sampling 10 circuits at MRB length 0 (1 of 11 depths) with seed 287329\n",
      "- Sampling 10 circuits at MRB length 2 (2 of 11 depths) with seed 287339\n",
      "- Sampling 10 circuits at MRB length 4 (3 of 11 depths) with seed 287349\n",
      "- Sampling 10 circuits at MRB length 8 (4 of 11 depths) with seed 287359\n",
      "- Sampling 10 circuits at MRB length 16 (5 of 11 depths) with seed 287369\n",
      "- Sampling 10 circuits at MRB length 32 (6 of 11 depths) with seed 287379\n",
      "- Sampling 10 circuits at MRB length 64 (7 of 11 depths) with seed 287389\n",
      "- Sampling 10 circuits at MRB length 128 (8 of 11 depths) with seed 287399\n",
      "- Sampling 10 circuits at MRB length 256 (9 of 11 depths) with seed 287409\n",
      "- Sampling 10 circuits at MRB length 512 (10 of 11 depths) with seed 287419\n",
      "- Sampling 10 circuits at MRB length 1024 (11 of 11 depths) with seed 287429\n",
      "2 ('Q0', 'Q1')\n",
      "- Sampling 10 circuits at MRB length 0 (1 of 10 depths) with seed 857746\n",
      "- Sampling 10 circuits at MRB length 2 (2 of 10 depths) with seed 857756\n",
      "- Sampling 10 circuits at MRB length 4 (3 of 10 depths) with seed 857766\n",
      "- Sampling 10 circuits at MRB length 8 (4 of 10 depths) with seed 857776\n",
      "- Sampling 10 circuits at MRB length 16 (5 of 10 depths) with seed 857786\n",
      "- Sampling 10 circuits at MRB length 32 (6 of 10 depths) with seed 857796\n",
      "- Sampling 10 circuits at MRB length 64 (7 of 10 depths) with seed 857806\n",
      "- Sampling 10 circuits at MRB length 128 (8 of 10 depths) with seed 857816\n",
      "- Sampling 10 circuits at MRB length 256 (9 of 10 depths) with seed 857826\n",
      "- Sampling 10 circuits at MRB length 512 (10 of 10 depths) with seed 857836\n",
      "3 ('Q0', 'Q1', 'Q2')\n",
      "- Sampling 10 circuits at MRB length 0 (1 of 10 depths) with seed 583582\n",
      "- Sampling 10 circuits at MRB length 2 (2 of 10 depths) with seed 583592\n",
      "- Sampling 10 circuits at MRB length 4 (3 of 10 depths) with seed 583602\n",
      "- Sampling 10 circuits at MRB length 8 (4 of 10 depths) with seed 583612\n",
      "- Sampling 10 circuits at MRB length 16 (5 of 10 depths) with seed 583622\n",
      "- Sampling 10 circuits at MRB length 32 (6 of 10 depths) with seed 583632\n",
      "- Sampling 10 circuits at MRB length 64 (7 of 10 depths) with seed 583642\n",
      "- Sampling 10 circuits at MRB length 128 (8 of 10 depths) with seed 583652\n",
      "- Sampling 10 circuits at MRB length 256 (9 of 10 depths) with seed 583662\n",
      "- Sampling 10 circuits at MRB length 512 (10 of 10 depths) with seed 583672\n",
      "4 ('Q0', 'Q1', 'Q2', 'Q3')\n",
      "- Sampling 10 circuits at MRB length 0 (1 of 9 depths) with seed 101513\n",
      "- Sampling 10 circuits at MRB length 2 (2 of 9 depths) with seed 101523\n",
      "- Sampling 10 circuits at MRB length 4 (3 of 9 depths) with seed 101533\n",
      "- Sampling 10 circuits at MRB length 8 (4 of 9 depths) with seed 101543\n",
      "- Sampling 10 circuits at MRB length 16 (5 of 9 depths) with seed 101553\n",
      "- Sampling 10 circuits at MRB length 32 (6 of 9 depths) with seed 101563\n",
      "- Sampling 10 circuits at MRB length 64 (7 of 9 depths) with seed 101573\n",
      "- Sampling 10 circuits at MRB length 128 (8 of 9 depths) with seed 101583\n",
      "- Sampling 10 circuits at MRB length 256 (9 of 9 depths) with seed 101593\n"
     ]
    }
   ],
   "source": [
    "# Samples randomized mirror circuits, using the `edgegrab` sampler with the two-qubit gate\n",
    "# density specified above. The `edgegrab` sampler is what is used in the experiments of\n",
    "# Figs. 2 and 3 in arXiv:2008.11294 (and not what was used for the experiments of Fig. 1d).\n",
    "edesigns = {}\n",
    "for w in widths:\n",
    "    for qs in qubit_lists[w]:\n",
    "        print(w, qs)\n",
    "        key = str(w) + '-' + '-'.join(qs) + '-' + 'RMCs'\n",
    "        edesigns[key] = RMCDesign(pspec, depths[w], circuits_per_shape, \n",
    "                                  clifford_compilations=clifford_compilations,\n",
    "                                  qubit_labels=qs, sampler='edgegrab', \n",
    "                                  samplerargs=[2 * xi,])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ('Q0',)\n",
      "2 ('Q0', 'Q1')\n",
      "3 ('Q0', 'Q1', 'Q2')\n",
      "4 ('Q0', 'Q1', 'Q2', 'Q3')\n"
     ]
    }
   ],
   "source": [
    "# Samples periodic mirror circuits using the random germ selection algorithm specified\n",
    "# in arXiv:2008.11294, designed to match the RMCs sampled above (except that they're\n",
    "# periodic, not disordered).\n",
    "for w in widths:\n",
    "    for qs in qubit_lists[w]:\n",
    "        print(w, qs)\n",
    "        key = str(w) + '-' + '-'.join(qs) + '-' + 'PMCs'\n",
    "        edesigns[key] = PMCDesign(pspec, depths[w], circuits_per_shape,\n",
    "                                  clifford_compilations=clifford_compilations, \n",
    "                                  qubit_labels=qs, sampler='edgegrab', \n",
    "                                  samplerargs=[xi,])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "edesign = pygsti.protocols.CombinedExperimentDesign(edesigns)\n",
    "\n",
    "pygsti.io.write_empty_protocol_data('../tutorial_files/test_mirror_benchmark', edesign, clobber_ok=True)\n",
    "\n",
    "# All the circuits that need to be run\n",
    "circuits = edesign.all_circuits_needing_data\n",
    "\n",
    "# Shuffle the circuits: best to run them in a random order.\n",
    "np.random.shuffle(circuits)\n",
    "\n",
    "# Write this circuit list to file (the non-random order list is in the edesign folder).\n",
    "pygsti.io.write_circuit_list('../tutorial_files/test_mirror_benchmark/randomized_circuits.txt', circuits)\n",
    "\n",
    "# Convert to a list of OpenQASM format circuits. You may or may not want to use this \n",
    "# to get the pyGSTi circuits into a format that you can run on your device.\n",
    "qasm = [c.convert_to_openqasm(standard_gates_version='x-sx-rz') for c in circuits]\n",
    "\n",
    "# You'd then run the circuits of `qasm` or `circuits` and put them into a pyGSTi dataset\n",
    "# that replaces the empty dataset `test_mirror_benchmark/data/dataset.txt`. Below we instead\n",
    "# create simulated data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creates simulated data.\n",
    "lindblad_error_coeffs = {g:{('H','Z'):0.01, ('S','X'):0.001} for g in gate_names if g != 'Gcnot'}\n",
    "lindblad_error_coeffs['Gcnot'] = {('H','XX'):0.05, ('S','XI'):0.005}\n",
    "noisemodel = pygsti.models.create_crosstalk_free_model(pspec, lindblad_error_coeffs=lindblad_error_coeffs)\n",
    "ds = pygsti.io.fill_in_empty_dataset_with_fake_data('../tutorial_files/test_mirror_benchmark/data/dataset.txt', noisemodel, num_samples=1000, seed=1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loads the data\n",
    "data = pygsti.io.read_data_from_dir('../tutorial_files/test_mirror_benchmark')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The statistics to compute for each circuit.\n",
    "statistics = ['polarization', 'success_probabilities', 'success_counts', 'total_counts', 'two_q_gate_count']\n",
    "stats_generator = pygsti.protocols.SimpleRunner(SummaryStats(statistics_to_compute=statistics))\n",
    "\n",
    "# Computes the stats\n",
    "summary_data = stats_generator.run(data)\n",
    "\n",
    "# Turns this \"summary\" data into a DataFrame\n",
    "df = summary_data.to_dataframe('ValueName', drop_columns=['ProtocolName','ProtocolType'])\n",
    "\n",
    "# Adds a row that tells us which type of circuit the row is for. Will not work if the `keys` in the\n",
    "# edesign are changed to not include `RMCs` or `PMCs`. \n",
    "df['CircuitType'] = ['RMC' if 'RMCs' in p[0] else 'PMC' for p in df['Path']]\n",
    "\n",
    "# Redefines \"depth\" as twice what is in the Depth column, because the circuit generation code currently\n",
    "# uses a different convention to that used in arXiv:2008.11294.\n",
    "df['Depth'] = 2*df['Depth']\n",
    "\n",
    "# Puts the DataFrame into VBDataFrame object that can be used to create VB plots\n",
    "vbdf = pygsti.protocols.VBDataFrame(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ciostro\\Documents\\pyGSTi_random_bugfixes\\pygsti\\protocols\\vbdataframe.py:109: RuntimeWarning: divide by zero encountered in log\n",
      "  llr += -2 * (total_counts - s) * (_np.log(1 - threshold) - _np.log(1 - p))\n",
      "C:\\Users\\ciostro\\Documents\\pyGSTi_random_bugfixes\\pygsti\\protocols\\vbdataframe.py:109: RuntimeWarning: invalid value encountered in scalar multiply\n",
      "  llr += -2 * (total_counts - s) * (_np.log(1 - threshold) - _np.log(1 - p))\n",
      "C:\\Users\\ciostro\\Documents\\pyGSTi_random_bugfixes\\pygsti\\report\\vbplot.py:159: UserWarning: No data for colormapping provided via 'c'. Parameters 'vmin', 'vmax' will be ignored\n",
      "  ax.scatter([indd], [indw], marker=\"s\", s=280 * scale - 30 * linewidth, c=point_color,\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhwAAAEqCAYAAABeNYlRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABAzUlEQVR4nO3dd3gU5fo+8HvSFkIKSQhICYlAgBgNIfQQQJADShMUPH4lhCJFPDbQA1IUQYoKKoiNXkRBigICEgSkBqlCqCaU0EsgIQkl/fn9wW/nJGQ3pOzszsL9ua692MxOudlJdp595513FBEREBEREWnIwdYBiIiI6OHHgoOIiIg0x4KDiIiINMeCg4iIiDTHgoOIiIg0x4KDiIiINMeCg4iIiDTHggOAiCA1NRUckoSIiEgbLDgApKWlwdPTE2lpabaOQkRE9FBiwUFERESaY8FBREREmmPBQURERJpjwUFERESaY8FBREREmmPBQURERJpjwUFERESaY8FBREREmmPBQURERJpjwUFERESaY8FBREREmmPBQURERJpjwUFERESaY8FBREREmmPBQURERJpjwUFERESaY8FBREREmmPBQURERJpjwUFERESaY8FBREREmmPBQURERJpzsnWAh118fDzS0tJstn13d3cEBgaafI3ZzLPHbHrNBTBbYewxm15zkc4JSUpKigCQlJQUi643Li5OANj8ERcXx2wPeTa95mK2hy+bXnOR/rGFQ0PGbwABA6uhbBWD1bd/91IGEmZeMPlNhNnMs8dses0F2Ee2hSPbI8jf29rRcPxsEqImRheabdGiRQgKCrJ2NBw/fhyRkZFmf9f0lov0jwWHFZStYoBrQFlbxzCJ2UpGr9n0mgvQd7Ygf2+E1a5o6xgmBQUFISwszNYxCtBrLtIvdholIiIizbHgICIiIs2x4CAiIiLNseAgIiIizbHgICIiIs2x4CAiIiLNseAgIiIizT00Bcenn34KRVGgKAr++usvW8chIiKiPB6KguPIkSMYM2YMypUrZ+soREREZILdFxxZWVno3bs3QkND0a1bN1vHISIiIhPsvuCYMGECjh49irlz58LR0dHWcYiIiMgEu76XyoEDBzBhwgSMGzcOTzzxhK3jEBERkRl2W3BkZGQgKioKoaGhGDZsWLGXzcjIUH9OTU21dDwiIiLKw25PqXz44YeIj4/HvHnzin0qZdKkSfD09FQffn5+GqUkIiIiwE4Ljl27dmHKlCkYPXo0nnzyyWIvP2LECKSkpKiP8+fPa5CSiIiIjOzulEp2djZ69+6NkJAQvP/++yVah8FggMFgsHAyIiIiMsfuCo5bt24hPj4eAODi4mJynmbNmgEAfv31V3Tt2tVa0YiIiMgMuys4DAYDXn31VZOvbdu2DfHx8ejSpQt8fX0REBBg3XBERERkkt0VHGXLlsXs2bNNvtanTx/Ex8djxIgRaNq0qZWTERERkTl22WmUiIiI7AsLDiIiItLcQ1VwzJ8/HyLC0ylEREQ681AVHERERKRPLDiIiIhIcyw4iIiISHMsOIiIiEhzLDiIiIhIcyw4iIiISHN2N9KoPbp7KUO322W2km1Xr9n0mquo82ihKNs9fjbJCklKtt3jx49bIUnxt6vXXKRfLDg05O7uDgBImHlBFzlMTWM28+wpm15z5Z2m52xRE6OtHcdkDlPTIiMjrR3HZI77f9ZbLtI/RUTE1iFsLTU1FZ6enkhJSYGHh4dF1x0fH4+0tDSLrrM43N3dERgYaPI1ZjPPHrPpNRfAbIWxx2x6zUX6xoID2hYcRERExE6jREREZAUsOIiIiEhzLDiIiIhIcxa9SiU3NxfHjh3D6dOnkZaWhpycnAcuExUVZckIuqPnzlXMZp49ZtNrLoDZCmOP2fSaC9B3tkeeWMCdO3dk5MiR4uvrKw4ODkV+ODo6WmLzpZaSkiIAJCUlxaLrjYuLEwA2f8TFxTHbQ55Nr7mY7eHLptdces9GIqVu4bh79y7atGmDPXv2QHjBSz7GKjtgYDWUrWKw+vbvXspAwswLJqt9ZjPPHrPpNRdgH9kWjmyPIH9va0fD8bNJiJoYbVfZjD8vWrQIQUFB1s91/DgiIyMLfc/0mI0scErlyy+/xO7duwEATz75JN544w00aNAA3t7ecHBgFxEAKFvFANeAsraOYRKzlYxes+k1F6DvbEH+3girXdHWMUzSa7agoCCEhYXZOoZJes72KCt1wfHzzz8DAMLDw7F582a4uLiUOhQRERE9XErdBHHq1CkoioJhw4ax2CAiIiKTSl1wGIuM6tWrlzoMERERPZxKXXDUrVsXAHDlypVShyEiIqKHU6kLjj59+kBEsGzZMkvkISIioodQqQuOAQMGoE2bNli4cCEWL15siUxERET0kCnyVSrnzp0z+9r06dMxYMAAREZG4tdff8Urr7yCunXrwtXV9YHrZd8PIiKih1+RC47HH3/8gfOICFasWIEVK1YUaZ2KoiA7O7uoEVTp6ekYOXIk9u3bh5MnTyIpKQnly5dHzZo10b9/f0RGRsLZ2bnY6yUiIiJtFPmUiog88FHU+e5fprhu3bqF7777DoqioGPHjhg6dCi6deuGixcvol+/fujUqRNyc3NLtG4iIiKyvCK3cMybN0/LHMXi7e2NlJSUAuN+ZGdn41//+hc2bNiA33//HR07drRRQiIiIsqryAVH7969tcxRLA4ODiYHGXNyckK3bt2wZcsWnDx50gbJiIiIyJSH6mYnubm5WL9+PYB793UhIiIifSj1vVTGjRsHAHj99ddRoUKFIi2TnJyM6dOnAwA+/PDDEm87MzMTEydOhIjgxo0b2LRpE06cOIG+ffvimWeeMbtcRkYGMjIy1J9TU1NLnIGIiIgerNQFx0cffQRFUdC9e/ciFxxJSUnqcqUtOMaOHav+rCgK3nvvPUyaNKnQ5SZNmpRvOSIiItKWXZ9ScXNzg4ggJycH58+fxzfffIPZs2fj6aefLrTVYsSIEUhJSVEf58+ft2JqIiKiR49NCo6srCwAsNhYGQ4ODqhWrRoGDx6MmTNnYufOnZgwYYLZ+Q0GAzw8PPI9iIiISDs2KTgOHjwIAPD19bX4utu1awcA2LJli8XXTURERCVT7D4cCxcuNDl91apV2LdvX6HLZmRk4NSpU5g7dy4URUGjRo2Ku/kHunTpEgDLtZ4QERFR6RW74OjTpw8URck3TUQwevToIq9DRODg4IC33367uJsHABw7dgwBAQEF7tVy584dDB06FADQoUOHEq2biIiILK9EV6mYGpK8qMOUu7i4oFGjRhgxYgRatWpVks1j6dKl+OKLLxAREYGAgAB4eHjg4sWL+P3333Hjxg20aNECQ4YMKdG6iYiIyPKKXXCcOXNGfS4iqFGjBhRFQXR0NAIDA80upygKypQpAx8fHzg6OpYs7f/XqVMnXLp0CTExMdi1axdu3boFT09PhISE4OWXX0a/fv3g5FTqK36JiIjIQop9VPb39zc5vUqVKmZfs7SGDRuiYcOGVtkWERERlV6pmwF4V1YiIiJ6ELse+IuIiIjsAwsOIiIi0lyRT6m0adPG4htXFAWbNm2y+HqJiIhIX4pccGzZsgWKohR6+aup8TmKM52IiIgeTkUuOFq2bFlogXDp0iXEx8cDuFdIBAQEoFKlSgCAq1evIiEhASICRVEQGBiIKlWqlDI6ERER2YtitXCY8/vvv6Nnz57w8PDAqFGj0Ldv3wK3qr9+/TrmzZuHiRMnIjExEVOnTsVzzz1X4uD25O6lDN1ul9lKtl29ZtNrrqLOo4WibPf42SQrJCnZdvWa7fjx41ZKUvzt6jnbI01K6Z9//hE3NzcpX768HDly5IHzHz16VMqXLy/u7u7yzz//lHbzFpGSkiIAJCUlxaLrjYuLEwA2f8TFxTHbQ55Nr7mY7eHLptdces9GIopIEcckN2PQoEGYNWsWJkyYgBEjRhRpmUmTJmHUqFHo378/Zs6cWZrNW0Rqaio8PT2RkpJi8VvVx8fHIy0tzaLrLA53d3ezI8Aym3n2mE2vuQBmK4w9ZtNrLkDf2R51pS44atSogbNnzyImJgZNmjQp0jJ//fUXwsPDERAQgNOnT5dm8xahZcFBREREFhiH4/Lly8Vextj59MqVK6XdPBEREdmBUhcc5cuXBwBs3bq1yMsYO6B6enqWdvNERERkB0p9L5UWLVpg+fLl+OSTT9C1a1fUrl270Pnj4uLw6aefQlEURERElHbzuqfn84nMZp49ZtNrLoDZCmOP2fSaC9B3tkdeaXud7tq1SxwdHcXBwUG8vLzkyy+/lBs3bhSYLykpSaZOnSo+Pj6iKIo4OjrKrl27Srt5i+BVKsxm79n0movZHr5ses2l92wkUuoWjqZNm2Ly5Ml49913kZKSgnfffRfvvfceHn/8cVSsWBGKouDq1as4c+YMREQdZfSzzz5D06ZNS7t5XTNW2QEDq6FsFYPVt3/3UgYSZl4wWe0zm3n2mE2vuQD7yLZwZHsE+XtbOxqOn01C1MRou8pm/HnRokUICgqyfq7jxxEZGVnoe6bHbGSBUyoAMGTIEAQEBODNN9/EpUuXICI4deqUegWK5LkQpnLlypg+fTpeeOEFS2zaLpStYoBrQFlbxzCJ2UpGr9n0mgvQd7Ygf2+E1a5o6xgm6TVbUFAQwsLCbB3DJD1ne5RZpOAAgG7duqFTp05YtWoVNm7ciMOHDyMp6d5IdV5eXnjqqafQtm1bdO3aFc7OzpbaLBEREdkBixUcAODs7Izu3buje/fullwtERER2blSXxZLRERE9CAsOIiIiEhzLDiIiIhIc0Xuw+Ho6Ajg3rDk2dnZBaaXxP3rIiIioodTkQsOMXOPN3PTiYiIiIyKXHCMGTOmWNOJiIiIjOyy4Lh48SKWLVuGdevW4cSJE7hy5Qq8vb3RvHlzDBs2DE2aNLF6JiIiIjKvWJ1GZ8yYgePHj2uVpcimT5+OIUOG4PTp02jXrh3effddREREYNWqVQgPD8fPP/9s64hERESUR7EG/ho8eDAURUGFChUQERGBli1bomXLlggNDYWiKFplLKBx48bYsmULWrVqlW/69u3b8cwzz2Dw4MHo2rUrDAbr37eBiIiICir2SKMigsTERKxcuRIrV64EAHh4eCA8PFwtQBo1agQnJ4sOYpqPufuwtGjRAq1bt8aGDRtw+PBhNGzYULMMREREVHTFqgrmz5+P7du3Y/v27YiLi1Onp6SkYP369Vi/fj0AoEyZMmjSpIlagDRr1gxly1rnpk3G+7QUVvBkZGQgIyND/Tk1NVXzXERERI+yYhUcUVFRiIqKAgAkJiaqxcf27dtx6NAh5OTkAADu3r2LrVu3YuvWrQDuFQFhYWFqARIREQEPDw8L/1eAc+fOYePGjahcuTKeeuops/NNmjQJY8eOtfj2iYiIyLQSn/fw9fXFCy+8oJ7euHXrFmJiYtQCZM+ePUhPTwcAZGZmYvfu3di9ezcmT54MBwcHPPXUU2jVqhW+/PJLi/xHsrKy0KtXL2RkZODTTz8tdECyESNGYOjQoerPqamp8PPzs0gOIiIiKshiHS3c3NzQrl07tGvXDsC9AmDv3r3Yvn07tm3bhpiYGKSkpAAAcnJycPDgQRw6dMgiBUdubi769OmDbdu2YcCAAejVq1eh8xsMBnYoJSIisiLN7qXi7OyM8PBwDB8+HGvXrsXVq1fx/fffo0aNGha9oiU3Nxf9+vXDTz/9hMjISHz//fcWWzcRERFZhmaXkmRkZOCvv/7Ctm3bsH37dvz111+4ffs2AMsNh56bm4u+ffti4cKF+L//+z/Mnz8fDg68Hx0REZHeWKzgSElJwc6dO9VTKPv370dWVhaA/xUYjo6OeOqppxAREYGIiAi0aNGixNvLW2z8+9//xg8//FCqG8kRERGRdkpccFy5ckXtILpt2zYcOXJELSyM/7q6uqJx48ZqgdGsWTO4u7uXOrTxNMrChQvRo0cPLFq0iMUGERGRjpV4HI5Tp06p040FRoUKFdC8eXO19SIsLEyTAcDGjRuHBQsWwM3NDbVr18b48eMLzNO1a1eEhoZafNtERERUfMWqBvr16wdFUdQCo2bNmmrrRUREBOrUqaNJyPslJCQAuHcp7oQJE0zOExAQwIKDiIhIJ0rU/ODk5IQePXqge/fuiIiIgK+vr6VzFWr+/PmYP3++VbdJREREJVesgsPLywvJycnIzs7GkiVLsGTJEgBAYGCgeholIiICNWvW1CQsERER2adiFRw3btzA0aNH1Y6i27dvx8WLFxEXF4e4uDjMmzcPAFCpUqV8p1rq169v1bvJEhERkb4U+5RKcHAwgoOD8dprrwG415/CWHwYb+p25coVLF++HCtWrABwbxTSpk2bqq0gTZs2RZkyZSz7PyEiIiLdKvUlJAEBAQgICMh3U7e8BcihQ4eQlpaGP/74Axs3bry3UScn1K9fHy1atMDkyZNLG4GIiIh0zuLXrPr6+uLFF1/Eiy++CABIS0vLNyDYvn37kJGRgT179mDv3r0sOIiIiB4Bmg1tbuTu7o4aNWrg4sWLOH/+PBISEnDp0iWLDW9uD+5eytDtdpmtZNvVaza95irqPFooynaPn02yQpKSbVev2Y4fP26lJMXfrp6zPcosXnCICA4ePKieUtm+fTsSExMLzPMoMI6qmjDzgi5ymJrGbObZUza95so7Tc/ZoiZGWzuOyRympuktm/HnyMhIW8QpkMPUND1mI0CRUh79s7KysHv3brW4iImJQVpamvr6/auvWbMmWrRogZYtW6Jly5aoUaNGaTZvEampqfD09ERKSgo8PDwsuu74+Ph874e1ubu7IzAw0ORrzGaePWbTay6A2Qpjj9n0mgvQd7ZHXbELjlu3biEmJkbtGLp3715kZPyvyTLv6hRFQXBwMFq2bKkWGZUrV7ZcegvRsuAgIiKiYp5SadiwIQ4dOoTc3Fx1Wt4Cw3j1ibHAaNGiBby8vCyXloiIiOxSsQqOAwcO5Pu5TJkyaNy4sXp6pFmzZihXrpxFAxIREZH9K1bB4ebmhubNm6sFRqNGjeDi4qJVNiIiInpIFKvguHnzJhwcHLTK8lDScwcmZjPPHrPpNRfAbIWxx2x6zQUwW2Fs3qFVSFJSUgSApKSkWHS9cXFxAsDmj7i4OGZ7yLPpNRezPXzZ9JqL2UqezVo0H/jrUWasZAMGVkPZKgarb//upQwkzLxgsqJmNvPsMZtecwH2kW3hyPYI8ve2djQcP5uEqInRdpVNr7mA/2VbtGgRgoKCrB0Nx48fR2RkpN1lsxYWHFZQtooBrgFlbR3DJGYrGb1m02suQN/Zgvy9EVa7oq1jmKTXbHrNBQBBQUEICwuzdQyT9JxNa+yQQURERJpjwUFERESaY8FBREREmmPBQURERJpjwUFERESaY8FBREREmmPBQURERJqz24Jj0aJFGDRoEBo2bAiDwQBFUTB//nxbxyIiIiIT7Hbgr9GjR+Ps2bOoUKECKleujLNnz9o6EhEREZlhty0cs2fPRkJCAhITE/Haa6/ZOg4REREVwm5bONq2bWvrCERERFREdtvCQURERPbDbls4SiMjIwMZGRnqz6mpqTZMQ0RE9PB7JFs4Jk2aBE9PT/Xh5+dn60hEREQPtUey4BgxYgRSUlLUx/nz520diYiI6KH2SJ5SMRgMMBgMto5BRET0yHgkWziIiIjIulhwEBERkeZYcBAREZHm7LYPx+zZs7Fjxw4AwOHDh9VpW7ZsAQBERESgf//+topHREREedhtwbFjxw4sWLAg37SdO3di586d6s8sOIiIiPTBbguO+fPn8+6wREREdoJ9OIiIiEhzLDiIiIhIcyw4iIiISHMsOIiIiEhzLDiIiIhIcyw4iIiISHN2e1msPbl7KUO322W2km1Xr9n0mquo82ihKNs9fjbJCklKtl29ZtNrLgA4fvy4FZKUbLt6zqY1Fhwacnd3BwAkzLygixympjGbefaUTa+58k7Tc7aoidHWjmMyh6lpesum11x5p0VGRlo7jskcpqbpMZu1KCIiNtu6TqSmpsLT0xMpKSnw8PCw6Lrj4+ORlpZm0XUWh7u7OwIDA02+xmzm2WM2veYCmK0w9phNr7kAZitMYdmsgQUHtC04iIiIiJ1GiYiIyApYcBAREZHmWHAQERGR5lhwEBERkeZYcBAREZHmWHAQERGR5lhwEBERkeZYcBAREZHmWHAQERGR5lhwEBERkeZYcBAREZHmWHAQERGR5lhwEBERkeZYcBAREZHmWHAQERGR5lhwEBERkeZYcBAREZHmWHAQERGR5lhwEBERkeacbB1AD0QEAJCammrjJERERPbJ3d0diqKYfZ0FB4C0tDQAgJ+fn42TEBER2aeUlBR4eHiYfV0R49f7R1hubi4uXbr0wOrM2lJTU+Hn54fz588XuhNtgdlKRq/Z9JoLYLaS0ms2veYCmK202MJRBA4ODqhWrZqtY5jl4eGh218wZisZvWbTay6A2UpKr9n0mgtgNq2w0ygRERFpjgUHERERaY4Fh44ZDAaMGTMGBoPB1lEKYLaS0Ws2veYCmK2k9JpNr7kAZtMaO40SERGR5tjCQURERJpjwUFERESaY8FBREREmmPBQURERJpjwUFkQzk5ObaOQKXEffhw4/61HBYc9MjRy4VZv/zyCzp16oSYmBhbRyng9OnTiIuLs3UMs3Jzc20dAYA+96GI4MCBA1i0aBGuXLli6zgmJSYmYuXKlbaO8UD37189fHaY2r96yFUULDjsSHJyMv755x/88ssv2Lt3L27cuGHrSHYhNjYWEydOxLhx4xAXF6eLbywZGRm4evUqoqOj8eGHH+LChQu2jqQ6f/486tSpg9dff11XuQDg2rVrAO7djsDW9LoPk5OTsWHDBkRFReG9997D5cuXbR0pnxkzZqBRo0Z44YUXcOLECVvHMcvU/lUUxeYHd1P7Vw+5ikRI95KSkmT8+PHStGlTcXd3F0VRRFEUCQ4Olm+//dbW8XRt4cKF4uXlpb5nAQEB8tlnn9k0U25urvp8+PDhoiiKdOvWzYaJ/seY7dNPP5XHH39cXnnlFZvmSU1NlcWLF8ugQYOkRo0aEhQUJG3atJFJkybJpUuXbJZLz/tQRCQnJ0f++9//io+Pj/Tq1cvWcUREJDo6Wlq0aCGKooi7u7s4OztLy5YtbR3LJO5fbbDg0LHMzEyZO3euVK9eXRRFET8/P+ndu7eMGjVKvvzySwkODpYyZcrI6tWrbR1VcnJyREQkOzs738+2dPnyZfHz8xM3NzeZMGGCrF27Vpo0aSKenp6ydu1am2TK+0GWlZUlq1atkqpVq4qiKLJx40abZMqby7jfMjMzZfjw4eLg4CArV660ep6srCxZuXKltG/fXtzd3cXT01MCAwMlIiJCwsLCRFEUadGihcTExFg9m173oZExX3Z2towcOdJm+9AoKSlJXn/9dVEURRwdHaVbt27y119/yXfffSeKosiKFStsls0Ue96/evjcLQwLDp06e/asdO/eXRRFEQ8PDxkzZoycPHlSUlJS1Hn+/vtvefrppyUoKMiq2S5evCjLli2T2NhY2bt3r1y7dk1u3LghaWlp+f5Y8z63hoMHD8q4cePkP//5j8yfP1/i4+NFUZR8LRr79++X1q1bS506daya7f4Psd27d8uwYcMkICBAypUrJx07dpQNGzZYNdP9UlNTJTMzU/352LFj0rJlS2nSpIlVc9y8eVN9b4wHqWHDhsm+ffvUeZYsWSI1a9aUp556ymq59LYPC/v7Mr527NgxCQsLk/DwcGvFKiAxMVEmTJggzs7O8vLLL0tWVpaarVWrVuLn52ezbHlx/2qPBYcO3blzR1544QVRFEW6du0qsbGxBeYxVrIjR44UNzc3+euvv6ySbenSpVK2bFlRFEXKli0rbm5u4ujoKJUrV5bKlStLvXr1pH79+tKrVy+JioqSNWvWWCXX/Pnzxd/fXxRFkcqVK4uzs7N06dJFFEWRzz//XET+95598cUX4u7uruk3q7t374rI/1p8jOLj42XatGnSoEEDURRFGjZsKN9//72cOnVKsyx5JSUlyfXr1wtM//XXX6V69eoFWn6GDh0qHh4esnPnTqvkExEZMmSIODs7i5OTk5QvX17q1q0rrq6u0rZt23x/C7NmzRKDwaDuX0vT6z5MT08vMC03N9fst9sXX3xRqlSpIvHx8VpHk6SkJLlx44bJ19544w3x8fGR5cuXq9MWLVokTk5OMm7cOM2z3e9h279xcXFaRys1Fhw6k5OTIwMHDhRFUWTw4MFy/vz5Quf/6KOPxGAwyJEjR6ySb+bMmfLYY49JSEiInD17VpYsWSK//fabTJ48WaZMmSLDhw+X0aNHS926ddV+E+Y+gCwlNjZW/P39xdPTU7799lv5559/5MSJEzJnzhxRFEVefvnlfOf7161bJy4uLvLNN99YPEtubq5MnTpVhg4dKleuXFGnX716VRYvXiwdO3YUFxcXqV69unz44Ydy8OBBycjIsHgOU06fPi2dO3eWbdu2iUj+5tfLly+LoijSp08fuXDhgjr9q6++krJly8qePXuskvGzzz4TRVHE399fvvjiC7ly5YpkZGRIdHS0eHt7S8eOHdUD5/nz56Vjx44SFhYmt2/ftliG0u5DrVr2jLnatm0rffv2lfnz58vhw4fVFoO88h5Eu3XrJuXKlZOrV69qksvo2LFj0rFjR9m+fbuIFGzez87OlsqVK0vXrl3V9/XKlSvSs2dPKVeunCQnJ2uaz0ivf6Ol2b+urq6a719LYMGhMxcuXBBvb29p3Lix2Yra+Mt29OhRqVatmtSuXTvfH44WjB+iqamp0r9/f1EURf7+++8C8925c0cWLFggXbp0EUdHRylTpoxER0drmm3evHmiKIq8+uqr+U45iYiMGjVKFEWRTz/9VHJyciQ3N1c++eQTURRFvvvuO03yDBs2TBRFkZkzZ0pubq5s3LhR+vfvL15eXuLu7i79+vWTzZs3S2pqqibbN2fv3r1SoUIFGTRoUL7pxg+0kSNHiqIo8vbbb0tycrLs2LFDGjduLIqiyI4dOzTPl5qaKk8++aRUq1YtX4ud8cA1b948cXJykl9//VV9bcCAARIWFianT5+2aJaS7kOtTyN+8MEHaiHv6Ogo7u7uUq9ePXnrrbdk5cqVcvr0afX9unbtmlrANW/eXNLS0jTNtnXrVilXrpwMHjy4wGvGz6yhQ4eKt7e3JCQk5FvunXfeyTdNa8b9O2vWrBL9jZoqAizB1P4NDQ1V9++ZM2dM7t+IiAjN968lsODQmdjYWFEURb766isRyV/J5n2elJQkL774oiiKIlOnTrVKNuOH6ZYtW8TPz09CQkLU1zIzM2XlypXy0ksvibOzs7i4uMiAAQPk0KFD+foFaGHatGmiKIp6IMrOzlb/KK9fvy4VK1YURVGkdevW0qZNG1EURerWrStnzpzRJE96erqUL19egoKC5I033pDAwEBxdHSU9u3by9KlSzUvDs3JysqSpk2bSkREhNr8mpubq+7XPXv2SIUKFcTZ2Vm8vLzE19dXHBwc5LXXXrNKvmvXrkmZMmWkX79+at6835KPHj0qiqLka36/evVqvr4dlqLXfZieni7e3t4SHh4u48ePlyFDhkjdunXFYDCIoihSvnx5qVGjhrRt21bq1Kkjzs7O4uzsLD/99JOIaNupMDMzUxo0aCAtWrRQf7/u357xQL9+/Xp1mi06OpZ0/+b9DE5PT5fjx49bPFdJ9u/ixYtFRLtCyFJYcOhMTEyMlC1bVkaNGqVOy3tQELnXYa5atWrqt/pbt25ZNWNOTo6MHj1aFEWRefPmyblz5+Stt96SypUri6Io0q5dO4mOjpY7d+5YJc/69etFURQZPXp0vqssRO6djw0NDZUhQ4ZIjx495Mknn5S2bdvKggULNP02OmPGDFEURZydnSUkJESmT58u//zzj8lOtdb8wJ07d644OjrK9OnT1WnG92rp0qUSHBwsv/zyizz33HPy7LPPyoQJE6xy7l/kXrHt6+srffv2VaflLTpWrFghiqLIe++9Z5U8xdmHeX8+f/68zJ49W7Nz6tOmTRMXFxeZP3++Om3//v3y3XffSe/evSU4OFgCAgLEYDBIly5dNG9hzGvOnDni6OiofmEyys7OlpSUFHnmmWfEyclJTp48abVM5pTmb3TZsmVSq1Yt8fb2tnguc/v322+/LfL+/e233yyeyxJYcOhQ/fr1pVGjRmoztvH84Y4dO+S5555Tm9xef/11uXz5slWzGQ9OCQkJEhISIuXKlZMnn3xSFEWRJ554QubMmaN5nw1T6tWrJ2FhYQX6GqxevVoURVH/KJOTkyUpKckqmerXry9OTk4yc+bMfNPNFTpXr16VnJwczQu1kJAQCQoKKtBBdNiwYeLm5iYpKSlqRuPv3q1bt2T27NkyY8YMk51OLaVp06YSEhIie/fuzTf977//lrCwMHFxcZGtW7dqtv37mduH5mRlZcm3334riqLI008/rVnfl6CgIGnYsKEcOHCgwGu3bt2Sq1evqt/S8/6+Xb16VWbOnKnp5cShoaFSo0YNWbJkiYjce0/u3Lkjn3/+ubi4uEjz5s3l1q1bBf4OUlNT5cyZM1b9AvWg/Xt/Z809e/ZI586dRVEUMRgM0rlzZ0lKSrL4l5fi7N+8rS579uyRrl27iqIo8vHHH1s0kyWw4NChrVu3ioeHh1SoUEEiIyNl4MCB0rJlS7XQCAkJkXXr1tksX2pqqixZskTtGOrq6iqTJ0+22jdhU/78809xcnKS5s2by9q1a+XEiRMyduxYKVeunPj4+Kj9Yax5qe6WLVvUVijjgfv+b0o3b96UzZs3S8+ePaVu3bpSq1Ytadiwobz33nv5Om9a0q5du6Ry5cri4eEh//3vf2X27NnSrVs3URQlX+tC3vcqLi5OnnnmGbWPh1aM+zE8PFx+/PFH2bdvn4waNUoee+wxURRFevToITdu3LDafizKPjTlhx9+kKpVq0qzZs00ybVx40b1oGLMlbc16P735/bt2/LHH3/IwIEDxcPDQ3x9fTXJJSKye/du9ZLm9u3by4ABA9TPr9q1a5scyyIjI0N+/fVXady4sdVOEYsUvn/zHsgvX74sb775pri6uoqiKNKqVStNx+R40P69/3fw0qVL+fI1a9ZMF2OG3I8Fh0798ssv0rFjRylXrpwoiiK1atWSZ599VubMmWPTXLGxsdK5c2fx8fERR0dH9YPF0ucyS2LMmDHi7e2tfvtQFEWcnJw0uRqlqDp27Ciurq7q5cF5P8RiYmIkMjJSLSS9vb2lW7duakfNwMBAWbhwoSa5li1bJq1atVK3rSiKhIeHP7BzaK9evcTb21s++eQTTXKJiEyYMEH8/PxEURRxcHBQ9+PEiRMLXU6rU1TGfVjcZuqvv/5a3N3d5YMPPrBoHqMuXbqIn5+fbN68udD59u7dKx9++KEEBASIg4ODNG3aVBRFkZEjR2qSS+Tegfzf//63+rvl6+srnTp1KvSL0okTJ8TX11fKly+v2e+9KYX9jebm5sqXX36pDr5Ys2ZNmTFjRr7l77+s1lLM7d/7802bNq3QfHrCgkPHsrKy5PDhw3Lq1Ck5deqURS/9Kynj5ZPGCnrhwoXi7OxstfPqhcnIyJA9e/ZIv379pEOHDjJ48GDNOoYW1cWLF6VLly6yefPmfN86Z8yYoXZmNX4TzHtp8759+yQ8PFy8vb3l4sWLmmS7deuWzJgxQ6ZPny6zZ8+Wmzdvmp3X2Bnt3Llz0rNnT3F1ddVsaPGsrCw5c+aMjBkzRt566y354IMP5MKFC3L48GFZs2aNREdHS3x8vMTGxkpqaqp6Ck+rU1EXLlyQzp07F9iH5hgLnitXrkj37t3lscce0+Q045kzZ0RRFBk/frzJsRtERDZt2qQ2sTdu3FhWr14t8fHx0r9/f3FwcNCsFU3k3oExJiZGfeQ9VXL/+2g8iMbFxUmlSpXE09PTaqeLjX+jGzZsyFesrlq1Sho1aqQOxT5ixAhJTEwskFkrxv07YcIESU9PL9CXb9WqVdKkSRN1cMjhw4fnO12sdb6SYMGhU9YepbM49uzZox4EMzMz5ffff7fp6RRTzH0A20LeS3Vv3bol7733Xr774YSEhEi1atWkXr16snnzZvWDYt26deLn56fJvRLM/X7lvcLHnDVr1oi7u7sMGzbM4rlETGfbsmWLOqR5+fLl1Q9Zd3d3qVq1qgQEBEirVq2kWbNm0r9//we2hhSX8fJIc++bqc6jIv8bJyfvVRmWtGbNGtm5c6fZg0tCQoK88847oiiKzJgxQ22e//PPP6Vq1ary/PPPa5LL3Pt0/+9Wbm5uvuzx8fFSp04dURRFevbsqUk2U/KOAXL48GHp0aOHemmql5eX2RY9rT+n16xZIzt27Mj3eRYbGysvvviilClTRpycnCQqKkr279+vvp6VlaXb4wcLDio1vf5y60neS4q9vLykYsWKMnPmTElMTJQrV67IwYMHJTg4WJ544gl1VM/bt29L//79pWrVqpqOInj79u1839zMyXsFUIUKFaRHjx6at7oZt7l161YJCwsTLy8vOXXqlGzYsEGWLVsms2fPli+//FLGjh0rgwYNkpdeekkdCXfXrl0WzbJ69Wpp3Lix9O3bV7755hs5dOjQA1tV3n77bXF0dLTKwGmFjUXSqlUrqVOnjvqe3LlzR8aOHSuKojzwlExpmStg817Cef36dXV8H2NrTN4RSa0hKSlJ3nrrLfHx8VFbcY3jYhgMBvH395e+ffvKqlWr5Nq1a1bNJnKvKHr//ffF09NTFEWRcuXKSf369eXEiRNWz1JSLDiIrCQ7O1u9ymjVqlUFXjeOwTJ58mT1aqCFCxdKvXr1NBt469q1a9KlSxepWrWq9OzZU+bMmSP79+83O+BRTk6O7N27V5ydnaVHjx6aZDJn3LhxoiiKfPHFF2qWvHbu3Cn9+/cXg8EgFStWlPHjx1t0+z///HO+Pi/GK7P+85//yOLFi+X06dPqaakrV65IdHS0VKxYUXx8fDQdCTg3N1dmzJghXl5e6mmu+/uz7N+/v8Dpl9jYWKlZs6ZV7sWUt5Xv/nF5pkyZIm5ubuoNKqdPn26TLzHGK9oCAgLkyy+/FJF7+9zFxUWGDh0qUVFRUqVKFXWe1157Tf271Gr8C+P78MUXX0jt2rXV92jatGnSsWNHtfCoWrWqDB48WP744w9dn1ZhwUFkBbm5uZKeni6NGzeWsLAwEZF8VxRkZWVJUlKSVKlSRbp27aoul5OTIz/++KOmLQn16tVTxyMwHkjr1Kkjb775pixfvlz+/vtvSU1NlYsXL8rBgwfl5ZdfFkVRZMyYMfn+H1oxrj8uLk6aN28ubm5u6vtx584dOXbsmLz77rvi5eUlDg4O0qlTJ/npp58K7ZNSUuHh4RIYGCjjxo2TKVOmqOf4je9fcHCwhIeHS5MmTcTb21vc3Nxk2rRpFs9xv/Hjx0vZsmXVVoH7x5K4e/euNGrUSFq1apVvubVr16pDkWtl2bJlUq9evQJ3tV69erV6pZuLi4sMGTIk34BbtjhYfvHFF/n6THXr1k3Kly+vtmRdvHhRlixZIpGRkeLj4yPly5e3Sq6GDRuqV4gZ3yM/Pz/p2rWrzJ07V55//nl57LHHxMXFRWrVqiVvvPGGuqyeWqBZcBBZSWJiotSvX18aN26sfsvM+83owIED4unpKe3atZPs7GyrfeDu3btXFEWRgQMHyrp162TMmDHSpEkTcXJyUg+mNWvWFD8/P6lUqZIoiiLdunWzyb0b5syZIw4ODjJw4EAREZk+fbp6zr9hw4YydepUOXfunDq/pT9sY2JiRFEU+eCDD9T9c/bsWVm1apW8++67EhoaKj4+PhIQECDt27eXzz//XD1dpeUH/7Fjx8THx0deffVVdYjrvJ0Mb968KSEhIZp1YC3Mjh07RFEUdQTZkydP5htP6Pnnn883WqzxFgS2lJubK0lJSVKpUiXp3r27yXnu3LkjX331lVWGZI+Pj8833P+ff/6p9ssxunjxovzwww/ywgsviIODg4wePVrzXMXFgoPIigYNGiQ+Pj6ycuVKdVpOTo7s379f2rVrJ4qiyJQpUwosp/UHcI8ePaRSpUrqt13jB+7q1avljTfekGeeeUZq164tnTt3lpEjR8rBgwc1zXM/4///+vXr6pghxh761atXl+HDhxe4t49W79lLL70kFStWNDuC5+XLl9XBmUzl0apFqHfv3uLr66sO8Z+3mD1+/Li4urpKu3bt1LukWlOvXr3E0dFROnTooBYaoaGhBfpp3P/e2GLYc2MhuW3btgIHdWMmW+QybltE5PPPPxdFUdTO+vd/OUlMTCzQoqQHLDiIrOjatWvi7e0ttWrVkp9++kmio6Nl2rRp6j1eunXrZrUh4fO6evWqODs7S1RUlHqgNHXlRXp6us0+bG/fvi1Hjx6Vtm3bioODg7i4uMjAgQMlOjo638FV63zXrl0TZ2dn6d27t9p5sCjfyrXer9euXRMvLy8JCgrK1+dnzZo18sQTT4iiKDJ79uwCy1mjNSExMVFcXFxEURSpWLGiTJ06Nd/78aDWPFsMCWC8yaO1i+uiaN26tdSoUUMyMzML7D8930+FBQeRlf3888/y1FNP5et8WKFCBRkwYIDaudAWB/WPPvpIXFxc1Bt95WU8IBg/3Kzd5J2cnCzvvPOOVK1aVRwcHNQB5xYsWKDOY8337KOPPhInJyf58ccfC50vJydH0tPTZenSpRIVFSWhoaHyzjvvyOHDhzXJtXDhQqlcubK4urpKkyZNJCwsTB08rUePHmqHQnPvlZan8T799FNRFEVGjBihTnvQwfH69esyatQo6devX4Hh7rWUm5srzz77rPj7+9uswDbn3Llz4urqKr1797Z1lGJjwUFkA5cuXZK5c+fK66+/LlOmTJE1a9ZY/b44plSpUkWefvpp3Y2rIiJSvXp1CQgIkOnTp8uvv/4q9erVk9atW9ssT7Vq1aRHjx75Tp2YOmBv3bpVqlWrJuXKlRNfX19xdnaW0NBQi1+2axQdHS1t2rQRX19fcXR0lLp16+a7EZhRamqqnD59WmJjY2XdunWSkJCg+bfj6tWrS7169dT/+4MK17S0NPnhhx/E2dlZGjVqpMmdgc2pUqWKvPzyyyKir46XxmHPly5dausoxcaCg4hUP//8s5QrV05++eUXW0cp4PDhw/lOFaxevVp+//13m+XZunWr+j7lPSBlZ2fnu9qiY8eO4uTkJHPnzpWEhARZunSp1KhRQ71aSQvp6ely/fp12b17d4HXsrOzZdGiRfLvf/9bAgMD1VY2Nzc3ad++vWzYsEGzXMuWLRNFUWTo0KHFOogvWrRIatasKc2bN9cs2/1WrFhhsj+Vrf3222+iKEq+3zF7wYKDyMbM3XDLVpYtW2aTjoUPg99++03at28vtWvXlvDwcFm8eLF07txZGjVqlG++GTNmiKurq8k+FZZg7jTArl275OWXX5aqVauKoijSvHlzeffdd+Wzzz6TMWPGSNWqVaVq1aryww8/aJJL5N49j4o6Lknev4lvvvlGnJycZPr06VpFK0Bv41gYffjhh5rd8kBLiogIiIjuIyJQFMXWMXTP+D4tXrwYr732GtLS0hAaGoq6devixIkTOHfuHCpXrowtW7bAx8cHAHDu3Dm0bt0awcHB+OWXX+Dk5KRZvpycHDg6OmLTpk0YO3Ysdu3ahZycHADAoEGDEBUVhWbNmgEAYmNj8c477+Dw4cM4c+YM3NzcNMt1f0ZFUeDg4FDgNeP7e/78eXTv3h25ubnYuXMnXFxcrJJNj+z1b7Pg3iUiAuzyA80WFEXB7du38e233yIzMxNfffUVDhw4gJ9++gnR0dHo1q0bTp48ifXr16vLVK9eHQaDAZmZmZB7Lc2a5XN0dMTZs2cxatQo7Ny5EyEhIejatSsGDBiA33//HV27dsWKFSuQnZ2NkJAQvPnmmwCAsWPHapYJAK5fv46dO3ciPT0djo6O+YqN7Oxs9bmiKMjOzoafnx8qVKiApKQkJCUlaZpN7+z1b5MtHEREpZScnIzHH38cNWvWxNatW1GmTBm11eLOnTvw9/eHh4cHvv76a9SqVQu///473nnnHTRp0gQxMTGaH0BeeeUVLFmyBL169cKgQYMQHh4O4N5B/5lnnoGzszPmzp2LkJAQJCcno0+fPjhz5gw2b96MChUqWDxPTk4OOnXqhG3btuGxxx5DgwYN0Lx5c7Rq1QqhoaEml0lNTUXLli1x6dIlnDx5Eh4eHhbPRdrSrh2PiOgRcfnyZXh6esLLyyvfaYicnBy4urqiZ8+emDVrFnr06AGDwYCbN2+iZs2amDRpkubFxvnz5/Hrr7+idevWmDZtGsqXLw8AyMzMRIUKFTBx4kR06dIFZ8+eRUhICLy8vBAYGIhy5cppdtrC0dERXbp0QXR0NJKSkrBjxw4sX74cAFCrVi20bNkSzZs3R7169VClShUcPXoUkydPRmxsLAYNGsRiw06x4CAiKqUnnngCNWvWxLlz53Dw4EGEhoYiOzsbTk5OyMrKwokTJ9CrVy906NABW7duhaurKxo1aoQmTZpofj7+9u3byM7ORvPmzVG+fHlkZmbCxcUFzs7OAIAyZcpARHDo0CF07twZADBp0iQ4OTlpmmvw4MGYNm0afH198f7778NgMGDt2rXYvXs3VqxYgblz5wIADAYDMjIyAAANGjTA22+/rVkm0hYLDiIiCxg2bBg6dOiAhQsXIjQ0VD2lcuTIEcTExMDd3R1dunRBly5drJorNzcXbm5uuHr1qlpsZGRkwGAwAABiYmIAAJUqVVKXMRYjWps8eTKef/55HDlyBMOHD0fbtm2Rnp6OhIQExMbGYu/evUhJScG1a9fQoUMH9O3b12rZyPLYh4OIyEKMfSU6duyIFi1a4ObNm/j888/h6OiItWvXonXr1vnmt9bVBp07d8bBgwfx9ddf4/nnn1enf/311xg2bBiqV6+O6Oho+Pv7a57lfu3atcPJkycxf/58tGzZ8oHvib1eoUEsOIiILObq1asYNmwYFi9erF5p4ePjg3feeQdDhgyBq6urTXKdPn0a4eHhyMnJwbPPPovHH38ca9aswcGDBwEAU6dOxRtvvAFFUax+MI+Pj0edOnXw5ptvYty4cfD09ERubq6axVhgsNCwfyw4iIgsKCcnB1u2bMHZs2dx584dPP3003jyySdtHQurV6/GrFmzsHbtWjg6OiInJweNGjXClClT0KJFC5tme/vtt/H999/jxx9/RPfu3W2ahbTDgoOIyAr08g19586duH37NpydnfOd4rFlvszMTFSvXh1jx45Fv3792E/jIcWCg4hIQ3opNMzlyM3NNTnCp7WdO3cOnp6e8PT0tHUU0ggLDiIiItKc7ctaIiIieuix4CAiIiLNseAgIiIizbHgICIiIs2x4CAiIiLNseAgIiIizbHgICIiIs2x4CAiIiLNseAgIiIizbHgICLKo0+fPlAUBQEBAbaOQvRQcbJ1ACLShy1btuS7mZeRo6MjPDw84OnpCT8/PzRo0AARERHo3LkzXFxcbJCUiOwRWziIqFA5OTlITk5GQkICtm/fjqlTp6J79+6oVq0axo8fj+zsbFtHfKD58+dDURQoioKEhARbxyF6JLGFg4gKGDx4MF5//XX151u3biE5ORmxsbHYtGkTNm7ciMTERHzwwQf47bffsGbNGvj6+towMRHpHQsOIiqgYsWKePLJJwtMf+655zB8+HAcO3YMkZGR+Pvvv7Fnzx5069YNmzdv5ikWIjKLp1SIqNieeOIJ7Ny5E/Xr1wcA7Ny5E998842NUxGRnrHgIKISKVu2LH744QcoigIAmDJlCrKyskzOe+XKFYwaNQoNGzaEt7c3DAYD/Pz88NJLL2Hjxo1mt5GQkKD2vZg/fz4AYNmyZWjbti0qVqyIsmXLom7duhgxYgRu3rxZYPktW7ZAURT07dtXnfb444+r6zQ+tmzZYjbDzZs38eGHHyI4OBjlypVD+fLl0bJlS/z4448PfpOISMWCg4hKLDg4GP/6178AAJcuXcLevXsLzPPjjz+iVq1amDhxIvbv34/k5GRkZmbiwoULWLZsGf71r3+hf//+Rep8+uqrr+Kll17Cpk2bkJiYiPT0dPzzzz/45JNPEBwcjBMnTlj0//fPP/+gfv36+Pjjj3Hs2DHcuXMHKSkp2L59OyIjI/HGG29YdHtEDzMWHERUKm3btlWfb9++Pd9rS5cuRa9evXD79m3UqFEDX3zxBdavX4/9+/djxYoV6NChAwBgzpw5GDZsWKHb+fbbbzF37lw0btwYixcvxr59+7Bu3Tq89NJLAO4VPO3bt0daWpq6TKNGjXD48GGMHz9enRYdHY3Dhw/nezRq1KjA9u7cuYPOnTvjxo0bGD16NLZs2YJ9+/Zh1qxZqFatGgDgm2++QXR0dDHfMaJHlBARiciff/4pAASAjBkzpsjLbdy4UV2uX79+6vTExETx9PRUp2dlZZlcfuTIkQJAHBwc5MSJE/leO3PmjLpuANKhQweT6xk3bpw6z3//+98Cr8+bN099/cyZM4X+f3r37q3O6+npKUeOHCkwT3x8vJQpU0YASJcuXQpdHxHdwxYOIioVHx8f9XlycrL6/LvvvkNKSgqqVq2Kb7/9Fk5Opi+KGzt2LKpWrYrc3FwsXLjQ7HYMBgNmzZplcj2jRo1Sr6qZM2cOMjMzS/rfyefjjz9GcHBwgem1atVC165dAQA7duywyLaIHnYsOIioVNzc3NTneU9nrF69GgDQqVMnGAwGs8s7OTmhWbNmAIBdu3aZna9du3aoUqWKydccHBzQu3dvAEBSUhIOHDhQ9P+AGYqi4JVXXjH7eoMGDdTtmeqwSkT5seAgolLJW2R4eHgAuDc66cGDBwEAM2bMKHBVyP2P5cuXA7h3NYs5pvpZ5NW4cWP1+eHDh0v631FVqFAhX+vN/by9vdXned8DIjKNBQcRlcr169fV58aDcFJSUomGPL9z547Z1ypWrFjospUqVVKfJyUlFXvb93N1dS30dQeH/3185uTklHp7RA87jjRKRKXy999/q8/r1KkDIP8BuH///nj77beLtK7CRio1jvdBRPaJBQcRlcoff/yhPo+IiACQ/3SDiJgcJr24rl69WuTX826fiPSBp1SIqMSOHDmCTZs2AQD8/PzQsGFDAPdaKoxXd+zcudMi2zI1qJi51+8vcNg6QmR7LDiIqETu3r2LqKgoiAgA4L333st3yWqXLl0AACdOnLDI4FgbNmzA5cuXTb6Wm5uLBQsWAAC8vLwQFhaW7/UyZcqozzMyMkqdhYiKjwUHERXbsWPHEBERofbfaNWqFQYPHpxvnrffflu9ZLZv3744evRooetcu3YtYmNjzb6ekZGBQYMGmeyg+cknn6hXpvTr16/AZbiVK1dWn586darQHESkDfbhIKICrl27hiNHjqg/3759G8nJyYiNjcWmTZvwxx9/qC0bTZs2xfLly+Hs7JxvHZUqVcKCBQvQvXt3XL58GQ0bNkSfPn3w3HPPoVq1asjKysKFCxewZ88eLF++HKdPn8Zvv/2GkJAQk5kaNmyI3377Dc2bN8eQIUMQGBiIa9euYcGCBViyZAkAoFq1avjggw8KLFu/fn2UKVMG6enp+OCDD+Ds7Ax/f3/1SpOqVauibNmyFnnviMgMG490SkQ6kXdo86I8fH19ZcKECWaHLDdavXq1eHt7P3B9Dg4Osnnz5nzL5h3afN68edKnTx+zy1euXFmOHj1qNsewYcPMLvvnn3+q8xmHNvf39y/0/1Wc4dKJSIQtHERUKAcHB7i7u8PT0xP+/v5o0KABWrRogU6dOhV6GatR586dcebMGcyaNQvr1q3D0aNHkZSUBCcnJzz22GMIDg5GmzZt0L17d/j5+RW6rnnz5qFdu3aYOXMmDh8+jFu3bsHf3x9du3bF+++/Dy8vL7PLfvLJJwgMDMTChQtx9OhRpKSkcPwMIitSRP5/uygRkc4kJCTg8ccfB3Cv2OjTp49tAxFRibHTKBEREWmOBQcRERFpjgUHERERaY4FBxEREWmOBQcRERFpjlepEBERkebYwkFERESaY8FBREREmmPBQURERJpjwUFERESaY8FBREREmmPBQURERJpjwUFERESaY8FBREREmvt/3s+7GhYy9AwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 600x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Creates a capability region plot like those in Fig. 3 of arXiv:2008.11294.\n",
    "fig, ax = pygsti.report.capability_region_plot(vbdf, figsize=(6, 8), scale=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extracts the data for a plot like Fig. 2a of arXiv:2008.11294.\n",
    "vb_min = {}\n",
    "for circuit_type in ('RMC', 'PMC'):   \n",
    "    vbdf1 = vbdf.select_column_value('CircuitType', circuit_type)\n",
    "    vb_min[circuit_type] = vbdf1.vb_data(metric='polarization', statistic='monotonic_min', no_data_action='min')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 550x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Creates the plot like those in Fig. 2a of arXiv:2008.11294. The inner squares\n",
    "# are the randomized mirror circuits, and the outer squares are the periodic\n",
    "# mirror circuits.\n",
    "from matplotlib import cm as _cm\n",
    "spectral = _cm.get_cmap('Spectral')\n",
    "fig, ax = pygsti.report.volumetric_plot(vb_min['PMC'], scale=1.9, cmap=spectral, figsize=(5.5,8))\n",
    "fig, ax = pygsti.report.volumetric_plot(vb_min['RMC'], scale=0.4, cmap=spectral, fig=fig, ax=ax, linescale=0.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 550x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Creates a plot like those in Fig. 1d of arXiv:2008.11294. But note\n",
    "# that these RMCs don't have the same sampling as those in Fig. 1d:\n",
    "# this is just the same type of plot from RMC data, not the same\n",
    "# type of RMCs. To get the same color map as in Fig. 1d, set cmap=None\n",
    "vbdf1 = vbdf.select_column_value('CircuitType', 'RMC')\n",
    "fig, ax = pygsti.report.volumetric_distribution_plot(vbdf1, figsize=(5.5,8), cmap=spectral)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Randomized mirror circuit data can also be used for \"RB\", i.e., estimating an average\n",
    "# gate error rate by fitting data to an exponential. Below shows how to do this, and\n",
    "# shows the RB error rates versus the number of qubits.\n",
    "rb = pygsti.protocols.RB(datatype='adjusted_success_probabilities', defaultfit='A-fixed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rb_results = {}\n",
    "r = {}\n",
    "for key, subdata in data.items():\n",
    "    if 'RMCs' in key:\n",
    "        rb_results[key] = rb.run(subdata)\n",
    "        n_qubits = int(key.split('-')[0])\n",
    "        r[n_qubits] = rb_results[key].fits['A-fixed'].estimates['r']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "plt.plot(widths, [r[w] for w in widths], 'o')\n",
    "plt.xlabel('Number of Qubits')\n",
    "plt.ylabel(\"RB Error Rate\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}