docs/tutorials/h02_mbd_data_gen.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "import json, pickle\n",
    "import glob, os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from qiskit import transpile\n",
    "from qiskit import execute\n",
    "from qiskit.providers.fake_provider import FakeLima\n",
    "from qiskit.primitives import Estimator\n",
    "from qiskit.circuit.random import random_circuit\n",
    "\n",
    "import torch\n",
    "from torch.optim import Adam\n",
    "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
    "from torch.nn.functional import dropout\n",
    "\n",
    "from torch_geometric.nn import GCNConv, global_mean_pool, Linear, ChebConv, SAGEConv\n",
    "from torch_geometric.data import Data\n",
    "from torch_geometric.loader import DataLoader\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "from blackwater.data.loaders.exp_val import CircuitGraphExpValMitigationDataset\n",
    "from blackwater.data.generators.exp_val import exp_value_generator\n",
    "from blackwater.data.utils import generate_random_pauli_sum_op\n",
    "from blackwater.library.ngem.estimator import ngem\n",
    "\n",
    "from qiskit.quantum_info import random_clifford\n",
    "\n",
    "import random\n",
    "from qiskit.circuit.library import HGate, SdgGate\n",
    "from qiskit.circuit import ClassicalRegister\n",
    "\n",
    "from blackwater.data.utils import (\n",
    "    generate_random_pauli_sum_op,\n",
    "    create_estimator_meas_data,\n",
    "    circuit_to_graph_data_json,\n",
    "    get_backend_properties_v1,\n",
    "    encode_pauli_sum_op,\n",
    "    create_meas_data_from_estimators\n",
    ")\n",
    "from blackwater.data.generators.exp_val import ExpValueEntry\n",
    "from blackwater.metrics.improvement_factor import improvement_factor, Trial, Problem\n",
    "\n",
    "from qiskit_aer import AerSimulator, QasmSimulator\n",
    "from qiskit.providers.fake_provider import FakeMontreal, FakeLima, FakeBelem\n",
    "\n",
    "from torch_geometric.nn import (\n",
    "    GCNConv,\n",
    "    TransformerConv,\n",
    "    GATv2Conv,\n",
    "    global_mean_pool,\n",
    "    Linear,\n",
    "    ChebConv,\n",
    "    SAGEConv,\n",
    "    ASAPooling,\n",
    "    dense_diff_pool,\n",
    "    avg_pool_neighbor_x\n",
    ")\n",
    "from torch_geometric.data import Data\n",
    "from torch_geometric.loader import DataLoader\n",
    "from torch_geometric.utils import to_dense_adj, to_dense_batch\n",
    "\n",
    "from qiskit import QuantumCircuit\n",
    "from qiskit.circuit.library import U3Gate, CZGate, PhaseGate, CXGate\n",
    "from mbd_utils import construct_random_clifford, cal_z_exp, calc_imbalance, cal_all_z_exp, construct_mbl_circuit, generate_disorder, random_clifford_circuit, modify_and_add_noise_to_model\n",
    "from gnn import ExpValCircuitGraphModel\n",
    "from qiskit.quantum_info import Clifford\n",
    "from qiskit_aer.noise import depolarizing_error, coherent_unitary_error, NoiseModel\n",
    "\n",
    "from functools import partial"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "backend = FakeLima()\n",
    "properties = get_backend_properties_v1(backend)\n",
    "\n",
    "## Local\n",
    "backend_ideal = QasmSimulator() # Noiseless\n",
    "backend_noisy = AerSimulator.from_backend(FakeLima()) # Noisy\n",
    "\n",
    "run_config_ideal = {'shots': 10000, 'backend': backend_ideal, 'name': 'ideal'}\n",
    "run_config_noisy = {'shots': 10000, 'backend': backend_noisy, 'name': 'noisy'}\n",
    "\n",
    "num_qubit = 4"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "backend = FakeLima()\n",
    "properties = get_backend_properties_v1(backend)\n",
    "\n",
    "# Local, coherent noise\n",
    "backend_ideal = QasmSimulator() # Noiseless\n",
    "backend_noisy_coherent, noise_model = modify_and_add_noise_to_model()\n",
    "\n",
    "run_config_ideal = {'shots': 10000, 'backend': backend_ideal, 'name': 'ideal'}\n",
    "run_config_noisy_coherent = {'shots': 10000, 'backend': backend_noisy_coherent, 'name': 'noisy_coherent'}\n",
    "\n",
    "num_qubit = 4"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "def fix_random_seed(seed=0):\n",
    "    random.seed(seed)\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)  # if you are using multi-GPU.\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    print(f'random seed fixed to {seed}')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "from qiskit.transpiler.exceptions import TranspilerError\n",
    "import scipy\n",
    "\n",
    "def generate_data(generating_func, two_q_gate_depths, save_path: str, n_entries_per_file: int, run_config_n):\n",
    "    for depth in two_q_gate_depths:\n",
    "        entries = []\n",
    "\n",
    "        for i in tqdm(range(n_entries_per_file)):\n",
    "            success = False\n",
    "            while not success:\n",
    "                try:\n",
    "                    circuit = generating_func(depth)\n",
    "                    success = True\n",
    "                except (scipy.linalg.LinAlgError, TranspilerError, np.linalg.LinAlgError) as e:\n",
    "                    print(f\"Ran into an error:, {e}\")\n",
    "\n",
    "            job_ideal = execute(circuit, **run_config_ideal)\n",
    "            job_noisy = execute(circuit, **run_config_n)\n",
    "\n",
    "            counts_ideal = job_ideal.result().get_counts()\n",
    "            counts_noisy = job_noisy.result().get_counts()\n",
    "\n",
    "            ideal_exp_val = cal_z_exp(counts_ideal)\n",
    "            noisy_exp_val = cal_z_exp(counts_noisy)\n",
    "\n",
    "            graph_data = circuit_to_graph_data_json(\n",
    "                circuit=circuit,\n",
    "                properties=properties,\n",
    "                use_qubit_features=True,\n",
    "                use_gate_features=True,\n",
    "            )\n",
    "\n",
    "            entry = ExpValueEntry(\n",
    "                circuit_graph=graph_data,\n",
    "                observable=[],\n",
    "                ideal_exp_value=ideal_exp_val.tolist(),\n",
    "                noisy_exp_values=[noisy_exp_val.tolist()],\n",
    "                circuit_depth=circuit.depth()\n",
    "            )\n",
    "            to_append = entry.to_dict()\n",
    "            to_append['circuit'] = circuit\n",
    "            entries.append(to_append)\n",
    "\n",
    "        path = f\"{save_path}/step_{depth}.pk\"\n",
    "        with open(path, \"wb\") as f:\n",
    "            pickle.dump(entries, f)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Sanity check on the all-z expectation value of the generated random Cliffords"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from qiskit.transpiler.exceptions import TranspilerError\n",
    "\n",
    "out = []\n",
    "for _ in tqdm_notebook(range(1000)):\n",
    "    d = random.choice(np.arange(0, 19, 2))\n",
    "    circuit, _ = construct_random_clifford(num_qubit, d)\n",
    "\n",
    "    success = False\n",
    "    while not success:\n",
    "        try:\n",
    "            circuit = transpile(circuit, backend_noisy, optimization_level=3)\n",
    "            success = True\n",
    "        except TranspilerError as e:\n",
    "            print(f'Run into {e}')\n",
    "\n",
    "    job_ideal = execute(circuit, **run_config_ideal)\n",
    "    counts_ideal = job_ideal.result().get_counts()\n",
    "    ideal_exp_val = cal_all_z_exp(counts_ideal)\n",
    "    out.append(ideal_exp_val)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "sns.histplot(out)\n",
    "plt.title('1000 \"random\" clifford all-Z expectation')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Generate cliffords"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [],
   "source": [
    "num_qubit = 4\n",
    "\n",
    "def construct_random_clifford_func(two_q_gate_depth_post_trans, be):\n",
    "    if two_q_gate_depth_post_trans in [6, 8, 16, 18]: factor = 1.2\n",
    "    elif two_q_gate_depth_post_trans in [2]: factor = 0.5\n",
    "    elif two_q_gate_depth_post_trans in [4, 10, 12, 14]: factor = 1\n",
    "\n",
    "    if not two_q_gate_depth_post_trans:\n",
    "        d = np.random.randint(1, 6)\n",
    "        rc = transpile(construct_random_clifford(num_qubit, d, max_operands=1)[0], backend=be, optimization_level=3)\n",
    "\n",
    "    elif 1 <= two_q_gate_depth_post_trans <= 8:\n",
    "        d = np.random.randint(1, two_q_gate_depth_post_trans//factor)\n",
    "        rc = transpile(construct_random_clifford(num_qubit, d)[0], backend=be, optimization_level=3)\n",
    "        while rc.depth(filter_function=lambda x: x[0].num_qubits == 2) != two_q_gate_depth_post_trans:\n",
    "            d = np.random.randint(1, two_q_gate_depth_post_trans//factor)\n",
    "            rc = transpile(construct_random_clifford(num_qubit, d)[0], backend=be, optimization_level=3)\n",
    "\n",
    "    elif 8 <= two_q_gate_depth_post_trans <= 18:\n",
    "        d = np.random.randint(5, two_q_gate_depth_post_trans//factor)\n",
    "        rc = transpile(construct_random_clifford(num_qubit, d)[0], backend=be, optimization_level=3)\n",
    "        while rc.depth(filter_function=lambda x: x[0].num_qubits == 2) != two_q_gate_depth_post_trans:\n",
    "            d = np.random.randint(5, two_q_gate_depth_post_trans//factor)\n",
    "            rc = transpile(construct_random_clifford(num_qubit, d)[0], backend=be, optimization_level=3)\n",
    "    else:\n",
    "        raise NotImplementedError\n",
    "    return rc"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "depths = np.arange(0, 19, 2)\n",
    "generate_data(partial(construct_random_clifford_func, be=backend_noisy_coherent), depths, './data/haoran_mbd_coherent/random_cliffords', 500)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Random Circuit"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "num_qubit = 4\n",
    "\n",
    "def construct_random_circuit(two_q_gate_depth_post_trans, be):\n",
    "    if two_q_gate_depth_post_trans in [6, 8, 16, 18]: factor = 1.2\n",
    "    elif two_q_gate_depth_post_trans in [2]: factor = 0.5\n",
    "    elif two_q_gate_depth_post_trans in [4, 10, 12, 14]: factor = 1\n",
    "    else: raise NotImplementedError\n",
    "\n",
    "    if not two_q_gate_depth_post_trans:\n",
    "        d = np.random.randint(1, 6)\n",
    "        rc = transpile(random_circuit(num_qubit, d, 1, measure=True), backend=be, optimization_level=3)\n",
    "\n",
    "    elif 1 <= two_q_gate_depth_post_trans <= 8:\n",
    "        d = np.random.randint(1, two_q_gate_depth_post_trans//factor)\n",
    "        rc = transpile(random_circuit(num_qubit, d, 2, measure=True), backend=be, optimization_level=3)\n",
    "        while rc.depth(filter_function=lambda x: x[0].num_qubits == 2) != two_q_gate_depth_post_trans:\n",
    "            d = np.random.randint(1, two_q_gate_depth_post_trans//factor)\n",
    "            rc = transpile(random_circuit(num_qubit, d, 2, measure=True), backend=be, optimization_level=3)\n",
    "\n",
    "    elif 8 <= two_q_gate_depth_post_trans <= 18:\n",
    "        d = np.random.randint(5, two_q_gate_depth_post_trans//factor)\n",
    "        rc = transpile(random_circuit(num_qubit, d, 2, measure=True), backend=be, optimization_level=3)\n",
    "        while rc.depth(filter_function=lambda x: x[0].num_qubits == 2) != two_q_gate_depth_post_trans:\n",
    "            d = np.random.randint(5, two_q_gate_depth_post_trans//factor)\n",
    "            rc = transpile(random_circuit(num_qubit, d, 2, measure=True), backend=be, optimization_level=3)\n",
    "    else:\n",
    "        raise NotImplementedError\n",
    "    return rc"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random seed fixed to 0\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 1262.35x385.28 with 1 Axes>",
      "image/png": "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\n"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fix_random_seed(0)\n",
    "# circuit = transpile(construct_random_circuit(2), backend=backend_noisy, optimization_level=3)\n",
    "ideal_circuit = construct_random_circuit(4, be=backend_ideal)\n",
    "noisy_circuit = transpile(ideal_circuit, backend=backend_noisy)\n",
    "noisy_circuit.draw('mpl', fold=-1)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 929.397x325.08 with 1 Axes>",
      "image/png": "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\n"
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ideal_circuit.draw('mpl', fold=-1)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/kj/mfqyg_tj77nf4gt67lvscdkw0000gn/T/ipykernel_86766/2271416955.py:4: DeprecationWarning: Back-references to from Bit instances to their containing Registers have been deprecated. Instead, inspect Registers to find their contained Bits.\n",
      "  measurement_qubits.append(qc.data[-1-measurement][1][0].index)\n"
     ]
    },
    {
     "data": {
      "text/plain": "[3, 2, 1, 0]"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qubit_mapping = get_measurement_qubits(circuit, 4)\n",
    "qubit_mapping"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [],
   "source": [
    "def get_measurement_qubits(qc, num_qubit):\n",
    "        measurement_qubits = []\n",
    "        for measurement in range(num_qubit-1, -1, -1):\n",
    "            measurement_qubits.append(qc.data[-1-measurement][1][0].index)\n",
    "        return measurement_qubits"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "transpile(circuit, backend_noisy, optimization_level=3).depth(lambda x: x[0].num_qubits == 2)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "depths = list(range(8, 20, 2))\n",
    "generate_data(partial(construct_random_circuit, be=backend_noisy), depths, './data/haoran_mbd/random_circuits/train', 500, run_config_n=run_config_noisy)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "is_executing": true
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "f = open('./data/haoran_mbl/rc_train/random_circuits_depth4.json')\n",
    "out = json.load(f)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Check distribution (potential concentration of measure)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "outputs": [],
   "source": [
    "def check_f(f, f_ext, step_indices):\n",
    "    return f.endswith(f_ext) and any([f\"%d\"%step_index in f for step_index in step_indices])\n",
    "\n",
    "def load_circuits(data_dir, step_indices, f_ext='.json'):\n",
    "    circuits = []\n",
    "    ideal_exp_vals = []\n",
    "    noisy_exp_vals = []\n",
    "    data_files = [os.path.join(data_dir, f) for f in os.listdir(data_dir) if check_f(f, f_ext, step_indices)]\n",
    "    for data_file in tqdm(data_files, leave=True):\n",
    "        if f_ext == '.json':\n",
    "            for entry in json.load(open(data_file, 'r')):\n",
    "                circuits.append(QuantumCircuit.from_qasm_str(entry['circuit']))\n",
    "                ideal_exp_vals.append(entry['ideal_exp_value'])\n",
    "                noisy_exp_vals.append(entry['noisy_exp_values'])\n",
    "        elif f_ext == '.pk':\n",
    "            for entry in pickle.load(open(data_file, 'rb')):\n",
    "                circuits.append(entry['circuit'])\n",
    "                ideal_exp_vals.append(entry['ideal_exp_value'])\n",
    "                noisy_exp_vals.append(entry['noisy_exp_values'])\n",
    "    return circuits, ideal_exp_vals, noisy_exp_vals"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [
    {
     "data": {
      "text/plain": "  0%|          | 0/1 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "1e27be03f24c45d39e07a8a579e1a9d5"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n"
     ]
    },
    {
     "data": {
      "text/plain": "  0%|          | 0/1 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "77456b3e60c54a9b92db4ba770240316"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "train_circuits, train_ideal_exp_vals, train_noisy_exp_vals = load_circuits('./data/haoran_mbd/random_circuits/train', [18], '.pk')\n",
    "print(len(train_circuits))\n",
    "\n",
    "test_circuits, test_ideal_exp_vals, test_noisy_exp_vals = load_circuits('./data/haoran_mbd/random_circuits/val', [18], '.pk')\n",
    "print(len(test_circuits))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "outputs": [],
   "source": [
    "a = train_ideal_exp_vals+test_ideal_exp_vals\n",
    "from itertools import chain\n",
    "a = list(chain.from_iterable(a))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "outputs": [
    {
     "data": {
      "text/plain": "(array([168., 103., 205., 324., 622., 613., 282., 192., 136., 155.]),\n array([-1. , -0.8, -0.6, -0.4, -0.2,  0. ,  0.2,  0.4,  0.6,  0.8,  1. ]),\n <BarContainer object of 10 artists>)"
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use({'figure.facecolor':'white'})\n",
    "plt.hist(a)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Random Brickwork"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "outputs": [],
   "source": [
    "num_qubit = 4\n",
    "\n",
    "def construct_random_brickwork_func(num_steps, be):\n",
    "    num_qubit = 4\n",
    "    rb = construct_mbl_circuit(num_qubit, [], 0, num_steps, completely_random=True)\n",
    "    rb = transpile(rb, backend=be, optimization_level=3)\n",
    "    return rb"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 2767.35x385.28 with 1 Axes>",
      "image/png": "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\n"
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "construct_random_brickwork_func(3, be=backend_noisy).draw('mpl', fold=-1)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "steps = [1]\n",
    "generate_data(construct_random_brickwork_func, steps, './data/haoran_mbd/random_brickwork', 500)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Random MBD"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "outputs": [],
   "source": [
    "num_qubit = 4\n",
    "\n",
    "W = 0.8 * np.pi\n",
    "theta = 0.1 * np.pi\n",
    "\n",
    "def construct_random_mbd_func(num_steps, be):\n",
    "    disorders = generate_disorder(num_qubit, W)\n",
    "    random_mbl = construct_mbl_circuit(num_qubit, disorders, theta, num_steps)\n",
    "    circuit = transpile(random_mbl, backend=be, optimization_level=3)\n",
    "    return circuit, random_mbl"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 899.479x325.08 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArUAAAEDCAYAAAAr2/y0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAABEQklEQVR4nO3deVxU9f7H8dfMAIqAIiLivmuC4l5qBrivpXnNtLKbWuZa6s2yxdzKa1pqmmaa6S3vtdTMNG1xAzPtdk3NXMqUvIobKouAqAzM7w9+0iWQRZg5zPB+3sd9NH7P95zzHjrJZ77zPd9jstlsNkREREREnJjZ6AAiIiIiIoWlolZEREREnJ6KWhERERFxeipqRURERMTpqagVEREREaenolZEREREnJ6KWhERERFxeipqRURERMTpqagVEREREaenolZEREREnJ6KWhERERFxeipqRURERMTpqagVEREREaenolZEREREnJ6KWhERERFxeipqRURERMTpqagVEREREaenolZEREREnJ6KWhERERFxem5GBxAREXFmsbGxWK3WXPvMmTOHiRMn5rjNzc0NPz8/e0QTKVFMNpvNZnQIERERZxUTE0NsbGyufRo1asSxY8dy3Obn50dAQIA9oomUKJp+ICIiIiJOT0WtiIiIiDg9FbUiIiJ2tm7dOqMjiLg8FbUiIiIi4vRU1IqIiNhZ//79jY4g4vK0pJdIHtI+/xHbuXijYxSYqYovlj4tHX7eX3dAYozDT4tPADTs6PjzihRX48aN4+DBg4acu1mzZsyfP9+Qc0vJpaJWJA+2c/HYogyo0pxUYgzERxudQkQOHjxIZGSk0TFEHEbTD0REROxs9OjRRkcQcXkqakVEROxszJgxRkcQcXkqakVEROwsNDTU6AgiLk9FrYiIiJ1dunTJ6AgiLk83iok4QP2lzzC1/QAeDWqfr/aSpMtEE6XcPTGZzJhMJkyYaFSzLU/f/xa1AxsbHU9ERJyEiloRMdzCZ37ILGCtaaks3/IiL7/fg49eOoXFbDE4nUjhBQUFGR1BxOVp+oGIFCtuFne6tR7CpYRoklLijI4jUiQ+/fRToyPkm7+/P8HBwQQFBeHr65trX5PJRIUKFRwTTCQPKmpFpFhJvBbHht0LqBXYmHJe/kbHESkSr776qtERctW+fXs++ugjTp8+zaVLlzh8+DBHjhwhLi6OkydP8v7779OyZdaHuXh5ebFjxw4uXrxIw4YNDUou8gdNPxCHSLwOR6LheiqU94LgquCmb5UzXUxO4KHP5+JhdiPFepMZ9z1Mx5olZz7puHfaYTJlfMZ2dyvFXTXuYcrjzjOyJZKXtWvXMn36dKNjZNOoUSOWL19O27ZtM9sSExM5c+YMJpOJWrVqUadOHerUqcOwYcP45ptveOqpp7hy5QpbtmwhNDSU6Ohozp8/b+C7EMlQIova9PR05s6dy3vvvceZM2do2LAhCxYsYPjw4YSFhbF06VKjI7qM1DT4bB98fxLSbX+0e5WCB5rDPXWNy+ZI7mYL1jRrtvbU9DTczRb8PX3YOXAKFrOZqPiLPLppIXsHv2ZAUmPMH7NHN4WJONjQoUNZvHgxpUqV4uLFiyxdupTVq1fzyy+/YLNl/IVtsVho3LgxgwcPZujQoXTt2pXDhw9z+vRpgoODiY6OJjw8nKtXrxr8bkRKaFE7bNgw1q9fz+TJk2nZsiV79uxh0KBBXLp0iQkTJhgdz2Wk22Dlt3DkbPZtyTdg9fcZfdrWc3w2R6tZriIn4i9maUu6eZ0LyfHUKReAxfzHTKCEG9doUrGGoyOKSAny9NNPs2TJEgDef/99/va3v+VYmKalpfHTTz/x008/8cYbb7BkyRL69etHcHAwV65cITw8nJMnTzo6vkiOSlxRu3r1alauXElERARhYWEAdOjQgf3797N+/XpatGhhcELX8ev5nAva/7VhP7SsBR4ufiUODg7luZ0f0a12U9pWacDVm9d4IeJfNPavQbNKtQD4PT6GIV8u5njseZZ1f9rYwCJSpCIjI42OkOnuu+9m0aJFAIwdO5Z33nknX/tdu3YNf/8/5rmXKVMGk8lkl4wid6LE3Sg2c+ZMunfvnlnQ3lKvXj3c3d0JCQkB4NSpU4SFhdGgQQOaNGnCt99+a0Rcp7b3BOT1192NVDh42iFxDPVIUHtm3Pcwz2xbQaV3nqL5yhdIsd7kswefw+3/l6yq7RtAxKCp7H50OuO2rzQ2sIgUqSNHjhgdAQAPDw9WrFiBxWLhrbfeyndB6+XllWUO7YYNG/D09GTFihV2TiySfybbrYkzJUB0dDTVq1dn+fLlDB06NMu2QYMG8csvv3DgwAEAunXrRp8+fRg1ahR79uzhoYce4vfff8fDwyPP8/Tq1YstW7bY5T04k8dmHaZCteBc+9hsNn74/DW+X1d87wze+vArhFW37xqTN6yplHJzB+Dytat0/uQ1Dg6ZXahjRp45SpdPHD8v980RO2laN9zh5/3pZATPLeng8PNKyTZhwgRCQ0PzHImdN28e48ePz3FbWFgYu3btYu7cufaImMUjjzzCP//5T44fP07Tpk25fv16nvv8uaANDw8nNjaWo0ePEhgYSKdOndixY4fds0vJ1LNnTzZv3pyvviVqpDY6OhqAwMDALO0pKSlERkZmTj24fPkyu3fvZtiwYQC0a9eOKlWqsHPnTscGdnKp1xOx2dJz7WMymbDeuOagRMXXvgsn6fjxdLp88hr9P5/L3I6PGx1JRFzQqFGjAJgzZ84dF7QnT54kLi4ucwrDrWOKGK1EjdSeOHGC+vXrM2/ePMaNG5fZPm3aNKZOncqiRYsYNWoU+/fvp3///kRFRWX2GTBgAJ07d2b48OEGJHdO247AFwfz7jepNwSWs3ucO2Z9dzu2qBijYxSYqU4AbiM7Ofy8+z6G+GiHnxbfatBqoOPPKxITE0NsbGyufRo1asSxY8dy3Obn50dAQECR5woPD88yguzj48PVq1e5ceMGfn5+XLuW+4DC7QraW6pWrUp0dDRXr17F19eX/y0nwsLCiIiIKPL3JJIbF789J6s6deoQEhLCzJkz8fPzo2rVqqxbty5zqsCfF5aWwmlTF7YehptWyOmTkwloWLl4F7QiIkVh2rRpRkegefPmABw6dKjQBS3A2bNnOXPmDNWrV6d+/focP37cbtlF8qNETT8wm82sXbuW4OBgRo4cyZAhQ/D392f06NFYLJbMm8Rq1KjBxYsXuXHjRua+v//+OzVr1jQqulPyLg1Pd8i+ssGtm8eqlIfB9zo8loiIww0YMMDoCNSokbFU4K+//ppn37Vr1+Za0N5y61j6/SjFQYkaqQVo0KBBtrmxgwcPJigoCE9PTyDjudf33nsvy5cvz7xR7OzZs3TooJtQCqpOALx4P+z5Db45nNFWwx/a1YPmNV1/KS8REch9+oGjbNiwgYYNG+Y5Smsymbjrrrs4deoUnTt3znUd2qeeegoPDw/OnDlT1HFFCkwlBbBv3z7atGmTpW3JkiU88cQTzJ8/Hw8PD1avXp2vlQ8kO98y0LPpH0Xt+G7G5hERKYmSkpLyNUXAZrMRHByM1WolNTU1176nTp0qonQihVfii9pb/5H/+e7NOnXqsGvXLoNSSXEVefooD30+l5CKNTmVcImQgJq0DKzNyGZd8fP05kTcBQZtepv/PP53zibG8nzEKvxKexPkX42RzbtmO15++hQky/oH/1aUb1dESqiUlBSjI4gUWImaU5sTb29v0tLSGDt2rNFRxAncV/0uWleuy7aBk7mv+l0s7DyEuOvJ+Hl6cyE5ng9+3omXeykAlv20nTEturOwy1C+jDpAapo12/Hy06cgWVzBkVN7eGP14yxYP5qPtk43Oo5IkQgPDzc6gojLK/EjtSIFERUfQ+1yGUvvRCfGEnc9mWD/agAEevkyM3QQvdfNAuDitXiq+VQAwLe0Fwk3ruFfpmyW4+Wnz4XkeB7btDBLWyWvckxrPyBLlqo+fkX8bo2RlBLH2AcXUaa0Dy8szf/ItUhx9u677xodQcTlqagVKYCjV6IJqlCNtPR0zCYTG0/s4+lmnXPsW93Hn7NJV6hetgJxKcn4lva6oz6BXr5sGzg5W/vGE/uyZHE2sVcv8Po/sy4s6+cTyMuPfYzNZuOf21+nU4tHDUonUrRGjhypwlbEzlTUihTA0cvRtKlSnxtpqcRcu0p04hUqePrk2HdoSAcm7lzFh4d30bdBa/ZdOMnx2PM83jisQH3ym+V8UhyVvcsX2Xu1N7+ygbw1MiJb+7Xriby7cRwdmj9Ci/qOf3iEiD3oQQQi9qeiVqQAJrXpm/n6wBNv5Njni/6TgIwR1o96j8lsP5cUR8y1q1n65qdPYbI4o8Ubn+Xs5d/45j8r2Pbjhzw/8B9GRxIRESegolbEQap4l+eBeq0K3cfVPTfgA6MjiIiIEyrxqx+IiIjYm9EPXhApCTRSK5IHUxVfoyPcEaNy+wQYclrDziuSH2vWrHH4o3KbNWtW4H2iTp8HoE6NylleO+LcIoVlstlsNqNDSMkw7p8Z/5yvG9pFxIXExMQQGxuba5/cHpPr5+dHQEDx+FQ26Y2lAMx6YXiW1yLOQNMPRERERMTpqagVEREREaenolZERMTOFi9ebHQEEZenolZERMTOgoODjY4g4vJU1IqIiNhZWFjeTwkUkcLRkl4iIiKF4O3tjaenZ579qlatmmO7xWIp6kgiJZKKWhERkUK4fv06Vqs11z5t27YlJSUlx21ubm6UKVPGHtFEShQVtSIiIoVgtVrzXKd27969t+3j5+dnj1giJY7m1IqIiIiI01NRKyIiIiJOT0WtiIiIna1bt87oCCIuT0WtiIiIiDg9FbUiIiJ21r9/f6MjiLg8rX5goL/9epSfEhMNOXdTHx/eahhkyLmdTdrnP2I7F290jAIzVfHF0qel0TFcnrNeH2DMNfLrDkiMcegpM/kEQMOOxpxb8m/cuHEcPHjQ4edt1qwZ8+fPd/h5peioqDXQT4mJ7IrLfRkYMZ7tXDy2KIN+C0uxp+ujYBJjID7a6BRSnB08eJDIyEijY4gT0vQDEREROxs9erTREURcnopaEREROxszZozREURcnopaEREROwsNDTU6gojLU1ErIiJiZ5cuXTI6gojLU1Er4gD1lz7DP4/uzne7lDy6RkRECkerH4iISLHWZaKJUu6emExmTCYTJkw0qtmWp+9/i9qBjY2Oly9BQVpCUcTeVNSKiEixt/CZHzILWGtaKsu3vMjL7/fgo5dOYTFbDE6Xt08//dToCCIuT9MPRETEqbhZ3OnWegiXEqJJSokzOk6+vPrqq0ZHcEnlypXj4YcfZs6cOWzcuJGvv/6a9evXM23aNHr16oWHh0e2ffz9/Vm6dCndunUzILHYk0ZqRYqBi8kJPPT5XDzMbqRYbzLjvofpWNM5vlYtSjYbmExGpyiedI38IfFaHBt2L6BWYGPKefkbHSdf1q5dy/Tp042O4TKqVq3Kq6++yqOPPoqXl1e27Q8++CAAMTExLF26lDfeeIOkpCT8/f3Zvn07ISEhuLm58fXXXzs6uthRiS1q09PTmTt3Lu+99x5nzpyhYcOGLFiwgOHDhxMWFsbSpUuNjpiNLep3rM+MxzLpeczt22W2p3/5FWn/+gS3RQswlfUxMGHOzsdD5C9//HnqZ9CuPtxbH7xKGRbLodzNFqxp1mztqelpuJst+Hv6sHPgFCxmM1HxF3l000L2Dn7NgKSOl3IT9vyW8f/YZHB3g6bVIewuqOZndDrH0TWSu3HvtMNkyvhy0d2tFHfVuIcpj+sr/ZLor3/9K2+//TblypUDICIigp07d/Lzzz+TnJxM+fLlad68OT169CAkJIRXXnmFxx57jHHjxjF9+nRCQkI4duwYL774osHvRIpaiS1qhw0bxvr165k8eTItW7Zkz549DBo0iEuXLjFhwgSj4+XIVKc25uFPkjbvbUwN6mMKqEj68eOkLV2O2xszi2VBezgaPtiVMQJ3S/w12PITfH8CxnaB8tk/ZLucmuUqciL+Ypa2pJvXuZAcT51yAVjMf8wESrhxjSYVazg6oiESU2DhNoi5+kfbTSvs+x1+PAWPtYMWtYxK51i6RnI3f8wep7kpTOxn+vTpTJ48GYCNGzfywgsv8Msvv2Tr98knnzBp0iTat2/P22+/TYsWLfjss88wmUwcO3aMDh06cPHixWz7iXMrkXNqV69ezcqVK9m4cSPPPfccHTp04OWXX6Zt27ZYrVZatGhhdMTbsjzQG1PTJqTNmo0tIYG06a9jHjYEU4P6RkfLJv4arPw2o6C15bA9Lhn+UUJWKhocHMryQzvYHf0LaenpxF1PYsKOD2nsX4NmlWoB8Ht8DOGrp9Jr3Sz61G9lbGAH+WgPXLqavd0GpNtg1W22uyJdI64tMjLS6AhOb/To0UyePBmr1cqTTz5Jnz59cixo/9fu3bvp1asXly5dwmQyYbPZePnll1XQuqgSOVI7c+ZMunfvTlhYWJb2evXq4e7uTkhICJAxsf/jjz/mxIkTrFmzhv79+xsRNxvL+GexjhqLdeRYTE2bYOnd0+hIOdrzG1jTb7/dBpy6DKevQI0KDotliEeC2pNivckz21Zw+uplvD1Kc1+1Rnz24HO4/f+d27V9A4gYNJWo+It0W/M6veoW3w9XReFCAhy/kHufdBt89xv0bemYTEbSNeLajhw5QkBAgNExnFaDBg2YM2cOkDH94F//+le+9vP39+frr7+mYsWKXLlyhQoVKjB37ly2bt1KUlKSPSOLAUpcURsdHc3hw4cZP358tm2nT58mODiYUqUyJnp2796dJ554gqFDhxboHL169WLLli159rPMmYW5aUiBjg1g8vHB3K4d6Z9twBwelvcOOYiIiMDUus0d7ZtfA6f/h4DaLTHlcedP/2Gv8J/PX7drlsLY+vArhFUv/BqTw0I6MiykY47bblhTKeXmDkBZD0+83EsX+nwRkRF0GdW50Mexl2bdniVs8Pw8+63f8SsPtrrL/oHuUFFdH1AyrpE3R+ykad1wh57zlsjICFoP6lCkx5wwYQKhoaF5jsTOmzcvx987AGFhYezatYu5c+cWabY78cKs9wAwmUxZXhtt3rx5eHp6snLlygIVtLduCjt27BhdunTh888/p2XLlrz44ou8/PLLWfpHRkYWi/cqWfXs2ZPNmzfnq2+JLGoBAgMDs7SnpKQQGRlJjx49MtvatWtHcZS+/wDpX32NuVcP0uYtwPTuO5jK+xodKxuLu0eef0HYbDYsbtmXXClp9l04yeTda7CYzKSmW5nb8XGjI9ldfv+9W9x1fUDJvEZu2TonpwlMUlLUrVuXnj17kpKSwnPPPZevff5c0N6aQ/vMM8/w3Xff8dRTTzFt2jRu3rxp5/TiSCWuqPX3z1j+5fjx4/Ts+cfX9rNnz+b8+fO0bFn47znz+4mi875/sysutkDHtl2+TNrfZ2N5+ilM3btiiz5L2uw3scycUaBPmOHh4Wyz2fcXxUffwf5TOc+nvcVkMrHozVdpsa74ruFofXc7tqgYu57j3mp3sWNg0f4MwsPCsX08o0iPWZSOnIVlEbn3MZmgXbParLDztVoYjrg+wHWukX0fQ3y0Q0+ZKSwsHNu7RX8txcTE0LBhw1z7zJs3j+HDh+e4zc/Pjz59+vDWW28VebaCmvRGxso/Npsty2tHCg8PzzLy/eijjwLw8ccfc+XKlTz3v11BC7Bnzx4OHDhA8+bN6d69Oxs3bszcLywsjIiIiKJ9M+JQJe5GsTp16hASEsLMmTP58MMP2b59OyNHjuSDDz4AKJKi1l5saWmkvT4LU4tmmHt2x2Q2Y3nhOWy/nSD94zVGx8umXf08CloylvQKqe6oRFKcNKoM5TwzroPbsdkyln4TcXbTpk0zOoLTuvvuuwH48ssv8+ybW0F7y1dffQVA69atiz6sGKrEFbVms5m1a9cSHBzMyJEjGTJkCP7+/owePRqLxZJ5k1hxlL5sObb4eCzPjs1sM/n7Y/nbONI/XEX64SMGpsuuTkVoUzfnbbcKmQF3g1vxf8Kl2IHZDAPbZIzG3q6wbV4D7qri0FgidjFgwACjIzitxo0zlnI7cOBArv0qVKiQZ0H7v8cpzr/v5c6UuOkHkHEX5c6dO7O0DR48mKCgIDw9PQ1KlTfLiOFYRmT/+srctg3mLzcZkCh3JlNG0epbJuPhCympf2yrWBb6tIDgqsblE+M1qgJPd4DPfsxYDeGWUm5wX0PoEQJm3bchLqBRo0YcO3bM6BhOae3atVSoUIELF3JfLmXkyJF5FrQAR48eZfny5Rw6dMgeccVAJbKozcm+ffto0ybragCTJ09mxYoVXLp0iZ9//plx48YRGRlJ3bq3GX6UbMxm6B4CHYPgxEW4ngp+3lCzgh6HKhkaVoYXesGZWJib8a0g0/+SUdiKiEycODFf/f71r3/h5ubG4sWLiYm5/Tz3I0eO8OSTTxZVPClG9GsDSEpK4vjx44waNSpL+4wZM5gxo/jeaONMPNwgyAVGZSNPH+Whz+cSUrEmpxIuERJQk5aBtRnZrCt+nt6ciLvAoE1v85/H/87ZxFiej1iFX2lvgvyrMbJ512zHy0+fgmRZ/+DfivLtOozJlHWtYmctaHV9iBgnKiqKqVOnGh1DDFTi5tTmxNvbm7S0NMaOHZt3ZynR7qt+F60r12XbwMncV/0uFnYeQtz1ZPw8vbmQHM8HP+/Eyz1jneNlP21nTIvuLOwylC+jDpCaZs12vPz0KUgWMZauj6J39vIJRsxrnq39csJZXl81kAXrR/H5d4s4+t/vmfHRABZteIYdB1YbkDR34eHhRkcQcXlOOh4iYoyo+Bhql8t4KlB0Yixx15MJ9q8GQKCXLzNDB9F73SwALl6Lp5pPxvCjb2kvEm5cw79M2SzHy0+fC8nxPLZpYZa2Sl7lmNZ+QJYsVX38ivjdSkHp+ihasVcv8OUP71Pawyvbti++f4++7Z8huFY7Xlrek/9ePMojnV6mbpWmvL5qIO2C+1Dao4wBqXP27rvvGh1BxOWpqBUpgKNXogmqUI209HTMJhMbT+zj6WY5P5Gpuo8/Z5OuUL1sBeJSkvEtnf0Xc376BHr5sm3g5GztG0/sy5JFjKfr487EXr3A6/8cmKXNzyeQlx/7mCd7zuLFZd2z7ROXeIGKvhnrAfp4lqdb6yF8tvttfDz9SLmZRFJKfLEqakeOHKnCVsTOVNSKFMDRy9G0qVKfG2mpxFy7SnTiFSp4+uTYd2hIBybuXMWHh3fRt0Fr9l04yfHY8zzeOKxAffKb5XxSHJW9yxfZe5WC0/VxZ/zKBvLWyIgC7RPgW4PL8dEE+FYn8VosN1Kv8WinV6hcoQ4vL+9FOS9/+4S9Q1rUX8T+VNSKFMCkNn0zXx944o0c+3zRfxKQMYL2Ue8xme3nkuKIuXY1S9/89ClMFnEsXR/2dzz6R36L/pEedz/Jkk0T+GbfSto36UfFctV474vn8Pb0pV1wH9z1+G2REkdFrYiDVPEuzwP1WhW6j7gmXR+39/envsp83aBaSxpUy3jy40uP/itLv6l/Xe/QXCJSvGj1AxERETvTgxdE7E9FrYiIiJ2tWbPG6AgiLk/TDwzU1CfnG0hc/dzOxlTF1+gId8RZczsbZ/45G5HdJ8DhpywW554yZQoDBgwwLoATadasWYH3iTp9HoA6NSpneW3v80rxoqLWQG81DDI6guSDpU9LoyNIMabro2AadjQ6gRR38+fPL/A+k95YCsCsF4ZneS0li6YfiIiIiIjTU1ErIiJiZ4sXLzY6gojLU1ErIiJiZ8HBwUZHEHF5KmpFRETsLCws76fAiUjhqKgVEREREaen1Q9EREQKwdvbG09Pzzz7Va1aNcd2i8VS1JFESiQVtSIiIoVw/fp1rFZrrn3atm1LSkpKjtvc3NwoU6aMPaKJlCgqakVERArBarUSGxuba5+9e/feto+fn589YomUOJpTKyIiIiJOT0WtiIiIiDg9FbUiIiJ2tm7dOqMjiLg8FbUiIiIi4vRU1IqIiNhZ//79jY4g4vK0+oFIHtI+/xHbuXijYxSYqYovlj4tjY7h8pz1+gBjrpFfd0BijENPmcknABp2NObc4trGjRvHwYMHDTl3s2bNmD9/viHnLm5U1IrkwXYuHluUQb+FpdjT9VEwiTEQH210CpGidfDgQSIjI42OUeJp+oGIiIidjR492ugIIi5PRa2IiIidjRkzxugIIi5PRa2IiIidhYaGGh1BxOWpqBUREbGzS5cuGR1BxOWpqBVxgPpLn+GfR3fnu11KHl0jt9dlooneL5Xh/pe9eeAVH/q8UpZJy7rx+4XDRkcTkWJEqx+IiEixt/CZH6gd2BgAa1oqy7e8yMvv9+Cjl05hMVsMTpe3oKAgoyOIuDyN1IqIiFNxs7jTrfUQLiVEk5QSZ3ScfPn000+NjiDFjIeHB82bN6dz58507NiRevXqYTKZbtvf29ubevXqOTCh81FRKyIiTiXxWhwbdi+gVmBjynn5Gx0nX1599VWjI0gx4OnpyRNPPMF3331HYmIi+/fvZ+vWrWzfvp3ffvuNuLg41q5dS4cOHbLsV7NmTX7++Wd++eUXAgICDEpf/JXY6Qfp6enMnTuX9957jzNnztCwYUMWLFjA8OHDCQsLY+nSpUZHdCkXEuDQabieCuW9oGUtKFPK6FTFx8XkBB76fC4eZjdSrDeZcd/DdKzZ2OhYDpNyE/b/948/n4uDKuWNy1MclfRrZNw77TCZMsZh3N1KcVeNe5jyuPOMfq5du5bp06cbHUMM1KtXL5YuXUqVKlWAjDrk2LFjnD17FovFQsOGDalSpQr9+/enf//+fPvttwwdOpTU1FQiIiKoVasWe/bs4fLlywa/k+KrxBa1w4YNY/369UyePJmWLVuyZ88eBg0axKVLl5gwYYLR8VxGyk1YtQeOnM3avmE/dGsCXYIhl29bXIa72YI1zZqtPTU9DXezBX9PH3YOnILFbCYq/iKPblrI3sGvGZDU8SKOwRc/gTXtj7bZW6BBIPy1PXiVkA8/ukZyN3/Mnsw5tSLOxGQyMW/ePJ599lkADhw4wNtvv8369etJTEzM0rd69eo88cQTjB49mvvuu49Dhw6RmJhIQEAAe/fupUePHqSnpxvxNpxCiZx+sHr1alauXMnGjRt57rnn6NChAy+//DJt27bFarXSokULoyO6hLR0WLoze0F7a9uWn2D7UcfnMkLNchU5EX8xS1vSzetcSI6nTrkALGYzFnPGf44JN67RpGINI2I63Le/ZnzA+d+C9pbfLsDi7ZCawzZXpGtExDUtXryYZ599luvXrzN+/HhatWrFP/7xj2wFLcCZM2eYMWMGjRo14rPPPsPT05OAgAB+/fVXunfvztWrVw14B86jRBa1M2fOpHv37oSFhWVpr1evHu7u7oSEhBAXF0fv3r1p0KABTZs2pWvXrpw4ccKgxM7pcDT8nse3JF/9nDGa6+oGB4ey/NAOdkf/Qlp6OnHXk5iw40Ma+9egWaVaAPweH0P46qn0WjeLPvVbGRvYAW5aYfNPt99uA87GwYH/3r6PK9E14toiIyONjiAGeOyxxxgxYgQpKSn06tWL+fPn52uktWzZsjRv3jzzz1WqVKF8ec3JykuJm34QHR3N4cOHGT9+fLZtp0+fJjg4mFKlSpGSksK4cePo3LkzAAsWLGDIkCF8++23jo7stL4/mTG1wGa7fR9rWkbR0q6+43IZ4ZGg9qRYb/LMthWcvnoZb4/S3FetEZ89+Bxu/78cUW3fACIGTSUq/iLd1rxOr7qu/Y3BoTMZc6xzYwK+PwF313FIJEPpGnFtR44c0Q0+JUzFihVZsGABAKNGjWLHjh352q9mzZqZc2j37t3LhQsXePDBB1m2bBldu3a1Z2SnVyKLWoDAwMAs7SkpKURGRtKjRw8AfH19MwtagHbt2jF79ux8naNXr15s2bKliBI7r8dmHaZCteBc+9hsNp576XX2rpvsoFQFt/XhVwirXvg1JoeFdGRYSMcct92wplLKzR2Ash6eeLmXLvT5IiIj6DKqc94dDdLq/he49+FZufaxAQeP/RdTt1oOyXQniur6gJJxjbw5YidN64YXaJ+tc3L5ZFwAkZERtB7UIe+OBTBhwgRCQ0PzHImdN29ejoMpAGFhYezatYu5c+cWabY78cKs94CMeaD/+7q4K465R4wYQfny5fnmm29YuXJlvvb5c0HbvXt3PDw8CAsLo0uXLrRq1Yp9+/Zl2ScyMtLw92pPPXv2ZPPmzfnqW+KKWn//jOVfjh8/Ts+ePTPbZ8+ezfnz52nZsmWO+82fP5++ffs6IqLLuJEchy09HZP59rNcTCYTN1ISHJiqeNp34SSTd6/BYjKTmm5lbsfHjY5kdzeu5f3v3WZL58a1ePuHcQIl8RoRcVZms5mnn34agFmzcv/wfktOBe2tObTLly9n4sSJjBgxgieffNJuuZ2dyWbL7cth15Oenk7z5s05f/48b775JlWrVmXdunVs2bKF06dP8/3333PPPfdk2WfatGl8+eWX7NixgzJlyhiU3Pns+hXW78u73+Q+UMHb/nnulPXd7diiYoyOUWCmOgG4jexkdIzbSkiBaZ9Beh5/A/VuBp1zH/A3lLNeH2DMNbLvY4iPdugpM/lWg1YDi/64MTExxMbG5tqnUaNGHDt2LMdtfn5+xWZqwqQ3MpaznPXC8Cyvizujc4eHh2cZrW/UqBFHjx4lOjqa6tWr57l/bgUtQJMmTTh06BCnTp2idu3aWfYNCwsjIiKiyN6LMytxN4qZzWbWrl1LcHAwI0eOZMiQIfj7+zN69GgsFgshISFZ+r/22mt88cUXfPXVVypoC6h1bfAunfuSXc1rFu+CVuynnCfcU/f2200mKOMBbXLpI+Ispk2bZnQEcaBb3/r++9//zrNvXgUtZMzJTk5OplatWlSoUMEumV1BiStqARo0aMDOnTtJTk7m9OnTzJgxg59//pmgoCA8PT0z+02bNo1NmzaxdetWfH19jQvspDw9YFRH8P7TOqO3itwGgTCwjeNzSfHRrxUEV814/ecPP57uMKJjxgcjEWc3YMAAoyOIA916wMLJkydz7efm5sa2bdtyLWgh41vmqKgoACpXrlz0gV1EiZtTezv79u2jTZs/KqwjR44wdepU6tatS3h4eGb7wYMHHR/OiVUpDy8/APt+h3X/yWgLqQZt6kHDymB23bntkg/uFngyDH67CHt+g8uJUModQqpnrHjg6WF0QpGikdv0A3E9c+fOZcmSJaSl5b7QtsViwWKxsH37dvr165frOrShoaFYrVaSk5OLOq7LUFELJCUlcfz4cUaNGpXZFhwcTAmbbmw3pd2hfYM/itohocbmkeLFZMoYtW8QmHdfERFnYLVa8/WghBs3blCvXr18rV0bHx9fBMlcm4pawNvbO89PUyIAkaeP8tDncwmpWJNTCZcICahJy8DajGzWFT9Pb07EXWDQprf5z+N/52xiLM9HrMKvtDdB/tUY2Tz7+oL56VOQLOsf/FtRvl0pIF0fhXfk1B6+2LsEz1I+lPepxOAurwKw9ceP+DlqFzdSrzG4yxQCytdk9NutqF+1JW4WdyY8tMzg5CJ3Ro+9LTolck6tyJ26r/pdtK5cl20DJ3Nf9btY2HkIcdeT8fP05kJyPB/8vBMv94xJxMt+2s6YFt1Z2GUoX0YdIDXNmu14+elTkCxiLF0fhZeUEsfYBxfxTL9FHP59d2b71n3/YMJDy3ii+2usjXyTX0//QJlSPljMFhrVLP6T8/93GpuI2IdGakUKICo+htrlMpbeiU6MJe56MsH+1QAI9PJlZuggeq/LWJPw4rV4qvlk3KXqW9qLhBvX8C9TNsvx8tPnQnI8j21amKWtklc5prUfkCVLVR+/In63UlC6Pgrvnka9sNls/HP763Rq8Whmu5sl48ETFctV48rVc1Tyq8XzAz+kqn89Xlv1MC0bdCXAN++lk4zy7rvvGh1BxOWpqBUpgKNXogmqUI209HTMJhMbT+zj6WY5P5Gpuo8/Z5OuUL1sBeJSkvEt7XVHfQK9fNk2MPsT1zae2JclixhP10fhXbueyLsbx9Gh+SO0qP/HGromU8YXi5cSoqlQtgpnYn7Bp0xGoe7tWZ609PyPYhth5MiRKmxF7ExFrUgBHL0cTZsq9bmRlkrMtatEJ16hgqdPjn2HhnRg4s5VfHh4F30btGbfhZMcjz3P443DCtQnv1nOJ8VR2bt8kb1XKThdH4W3eOOznL38G9/8ZwXbfvwQD7fSjOv/Hl1aPs5ba5/k2vWrDO89B5vNxtIvnsO/XDUq+FSmsl/tvA9uIC2OL2J/KmpFCmBSm76Zrw888UaOfb7oPwnIGEH7qPeYzPZzSXHEXMt6N2x++hQmiziWro/Ce27ABzm2hzd7mPBmD2dpe/XxdY6IJCJOQjeKiThIFe/yPFCvVaH7iGvS9SEiUjgqakVEROxMD14QsT9NPxDJg6mKr9ER7oiz5nY2zvxzNiK7T4DDT1kszr1mzRo9KteFNWvWrMD7RJ0+D0CdGpWzvHbEuV2VilqRPFj6tDQ6ghRjuj4KpmFHoxMYY8qUKSpqXdj8+fMLvM+kN5YCMOuF4Vley53T9AMRERERcXoqakVERETE6amoFRERsbPFixcbHUHE5amoFRERsbPg4GCjI4i4PBW1IiIidhYWlvdT4ESkcLT6gYiISCF4e3vj6emZZ7+qVavm2G6xWIo6kkiJpKJWRESkEK5fv47Vas21T9u2bUlJSclxm5ubG2XKlLFHNJESRUWtiIhIIVitVmJjY3Pts3fv3tv28fPzs0cskRJHc2pFRERExOmpqBURERERp6eiVkRExM7WrVtndAQRl6eiVkREREScnopaERERO+vfv7/REURcnlY/MNDffj3KT4mJhpy7qY8PbzUMMuTczibt8x+xnYs3OkaBmar4YunT0uHn/XUHJMY4/LT4BEDDjo4/r4iIsxo3bhwHDx50+HmbNWvG/Pnzi/y4KmoN9FNiIrvicl8GRoxnOxePLcqAKs1JJcZAfLTRKUREJC8HDx4kMjLS6BhFRtMPRERE7Gz06NFGRxBxeSpqRURE7GzMmDFGRxBxeSpqRURE7Cw0NNToCCIuT0WtiIiInV26dMnoCCIuTzeKiThA/aXPMLX9AB4Nap+v9pKky0QTpdw9MZnMmEwmTJhoVLMtT9//FrUDGxsdT0REnISKWhEx3MJnfsgsYK1pqSzf8iIvv9+Dj146hcVsMTidSOEFBWkJRRF70/QDESlW3CzudGs9hEsJ0SSlxBkdR6RIfPrpp0ZHEHF5KmpFpFhJvBbHht0LqBXYmHJe/kbHESkSr776qtERRAqlYcOGTJw4kU8++YQff/yRQ4cOsXv3bhYtWsTgwYPx9vbOtk+TJk346quv6Natm0MyavqBOJw1Ddz0jXIWF5MTeOjzuXiY3Uix3mTGfQ/TsWbJmU867p12mEwZn7Hd3UpxV417mPK4RrbEdaxdu5bp06cbHUOkwNq0acNrr71Gp06dctx+7733MmrUKK5evcqKFSuYMmUKCQkJNGnShB07duDv78+ePXv4+uuv7Z61xI7Upqen8+abb1K/fn1Kly5N06ZNiYyMpGHDhgwfPtzoeDmyRf1Oau++pO/ek6U9/cuvSB08BNtVYx65m5ffLsJ7O//480vrYN1/IC7ZuEyO5m62YE2zZmtPTU/D3WzB39OHnQOnsG3gZD7qPYaXd31sQErjzB+zhw0z4tkwI561Uy4yY8hGqlVsYHQsEZESy83NjdmzZ7N79246depEcnIyH3zwAUOGDOHuu++madOmdOrUiYkTJ/Ltt99StmxZnn32WY4cOcLw4cMzC9rNmzcza9Ysx2R2yFmKoWHDhrF+/XomT55My5Yt2bNnD4MGDeLSpUtMmDDB6Hg5MtWpjXn4k6TNextTg/qYAiqSfvw4aUuX4/bGTExlfYyOmM33J+Hj78H0P203rfDdcTjwXxjbBQLLGRbPYWqWq8iJ+ItZ2pJuXudCcjx1ygVgMf/x+TLhxjWaVKzh6IgiIiJARkG7du1a+vbtS1paGrNmzWLWrFkkJCRk67tjxw7efPNNmjZtyrvvvkvbtm1ZsmQJJpOJzZs3069fP27evOmQ3CVypHb16tWsXLmSjRs38txzz9GhQwdefvll2rZti9VqpUWLFkZHvC3LA70xNW1C2qzZ2BISSJv+OuZhQzA1qG90tGwuJcIn/854bfvTNhtw7Sas/BZsf97oggYHh7L80A52R/9CWno6cdeTmLDjQxr716BZpVoA/B4fQ/jqqfRaN4s+9VsZG1hEilRkZKTREUTybeHChfTt25fY2FhCQ0N58cUXcyxo/9dPP/3EyJEjuXbtGiaTifT0dObMmeOwghZK6EjtzJkz6d69O2FhYVna69Wrh7u7OyEhIQD07duXqKgoLBYL7u7uzJw5k86dOxsROQvL+GexjhqLdeRYTE2bYOnd0+hIOdrzW+4Fq80GFxIg6hLUDXBcLiM8EtSeFOtNntm2gtNXL+PtUZr7qjXiswefw+3/l6yq7RtAxKCpRMVfpNua1+lVt/h+uBKRgjly5AgBAS7+F524hG7dujFixAiuX79Ot27d2LdvX772a9KkCdu2baNMmTJERUVRp04dli1bRtOmTUlJSbFz6gwlrqiNjo7m8OHDjB8/Ptu206dPExwcTKlSpQBYuXIlvr6+ABw4cIDw8HBiY2OxWHK/y6lXr15s2bIlzyyWObMwNw0p8Hsw+fhgbteO9M82YA4Py3uHHERERGBq3eaO9s2vQa/tJ6BW8zz7PfL0q/ywYYZdsxTG1odfIax64deYHBbSkWEhHXPcdsOaSik3dwDKenji5V660OeLiIygyyjHfwh7c8ROmtYNz3f/rXOKZqg+MjKC1oM6FMmxRPJrwoQJhIaG5jkSO2/evBx/7wCEhYWxa9cu5s6da4+IBfLCrPcAMJlMWV4Xd86YuzhmNplMLFiwAMhYsaMgBe3/zqEdOHAge/bsoUmTJjz77LPZ5tRGRkbm+7327NmTzZs356tviZt+EB0dDUBgYGCW9pSUFCIjI7NMPbhV0AIkJCRgMpmwFYPvytP3HyD9q68x9+pB2rwF2OLijY6UI3MexX9mPy2uz74LJ+n48XS6fPIa/T+fy9yOjxsdSURESpjOnTvToEEDTp8+ne8PWX8uaPv160dSUhITJ04EYMSIEZjNjik3S9xIrb9/xrqXx48fp2fPP762nz17NufPn6dly5ZZ+o8ePZovv/yShIQEPv30U9zc8v6R5fcTRed9/2ZXXGwB0oPt8mXS/j4by9NPYereFVv0WdJmv4ll5owCfcILDw9nm50L9I+/h3+fzD6f9s+WvT2Fxp9OsWuWwrC+ux1bVIxdz3FvtbvYMbBo17EMDwvH9rHjR8D3fQzx0Q4/LWFh4djeNf5Dp5Q8MTExNGzYMNc+8+bNu+3KOn5+fvTp04e33nrLHvEKZNIbSwGw2WxZXhd3zpi7OGQODw/P8i3DoEGDAFi2bBlpaWl57p9TQXtrDu0333zDyZMnqVu3Lm3btuW7777L3C8sLIyIiIiifTOUwJHaOnXqEBISwsyZM/nwww/Zvn07I0eO5IMPPgDIVtQuWrSIqKgo1q9fz8SJE0lKSjIiNgC2tDTSXp+FqUUzzD27YzKbsbzwHLbfTpD+8RrDct3OvfVzL2hNQDlPCKriqEQiIsaYNm2a0RFE8tSqVcZNylu3bs2zb24FLWQU6Dt27MhyXHsrcUWt2Wxm7dq1BAcHM3LkSIYMGYK/vz+jR4/GYrFk3iT2Z2FhYZjN5iyfNBwtfdlybPHxWJ4dm9lm8vfH8rdxpH+4ivTDRwzLlpPqFaBzcM7bTIDZDI/dm/FPERFXNmDAAKMjiOSpUaNGABw6dCjXfkFBQbkWtLccPHgQgODg2xQDRazETT8AaNCgATt37szSNnjwYIKCgvD09AQgKSmJK1euULNmTSDjRrGTJ09m/gs3gmXEcCwjsn99ZW7bBvOXmwxIlLdeTaGCN2w7DFf+52EL9SpBr2ZQS09BFZESoFGjRhw7dszoGCK3ZTabmT59Oh4eHnmuVjBmzJg8C1qAvXv38tprr+X7hrPCKpFFbU727dtHmzZ/rAaQnJzMww8/TFJSEm5ubpQuXZpVq1ZRo4YWxS8Ikwna1oN76sK5OLieCuW9MgpdERERKR7S09OZMSN/92HMmTOH/fv38+GHH+a6Du2BAwc4cOBAUUXMk4paMkZljx8/zqhRozLbKlWqxPfff29gKtdiNkE1P6NTFF7k6aM89PlcQirW5FTCJUICatIysDYjm3XFz9ObE3EXGLTpbf7z+N85mxjL8xGr8CvtTZB/NUY275rtePnpU5As6x/8W1G+XRERkWx+//133n//faNjZKPZjIC3tzdpaWmMHTs2785Sot1X/S5aV67LtoGTua/6XSzsPIS468n4eXpzITmeD37eiZd7xjrHy37azpgW3VnYZShfRh0gNc2a7Xj56VOQLM7k7OUTjJiXdR3jL/a+x5xPhvDOhrH8emYfN1Ov88bqx1my6W8s++J5g5KKFF54eLjREURcnkZqRQogKj6G2uUyngoUnRhL3PVkgv2rARDo5cvM0EH0XpexyPTFa/FU86kAgG9pLxJuXMO/TNksx8tPnwvJ8Ty2aWGWtkpe5ZjWfkCWLFV9nGcoPPbqBb784X1Ke3hlad91aC1/f+prsNmYsWoAzzy4mJ73PEWTOvcxZWVfblpv4OFWyqDUInfu3XffNTqCiMtTUStSAEevRBNUoRpp6emYTSY2ntjH081yfmpXdR9/ziZdoXrZCsSlJONb2uuO+gR6+bJt4ORs7RtP7MuSxZn4lQ3kyZ6zeHFZ9yztgzq9xJufDKGSXy2saTfxKxuIX9lA5q0bjun//yfijEaOHKnCVsTONP1ApACOXo4myL8aN9JSibl2lejEK1Tw9Mmx79CQDiza/w2jvnmfvg1as+/CST48HFngPvnNcj4prtDvz2iX4s8w8eGVPBz+PG5mdy4nnOO/F48xvv9SmtbrwA+/5P34aZHiyB4LzYtIVhqpFSmASW36Zr4+8MQbOfb5ov8kIGOE9aPeYzLbzyXFEXPtapa++elTmCzO4p0NY3m691t4l/bljY8HY01L5eGOk/BwL82STePx86lMUkocXVrq8cEiIpIzFbUiDlLFuzwP1Mv9qSr56eNK/v7UVwCM6ZsxZ7hd4z60a9wnS59XHvvE4blERMT5aPqBiIiInenBCyL2p6JWRETEztasWWN0BBGXp+kHBmrqk/MNRq5+bmdjquJrdIQ7YlRunwBDTmvYeUXyY8qUKQwYMMDoGCJZNGvWrMD7RJ0+D0CdGpWzvLb3efNDRa2B3moYZHQEyQdLn5ZGR3AqDTsanUBERPJj/vz5Bd5n0htLAZj1wvAsr4sDTT8QEREREaenolZERMTOFi9ebHQEEZenolZERMTOgoODjY4g4vJU1IqIiNhZWFiY0RFEXJ6KWhERERFxelr9QEREpBDc3Nzw8/PLs9/t+ri56VexSFHQf0kiIiKFkJ+CdsqUKQQEaDFlEXvS9AMRERE7mzp1qtERRFyeiloRERERcXoqakVERETE6amoFRERERGnp6JWRERERJyeiloRERERcXoqakVERETE6amoFRERERGnp6JWRERERJyeiloDJCUl0bRpUzZs2GB0FBERkSJhs9kYP34899xzD23atGHHjh1GR8q33377jXr16hkdI9+sVitDhgyhffv2tG7dmiVLlhgdKU/p6emMHj2atm3b0qZNG3bu3Fnk59Bjch3MZrPx5JNPYrFYjI4iIiJSZDZt2sTp06f597//zblz5+jYsSOHDx/Gza14lxqLFy/mgw8+4PLly0ZHybePPvoId3d3du/ezfXr1wkKCuLBBx+kUqVKRke7rc2bN3P58mX27t3L77//To8ePfjll1+K9BzF+0pzQS+99BL3338/W7duNTqKiIgIAP89exGrNY3qlQMAOPnfc1leA5TycKda5Yq3PUZkZCS9e/cGoEqVKgQGBnLs2DGaNGlS5Hlv3Ewl5foNrsRdBcg1d5VKFXBzs+B+m+K6UqVKfPvtt1SuXLnIc/4vm82GyWQi6vR5bDZbrpnLeJaikn95zOacv1B/6KGH+Mtf/gKAyWTCarXi4eFhl9w3U60kJl8jPiEJyP1nXaNKAGazKceBu/vvv58ePXoAcOrUKcqVK1fkWVXUOtCqVatIT0/n0UcfVVErIiLFws3UVM7HXGHDN7sz25Z9/EW214/360qqtfxti8OEhIQshUrZsmVJSEiwS+ZSHu7YbDY+3rSdxOSU2+auUSWAJwf2vm1mILM4tDeTycSNm6kcP3WGiL0HM9v/nNkEjBrcF5vNdttjeXt7A3D9+nUeeeQR/vrXv1K+fHm75HZ3s+Dh7sY/1n/NzZupt80dVK8m1e/viMVy+5+1m5sbY8eOZcWKFcyaNavIs2pOrQMtXbqUvXv3Eh4ezldffcUrr7zC7t27895RRETETjzc3WnRuD71ala9bZ+mjepSt2bVXIvDsmXLcvXq1cw/X7161W6FFoCbm4WB93e67XYPdzce69sFd7fiM92vlIc7Hdu2oHJAhdv2ue/uEAL8y+c5TfHcuXN06NCBu+++mxkzZhR11Ewmk4lSHh482LX9bft4lSnNQ73C8fBwz/N4Cxcu5Pz58yxbtoyDBw8WYVIVtQ61a9cudu3aRUREBN27d+e1116jffvbXyQiIiKO4O7mxqA+nfAslf0r7LI+XvTrHkqpPAqW0NBQNm3ahM1m49y5c5w9e5a77rrLXpFxs1ioVrki9zRrlOP2B7rcS+nSpTCZTHbLcCfc3Cw89mAX3HIoWiv5l6dz+1Z5/qwvXLhAhw4dePHFF5k0aZK9ombycHcjuH4tgurVzHH7wN4dc/3AAxnzgF955RUAPD098fDwKPJ/NypqRURESjiTyYSHuxt/6RmWtR14tE9n3Cx5lwt9+vShevXqtG3blvvvv59FixbZ/aboUh7u9OrQhgq+ZbO0N6xTnZC76uDhXvxmWZpNJny8POkRfk+WdovFzOAHu+brZz1jxgzi4uKYO3cu4eHhhIeH8+uvv9orMgAeHu481CscrzKls7S3atKQGlUr4ZbHiPhf/vIXTp48Sfv27Wnfvj1PPPEETZs2LdKMJltukzbEob778TCepTxo0biB0VFERKQEunkzlXVfRnLolygA7m3VmK73tc5z5NBIaenpxFyOY+HK9aTbbJTxLMVzwwdSpnQpo6Pl6maqlZVrvyTqzHkAenZoQ5vmjfBwL74/a6s1jd/PnGf5mi0A+JXzYdzQ/vmaduAIGqktJq7EX2Xzjr1cuBRrdBQRESmhPDzc+UuPUMp6l6FiBV+6hRbvghbAYjbj51uWDm2bA/Bw7w54FPNlxCDjBqxH+nSmlIc7NatWok3zoGJd0ELG1IkaVSvRqklDTCYTj/btUqyWKC3WRW2tWrX4+9//zujRoylfvjzly5dn/PjxJCcnM3bsWMqXL0+lSpWyzCe5fPkyQ4YMwd/fnzJlytC5c2cOHTqU5bj79+/ngQceoEKFCnh4eFC7dm1mzJiR5U7DVatW0aRJEzw9PalcuTJPP/203e7iBNi59wBmk5n2rYp+6RMREZH8slgyiq3BfXOe91kclfJwJ6xNM3qE30OtapXz/Cq8OMi4AcudAb07FLsb2nJTysOdBzq344HO7fD3K4clH9MlHKVYTz+oVasWsbGx9OnThyeeeIKvvvqKN998kwYNGtC2bVsee+wxPv/8c9555x02bNhAt27daN26NQkJCbz22mv4+voyb948Dhw4wIEDB6hduzZnzpyhUaNGdOzYkVGjRmE2m1m9ejUrV67k008/pV+/fuzatYsOHTowdepUQkNDiYqKYvz48dx///189NFHeeZesfZLfo0644CfkIiIiIjralinOkMe6pGvvsV+fD4wMJB//OMfmM1mwsPDWbJkCRaLhRUrVmAymejUqRMffvghe/fu5eLFixw5coSDBw8SEhICQLdu3WjQoAGvv/4677//PocPH6Z169Z88skneHp6AtC5c2c2bNhAZGQk/fr1Y8+ePXh5efH8889TqlQpwsLC8PLy4vz580b+KERERETkNop9Udu6devMJ2pYLBYqVKhAq1atMpeBMJlMlC9fnvj4eHbs2EHNmjUJCgrCarVm7tO1a9fMhx306NGDHj16cPPmTQ4fPsxvv/3GgQMHSE1N5ebNmwCEhYXx0ksvERISQv/+/enZsyf9+/e/7ZM9/iy/nyggYy7tW8s+oU3zYB7o3C7f+4mIiIjIH4p9Uevj45OtrUyZMjn2vXLlCqdOncI9h4nWt9rS0tJ4/vnnWbJkCSkpKdSqVYt27drh7u6eOae2bdu2bN68mblz5zJnzhxmzpxJlSpVmD17No8++mieme9k+sGeHw+z58fDBdpHRERExJW51PSDgihXrhyNGzdmxYoVt+0za9YsFi1axAcffMD999+fWTQHBARk6XdrRDcpKYlvvvmG2bNn89e//pXw8HCqVr39U1dERERExPFcqqgNDQ3l66+/plq1agQGBma2jxkzBnd3d1q1asV3331H8+bNeeSRRzK379+/n0uXLpGeng7A5MmT+frrr/nhhx/w9vamX79+eHl50b17d86fP59nUZvfTxTrvozk4JETPP/0QMr6eN3BOxYRERERKOZLehXUkCFDqFSpEl26dGH16tXs2LGD4cOHs2jRIho3bgxkzNH9z3/+w7x584iMjGTRokX07NkTk8lEcnIyAB07dmTfvn0MHTqUbdu2sWHDBl588UXq1atXZE+/iL+axP7Dx7m7WSMVtCIiIiKF5FIjtT4+PuzatYtJkyYxduxYrl27RsOGDVm1alXmXNgXX3yRixcvMmvWLJKTk6lduzaTJk3iyJEjbNu2DYAOHTqwevVq3njjDdasWYO7uzudOnVizpw5Oc7XvRMmoFG9mnRo06xIjiciIiJSkhXrdWpFRERERPLDpaYfiIiIiEjJpKJWRERERJyeiloRERERcXoqakVERETE6amoFRERERGnp6JWRERERJyeiloRERERcXoqakVERETE6amoFRERERGnp6JWRERERJyeiloRERERcXoqakVERETE6amoFRERERGnp6JWRERERJyeiloRERERcXoqakVERETE6amoFRERERGnp6JWRERERJyeiloRERERcXoqakVERETE6amoFRERERGnp6JWRERERJyeiloRERERcXoqakVERETE6amoFRERERGnp6JWRERERJyeiloRERERcXoqakVERETE6f0fH+Y2z2mrDWkAAAAASUVORK5CYII=\n"
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit, random_mbl = construct_random_mbd_func(1, backend_noisy)\n",
    "random_mbl.draw('mpl', fold=-1, idle_wires=False)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1268.33x325.08 with 1 Axes>",
      "image/png": "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\n"
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit.draw('mpl', fold=-1, idle_wires=False)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "steps = list(range(10))\n",
    "generate_data(partial(construct_random_mbd_func, be=backend_noisy_coherent), steps, './data/mbd_datasets2/theta_0.1pi_coherent/val', 200)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "with open('./data/mbd_datasets/train/step_5.json', 'r') as in_f:\n",
    "    train_data = json.load(in_f)\n",
    "train_data[0]['circuit_graph']"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "with open('./data/mbd_datasets/val/step_4.json', 'r') as in_f:\n",
    "    val_data = json.load(in_f)\n",
    "val_data[0]['circuit_graph']"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}