From 53f22e7c1795692fd4e01a0e9f096bb4b4b253cc Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Tue, 6 Apr 2021 13:55:28 +0300
Subject: [PATCH 01/16] RB experiment class based on Chris' draft

---
 .../randomized_benchmarking/__init__.py       |  13 ++
 .../randomized_benchmarking/rb_analysis.py    | 133 ++++++++++++
 .../randomized_benchmarking/rb_example.ipynb  | 160 ++++++++++++++
 .../randomized_benchmarking/rb_experiment.py  | 196 ++++++++++++++++++
 4 files changed, 502 insertions(+)
 create mode 100644 qiskit_experiments/randomized_benchmarking/__init__.py
 create mode 100644 qiskit_experiments/randomized_benchmarking/rb_analysis.py
 create mode 100644 qiskit_experiments/randomized_benchmarking/rb_example.ipynb
 create mode 100644 qiskit_experiments/randomized_benchmarking/rb_experiment.py

diff --git a/qiskit_experiments/randomized_benchmarking/__init__.py b/qiskit_experiments/randomized_benchmarking/__init__.py
new file mode 100644
index 0000000000..d4a69734e5
--- /dev/null
+++ b/qiskit_experiments/randomized_benchmarking/__init__.py
@@ -0,0 +1,13 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+from .rb_experiment import RBExperiment, RBAnalysis
\ No newline at end of file
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
new file mode 100644
index 0000000000..5b2a53717e
--- /dev/null
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -0,0 +1,133 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Standard RB analysis class.
+"""
+
+from typing import Optional, List
+
+import numpy as np
+from qiskit_experiments.analysis.curve_fit_analysis import CurveFitAnalysis
+
+try:
+    from matplotlib import pyplot as plt
+
+    HAS_MATPLOTLIB = True
+except ImportError:
+    HAS_MATPLOTLIB = False
+
+
+class RBAnalysis(CurveFitAnalysis):
+    """RB Analysis class."""
+
+    # pylint: disable = arguments-differ
+    def _run_analysis(
+        self,
+        experiment_data,
+        p0: Optional[List[float]] = None,
+        plot: bool = True,
+        ax: Optional["AxesSubplot"] = None,
+    ):
+        """Run analysis on circuit data.
+        Args:
+            experiment_data (ExperimentData): the experiment data to analyze.
+            p0: Optional, initial parameter values for curve_fit.
+            plot: If True generate a plot of fitted data.
+            ax: Optional, matplotlib axis to add plot to.
+        Returns:
+            tuple: A pair ``(analysis_result, figures)`` where
+                   ``analysis_results`` may be a single or list of
+                   AnalysisResult objects, and ``figures`` may be
+                   None, a single figure, or a list of figures.
+        """
+        # TODO: Get from experiment level metadata
+        num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
+
+        # Fit function
+        def fit_fun(x, a, alpha, b):
+            return a * alpha ** x + b
+
+        # Initial guess function
+        # NOTE: I don't think this is a good guess function
+        # its just inserted as a place holder for one
+        # pylint: disable = unused-argument
+        def p0_func(xdata, ydata, sigma=None):
+            xmin = np.min(xdata)
+            y_mean_min = np.mean(ydata[xdata == xmin])
+
+            xmax = np.max(xdata)
+            y_mean_max = np.mean(ydata[xdata == xmax])
+
+            b_guess = 1 / (2 ** num_qubits)
+            a_guess = 1 - b_guess
+            alpha_guess = np.exp(
+                np.log((y_mean_min - b_guess) / (y_mean_max - b_guess)) / (xmin - xmax)
+            )
+            # Make sure alpha guess is feasible
+            alpha_guess = max(min(alpha_guess, 1), 0)
+            return [a_guess, alpha_guess, b_guess]
+
+        # Run CurveFitAnalysis
+        analysis_result, figs = super()._run_analysis(
+            experiment_data,
+            fit_fun,
+            p0=p0,
+            p0_func=p0_func,
+            bounds=([0, 0, 0], [1, 1, 1]),
+            fit_mean_data=True,
+            plot=plot,
+            ax=ax,
+        )
+
+        # Add EPC data
+        popt = analysis_result["popt"]
+        popt_err = analysis_result["popt_err"]
+        scale = (2 ** num_qubits - 1) / (2 ** num_qubits)
+        analysis_result["EPC"] = scale * (1 - popt[1])
+        analysis_result["EPC_err"] = scale * popt_err[1] / popt[1]
+        analysis_result["plabels"] = ["A", "alpha", "B"]
+
+        # Format figure
+        if figs is not None:
+            self._format_plot(figs[0], analysis_result)
+            # TODO: figure out what to do with plots
+            plt.show()
+        return analysis_result, figs
+
+    @classmethod
+    def _format_plot(cls, ax, analysis_result, add_label=True):
+        """Format curve fit plot"""
+        # Formatting
+        ax.tick_params(labelsize=14)
+        ax.set_xlabel("Clifford Length", fontsize=16)
+        ax.set_ylabel("Ground State Population", fontsize=16)
+        ax.grid(True)
+
+        if add_label:
+            alpha = analysis_result["popt"][1]
+            alpha_err = analysis_result["popt_err"][1]
+            epc = analysis_result["EPC"]
+            epc_err = analysis_result["EPC_err"]
+            box_text = "\u03B1:{:.4f} \u00B1 {:.4f}".format(alpha, alpha_err)
+            box_text += "\nEPC: {:.4f} \u00B1 {:.4f}".format(epc, epc_err)
+            bbox_props = dict(boxstyle="square,pad=0.3", fc="white", ec="black", lw=1)
+            ax.text(
+                0.6,
+                0.9,
+                box_text,
+                ha="center",
+                va="center",
+                size=14,
+                bbox=bbox_props,
+                transform=ax.transAxes,
+            )
+        return ax
\ No newline at end of file
diff --git a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
new file mode 100644
index 0000000000..cd909ad30c
--- /dev/null
+++ b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
@@ -0,0 +1,160 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Standard RB Demo\n",
+    "\n",
+    "This is a very basic implemention of a standard RB experiment\n",
+    "\n",
+    "*NOTE: the circuit generation code of this demo is quite slow*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "AttributeError",
+     "evalue": "module 'qiskit_experiments' has no attribute 'randomized_benchmarking'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-1-d05adedf1579>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mqiskit_experiments\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mqe\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mrb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mqe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandomized_benchmarking\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# For simulation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mAttributeError\u001b[0m: module 'qiskit_experiments' has no attribute 'randomized_benchmarking'"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import qiskit_experiments as qe\n",
+    "rb = qe.randomized_benchmarking\n",
+    "\n",
+    "# For simulation\n",
+    "from qiskit.test.mock import FakeParis\n",
+    "backend = FakeParis()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running 1-qubit RB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
+    "num_samples = 10\n",
+    "seed = 1010\n",
+    "\n",
+    "# Run an RB experiment on qubit 0\n",
+    "exp1 = rb.RBExperiment([0], lengths, num_samples=num_samples, seed=seed)\n",
+    "expdata1 = exp1.run(backend)\n",
+    "\n",
+    "# View result data\n",
+    "expdata1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running 2-qubit RB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lengths = [1, 10, 20, 30, 40, 50, 80, 120, 160, 200]\n",
+    "num_samples = 10\n",
+    "seed = 1010\n",
+    "\n",
+    "# Run an RB experiment on qubits 0,\n",
+    "exp2 = rb.RBExperiment([0, 1], lengths, num_samples=num_samples, seed=seed)\n",
+    "expdata2 = exp2.run(backend)\n",
+    "\n",
+    "# View result data\n",
+    "expdata2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running parallel RB experiments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
+    "num_samples = 10\n",
+    "seed1 = 1010\n",
+    "\n",
+    "exps = [rb.RBExperiment([i], lengths, num_samples=num_samples, seed=seed + i)\n",
+    "        for i in range(5)]\n",
+    "\n",
+    "par_exp = qe.composite.ParallelExperiment(exps)\n",
+    "par_expdata = par_exp.run(backend)\n",
+    "\n",
+    "# View result\n",
+    "par_expdata"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Viewing sub experiment data\n",
+    "\n",
+    "The experiment data returned from a batched experiment also contains individual experiment data for each sub experiment which can be accessed using `experiment_data(index)`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Print sub-experiment data\n",
+    "for i in range(par_exp.num_experiments):\n",
+    "    print(par_expdata.component_experiment_data(i), '\\n')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qiskit-exp",
+   "language": "python",
+   "name": "qiskit-exp"
+  },
+  "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
new file mode 100644
index 0000000000..3c8f17237d
--- /dev/null
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -0,0 +1,196 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Standard RB Experiment class.
+"""
+from typing import Union, Iterable, Optional
+
+import numpy as np
+from numpy.random import Generator, default_rng
+
+from qiskit import QuantumCircuit
+from qiskit.quantum_info import Clifford, random_clifford
+
+from qiskit_experiments.base_experiment import BaseExperiment
+from .rb_analysis import RBAnalysis
+
+
+class RBExperiment(BaseExperiment):
+    """RB Experiment class"""
+
+    # Analysis class for experiment
+    __analysis_class__ = RBAnalysis
+
+    def __init__(
+        self,
+        qubits: Union[int, Iterable[int]],
+        lengths: Iterable[int],
+        num_samples: int = 1,
+        seed: Optional[Union[int, Generator]] = None,
+        full_sampling: bool = False,
+    ):
+        """Standard randomized benchmarking experiment
+        Args:
+            qubits: the number of qubits or list of
+                    physical qubits for the experiment.
+            lengths: A list of RB sequences lengths.
+            num_samples: number of samples to generate for each
+                         sequence length
+            seed: Seed or generator object for random number
+                  generation. If None default_rng will be used.
+            full_sampling: If True all Cliffords are independently sampled for
+                           all lengths. If False for sample of lengths longer
+                           sequences are constructed by appending additional
+                           Clifford samples to shorter sequences.
+        """
+        if not isinstance(seed, Generator):
+            self._rng = default_rng(seed=seed)
+        else:
+            self._rng = seed
+        self._lengths = list(lengths)
+        self._num_samples = num_samples
+        self._full_sampling = full_sampling
+        super().__init__(qubits)
+
+    # pylint: disable = arguments-differ
+    def circuits(self, backend=None):
+        """Return a list of RB circuits.
+        Args:
+            backend (Backend): Optional, a backend object.
+        Returns:
+            List[QuantumCircuit]: A list of :class:`QuantumCircuit`s.
+        """
+        circuits = []
+        if self._full_sampling:
+            sample_fn = self._sample_circuits_full
+        else:
+            sample_fn = self._sample_circuits_reuse
+        for _ in range(self._num_samples):
+            circuits += sample_fn(self._lengths, seed=self._rng)
+        return circuits
+
+    def transpiled_circuits(self, backend=None, **kwargs):
+        """Return a list of transpiled RB circuits.
+        Args:
+            backend (Backend): Optional, a backend object to use as the
+                               argument for the :func:`qiskit.transpile`
+                               function.
+            kwargs: kwarg options for the :func:`qiskit.transpile` function.
+        Returns:
+            List[QuantumCircuit]: A list of :class:`QuantumCircuit`s.
+        Raises:
+            QiskitError: if an initial layout is specified in the
+                         kwarg options for transpilation. The initial
+                         layout must be generated from the experiment.
+        """
+        circuits = super().transpiled_circuits(backend=backend, **kwargs)
+        # TODO: Add functionality for gates per clifford which depends
+        # on the transpiled circuit gates
+        return circuits
+
+    def _generate_circuit(self, elements, lengths=None):
+        qubits = list(range(self.num_qubits))
+        circuits = []
+        if lengths is None:
+            lengths = [len(elements)]
+
+        circ = QuantumCircuit(self.num_qubits)
+        circ.barrier(qubits)
+        circ_op = Clifford(np.eye(2 * self.num_qubits))
+
+        for current_length, group_elt in enumerate(elements):
+            circ_op = circ_op.compose(group_elt)
+            circ.append(group_elt, qubits)
+            circ.barrier(qubits)
+            if current_length in lengths:
+                # copy circuit and add inverse
+                inv = circ_op.adjoint()
+                rb_circ = circ.copy()
+                rb_circ.append(inv, qubits)
+                rb_circ.barrier(qubits)
+                rb_circ.metadata = {
+                    "experiment_type": self._type,
+                    "xdata": current_length,
+                    "ylabel": self.num_qubits * "0",
+                    "group": "Clifford",
+                    "qubits": self.physical_qubits,
+                }
+                rb_circ.measure_all()
+                circuits.append(rb_circ)
+
+
+    def _sample_circuits_full(self, lengths, seed=None):
+        """Sample a single RB circuits"""
+        qubits = list(range(self.num_qubits))
+        circuits = []
+        for length in lengths:
+            circ_op = Clifford(np.eye(2 * self.num_qubits))
+            circ = QuantumCircuit(self.num_qubits)
+            circ.metadata = {
+                "experiment_type": self._type,
+                "xdata": length,
+                "ylabel": self.num_qubits * "0",
+                "group": "Clifford",
+                "qubits": self.physical_qubits,
+            }
+            circ.barrier(qubits)
+
+            # Add random group elements
+            for _ in range(length):
+                group_elt = random_clifford(self.num_qubits, seed=seed)
+                circ_op = circ_op.compose(group_elt)
+                circ.append(group_elt, qubits)
+                circ.barrier(qubits)
+
+            # Add inverse
+            inv = circ_op.adjoint()
+            circ.append(inv, qubits)
+            circ.barrier(qubits)
+            circ.measure_all()
+            circuits.append(circ)
+        return circuits
+
+    def _sample_circuits_reuse(self, lengths, seed=None):
+        """Sample a single RB circuits"""
+        qubits = list(range(self.num_qubits))
+        circuits = []
+        circ_op = Clifford(np.eye(2 * self.num_qubits))
+        circ = QuantumCircuit(self.num_qubits)
+        circ.barrier(qubits)
+
+        # Add random group elements reusing shorter sequences
+        current_length = 0
+        for length in lengths:
+            # Add new samples
+            for _ in range(length - current_length):
+                group_elt = random_clifford(self.num_qubits, seed=seed)
+                circ_op = circ_op.compose(group_elt)
+                circ.append(group_elt, qubits)
+                circ.barrier(qubits)
+            current_length = length
+
+            # copy circuit and add inverse
+            inv = circ_op.adjoint()
+            rb_circ = circ.copy()
+            rb_circ.append(inv, qubits)
+            rb_circ.barrier(qubits)
+            rb_circ.metadata = {
+                "experiment_type": self._type,
+                "xdata": length,
+                "ylabel": self.num_qubits * "0",
+                "group": "Clifford",
+                "qubits": self.physical_qubits,
+            }
+            rb_circ.measure_all()
+            circuits.append(rb_circ)
+
+        return circuits
\ No newline at end of file

From d8ae11517bbab1281ebdf830fb6de07ed1f6154e Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Tue, 6 Apr 2021 16:41:18 +0300
Subject: [PATCH 02/16] Unifying sampling procedures

---
 .../randomized_benchmarking/rb_experiment.py  | 85 +++----------------
 1 file changed, 12 insertions(+), 73 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index 3c8f17237d..c8ef792f2f 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -70,12 +70,8 @@ def circuits(self, backend=None):
             List[QuantumCircuit]: A list of :class:`QuantumCircuit`s.
         """
         circuits = []
-        if self._full_sampling:
-            sample_fn = self._sample_circuits_full
-        else:
-            sample_fn = self._sample_circuits_reuse
         for _ in range(self._num_samples):
-            circuits += sample_fn(self._lengths, seed=self._rng)
+            circuits += self._sample_circuits(self._lengths, seed=self._rng)
         return circuits
 
     def transpiled_circuits(self, backend=None, **kwargs):
@@ -97,6 +93,16 @@ def transpiled_circuits(self, backend=None, **kwargs):
         # on the transpiled circuit gates
         return circuits
 
+    def _sample_circuits(self, lengths, seed=None):
+        circuits = []
+        for length in (lengths if self._full_sampling else [lengths[-1]]):
+            elements = [random_clifford(self.num_qubits, seed=seed) for _ in range(length)]
+            if self._full_sampling:
+                circuits += self._generate_circuit(elements)
+            else:
+                circuits += self._generate_circuit(elements, lengths)
+        return circuits
+
     def _generate_circuit(self, elements, lengths=None):
         qubits = list(range(self.num_qubits))
         circuits = []
@@ -111,7 +117,7 @@ def _generate_circuit(self, elements, lengths=None):
             circ_op = circ_op.compose(group_elt)
             circ.append(group_elt, qubits)
             circ.barrier(qubits)
-            if current_length in lengths:
+            if current_length+1 in lengths:
                 # copy circuit and add inverse
                 inv = circ_op.adjoint()
                 rb_circ = circ.copy()
@@ -126,71 +132,4 @@ def _generate_circuit(self, elements, lengths=None):
                 }
                 rb_circ.measure_all()
                 circuits.append(rb_circ)
-
-
-    def _sample_circuits_full(self, lengths, seed=None):
-        """Sample a single RB circuits"""
-        qubits = list(range(self.num_qubits))
-        circuits = []
-        for length in lengths:
-            circ_op = Clifford(np.eye(2 * self.num_qubits))
-            circ = QuantumCircuit(self.num_qubits)
-            circ.metadata = {
-                "experiment_type": self._type,
-                "xdata": length,
-                "ylabel": self.num_qubits * "0",
-                "group": "Clifford",
-                "qubits": self.physical_qubits,
-            }
-            circ.barrier(qubits)
-
-            # Add random group elements
-            for _ in range(length):
-                group_elt = random_clifford(self.num_qubits, seed=seed)
-                circ_op = circ_op.compose(group_elt)
-                circ.append(group_elt, qubits)
-                circ.barrier(qubits)
-
-            # Add inverse
-            inv = circ_op.adjoint()
-            circ.append(inv, qubits)
-            circ.barrier(qubits)
-            circ.measure_all()
-            circuits.append(circ)
-        return circuits
-
-    def _sample_circuits_reuse(self, lengths, seed=None):
-        """Sample a single RB circuits"""
-        qubits = list(range(self.num_qubits))
-        circuits = []
-        circ_op = Clifford(np.eye(2 * self.num_qubits))
-        circ = QuantumCircuit(self.num_qubits)
-        circ.barrier(qubits)
-
-        # Add random group elements reusing shorter sequences
-        current_length = 0
-        for length in lengths:
-            # Add new samples
-            for _ in range(length - current_length):
-                group_elt = random_clifford(self.num_qubits, seed=seed)
-                circ_op = circ_op.compose(group_elt)
-                circ.append(group_elt, qubits)
-                circ.barrier(qubits)
-            current_length = length
-
-            # copy circuit and add inverse
-            inv = circ_op.adjoint()
-            rb_circ = circ.copy()
-            rb_circ.append(inv, qubits)
-            rb_circ.barrier(qubits)
-            rb_circ.metadata = {
-                "experiment_type": self._type,
-                "xdata": length,
-                "ylabel": self.num_qubits * "0",
-                "group": "Clifford",
-                "qubits": self.physical_qubits,
-            }
-            rb_circ.measure_all()
-            circuits.append(rb_circ)
-
         return circuits
\ No newline at end of file

From eed5f375bbabfd8e8bfe2c94014d49e98a5d4572 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Tue, 6 Apr 2021 16:49:18 +0300
Subject: [PATCH 03/16] Some more unification

---
 .../randomized_benchmarking/rb_experiment.py           | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index c8ef792f2f..c7443c1690 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -97,17 +97,13 @@ def _sample_circuits(self, lengths, seed=None):
         circuits = []
         for length in (lengths if self._full_sampling else [lengths[-1]]):
             elements = [random_clifford(self.num_qubits, seed=seed) for _ in range(length)]
-            if self._full_sampling:
-                circuits += self._generate_circuit(elements)
-            else:
-                circuits += self._generate_circuit(elements, lengths)
+            element_lengths = [len(elements)] if self._full_sampling else lengths
+            circuits += self._generate_circuit(elements, element_lengths)
         return circuits
 
-    def _generate_circuit(self, elements, lengths=None):
+    def _generate_circuit(self, elements, lengths):
         qubits = list(range(self.num_qubits))
         circuits = []
-        if lengths is None:
-            lengths = [len(elements)]
 
         circ = QuantumCircuit(self.num_qubits)
         circ.barrier(qubits)

From 03ab26ec60b1ca280aef4dc03d0e3915560cb83f Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Wed, 7 Apr 2021 17:55:38 +0300
Subject: [PATCH 04/16] Style

---
 .../randomized_benchmarking/__init__.py       |  2 +-
 .../randomized_benchmarking/rb_analysis.py    |  2 +-
 .../randomized_benchmarking/rb_example.ipynb  | 80 ++++++++++++++++---
 .../randomized_benchmarking/rb_experiment.py  |  6 +-
 4 files changed, 74 insertions(+), 16 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/__init__.py b/qiskit_experiments/randomized_benchmarking/__init__.py
index d4a69734e5..2a30da17fc 100644
--- a/qiskit_experiments/randomized_benchmarking/__init__.py
+++ b/qiskit_experiments/randomized_benchmarking/__init__.py
@@ -10,4 +10,4 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-from .rb_experiment import RBExperiment, RBAnalysis
\ No newline at end of file
+from .rb_experiment import RBExperiment, RBAnalysis
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 5b2a53717e..4c2c5bb291 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -130,4 +130,4 @@ def _format_plot(cls, ax, analysis_result, add_label=True):
                 bbox=bbox_props,
                 transform=ax.transAxes,
             )
-        return ax
\ No newline at end of file
+        return ax
diff --git a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
index cd909ad30c..f81152cbfa 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
+++ b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
@@ -15,27 +15,59 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import qiskit_experiments as qe\n",
+    "rb = qe.randomized_benchmarking\n",
+    "\n",
+    "# For simulation\n",
+    "from qiskit.test.mock import FakeParis\n",
+    "backend = FakeParis()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
    "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABKc0lEQVR4nO3dd3iV5fnA8e+dPSEhO2xFlrRiQQEXoQ5ctGpbsQ7Eule1tHV1iHtVC1atBQeK66etoqhVQRu3oCgtS3YYWZAQAiE75/798Z4TTg4Zb+CErPtzXe+VnHc+zyGc+zxbVBVjjDHGjZD2ToAxxpjOw4KGMcYY1yxoGGOMcc2ChjHGGNcsaBhjjHEtrL0T0JaSk5N1wIABrbpmz549xMbGtk2COqjumGfonvnujnmG7pnvA8nzkiVLilQ1pbFjXTpoDBgwgG+++aZV12RnZ5OVldU2CeqgumOeoXvmuzvmGbpnvg8kzyKyqaljVj1ljDHGtS5d0jBd24ABA9i0qckvRMYcNP379ycnJ6e9k3FQWNAwndamTZuwGQ1MRyAi7Z2Eg8aqp4wxxrhmQcMYY4xrFjSMMca4ZkHDGGOMaxY0jNkPTzzxBAMHDiQqKopRo0bx6aeftnjN448/zrBhw4iOjmbIkCE8//zzDY7X1NRw5513cuihhxIVFcURRxzBe++9t8998vPzufjii0lJSSEqKorhw4fz8ccf1x8vLCxk6tSpZGZmEhMTw6mnnsratWsPPNMt2Lx5M5MmTSI2Npbk5GR+/etfU11d3ew1VVVVXH/99SQnJxMbG8tPfvITtm7d2qr75ufnc/755zN06FBCQ0OZOnXqPs957bXXGD16NAkJCcTGxjJy5Eiee+65oOS721HVLruNGjVKW+s///mPqqpWV6vm56tu26a6c6fq7t2qe/aoVlQ4x2prVT2eVt++Q/LlubNx/nwPvldeeUXDwsJ01qxZunLlSr3uuus0NjZWN23a1OQ1TzzxhMbGxupLL72k69ev15dfflnj4uL0rbfeqj/npptu0vT0dH377bd1/fr1+sQTT2hUVJR+++239eeUlJTowIED9aKLLtJFixbphg0bdOHChbpy5UpVVfV4PDp27Fg95phjdNGiRfr999/rFVdcof369dOysjLXeXz22Wd1/Pjxrs+vra3VESNG6Pjx43XJkiX6wQcfaEZGhl533XXNXnfVVVdpRkaGfvDBB7pkyRIdP368HnHEEVpbW+v6vhs3btTrr79en332WR03bpxefPHF+zznww8/1DfeeENXrVql69at0xkzZmhoaKi+8847rvPYnPb6W2zOgfy/Br7RJj5X2/2DvS23Awka5eWqK1eqrlunumaN6urVzvb993t/X73aOZ6To7p1q2pBgeqOHaq7dqmWlTn3qKpSralRratrdVIOmu4aNMrKyvTyyy/XHj16aFJSkt522226e/dujYmJ0ZycnCavO/roo/Wyyy5rsG/QoEF6yy23NHnNuHHj9MYbb2ywb9q0aXrsscfWv87IyNAZM2Y0OOecc87RCy64oP71rbfeqsccc0yTz1m9erUCunTp0vp9dXV1mpKSorNnz27yukCtDRrvvvuuiohu3ry5ft/cuXM1MjJSS0tLG71m586dGh4eri+88EL9vs2bN6uI6Hvvvbdf9z3jjDMaDRqNOfLII5v9N2uN7hQ0rHqqGaGhEB0NsbEQF+ds8fF7f4+Lg8hIEIGaGigrg+JiyM+H3FzYvBlycmDDBli3DtauhY0bYcsW55yiIigtda4rL4fKSuc+dXWgNvygzf3qV7/io48+YuHChbz88svMnDmT6667jqFDh9K/f38AcnJyEBHmzJkDQHV1NUuWLOGUU05pcK9TTjmFL774oslnVVVVERUV1WBfdHQ0ixcvpqamptlzPvvss/rX8+bNY8yYMUyePJnU1FRGjhzJY4895nwD9N4DaHCfkJAQIiMjG9wn2L788kuGDRtG37596/dNnDiRqqoqlixZ0ug1S5YsoaampsF72bdvX4YNG1b/Xu7PfVuiqnz44YesXr2aE044Yb/u0Z3Z4L4DFBLibG6ogsfjbJWVTqDwePYGCFUnAPnfOzwcwsL2bhERe58ZEuIEttakwTiKiop47bXXeO655zjqqKMAOPfcc3n22We566676s8LDw9nyJAh9OzZs/66uro60tLSGtwvLS2NhQsXNvm8iRMn8vTTT3POOecwevRolixZwlNPPUVNTQ1FRUVkZGQwceJEZsyYQVZWFocddhgffvghr7/+OnV1dfX32bBhA0888QS/+c1vuOWWW1i6dCnXX389QH3A69evH7fddhuzZ88mLi6Ov/71r2zdupX8/Pwm0/fpp59y2mmn1b+ura2lpqaGuLi4+n233XYbt912W6PXFxQU7POeJCcnExoaSkFBQZPXhIaGkpyc3GB/Wlpa/TX7c9+mlJaW0rt3b6qqqggNDeXxxx9vkGfjjuugISIXA78E+gFRAYdVVQ8NZsK6IhHnQz401N35vgBTUwNVVXtf+wQGmbAw594REQ0DTWBwsSAD69atQ1UZN25c/b4xY8bw7LPPcs4559Tv6927N99///0BP+9Pf/oTBQUFHHPMMagqaWlpXHzxxTz44IOEeP8xZs6cyeWXX87w4cMREQ499FAuueQSnnnmmfr7eDweRo8ezX333QfAkUceydq1a3n88ce57rrrCA8P5/XXX+fSSy8lKSmJ0NBQTjrpJE477bT60khjRo8ezdKlS+tfv/766/zrX//ixRdfrN/Xq1evA34f2lN8fDxLly6lrKyMDz/8kGnTpjFgwABOPPHE9k5ap+IqaIjIn4A7gOXAUqCqDdNkvFr74e7xOFVblZV7SzD+QSbw3qGhTlCpqXGqysLD9w0uvtddbZaEyMhIACIiIur3paWlkZiYyPDhw5u8zvctt7CwsMH+wsJC0tPTm7wuOjqaZ555hn/84x8UFhaSkZHBrFmziI+PJyXFmYE6JSWFefPmUVlZSXFxMZmZmdxyyy0ccsgh9ffJyMjYJ33Dhg1j5syZ9a9HjRrF0qVLKS0tpbq6mpSUFMaMGcPo0aObTd+gQYPqX6empu6zrznp6el8/vnnDfb5SmVNvS/p6enU1dVRVFRU/x6A814ef/zx+33fpoSEhNTnZ+TIkaxatYp7773XgkYruf1IuhSYqao/VNXzVfWSwK0tE2nc8VVnRUY6bTExMQ3bX/y36GgnYPiCS2kpbNsGeXmwdSts2uS0x6xf77TFrFvntMfk5kJhodN242uPqahwSkKdqT1m4MCBhISENOiK+tZbb1FSUkJpaWmT10VERDBq1CgWLFjQYP+CBQs45phjWnxueHg4ffr0ITQ0lFdeeYUzzzyzvqThExUVRe/evamtreVf//oXP/3pT+uPHXvssaxevbrB+WvWrKlvg/HXs2dPUlJSWLt2Ld98802D+wTbuHHjWLVqVYPusgsWLCAyMpJRo0Y1es2oUaMIDw9v8F5u3bqVVatW1b+X+3NftzweT30bkHHPbfVUEjC/LRNiDi7/qjIRJ4g0R9UJCL6qMv/2mcZKIY21x/iqzxqrKjvYJZmEhATOOecc7r33XsaNG8eWLVv45z//SWZmJvPnz+fCCy8EIDc3lxNPPJH77ruPs88+G4Bp06Zx0UUXcfTRR3Psscfy5JNPkpeXx1VXXVV//ylTpgDUj8VYs2YNixYtYuzYsZSUlPDII4+wfPnyBmMFFi1aRG5uLiNHjiQ3N5fp06fj8Xi46aab6s/5zW9+wzHHHMM999zD5MmT+e6773j00Ue5995768957bXXSE5Opn///ixbtowbbriBs846a5/Ge3/V1dXs2LGj/vWpp57Kqaee2qDdIC4urkEbh79TTjmFww8/nClTpvDwww9TXFzM73//ey6//HJ69OgBwOLFi5kyZQrPP/88Rx99ND179uTSSy/lpptuIjU1laSkJKZNm8YPf/hDTjrpJNf3Beqr1nbt2kVISAhLly4lIiKivlR2zz33MGbMGA455BCqqqp49913mTt3Ln/729+afE9M49wGjY+BI4CP2jAtpgMTcT703Qpsj/EFnUC+UomvaiwwyPjaZNoiyDz++ONceeWV9T1zpk+fzrBhw7jssstYt24d06dPp6amhtWrVzcofUyePJni4mLuvvtu8vPzGTFiBO+++26Db/ubN29u8Ky6ujoeeeQRVq9eTXh4OBMmTOCLL77Af2XJyspK/vjHP7Jhwwbi4uI4/fTTmTt3LgkJCfXnHHXUUcybN4/bbruNu+66i379+nHXXXdxzTXX1J+Tn5/PtGnT6qvBpkyZwp/+9Kdm34svvviCCRMmNHvO7bffzvTp0xs9FhoayjvvvMM111zDscceS3R0NBdccAEPPfRQ/Tnl5eWsXr2a8vLy+n0zZswgLCyMyZMnU1FRwYknnsjzzz9PqLfhz819wWnb8Td//vwG05WXlZVx9dVXs3XrVqKjoxk6dCjPP/88v/zlL5vNs9mXNNc4Vn+SyCDgdeAvwLvAjsBzVLWJ2vP2M3r0aN3flfsqKpyusU18sepSVqzI5vDDs9o1Db4gE7g1RsQJHIMGSbONu8YcLCId72/xAFfuW6KqjTaCuf3uuMb789kmjmsr7mXMPvan0d8Yc/C5/aC/EycwGNMhdPcuw8a0F1dBQ1Wnt3E6jDHGdAKt/r4mInEi0ldEukFtvzHGGH+ug4aITBSRb4CdQA6wU0QWi8jJrXmgiJwgIm+JSK6IqIhMbeH8LBF5U0TyRaRcRP4nIr9qzTONMcYEh6ugISITgXeAOOAu4BrgbiAeeLeVgSMOZ2T5DUCFi/OPAZYBPwdGAH8HZonI+a14pukmpk6diojss40dO7b+nAEDBtTvj4mJYcSIEcyaNavBfaqrq3nooYc48sgjiYmJoVevXowdO5Z//OMfrR4Q9vHHHzNq1CiioqI45JBDePLJJ1u8xs3aFC3d95NPPuEnP/kJvXv3bjDpor/G3i//96qttNfaG9Dy++b/9+G/nXHGGcHJfCfntiF8OvABcKZ/11oRuRN4G2eKkQWNX9qQqr6L020XEZnj4vx7A3b9XUQmAD8DXnLzTNO9nHTSScydO7fBPv/pQgD+/Oc/c/XVV1NWVsacOXO48sor6dmzJ5MnT6a6upqJEyfy3Xffceedd3L88ceTkJDA119/zSOPPMKQIUNcd2XcuHEjp59+Or/61a944YUX+Oyzz7jmmmtISUnhZz/7WaPX1NXVccYZZ5CUlMSnn35KcXExF198MapaPxjNzX3LysoYMWIEU6ZMqR9s6Ob9CnyvWjJnzhzmzJlDdna2q/Pd5K8xN954I2+++SYvv/xy/UDAM888kyVLlhAaGhq09+3rr79uMElkfn4+o0aN4txzz23V+9JVuQ0aRwC/CByLoaoeEXkCeDXoKWteD2Bri2eZbikyMrLFeYni4+Prz7n77rt59dVXmTdvHpMnT2bGjBl8/PHHLF68uMF8TQMHDuTnP/85ZWVlrtPy5JNPkpmZWf+hNWzYMBYtWsRf/vKXJoPGBx98wIoVK9i0aVP9wMMHH3yQyy67jHvuuYcePXq4uu/pp5/O6aefDtDoanY+bt6vYHKTv0ClpaU8/fTTPPvss5x8slOxMXfuXPr378/ChQuZOHFi0N43/3mwAJ5++ml69OhhQcPLbdCowvmgbkw8B3ECQxE5EzgROLaJ41cAV4AzAZ3bbz8+ZWVlZGdnowrV1d2ja2dlZRkrVmS3dzLaVVRUVP26Fi+++CInnXRSoxP8hYSE1H+ozZkzh0suuYSNGzc2GNnt78svv9xn+o6JEyfy3HPPUVNTQ3h4eKPXNLeGxIQJE/brvk357LPPSE1NJSEhgfHjx3PPPfeQmprq+vrWcpO/QC2tvTFx4sQ2ed9UlaeffpoLL7yQ6Bbm2mntZ01b832WBZvboJEN3CUiX6nqRt9OEemHU3X1n6CnrBEicixOldSvVXVxY+eo6ixgFjgjwls7ItJGhHd+77333j5zJF177bU88MAD+5xbW1vLCy+8wLJly7j66qsBWLt2ravqp549ezJkyJBmP6ALCgrq51HySUtLo7a2tn4djcauaWkNif25b2NOPfVUzjnnHAYOHEhOTg5//OMf+fGPf8ySJUvqZwIO1JnX3mjt+7ZgwQI2btzI5Zdf3mi6/O3v6Ou2ciAjwpvjNmjcDHwOrBaRr4B8IB0Yi9Ob6uagpyyAiByH0xbyZ1X9e1s/z3ReJ5xwwj4N2/7zNwH84Q9/YPr06VRVVREREcHvf/97rrzySgDX00GcffbZ9ZMYdlbnnXde/e8/+MEPGDVqFP379+edd95psK6Iv+6w9obP7NmzOeqoozjiiCPaOykdhtvBfWtE5IfAb4HjgR/hzD81E/irqja9JFgQiMgJOL23blfVGW35LNP5xcTEtLgOxLRp07j00kuJiYkhIyMD8ZsBcfDgwaxatSooaUlPT2907Y2wsLB9vjX7X9PSGhL7c183MjMz6dOnT4Mp4wN15rU3WvO+bdu2jTfffJPHH3/cVb66C9c19qqar6q/U9UxqnqY9+dNrQ0Y3sGBI0VkpPf5/byv+3mP3yciH/qdnwX8G3gSeElE0r1byr53N8adpKQkBg0aRGZmZoOAAXD++eezcOFCGpvs0uPxsGvXLtfPGTduXKNrb4wePbrJai03a0jsz33dKCoqIjc313X11v5oz7U3WvO+zZkzh8jISNcz4W7c6FRp5+fD9u1QUgK7d8OePZ1zzZmmtEcz72jgO+8WjdNd9zuc+a0AMgD/pWOnAjHA73CqxXzb1wcnuaazqaqqoqCgoMG2fft219ffeOONHHfccZx88sk8+uijLF26lI0bN/L6669z3HHH8e233wLwxhtvMHToUHJzc5u811VXXUVubi433ngjq1at4qmnnmLOnDn87ne/qz/nscceY+jQofWv/deQ+O6771i4cOE+a0i4uW9ZWRlLly5l6dKleDweNm/ezNKlS+unbS8rK+N3v/sdX375JTk5OWRnZzNp0iRSU1ObrXarrq5u8N6eeuqpvPLKKw32NdfDzE3+Fi9ezNChQ1m82Gm69F97Y+HChXz33XdcdNFFTa69cSDvGzhVlE899RTnnXdek2uIBPItalZZCbt2OQuV5ec7C5dt2eIsbLZx474Lm/kCzbZtsGOHc21ZGZSXO/eqroba2o4zSWeT1VMi8hFwjap+7/29OaqqrtZMVNVsoMnVEFR1aiOvpzZ2rjGNWbhw4T7flHv37r3PQLCmREZGsmDBAmbMmMHTTz/NzTffTFRUFEOGDOGSSy6p/2ZbWlrK6tWr63tdNWbgwIG8++67/OY3v+Hvf/87mZmZPProow262xYVFTVYjc/NGhJu7vvNN9806Il0++23c/vtt3PxxRczZ84cQkNDWbZsGc8//zw7d+4kIyODCRMm8OqrrxIfH99knjrz2htu3jdwGpHXrl3LCy+80Gw+G+bL2dzyX8gscIlmX0mksXVjfIuZtbTuTFtpcj0NEfkPcLU3aGTTwiy3qtr8X1E7sPU03Omsvad69+54axiY7klEyM09OH+LgWvOBAYa38+cnGxOOSVrvxYs26/1NPyDgKpmtf6xxhhjgq2tSxItPt/NSSIyRUSSmjjWS0SanqPAGGNMl+E2Xj1Lw8ZpfwNpekU/Y4wxXYjboNFcrVgsUBuEtBhjjOngmus9NRJnEJ/PJBEZEXBaNHAe0PRIIGOMMV1GcyPCfwrc7v1dgT80cV4xcGkwE2WMG3379t9nYJ4x7aFv3/7tnYSDprmgMQOYg1M1tQE4B2cQnr8qoFCt36NpB199lXNA13fWrsYHojvmGbpvvttCc11uS4FSABEZCOSravNLaxljjOnS3E5YuKmtE2KMMabjcz1ERESuEJHvRKRcROoCt7ZMpDHGmI7B9eA+4G84kwRG4YzLeAHYBaxn72SDxhhjujC3JY0bgfuAq72vn1DVi4FDgAqcHlTGGGO6OLdB4zDgE8Dj3SIAVLUEuAe4oU1SZ4wxpkNxGzQqgBBv19oCnBKGTxmQGeyEGWOM6XjcrhG+DBgELAQ+BW4TkY0404dMB75vk9QZY4zpUNwGjVnsLV38CSd4fOZ9vRs4K7jJMsYY0xG5Hafxf36/rxORw4FxOMuwfqGqRW2UPmOMMR2I25JGA6q6B6e0YYwxphtpbpbbfq25kapuPvDkGGOM6ciaK2nk0MK64AFasaS6McaYzqi5oPErWhc0jDHGdHHNzXI75yCmwxhjTCfgesJCY4wxxlXvKRF5poVTVFVt9T5jjOni3Ha5/TH7tm/0AuKBnd7NGGNMF+d2cN+AxvaLyAnAk8AFQUyTMcaYDuqA2jRU9RPgrzhrbRhjjOnigtEQvgE4Mgj3McYY08EdUNAQkTBgKrA1KKkxxhjTobntPfVRI7sjgMFAEnBVMBNljDGmY3LbeyqEfXtP7QZeB15R1exgJsoYY0zH5Lb3VFYbp8MYY0wnYCPCjTHGuOY6aIjIYSLynIisEZE93p9zRGRQWybQGGNMx+G2ITwLeBeoAN4BCoE0YBIwWUROVdWP2yiNxhhjOgi3DeEPA98BE1W1zLdTROKBD7zHRwc/ecYYYzoSt9VTw4EH/AMGgKruBh4ADg92wowxxnQ8boPGVpxxGY2JAHKDkxxjjDEdmdug8QBwh4hk+u8Ukd7A7cC9wU6YMcaYjsdtm8Z4oAewQUS+Ym9D+Fjv71nexnJw1ta4OMjpNMYY0wG4DRrHAbVAPtDfu+F9DXC837m2rrgxxnRRbkeED2zrhBhjjOn4bES4McYY19xWTyEiMcCvcNo3egE7gP8Az6pqRdskzxhjTEfiqqQhIunAt8CjOIP4Yrw/HwO+FZE0tw8UkRNE5C0RyRURFZGpLq75gYh8LCIV3uv+LCLi9pnGGGOCw2311INAInC8qg5U1XHedo7jgAScLrluxQHLgRtwpiVploj0ABbg9NI6ynvd74FprXimMcaYIHBbPXUacLOqfu6/U1W/EJE/Ave7faCqvoszjxUiMsfFJRfglGwu9laDLReRocA0EXlEVa23ljHGHCRuSxpxQF4Tx7Z6j7eVccCnAe0m7wOZwIA2fK4xxpgAbksaq4GLgPcaOXYh8H3QUrSvdPZdg7zQ79hG/wMicgVwBUBaWhrZ2dmtelhZWRnZ2dmoQnU1hHSD/mWVlWWsWJHd3sk46LpjvrtjnqF75ruqqoyPP84O+n3dBo2/AM97G7xfwhnUlw6cB5yEE1A6BFWdBcwCGD16tGZlZbXq+uzsbLKysqiogC1bIK4ty1AdxIoV2Rx+eFZ7J+Og64757o55hu6Z72XLshk/PotgdxlyO7jvBW+X2zuBp/wOFQJXqepLwU1WAwU4U5b4S/M7Zowx5iBxPU5DVWeJyFPAEPaO01itqp62SpzXl8ADIhKlqpXefSfjtLHktPGzjTHG+Gm2xl5EporIUhEpE5GtwEPAelX9XFVX7U/AEJE4ERkpIiO9z+/nfd3Pe/w+EfnQ75KXgHJgjoiMEJFzgFsA6zlljDEHWZNBQ0TOB57B6e76Dk47xm848GnQR+OsAvgdEA3c4f39Tu/xDOBQ38mqWopTssgEvgEex1kp8JEDTIcxxphWaq566gbgDeBcVa0DEJHbgVtE5GbfvtZS1WygyaYZVZ3ayL5lwAn787z94RRgpMFrG4BujDHNV08NBmYHBIcngEigX5umqh2VlZXx3nvv4av5UlW+/PI9lizJbt+EGWNMB9Bc0OiJ09jtz/c6sW2S075UlcrKShYvXsyHH75XHzBWrFjMli3rsCYUY0x311LvqRAR8Q8soU3s5yD0ojooampqAPj228V8++3i+v1FRflNXWKMMd1GS0Hj8yb2Lwp4rS7u1eHV1dXVt13E7t5N4s6dlCQksCc+npCQEOrq6ggL6/TZrBfYVmNtN8aYljT3CXjHQUtFBxEWFkZsbCyDF6/kF+/+CwQ0VJg/aRIhU67tUgFjyZJsqqsrGTt2IuAEjK++ep+IiChGjcpq38QZYzqsJj8FVbXbBQ2Px0Ndbi7nvD+PMOqc8lMtTHrjLR5/vy9rBmxh04gz6XFIMpmptWT0CSUjU8jIgKio9k69e6pKdXUly5c7BcYePaL46qv3Wb58ESNGjLEShzGmSV3nq3MQqCoxhYXUhYSCX5+xMOq4sfxRWAkjV37Hf0nmSp7iSn5NPhnkk0FxeAa74zN4/Yd3ENM/hWExm+gfV0zcYRkkDkklo09ohwksIkJ4eCS9eqWxfPkiBg8ezJo1a+jVK43w8EgLGMaYJlnQ8OPxeNiTmkq41jTYXxMWzu3nTOeHI87h3NqBjNsG8StG8vLaacTsyiehIp9+NevI3PEJ12XfSTFwF7M5j3sAqCOEbaSyLTSDywZ/SkLvWE5iIYND1hLWJ4PoQzLoMSSDXsPTiUmIaPN8qiqrV39HefnuBvt37CiksrKcUaOyLHAYYxplQcNPeHg4VYmJzJ80iUnz51MXGkpoXR1vTzqTuB/C+EuGMr7+7LHeDerqYPt2+Cof7s+HvDyo+v4S7ls3itBt+UTuyKdHWR5Jddv5ZlUMrILzeZGzmdPg+buJo1/CbjIy4IbqhximK6hNzkAyMwjvl0H0kH7E/ngM8fEc0MyVqkp5eVmjx8rLy6x6yhjTJAsaflSVmJgYvjviCDYcckiD3lPDBx/Z5IdpaCikpzvbkUf69h6K32woeDxQVATv5EF+PuRtnc2tG+6hZnM+5OcTuj2fmtIKdu6EnTuhhk0M5EPSNxQQTi0A3zOEYXxPbCzM46cc5lnN7rgMKntlUpeSQfXQH1Lxiymkp0NKxWZISEDj9o0wHo+HkJAQPJ46fvXUU8SGhpL785/X9xLzHTfGmEAWNPyoKhUVzgKBe+Lj2RMfX39s48YVjBs3cb+/gYeEQGqqs40cCc5bn+ndfM+HS3Y4JZX8/Md4If8x8nM97NlcTO2WfEq3VRJdAnv2wEeMYSfhZFTkk7H9SzJW5/P5Z8cy8akpAKzlRAaxjoqQGHZGZVDWI4PNw09j7S9uIyMjjGGrdpC6YTG9t26FkBBumDmT+ZMmse2UM7tULzFjTHDZp4Mf/4Bw5JFHMWTIafzvf/9m5cqvEQlp8yobEUhKcrYf/MC3NwRI8W5OYNm1C/LybqOgAL4qcIJMQb5SnFfFsG1OSebWnffSn01kePLJKHe2RQVl/OEjAKWcJ4imynmEx0OIx8NP3niLqbsup2x3HRO/vIPw/r2JGdKXyEP74OndF+2ZcGD1YsaYTs910BCR3sBvcSYO7AX8RFWXi8iNwJeqGjjgr9MREWJjYznqqKPIyjqNrVuFY445DYCoqJgOUc8vAj17OtuwYQ2OAHu7Z1VU/IL8fCgocILIigLn99PyIT9PuWrNP3i84lri2FN/TRWRrP8wgXc/LOU33EMoDQf5P9VnOu8edTsDE0u46Ntp1PXuS1j/PkQP7kvcsL7IIQPRmNi2fQOCILD6zarjjHHPVdAQkcOBT3E6on4JHAn4uvn0B44Gzm+LBB5scXFxjB8/nspKJ0CIOIGjIwSM1oiOhkMOcbZAdXXKq48uJ3JGFd7mEgDCQmpJHb2NzD5j+HFBFXW5BUQUbiG5cgt92MqXW8fx1VYYzDam8QEZS/MJYe98XNPiZrFgwOUcHb+KG3NuoCKpL3UZfZB+fYk4tC/RJxxFjwG92rWwMn/+HKqrKzn77CsAJ2C88cYsIiKimDRpavslzJhOwm1J42FgFTARqASq/Y59ATwQ5HS1q8AA0dkCRktCQ0PZE9+D+ZMmcda8eSBCXUgI70w6g1Ej/8dll/0Up1qsD9CH3bvHUVAAR+fD5AIoKBjCHwpy2Z5XQ93WfMILthC3cyuLyo5i43KIooxySumbv5z05QX1geVU/k125Kn8Iv497ij7LSXxfSlP7ENNel+0Tx/2nPhTEg9LJj3VQ2x88L/5ezweSkuLqKjYwxtvzGLo0KG88cYsduwoJDo61kocxrjgNmgcB/xSVctEJDTgWCGQHtxkmbZUV1dHZGQUy444grzhIzg6JY3F2wspDg8lKjKKuro6QkP3/jPHxzvbYYcF3ikcZ5b8ftTWOt2OCwuhoOAoPixYRH4+FOVXU7vZCSyrdh5O1W7IqYplKUPoW7mFw7YvJX1NIQCHvzSWlSRzDX/nHv7Atog+7Ijpy+6EvlSl9GHFSTeQOKAnveNKSc0MI7l/LJGR7vPtVD/2pKJiDzt2FFJU1JMdO5xnx8b27HJfDoxpC26DRnMz2CYDFUFIizlIQkNDGTp0FN9/v4Riylmf2ovinUVERcUwdOioBgHDrbAwyMhwtoYicGow+wNQXg6FhcdTWHg8XxfA/ALYnltN7aZcEnf1pv82WJM/grnVF9G3egt9qrfyw53fkpazjQu+voFdwH3cxy08wA4SyQ/pQ1F0X0p79OGVYx8jOSOcoeHrSU6sI25oH1L6x5CSAhHeytSdO7cDzoSUSWvWELt7N3vi4+v3G2Oa5zZoLAYuAeY3cuxcmp4N13RQRx31Y370o/E888zd9fvOP3/afgWM1oiJgYEDnW2vCGDvDtXxlJaOp6AA1hTAp4VQnFvJOcVRFBTA6vWTuLcggcSyLWR6ttJ3zxb67lnFy/8MB2Aut3MuLwJQTC+20Jf1EcP406EvUVNzLr/fdT+XbJuDR0LJEuX54y5k5agjqKz0EB3dtvlvLzajsQkWt0HjLmChiHwAvIQzld9JInIDcDYHcSlWExwej4c333yqwb4333yKs866vN3r9UUgIcHZhg717fWfuOtY4Fg8Htixw+kVtrwAHtrmVI99v/K3PLh5IlFFW+lRuoXkii1QXc2qVUIacVzKs07PMHUmpbz0k2f5zydZDPrrDfTqBTeHPUxyTDk1SemQkUF433QiDu1L/KA0Z+BkSueaoHLJkmyqqioZN27vjMZffvk+kZE2o7FpPVdBQ1U/FpGzgBnAM97d9wM5wFldobttd+LxeJg3bzbFxQUkJaWTnJxBcfEuiosLmDdvdocIHG6EhEBysrONGOF/5Ejv5qir847Gz/fw9aOzqVoYSUzd3hrVaiJYH3YoIR5lxw7hx7zMaJY4f91e7zGR03gPgH9zKhFhHnZFp1PeM4PqXumUHDKKXSNPIDUVesfvolf/eNLShdh27oGsqmzZso7t23MB6Nkzii+/fJ8VKxaRktKbH/1ovJU4TKu4Hqehqu8A74jIICAVKFbV1W2WMtNmQkJCCA+PJCkpnbPOupxVqz7hrLMuZ9682YSHR3aKgNEaoaGQlgapqULecRGEf9hwQsqQMA9y+2FsnOKUXLZt+4YXtlSxZ+M2qnLyqcstIH9PD46sdUo1pQUJ9K/N4ZDda8jYnU/k1mpm/+8yps07AcFDFUnUEkY+GWwOSWdnVDqfZ/yC/w7/JWnJdRxf9m/C+6YTc2gGPQalkpIZTmJi242bTE3tzfbtuaxYsXdGY99+Y1rL7TiNPwNPqWqeqq4D1vkdywAuV9U72yiNpg1MmjS1QRfTkJCQTlPC2F8ej4cCausnpNTwcKSmhvmTJlFALSIeUlNDSU0FRkQCfb2b48b6+7xCSQmsK4TPC5TSTTspKqzjkjIoyq/j8eX3E11aQPyeAlI9+fQpX0PF+lzmr4c0tjObSXvThFBEMtND7uLN9Cs5rFcxV5c9RE1SOpqWTmifDCL7pxMzpC/J/WJITqbVPcZycr5HJISYXaX1jf/lPXqSk/N9/eBVY9xyW9K4HXgPyGvkWKb3uAWNTiYwQHTlgAHOB6jH42GZd0LKH8bH8z9v7ynxeFxX04SE7J3uZfhwARL9jobjTJywd8qXbdvg6EJ4bDsU5fXi/pVfofkFhG3PJ7KkgLiyAtbWHEJeHiTnbeUs/kpkTnWDZ07lWZ5jKkewlH+EXsvO6HTK4jOoSkynNiWDbSMnEjWoD2m9akhNE5LTw0hIAI+njj17dvGD//63PlBO8AbKZUccsU/36q7GOgAEn9ug0dy7nAi+SYyM6bhEhOjoWMrLd9N/zIlIQjT9d1awcuVioqNjg/5h4j/ly94xLhHAmH3OHV/hjHPZtu0I5hZWsmtTCdWbnKqxkMJ8CuuOJb0UIrbVUVYXRZ+y78ko+w+98ksAOOnjBXxIH37Gm7zKuWwnhUJJZ0dEOkeGRHJK5fuEay3UOlMAnPnm2ywKH8OmTUpGhjODQFdjSxq3jSaDhohkAT/223WliJwZcFo0cAawIugpMybIRIShQ39EZWUFxxxzKitXfswxx5wKQFRUdLt+A42Ohn79nM35jtbLux0OwMXe8+rqRlFS8iH52+C/26A4r4rKnAIGl6UQWwKROUP52+Y/E7engOSafNKrChhKDtVEEOU3kUOEp4YHXr2FHa8+QB6ZnB77PrVpvTkp6jN+FLKUurRMyMwkYkAm0QPTSc6MICXFKV2Fhx/c92Z/2JLGbae5ksZ44I/e3xVnnEagamAl8Osgp8uYNjFqVFaDDwxnbrFTO80HSGjo3h5jw4cDROIbOOkY4d2gogIKC5Unn5/DrU9d1WAJ42rCmB1/NTF1dSRW5LN1TwLlG+Aw5nElD8Pyhs+NppxKormM2YyP+Ipd8ZmUJ/SmJiUTzcik4vDRJCc7U/8nJ1MfYNqr5su3pHFSUnqDJY2TktK7/JLGbV0l12TQUNU7gDsARMQDjFXVxUF7sjHtpKvPLeYTHQ19+3qI7L+dd35yRoPG/7cnTWLXUX34yYW/JSQklEUlTrfk7YUP8szGm6jOycOzNQ8pyCN0RxGHREezfTscun0DE6rfI724gNBiD6yHIpJIeaMIgCe4msEsZguZLCaTkphMihIOY/Gg80lOhn4Ju+iRGUdSSkiDANOrV3ADjKpSU1NFcXFBg/3FxQVkZPTvsiWNxqrkPvjgfaKiosjKygrKM9yO0+jaLaTGdGHV1RWNNv5T7YxVEXE+tHv1gsGDQ+D4VJxe9SPr7+Grl66ru4+iHfexMq+Wsg3bqNyQR3nBLi6PdYIO3w6grGgT/Su3cnTdYtLKt/Fd+Uj+kudMgv0FExnNN+STQR6Z5JHJB4zl4ZCbSEqCH8d+RVRSHJqRSXRmIimpUh9Y/EswLa0TJiKEhUUQERFFdXVl/f6IiCjCwiK6ZMAIrJKLi4vigw/eZ9GiRYwZE7wquVYvwiQiqTQcnutL8OYDTo0xJqhCQkIIC4ugtraaPfHxFA8ezB7vOI2wsIhW95gLDXU+uFNSwuCIvStP7u24e7N3g8oa+K6gmp2bdzG3ymno3/rR1ZRs+Z6oHXnE7cpjRMUa6ojGU+0c/8v2n9MnxxmIWEkkeWTyKudyAfcDcC2PUUoCZfHeZY7TMolJ70FySsPgkpTkITv7v8TG1nDlc/5LGsPSpZ8yalRWl+stKCKMHTsRj0cbVMkdffTRTJy4/6uOBnI7TiMEuBu4Ekho4rSu22/PmE4sMTGF7dtzOfzwo+nZM5rw8ARWrFhMYmJKmz43PBzS+kaQ1jeZIb6dk6fsc96xQE4NFBdD7sevsnHDVjxb8wgpyCOiKI/U6HSO6wk7ttcxc/UNzhQwu3G2TTCTX3MjMwmjhueZQh6Z/I9MCshkBMtIpogawrn2kceZnn47H/U+kZ07dZ/2l5QUZzbnzlwIefvt56iqajh/bE5ODs899xxTp04NyjPcljRuBK7FWTfjbuAenJlvL/D+vD8oqTHGBJWI0LfvIFJTezNunNNjbNw4p8dYZGT79hjzFx4O6enA5GP2OdYXcFIcyraynWhePuXr8qjYkE/t5jz6JxzBn5OgcstOsl77hsTyXKI8DT84o6kEhfvzb2Vrfh+2f5NCCYmUkMjfuJqPOJFktjM57F/UxvdCExIJSUokPDWRkD6Z9EyPru+AkJS092dH6knm8XjYubOIyso9DfZv27aN2NjgrRfjNmhcgjN4bwZO0HhDVb8VkbuBD3AWVTDGdECN9RgbN67z9Bjzp3HxMDiemMGDifHuS8NZOhRS0LvXskMVdpWy/KHfk/XCc0TU7J02pjYkjKLU3kREp9CnrIRB5av4Oq2E9XUwqHANj1VeDSU420bnmnP5P2ZyLsfxKc9xMSUksoNE1pPInohEXkm7kZ2ZwxkWu5nRdYsIS0kkIi2R6MxE4vom0qNvT5JTQ+jZs+1LMTExcVRW7uHiZ58lOiaGNZMnA86KpMHiNmgcAnyjqnUiUoszPgNVrRGRGcDfgOlBS5UxJqi6S48xAETQHj3ZNPBQRLXhsRD45pqzOP1XN9e/Bzd4N2rHkLM1l9KcEvZsLaE8r4Sagh2M6jWGHtUQvz6etSuOJbKihB6VJfSuzSWxuoRZW6ayaAsM4hOu5aJ9kjOar1nCaM4LeZVbQh5kT2QiVdGJ1MQlUtuzF0vG/5aYfskMqFtPZk0Osb0Tie+XSGRGL6e+zGXpwDenXGRkNKF1dYSXlxO7ezee1FQiI4M3p5zboFHK3sbvPGAIe9fQCMMZhWSMMR1CTU0NeZ6qRucZy/NUUVNTQ4RvZS6fsDAiBmSSMiAT/9aeI+p/GwnMrX/l8UDRTri3yGnEL936U/6xYRmV+SXUbd+B7ihBdpbgkQHE74Tdu2PY6kmjV+0OMvZsIbHIqSC7/L/XkQf8iRf5Gbc3SFIdIUw4fDvhab04b+ffOXbbG9T1SMST0IuQpETCUhLZfdk0klJDic1fS+KmjQz4dhG9c3NBhBtmzmT+pEkUn3baQe899R0wHHjfu90hIhVALU77xrcHnBJjjAmSiAinZ1hjXY1DQkL2DRj7ISTEv6syQDy+gZX+zvP+rKo6k6KiMykuhnXbnYb/HcXKT7ZD8Q5YnXcplxaMR3aWEFJaQlytE1S+WNGDuhUwjDp+wC4S2eRtjSlBESKf+R0Ac0Pv4cK65/Y+WJUQj4dJ8+fz6KGH4vF4gjLPmNugMQOnigqcyQl/BN6l0WATcN0Bp8QYY4JEVRk+/CiWL1+0T1fj4cOPapfBfZGR0Lu3s+3ln4be3s2Z7HLPHiewHFnsjIHZseM63iq6jqIiZ39xkbJneznpJcKOHfBA9W9ZzlD+zJ3E+K3AXRcaSkJJSdDy4XZw3wK/3wtE5GjgUCAGWKWqNU1ebIwxB5n/NCL+o8I7yzQiIhAX52z9+zd5FuCs8qUKu3ePYP7szwibWdtgypjQujoihgwJWpuGq7uIyBQRSfK9Vsc6Vf0fEC8i+3a+NsaYduI/jciIEWNITs5gxIgxFBcXUFNThQY2kHdyIk6beeyhYbz9kzPxiOAJCaEmLIz5kyZRmZAQtGe5rZ56FhgHFDdybKD3+PPBSpQxxhwIESEiIooRI8YwduxEVq78uH4+poiIqA5f0tgfqsquXTvZ3kg7TszOnQe9Iby5J8XiNIgbY0yH0dj4lLFjgzedRkfky1tgO85BmeVWREbiNHj7TBKRwK4B0TidA9YGLUXGGBMk3Wl8iog02W4REhJyUOae+inUdxpW4A9NnFcMXBqU1BhjjNkvIsKQIUeSk/M9JSXb6venpqYydOjQgxI0ZgBzcKqmNgDn4IzX8FcFFGpXa1UyxphOxtf4X1KyjREjxhAXF8WYMYksWrSIgQMHtn2bhqqW4owER0QGAnnWtdYYYzqmwMb/5cs/5pRTnMb/qKjgNf67HaexyS9hkTjVUcNxphSZo6p5QUmNMcaY/dZY438w19KAZsZpiMidIrIiYF8ksAhngsJrcGa8/c5bEnFNRK4RkY0iUikiS0Tk+BbOP19ElopIuYgUiMgLIpLemmcaY0x30NaN/80N7jsJeDdg37XAD4GHgJ7AWKAG+KPbB4rIZGAmcC9wJPAF8G8RaXR6dRE5FmeWsOeAw4GzcEo5LzZ2vjHGmLbTXNA4FFgcsO8sIB+4VVV3q+pinAByYiueOQ2nSmu2qq5S1eu997y6ifPHAVtV9a+qulFVv8Ip6YxpxTONMcYEgTTV8UlEKoFTVPUT7+sIYBfwT1W90O+8LOB9VY1s8WHOPcqBX6rqa377HwdGqOr4Rq4ZB3wM/Ax4G0jCKWWUquq5jZx/BXAFQFpa2qhXXnmlpWQ1UFZWRlxcHKpQXe16KvtOrbKyjKio4C3S0ll0x3x3xzxD98x3RUUZPXrsX54nTJiwRFVHN3asuYbwXGAA8In39RggAqc6yV84sAd3knHWEi8M2F+IUx22D1X9UkTOwwkU0d40LwAubuL8WcAsgNGjR2tWVpbLpDmys7PJysqiogK2bHEmDOvqVqzI5vDDs9o7GQddd8x3d8wzdM98L1uWzfjxWUFfLbC579GfAjeKSII4LSm/xlkP/J2A80YCW4ObrL1EZDhOddRdwCic5YLTgX+01TONMcY0rrmSxh3AEpxSQCXOCiNP+ne/9ToP+Mzl84pwJu1NC9ifBhTsezoAtwKLVfUh7+v/icge4FMRuU1V2yxgGWOMaai5wX0bvfNPXQYk4nxwz/U/x9vt9QtcznCrqtUisgQ4GXjN79DJwL+auCyGBrPDg9/rbtDiYIwxHUezg/tUdTPw52aOFwDXt/KZjwBzRWQxzjrjVwGZwJMAIvK8996+NTrmA7NF5GqcpWYzcKY4+dabPmOMMQeJ26nRg0ZV/8+7oNMfcQLAcuB0v2qvfgHnzxGReJwlZR/GmdrkI+Dmg5dqY4wx0A5BA0BVnwCeaOJYViP7/obTGG6MMaYdWZuAMcYY1yxoGGOMcc2ChjHGGNcsaBhjjHGtuTXCP2rFfVRVWzNpoTHGmE6oud5TIThrg/sMwZm+IwdnlHgaztxU+cDqtkmeMcaYjqS5EeFZvt9F5CycNTDGqeoiv/1jgP/zHjPGGNPFuW3TuAv4k3/AAPC+no6zgp8xxpguzm3QOAzY3sSxbcCg4CTHGGNMR+Y2aGwErmzi2JU47RzGGGO6OLfTiNwBvCgiy4F/srch/OfAUOCCtkmeMcaYjsRV0FDVV0SkCCd43IqzWl8N8DUwUVU/bLskGmOM6ShcT1ioqguBhSISgrNsa5GqetosZcYYYzqcVs9y6w0U29ogLcYYYzo410FDRA4BzsVZ7yIq4LCq6qXBTJgxxpiOx1XQ8A7uexWnt9U2oCrgFA28xhhjTNfjtqRxF5ANXKCqTY3XMMYY08W5DRqHAL+1gGGMMd2b28F93wNJbZkQY4wxHZ/boHETcJu3MdwYY0w35bZ6ajpOSWOViKwFdgQcV1UdH8yEGWOM6XjcBo06bM0MY4zp9txOI5LVxukwxhjTCdga4cYYY1xzO7jvhJbOUdVPDjw5xhhjOjK3bRrZtDzqO/TAkmKMMaajcxs0JjSyLwk4ExgPXBe0FBljjOmw3DaEf9zEoddF5K/AJODfQUuVMcaYDikYDeHv4Mx+a4wxposLRtAYAthiTMYY0w247T01pZHdEcAI4FLg9WAmyhhjTMfktiF8ThP7q4D/A24ISmqMMcZ0aG6DxsBG9lWqamEwE2OMMaZjc9t7alNbJ8QYY0zH53qNcAAR8Y3L6IUz0222qr7TFgkzxhjT8bhtCI8H3gaOB2qBYpzBfdNE5FPgTFUta7NUGmOM6RDcdrm9F/gRcBEQraoZQDQwxbv/3rZJXvsRAVUoK9u7VVRAZSXU1IDHOhkbY7oht9VTPwP+qKov+naoah3woogk46zs9+s2SF+7iYqCgQOd4FBX52w1NXu36mqorW14jaoTbEJCnC00dO/vIu2TD2OMCSa3QSMJWNnEsZV00fXDIyKaP666N6j4//QFFN/PmprGr/cFE19wCQ214GKM6djcBo2NOJMTLmjk2One492O7wM/1MX8vv4lFt/vvoDiX3rxVXv5Si2+5/hKLP4lGGOMOdjcBo1/AA+LSBzwIpAPpAPnAZcB09omeV2H7wM/PLz58zyefUsvbqrG/J9jpRdjTFtxO07jryKSghMcpnp3C1AN3K+qM9smed2PL7iEtfAv46saCwww/qWX2lqn8d7j2Vty8S/B+J6l6lxrbS/GmJa47XLbE7gTeAgYy95xGl+paknbJc80xb9qrKXSiy8o+AcY/7YXEeenr1TTWODwlVj8q8cswBjT/bQYNEQkDGdcxtmqOh9bN6PTEWm+5BIe7vQUg31LLx6PE1B8my/QWIAxpntqMWioaq2IFAJ1ByE9pp25rR6DlgOML8j4jvtXjfl3T/Zvg/FtxpiOyW1D+As4Dd7vBuOhInIN8HsgA1gB3KiqnzZzfgTwR5zBhZlAIfAXVX00GOkx+6c1Aca/isw/0AS2wTQ3/iWwF5mNgTHm4HMbNHKA80Xka+BNnN5T6n+Cqj7j5kYiMhmYCVwDfOb9+W8RGa6qm5u47BWgD3AFsBZIwxmRbjqJlqrI/Pk38gc29PsHGF81WVOj830BJXCgpTFm/7kNGo97f/YGRjVyXAFXQQOnB9YcVZ3tfX29iJwKXA3cGniyiJwCnAgcqqpF3t05Lp9lOqHWjH+BhgEmsBTjX3rxL8X4AlOZ34xpjZViLMgY05CoassnifRv6Rw306d7q5nKgV+q6mt++x8HRqjq+EaueQIYDCzGmeuqAqcx/rbGJkkUkStwSiSkpaWNeuWVV1pKVgNlZWXExcW16prOrjvm2ZlXzMm377+AasPNt68l/oMwO7rKyjKiorrXvzV0z3xXVJTRo8f+5XnChAlLVHV0Y8cO9noayUAoTpuEv0LgpCauOQQ4DmeVwJ8BCcDfcNo2ft5IWmcBswBGjx6tWVlZrUpgdnY2rb2ms+uOeQZ3+Q6sKvPf/EsvvqqyptpjoGF1WXu1yaxYkc3hh2cdvAd2EN0x38uWZTN+fFbQ/75atZ4GgIgEFthV3RRX9l8ITvXX+apa6k3DdcD7IpJmqweattTaqjJovFdZYz3L/Lsu+54V+OymAo0x7aXJoCEi6cDTwP+p6vPefaE4o8D9lYnIYJcf3kU4XXfTAvanAQVNXJMP5PoChtcq789+7FtqMaZdtaZXGTRdkvGVXBobJwMNq846UmnGdG3N/Vlfg7NWRmAVkACzgTzv75OBq4A7WnqYqlaLyBLgZOA1v0MnA/9q4rLPgV+ISJxfG8Zg709bhtZ0eq0tPfjaXFpTmvH1MAts/Pc93wKNcau5oHEqMFtVKwL2K/APVf0WQES24zRQtxg0vB4B5orIYpyAcBVO+8ST3vs9D6CqU7znvwT8CXhWRKbjtGnMBP6pqttcPtOYLsN/zEpruzHn5kL//q0LNE2lwarOuqfm/uSGAH9uZH/g94813nNdUdX/E5EknMF6GcBy4HS/xvZ+AeeXichJOI3fXwMlwDzgFrfPNKa787XNiEBkpLtrWuoEENgBoKZmb/tMU2nwDzT+AcdKNZ1Hc0EjCmhQkFXVOhHJwGmb8Kn0nuuaqj4BPNHEsaxG9q0GTmnNM4wxB2Z/OgH4V5211EbjG6zpO97U/fwDi5Vq2l9zQWMbTnfXz/x3NtLgPRDYHuR0GWM6If+qs9ZoqVTj62XWVIeAxkoq/iUaVed8CzYHrrmg8RnOXE/Pt3CPKThtE8YYs1/2p1QDDYNLYOAJnI1ZdW+waSrQ+NJi1WhNay5oPAp8JiJ/AW5R1QbDlrxTpj8IZAHHt1kKjTGmCW5LDuHhTgcAn8aCTGs6BzQVdJoKNl2pdNNk0FDVL0XkJpzAcKGILAB8Ewr2w+kmmwzcqqpftnlKjTEmSHwf4q0t2fgHmsCg46sC89/8FzsLDDT+r33VeoGlmo4YcJrtsKeqD4vIt8DNOFN4+Bq8K4FPgAdV9aO2TaIxxnQM+1uNBk0HGl8ngcB2G//fm6tOg8ZLOG3FzSJM/wH+4x0NnuTdXayqtiiTMca4tL+lG2g54PhXqfl+b6s2GNdzT3mDhA2mM8aYg2x/As7GjW2Ulra5rTHGmK7IgoYxxhjXLGgYY4xxzYKGMcYY1yxoGGOMcc2ChjHGGNcsaBhjjHHNgoYxxhjXRP0XGu5ivKsKtnZJ2GQarhfSHXTHPEP3zHd3zDN0z3wfSJ77q2pKYwe6dNDYHyLyjaqObu90HEzdMc/QPfPdHfMM3TPfbZVnq54yxhjjmgUNY4wxrlnQ2Nes9k5AO+iOeYbume/umGfonvlukzxbm4YxxhjXrKRhjDHGNQsaxhhjXLOgYYwxxjULGl4ico2IbBSRShFZIiLHt3eagkVEbhWRr0Vkl4hsF5H5IjIi4BwRkekikiciFSKSLSKHt1eag837HqiIPOa3r0vmWUQyROQ57791pYisFJHxfse7XL5FJFRE7vL7P7xRRO4WkTC/czp1vkXkBBF5S0RyvX/LUwOOt5g/EUkUkbkiUurd5opIQmvSYUEDEJHJwEzgXuBI4Avg3yLSr10TFjxZwBPAMcCPgVpgoYj08jvnJuC3wPXAUThL+y4QkfiDm9TgE5GxwBXA/wIOdbk8ez8APgcEOAMYhpM//6Wau1y+gZuBa4FfA0OBG7yvb/U7p7PnOw5YjpO3ikaOu8nfS8CPgFO924+Aua1Khap2+w1YBMwO2LcWuK+909ZG+Y0D6oBJ3tcC5AN/8DsnGtgNXNne6T3AvPYE1gMTgGzgsa6cZ5wvPp83c7yr5vtt4LmAfc8Bb3fFfANlwNTW/LvifIFQ4Fi/c47z7hvi9tndvqQhIhHAKOCDgEMf4Hwz74ricUqZJd7XA4F0/N4DVa0APqHzvwezgH+q6n8C9nfVPJ8FLBKR/xORbSKyVESuExHxHu+q+f4MmCAiQwFEZDhOqfpd7/Gumm8fN/kbhxNsvvC77nNgD614D8JaPqXLSwZCgcKA/YXASQc/OQfFTGAp8KX3dbr3Z2PvQe+DlKagE5HLgUHAhY0c7pJ5Bg4BrgH+CtwPjAT+5j32GF033w/gfBlaKSJ1OJ9t96jqE97jXTXfPm7ylw5sV28RA0BVVUS2+V3fIgsa3YyIPIJTJD1OVevaOz1tRUSG4FTVHKeqNe2dnoMoBPhGVX11+d+JyGE49fuPNX1ZpzcZmAKcD6zACZYzRWSjqj7dngnrarp99RTO1MF1QFrA/jSg4OAnp+2IyF+BXwI/VtUNfod8+exK78E4nFLkChGpFZFaYDxwjff3Yu95XSnP4NRrrwzYtwrwderoiv/WAA8Bf1HVV1R1marOBR5hb0N4V823j5v8FQApflWVeH9PpRXvQbcPGqpaDSwBTg44dDIN6/46NRGZyd6A8X3A4Y04fzQn+50fBRxP530P5gE/wPnG6du+AV7x/r6GrpdncOqohwTsG8zedWW64r81QAzOlz9/dez9jOuq+fZxk78vcTrBjPO7bhwQS2veg/buBdARNpyibTVwGU4Pg5k4DUb92zttQcrf48AunIbBdL8tzu+cm4FS4BxgBM6Hax4Q397pD+L7kI2391RXzTNOV8sa4A847Tm/8Obx2i6e7znAVpxuxgOAs4HtwMNdJd/eD/yR3q0c+LP3935u8wf8G1iGEyzGeX+f36p0tPcb0VE2nMbDHKAKp+RxQnunKYh50ya26X7nCDAdp3qjEvgYGNHeaQ/y+xAYNLpknr0fnP/15mkNztgF6cr5xmkEn4FToqoANuC0aUV1lXzjjLdq7P/xHLf5AxKBF3C+RO7y/p7QmnTYLLfGGGNc6/ZtGsYYY9yzoGGMMcY1CxrGGGNcs6BhjDHGNQsaxhhjXLOgYYwxxjULGqbDEpFxIvKqd1GZahEpFpEFInKxiIR6z5nqXZBmgN91OSIyJ+Bek0RkmXeBHhWRBBEJEZEZIpIvIh4RmdeGeRnQ2MI5jZzny8+gtkrL/hKRs0RkWiP7s7xp7qoTfBo/NmGh6ZBE5EacuYM+whnpuglnYNIpwN+BncCbTVx+Ns7AJd+9woAXcaZKuBZn9P9u4Oc4C9r8FmeKheJ97mT8nYUz8/Mj7ZwO044saJgOR0ROwPlgekxVfx1w+E3vTL2xTV2vqt8F7OqNM2L4VVX9xO85w7y/zlBVTxDSHamqVQd6H2M6MqueMh3RzcAOnOUr96Gq61U1cOnWev7VUyIyHWd6GICnvdUo2SKSgzPlAkCdf9WROGtsPy8iRSJSJSL/E5ELA57hq0Y6QUReE5GdOCtAIiIxIvKEtzqtTETeAvrsx/vQJBG5QkT+661uKxKRpwOW78WbvrtF5NfirJm9W0Q+ln3XjQ71npcvIuUi8pGIDPVeP917zhzgYqC3d79630N/MSLymDc9RSLygrRy/WnT8VlJw3Qo3raKCcA8Va0Mwi2fwllX+TXgbuAdnKqrSJw5maayd9bP9SISizNnTyJwG7AFZxGnuSISo6qzAu7/IvAyTlWX7//TP3AmwbwD+Bpn5tGXgpAXAETkfpwqtUeB3+OUpO4GRojIMdpwnZQLgdU41XAROFOIvykiQ1W11nvOHd68PgQsxFnJ8q2Ax94FpOBMiPgT777AUtVMnGVXz8eZafdBnJlmLz6Q/JqOxYKG6WiScdY23tTSiW6o6lYRWep9uV5Vv/IdE5Fc7zn++64DDgMmqGq2d/e/RSQNuFtEng74UP6nqt7kd/0QnA/NP6jq/d7dH4hIHHDVgebH2+D/e+AOVb3Tb/8anCVPJ+FMC+9TA5yp3oWovEspvAYcDXwhIonAjcCTqnqz95oFIlINPOy7iaquF5HtQLX/+xXgE1W93vv7B9734jIRmao2yV2XYdVTxjR0ApDrFzB8XsD5pj08YP8bAa/H4Py/ejVg/ytBSt/J3vu/KCJhvg2namw3Tvr9LdCGKxcu8/70Lcr0A5z2odcCrvvnfqTtnYDXy3BKdIELA5lOzEoapqMpxpnaun87Pb8XztTSgQr8jvsLPDfD+7OxtZqDIdX7c10Tx5MCXu8IeO2rUory/vSld1vAefuT3paeZboACxqmQ1HVWhHJBk5up95IO9h35TtwFq3yHfcXWO3iCyJpOGs64Pc6GHzdgk8BSpo57pYvvak4a2v7WOnANMqqp0xHdD/ON+YHGzsoIgNF5Idt9OyPgT4icmzA/vNxvo0Hrr8daBHgAc4N2H9ecJLHAu/9+6nqN41sG1t5v2XAHpwV/vwFvgan5BDd+iSbrsRKGqbDUdVPvCOPHxGR4ThLeW7G6dF0Is6yvOcDTXa7PQBzcHoavS4if8BZQvQCnLaEKwMawRtL+2oReQm4U0RCcHpPnQKc3sp0nCoiBQH7SlV1gYg8ADzmbWj+GGeVtr7eND6lqv9x+xBVLRGRGcBtIrIbp/fUj4BLvaf4j19ZCfQSkatx1luvVNVlmG7FgobpkFR1hogsBn4D/AWnV9VunA+rK4H5bfTcPSIyHqeUcz/OoMDVwEWq+oLL21yJs8b873C6uX6EE+Q+a0VS/tbIvhU4y3feJiKrcEa3X4tTRbYF+BBY24pn+NyOs1TopTjdkBfhdEX+HGfNaZ+ngLE4y6gm4PRwG7AfzzOdmC33aozZh4j8HKdH1Qmq+ml7p8d0HBY0jOnmRGQMcAZOCaMSZ3DfLTglrGNsjIXxZ9VTxpgynPEd1wI9cBr8XwVutYBhAllJwxhjjGvW5dYYY4xrFjSMMca4ZkHDGGOMaxY0jDHGuGZBwxhjjGv/D1LmsH3zzRjvAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
     {
      "ename": "AttributeError",
-     "evalue": "module 'qiskit_experiments' has no attribute 'randomized_benchmarking'",
+     "evalue": "'ExperimentData' object has no attribute 'add_figure'",
      "output_type": "error",
      "traceback": [
       "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-1-d05adedf1579>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mqiskit_experiments\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mqe\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mrb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mqe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandomized_benchmarking\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# For simulation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mAttributeError\u001b[0m: module 'qiskit_experiments' has no attribute 'randomized_benchmarking'"
+      "\u001b[0;32m<ipython-input-3-2049cb33e2e1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Run an RB experiment on qubit 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mexp1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRBExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mexpdata1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexp1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# View result data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, experiment_data, **kwargs)\u001b[0m\n\u001b[1;32m    136\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m             \u001b[0;31m# pylint: disable = not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    139\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    140\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     71\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m                     \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mAttributeError\u001b[0m: 'ExperimentData' object has no attribute 'add_figure'"
      ]
     }
    ],
    "source": [
-    "import numpy as np\n",
-    "import qiskit_experiments as qe\n",
-    "rb = qe.randomized_benchmarking\n",
+    "lengths = [1, 20, 40, 60, 80, 100]\n",
+    "num_samples = 10\n",
+    "seed = 1010\n",
     "\n",
-    "# For simulation\n",
-    "from qiskit.test.mock import FakeParis\n",
-    "backend = FakeParis()"
+    "# Run an RB experiment on qubit 0\n",
+    "exp1 = rb.RBExperiment([0], lengths, num_samples=num_samples, seed=seed)\n",
+    "expdata1 = exp1.run(backend)\n",
+    "\n",
+    "# View result data\n",
+    "expdata1"
    ]
   },
   {
@@ -47,9 +79,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "ename": "AttributeError",
+     "evalue": "'ExperimentData' object has no attribute 'add_figure'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-2-55fcbd6a6a73>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Run an RB experiment on qubit 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mexp1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRBExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mexpdata1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexp1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# View result data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, experiment_data, **kwargs)\u001b[0m\n\u001b[1;32m    136\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m             \u001b[0;31m# pylint: disable = not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    139\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    140\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     71\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m                     \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mAttributeError\u001b[0m: 'ExperimentData' object has no attribute 'add_figure'"
+     ]
+    }
+   ],
    "source": [
     "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
     "num_samples = 10\n",
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index c7443c1690..0ba579d02c 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -95,7 +95,7 @@ def transpiled_circuits(self, backend=None, **kwargs):
 
     def _sample_circuits(self, lengths, seed=None):
         circuits = []
-        for length in (lengths if self._full_sampling else [lengths[-1]]):
+        for length in lengths if self._full_sampling else [lengths[-1]]:
             elements = [random_clifford(self.num_qubits, seed=seed) for _ in range(length)]
             element_lengths = [len(elements)] if self._full_sampling else lengths
             circuits += self._generate_circuit(elements, element_lengths)
@@ -113,7 +113,7 @@ def _generate_circuit(self, elements, lengths):
             circ_op = circ_op.compose(group_elt)
             circ.append(group_elt, qubits)
             circ.barrier(qubits)
-            if current_length+1 in lengths:
+            if current_length + 1 in lengths:
                 # copy circuit and add inverse
                 inv = circ_op.adjoint()
                 rb_circ = circ.copy()
@@ -128,4 +128,4 @@ def _generate_circuit(self, elements, lengths):
                 }
                 rb_circ.measure_all()
                 circuits.append(rb_circ)
-        return circuits
\ No newline at end of file
+        return circuits

From 87b9de7fa22299e6f6d3ce65541efe3ba2fc176c Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Thu, 8 Apr 2021 09:17:30 +0300
Subject: [PATCH 05/16] Style fixes

---
 qiskit_experiments/randomized_benchmarking/__init__.py    | 2 ++
 qiskit_experiments/randomized_benchmarking/rb_analysis.py | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/qiskit_experiments/randomized_benchmarking/__init__.py b/qiskit_experiments/randomized_benchmarking/__init__.py
index 2a30da17fc..0ed14abb09 100644
--- a/qiskit_experiments/randomized_benchmarking/__init__.py
+++ b/qiskit_experiments/randomized_benchmarking/__init__.py
@@ -10,4 +10,6 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
+"""Randomized Benchmarking Experiment Classes."""
+
 from .rb_experiment import RBExperiment, RBAnalysis
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 4c2c5bb291..c9e768339d 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -29,7 +29,7 @@
 class RBAnalysis(CurveFitAnalysis):
     """RB Analysis class."""
 
-    # pylint: disable = arguments-differ
+    # pylint: disable = arguments-differ, invalid-name
     def _run_analysis(
         self,
         experiment_data,

From bf58824fb7049fe0c05ac03a25d72a362868cd71 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Tue, 13 Apr 2021 14:34:02 +0300
Subject: [PATCH 06/16] Analysis now works directly with curve_fit functions

---
 qiskit_experiments/__init__.py                |  2 +
 .../randomized_benchmarking/rb_analysis.py    | 98 +++++++++++--------
 .../randomized_benchmarking/rb_experiment.py  |  2 +-
 3 files changed, 58 insertions(+), 44 deletions(-)

diff --git a/qiskit_experiments/__init__.py b/qiskit_experiments/__init__.py
index eb4560cf67..72116c35dd 100644
--- a/qiskit_experiments/__init__.py
+++ b/qiskit_experiments/__init__.py
@@ -19,3 +19,5 @@
 
 # Experiment modules
 from . import composite
+from . import analysis
+from . import randomized_benchmarking
\ No newline at end of file
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index c9e768339d..229693687b 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -16,7 +16,9 @@
 from typing import Optional, List
 
 import numpy as np
-from qiskit_experiments.analysis.curve_fit_analysis import CurveFitAnalysis
+from qiskit_experiments.base_analysis import BaseAnalysis
+from qiskit_experiments.analysis.curve_fitting import curve_fit
+from qiskit_experiments.analysis.data_processing import level2_probability, mean_xy_data, filter_data
 
 try:
     from matplotlib import pyplot as plt
@@ -26,7 +28,7 @@
     HAS_MATPLOTLIB = False
 
 
-class RBAnalysis(CurveFitAnalysis):
+class RBAnalysis(BaseAnalysis):
     """RB Analysis class."""
 
     # pylint: disable = arguments-differ, invalid-name
@@ -49,59 +51,69 @@ def _run_analysis(
                    AnalysisResult objects, and ``figures`` may be
                    None, a single figure, or a list of figures.
         """
-        # TODO: Get from experiment level metadata
-        num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
+        self._num_qubits = len(experiment_data.data[0]["metadata"]["qubits"])
+        xdata, ydata, ydata_sigma = self._extract_data(experiment_data)
 
-        # Fit function
         def fit_fun(x, a, alpha, b):
             return a * alpha ** x + b
 
-        # Initial guess function
-        # NOTE: I don't think this is a good guess function
-        # its just inserted as a place holder for one
-        # pylint: disable = unused-argument
-        def p0_func(xdata, ydata, sigma=None):
-            xmin = np.min(xdata)
-            y_mean_min = np.mean(ydata[xdata == xmin])
-
-            xmax = np.max(xdata)
-            y_mean_max = np.mean(ydata[xdata == xmax])
-
-            b_guess = 1 / (2 ** num_qubits)
-            a_guess = 1 - b_guess
-            alpha_guess = np.exp(
-                np.log((y_mean_min - b_guess) / (y_mean_max - b_guess)) / (xmin - xmax)
-            )
-            # Make sure alpha guess is feasible
-            alpha_guess = max(min(alpha_guess, 1), 0)
-            return [a_guess, alpha_guess, b_guess]
-
-        # Run CurveFitAnalysis
-        analysis_result, figs = super()._run_analysis(
-            experiment_data,
-            fit_fun,
-            p0=p0,
-            p0_func=p0_func,
-            bounds=([0, 0, 0], [1, 1, 1]),
-            fit_mean_data=True,
-            plot=plot,
-            ax=ax,
-        )
+        p0 = self._p0(xdata, ydata)
+
+        analysis_result = curve_fit(fit_fun, xdata, ydata, p0, ydata_sigma, bounds=([0, 0, 0], [1, 1, 1]))
 
         # Add EPC data
         popt = analysis_result["popt"]
         popt_err = analysis_result["popt_err"]
-        scale = (2 ** num_qubits - 1) / (2 ** num_qubits)
+        scale = (2 ** self._num_qubits - 1) / (2 ** self._num_qubits)
         analysis_result["EPC"] = scale * (1 - popt[1])
         analysis_result["EPC_err"] = scale * popt_err[1] / popt[1]
         analysis_result["plabels"] = ["A", "alpha", "B"]
 
-        # Format figure
-        if figs is not None:
-            self._format_plot(figs[0], analysis_result)
-            # TODO: figure out what to do with plots
-            plt.show()
-        return analysis_result, figs
+        return analysis_result, None
+        # # Format figure
+        # if figs is not None:
+        #     self._format_plot(figs[0], analysis_result)
+        #     # TODO: figure out what to do with plots
+        #     plt.show()
+
+    def _p0(self, xdata, ydata):
+        fit_guess = [0.95, 0.99, 1 / 2 ** self._num_qubits]
+        # Use the first two points to guess the decay param
+        dcliff = (xdata[1] - xdata[0])
+        dy = ((ydata[1] - fit_guess[2]) / (ydata[0] - fit_guess[2]))
+        alpha_guess = dy ** (1 / dcliff)
+        if alpha_guess < 1.0:
+            fit_guess[1] = alpha_guess
+
+        if ydata[0] > fit_guess[2]:
+            fit_guess[0] = ((ydata[0] - fit_guess[2]) /
+                            fit_guess[1] ** xdata[0])
+
+        return fit_guess
+
+    def _extract_data(self, experiment_data, **filters):
+        """Extract the base data for the fitter from the experiment data.
+        Args:
+            data: the experiment data to analyze
+        Returns:
+            tuple: ``(xdata, ydata, ydata_sigma)`` , where
+               ``xdata`` is an array of unique x-values, ``ydata`` is an array of
+               sample mean y-values, and ``ydata_sigma`` is an array of sample standard
+               deviation of y values.
+        """
+        data = filter_data(experiment_data.data, **filters)
+        size = len(data)
+        xdata = np.zeros(size, dtype=int)
+        ydata = np.zeros(size, dtype=float)
+        ydata_var = np.zeros(size, dtype=float)
+        for i, datum in enumerate(data):
+            metadata = datum['metadata']
+            xdata[i] = metadata['xdata']
+            ydata[i], ydata_var[i] = level2_probability(datum, metadata['ylabel'])
+
+        ydata_sigma = np.sqrt(ydata_var)
+        xdata, ydata, ydata_sigma = mean_xy_data(xdata, ydata, ydata_sigma)
+        return (xdata, ydata, ydata_sigma)
 
     @classmethod
     def _format_plot(cls, ax, analysis_result, add_label=True):
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index 0ba579d02c..50b06bdbef 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -121,7 +121,7 @@ def _generate_circuit(self, elements, lengths):
                 rb_circ.barrier(qubits)
                 rb_circ.metadata = {
                     "experiment_type": self._type,
-                    "xdata": current_length,
+                    "xdata": current_length + 1,
                     "ylabel": self.num_qubits * "0",
                     "group": "Clifford",
                     "qubits": self.physical_qubits,

From 23aad0d327909af2057cab267ab1a61ad7d25052 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Tue, 13 Apr 2021 17:19:08 +0300
Subject: [PATCH 07/16] Added plotting (ad-hoc solution for now)

---
 .../randomized_benchmarking/rb_analysis.py          | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 229693687b..a796b63f6b 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -19,6 +19,7 @@
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.analysis.curve_fitting import curve_fit
 from qiskit_experiments.analysis.data_processing import level2_probability, mean_xy_data, filter_data
+from qiskit_experiments.analysis.plotting import plot_curve_fit
 
 try:
     from matplotlib import pyplot as plt
@@ -58,8 +59,8 @@ def fit_fun(x, a, alpha, b):
             return a * alpha ** x + b
 
         p0 = self._p0(xdata, ydata)
-
-        analysis_result = curve_fit(fit_fun, xdata, ydata, p0, ydata_sigma, bounds=([0, 0, 0], [1, 1, 1]))
+        analysis_result = curve_fit(fit_fun, xdata, ydata, p0, ydata_sigma,
+                                    bounds=([0, 0, 0], [1, 1, 1]), absolute_sigma=False)
 
         # Add EPC data
         popt = analysis_result["popt"]
@@ -69,12 +70,10 @@ def fit_fun(x, a, alpha, b):
         analysis_result["EPC_err"] = scale * popt_err[1] / popt[1]
         analysis_result["plabels"] = ["A", "alpha", "B"]
 
+        fig = plot_curve_fit(fit_fun, analysis_result)
+        self._format_plot(fig, analysis_result)
+        analysis_result.plt = plt
         return analysis_result, None
-        # # Format figure
-        # if figs is not None:
-        #     self._format_plot(figs[0], analysis_result)
-        #     # TODO: figure out what to do with plots
-        #     plt.show()
 
     def _p0(self, xdata, ydata):
         fit_guess = [0.95, 0.99, 1 / 2 ** self._num_qubits]

From 6dcd05265c4e1516599dd034b80526228c60b176 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Wed, 14 Apr 2021 10:38:16 +0300
Subject: [PATCH 08/16] Linting

---
 .../randomized_benchmarking/__init__.py       |   3 +-
 .../randomized_benchmarking/rb_analysis.py    |  39 +-
 .../randomized_benchmarking/rb_example.ipynb  | 397 ++++++++----------
 3 files changed, 209 insertions(+), 230 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/__init__.py b/qiskit_experiments/randomized_benchmarking/__init__.py
index 0ed14abb09..8a359dcc72 100644
--- a/qiskit_experiments/randomized_benchmarking/__init__.py
+++ b/qiskit_experiments/randomized_benchmarking/__init__.py
@@ -12,4 +12,5 @@
 
 """Randomized Benchmarking Experiment Classes."""
 
-from .rb_experiment import RBExperiment, RBAnalysis
+from .rb_experiment import RBExperiment
+from .rb_analysis import RBAnalysis
diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index a796b63f6b..4b0db9f201 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -18,7 +18,11 @@
 import numpy as np
 from qiskit_experiments.base_analysis import BaseAnalysis
 from qiskit_experiments.analysis.curve_fitting import curve_fit
-from qiskit_experiments.analysis.data_processing import level2_probability, mean_xy_data, filter_data
+from qiskit_experiments.analysis.data_processing import (
+    level2_probability,
+    mean_xy_data,
+    filter_data,
+)
 from qiskit_experiments.analysis.plotting import plot_curve_fit
 
 try:
@@ -32,7 +36,7 @@
 class RBAnalysis(BaseAnalysis):
     """RB Analysis class."""
 
-    # pylint: disable = arguments-differ, invalid-name
+    # pylint: disable = arguments-differ, invalid-name, attribute-defined-outside-init
     def _run_analysis(
         self,
         experiment_data,
@@ -59,8 +63,15 @@ def fit_fun(x, a, alpha, b):
             return a * alpha ** x + b
 
         p0 = self._p0(xdata, ydata)
-        analysis_result = curve_fit(fit_fun, xdata, ydata, p0, ydata_sigma,
-                                    bounds=([0, 0, 0], [1, 1, 1]), absolute_sigma=False)
+        analysis_result = curve_fit(
+            fit_fun,
+            xdata,
+            ydata,
+            p0,
+            ydata_sigma,
+            bounds=([0, 0, 0], [1, 1, 1]),
+            absolute_sigma=False,
+        )
 
         # Add EPC data
         popt = analysis_result["popt"]
@@ -70,23 +81,23 @@ def fit_fun(x, a, alpha, b):
         analysis_result["EPC_err"] = scale * popt_err[1] / popt[1]
         analysis_result["plabels"] = ["A", "alpha", "B"]
 
-        fig = plot_curve_fit(fit_fun, analysis_result)
-        self._format_plot(fig, analysis_result)
-        analysis_result.plt = plt
+        if plot:
+            fig = plot_curve_fit(fit_fun, analysis_result, ax=ax)
+            self._format_plot(fig, analysis_result)
+            analysis_result.plt = plt
         return analysis_result, None
 
     def _p0(self, xdata, ydata):
         fit_guess = [0.95, 0.99, 1 / 2 ** self._num_qubits]
         # Use the first two points to guess the decay param
-        dcliff = (xdata[1] - xdata[0])
-        dy = ((ydata[1] - fit_guess[2]) / (ydata[0] - fit_guess[2]))
+        dcliff = xdata[1] - xdata[0]
+        dy = (ydata[1] - fit_guess[2]) / (ydata[0] - fit_guess[2])
         alpha_guess = dy ** (1 / dcliff)
         if alpha_guess < 1.0:
             fit_guess[1] = alpha_guess
 
         if ydata[0] > fit_guess[2]:
-            fit_guess[0] = ((ydata[0] - fit_guess[2]) /
-                            fit_guess[1] ** xdata[0])
+            fit_guess[0] = (ydata[0] - fit_guess[2]) / fit_guess[1] ** xdata[0]
 
         return fit_guess
 
@@ -106,9 +117,9 @@ def _extract_data(self, experiment_data, **filters):
         ydata = np.zeros(size, dtype=float)
         ydata_var = np.zeros(size, dtype=float)
         for i, datum in enumerate(data):
-            metadata = datum['metadata']
-            xdata[i] = metadata['xdata']
-            ydata[i], ydata_var[i] = level2_probability(datum, metadata['ylabel'])
+            metadata = datum["metadata"]
+            xdata[i] = metadata["xdata"]
+            ydata[i], ydata_var[i] = level2_probability(datum, metadata["ylabel"])
 
         ydata_sigma = np.sqrt(ydata_var)
         xdata, ydata, ydata_sigma = mean_xy_data(xdata, ydata, ydata_sigma)
diff --git a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
index f81152cbfa..f5fe382492 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
+++ b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
@@ -1,218 +1,185 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Standard RB Demo\n",
-    "\n",
-    "This is a very basic implemention of a standard RB experiment\n",
-    "\n",
-    "*NOTE: the circuit generation code of this demo is quite slow*"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import qiskit_experiments as qe\n",
-    "rb = qe.randomized_benchmarking\n",
-    "\n",
-    "# For simulation\n",
-    "from qiskit.test.mock import FakeParis\n",
-    "backend = FakeParis()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "# Standard RB Demo\n",
+                "\n",
+                "This is a very basic implemention of a standard RB experiment\n",
+                "\n",
+                "*NOTE: the circuit generation code of this demo is quite slow*",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import numpy as np\n",
+                "import qiskit_experiments as qe\n",
+                "rb = qe.randomized_benchmarking\n",
+                "\n",
+                "# For simulation\n",
+                "from qiskit.test.mock import FakeParis\n",
+                "backend = FakeParis()",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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\n",
+                        "text/plain": ["<Figure size 432x288 with 1 Axes>"],
+                    },
+                    "metadata": {"needs_background": "light"},
+                    "output_type": "display_data",
+                },
+                {
+                    "ename": "AttributeError",
+                    "evalue": "'ExperimentData' object has no attribute 'add_figure'",
+                    "output_type": "error",
+                    "traceback": [
+                        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+                        "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+                        "\u001b[0;32m<ipython-input-3-2049cb33e2e1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Run an RB experiment on qubit 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mexp1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRBExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mexpdata1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexp1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# View result data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+                        "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, experiment_data, **kwargs)\u001b[0m\n\u001b[1;32m    136\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m             \u001b[0;31m# pylint: disable = not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    139\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    140\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+                        "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     71\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m                     \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+                        "\u001b[0;31mAttributeError\u001b[0m: 'ExperimentData' object has no attribute 'add_figure'",
+                    ],
+                },
+            ],
+            "source": [
+                "lengths = [1, 20, 40, 60, 80, 100]\n",
+                "num_samples = 10\n",
+                "seed = 1010\n",
+                "\n",
+                "# Run an RB experiment on qubit 0\n",
+                "exp1 = rb.RBExperiment([0], lengths, num_samples=num_samples, seed=seed)\n",
+                "expdata1 = exp1.run(backend)\n",
+                "\n",
+                "# View result data\n",
+                "expdata1",
+            ],
+        },
+        {"cell_type": "markdown", "metadata": {}, "source": ["## Running 1-qubit RB"]},
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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\n",
+                        "text/plain": ["<Figure size 432x288 with 1 Axes>"],
+                    },
+                    "metadata": {"needs_background": "light"},
+                    "output_type": "display_data",
+                },
+                {
+                    "ename": "AttributeError",
+                    "evalue": "'ExperimentData' object has no attribute 'add_figure'",
+                    "output_type": "error",
+                    "traceback": [
+                        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+                        "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+                        "\u001b[0;32m<ipython-input-2-55fcbd6a6a73>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Run an RB experiment on qubit 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mexp1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRBExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mexpdata1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexp1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# View result data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+                        "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, experiment_data, **kwargs)\u001b[0m\n\u001b[1;32m    136\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m             \u001b[0;31m# pylint: disable = not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    139\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    140\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+                        "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     71\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m                     \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+                        "\u001b[0;31mAttributeError\u001b[0m: 'ExperimentData' object has no attribute 'add_figure'",
+                    ],
+                },
+            ],
+            "source": [
+                "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
+                "num_samples = 10\n",
+                "seed = 1010\n",
+                "\n",
+                "# Run an RB experiment on qubit 0\n",
+                "exp1 = rb.RBExperiment([0], lengths, num_samples=num_samples, seed=seed)\n",
+                "expdata1 = exp1.run(backend)\n",
+                "\n",
+                "# View result data\n",
+                "expdata1",
+            ],
+        },
+        {"cell_type": "markdown", "metadata": {}, "source": ["## Running 2-qubit RB"]},
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "lengths = [1, 10, 20, 30, 40, 50, 80, 120, 160, 200]\n",
+                "num_samples = 10\n",
+                "seed = 1010\n",
+                "\n",
+                "# Run an RB experiment on qubits 0,\n",
+                "exp2 = rb.RBExperiment([0, 1], lengths, num_samples=num_samples, seed=seed)\n",
+                "expdata2 = exp2.run(backend)\n",
+                "\n",
+                "# View result data\n",
+                "expdata2",
+            ],
+        },
+        {"cell_type": "markdown", "metadata": {}, "source": ["## Running parallel RB experiments"]},
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
+                "num_samples = 10\n",
+                "seed1 = 1010\n",
+                "\n",
+                "exps = [rb.RBExperiment([i], lengths, num_samples=num_samples, seed=seed + i)\n",
+                "        for i in range(5)]\n",
+                "\n",
+                "par_exp = qe.composite.ParallelExperiment(exps)\n",
+                "par_expdata = par_exp.run(backend)\n",
+                "\n",
+                "# View result\n",
+                "par_expdata",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "#### Viewing sub experiment data\n",
+                "\n",
+                "The experiment data returned from a batched experiment also contains individual experiment data for each sub experiment which can be accessed using `experiment_data(index)`",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# Print sub-experiment data\n",
+                "for i in range(par_exp.num_experiments):\n",
+                "    print(par_expdata.component_experiment_data(i), '\\n')",
+            ],
+        },
+    ],
+    "metadata": {
+        "kernelspec": {"display_name": "qiskit-exp", "language": "python", "name": "qiskit-exp"},
+        "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.8.8",
+        },
     },
-    {
-     "ename": "AttributeError",
-     "evalue": "'ExperimentData' object has no attribute 'add_figure'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-3-2049cb33e2e1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Run an RB experiment on qubit 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mexp1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRBExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mexpdata1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexp1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# View result data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, experiment_data, **kwargs)\u001b[0m\n\u001b[1;32m    136\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m             \u001b[0;31m# pylint: disable = not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    139\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    140\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     71\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m                     \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mAttributeError\u001b[0m: 'ExperimentData' object has no attribute 'add_figure'"
-     ]
-    }
-   ],
-   "source": [
-    "lengths = [1, 20, 40, 60, 80, 100]\n",
-    "num_samples = 10\n",
-    "seed = 1010\n",
-    "\n",
-    "# Run an RB experiment on qubit 0\n",
-    "exp1 = rb.RBExperiment([0], lengths, num_samples=num_samples, seed=seed)\n",
-    "expdata1 = exp1.run(backend)\n",
-    "\n",
-    "# View result data\n",
-    "expdata1"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Running 1-qubit RB"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "ename": "AttributeError",
-     "evalue": "'ExperimentData' object has no attribute 'add_figure'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-2-55fcbd6a6a73>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Run an RB experiment on qubit 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mexp1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRBExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mexpdata1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexp1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# View result data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, experiment_data, **kwargs)\u001b[0m\n\u001b[1;32m    136\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m             \u001b[0;31m# pylint: disable = not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    139\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    140\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     71\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m                     \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mAttributeError\u001b[0m: 'ExperimentData' object has no attribute 'add_figure'"
-     ]
-    }
-   ],
-   "source": [
-    "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
-    "num_samples = 10\n",
-    "seed = 1010\n",
-    "\n",
-    "# Run an RB experiment on qubit 0\n",
-    "exp1 = rb.RBExperiment([0], lengths, num_samples=num_samples, seed=seed)\n",
-    "expdata1 = exp1.run(backend)\n",
-    "\n",
-    "# View result data\n",
-    "expdata1"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Running 2-qubit RB"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lengths = [1, 10, 20, 30, 40, 50, 80, 120, 160, 200]\n",
-    "num_samples = 10\n",
-    "seed = 1010\n",
-    "\n",
-    "# Run an RB experiment on qubits 0,\n",
-    "exp2 = rb.RBExperiment([0, 1], lengths, num_samples=num_samples, seed=seed)\n",
-    "expdata2 = exp2.run(backend)\n",
-    "\n",
-    "# View result data\n",
-    "expdata2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Running parallel RB experiments"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
-    "num_samples = 10\n",
-    "seed1 = 1010\n",
-    "\n",
-    "exps = [rb.RBExperiment([i], lengths, num_samples=num_samples, seed=seed + i)\n",
-    "        for i in range(5)]\n",
-    "\n",
-    "par_exp = qe.composite.ParallelExperiment(exps)\n",
-    "par_expdata = par_exp.run(backend)\n",
-    "\n",
-    "# View result\n",
-    "par_expdata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Viewing sub experiment data\n",
-    "\n",
-    "The experiment data returned from a batched experiment also contains individual experiment data for each sub experiment which can be accessed using `experiment_data(index)`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print sub-experiment data\n",
-    "for i in range(par_exp.num_experiments):\n",
-    "    print(par_expdata.component_experiment_data(i), '\\n')"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "qiskit-exp",
-   "language": "python",
-   "name": "qiskit-exp"
-  },
-  "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.8.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+    "nbformat": 4,
+    "nbformat_minor": 4,
 }

From 8f0ed8df5f45d8b0377146a9121e2452d1468e78 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Mon, 19 Apr 2021 18:53:56 +0300
Subject: [PATCH 09/16] Adding error bars to plots

---
 qiskit_experiments/randomized_benchmarking/rb_analysis.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 4b0db9f201..2f5aeb1d18 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -23,7 +23,7 @@
     mean_xy_data,
     filter_data,
 )
-from qiskit_experiments.analysis.plotting import plot_curve_fit
+from qiskit_experiments.analysis.plotting import plot_curve_fit, plot_scatter, plot_errorbar
 
 try:
     from matplotlib import pyplot as plt
@@ -82,8 +82,10 @@ def fit_fun(x, a, alpha, b):
         analysis_result["plabels"] = ["A", "alpha", "B"]
 
         if plot:
-            fig = plot_curve_fit(fit_fun, analysis_result, ax=ax)
-            self._format_plot(fig, analysis_result)
+            ax = plot_curve_fit(fit_fun, analysis_result, ax=ax)
+            ax = plot_scatter(xdata, ydata, ax=ax)
+            ax = plot_errorbar(xdata, ydata, ydata_sigma, ax=ax)
+            self._format_plot(ax, analysis_result)
             analysis_result.plt = plt
         return analysis_result, None
 

From cadb1ac2afa7fb0472917490229ce2decc6aed72 Mon Sep 17 00:00:00 2001
From: Yael Ben-Haim <yaelbh@il.ibm.com>
Date: Tue, 13 Apr 2021 08:41:11 +0300
Subject: [PATCH 10/16] fixed link in readme (#15)

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index b94753113d..ccf2b6e4cb 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ and analysis of experiments on noisy quantum computers.
 
 ## Contribution Guidelines
 
-If you'd like to contribute to Qiskit Terra, please take a look at our
+If you'd like to contribute to Qiskit Experiments, please take a look at our
 [contribution guidelines](CONTRIBUTING.md). This project adheres to Qiskit's
 [code of conduct](CODE_OF_CONDUCT.md). By participating, you are expected to
 uphold this code.
@@ -27,7 +27,7 @@ For questions that are more suited for a forum we use the Qiskit tag in the
 
 ## Authors and Citation
 
-Qiskit Experiments is the work of [many people](https://github.com/Qiskit/qiskit-terra/graphs/contributors) who contribute
+Qiskit Experiments is the work of [many people](https://github.com/Qiskit/qiskit-experiments/graphs/contributors) who contribute
 to the project at different levels. If you use Qiskit, please cite as per the included [BibTeX file](https://github.com/Qiskit/qiskit/blob/master/Qiskit.bib).
 
 ## License

From 637ffed2f4aa4a7c325f6f5faf6edf50174713b3 Mon Sep 17 00:00:00 2001
From: "Christopher J. Wood" <cjwood@us.ibm.com>
Date: Mon, 19 Apr 2021 11:35:24 -0400
Subject: [PATCH 11/16] Curve fitting analysis helper functions (#19)

* Add CurveFitAnalysis class

* Get outcome label from metadata

* Fix import error message if no matplotlib

* Add option for fitting means of batched data sets

* Reorganize helper functions into separate file

* Add curve_fit, multi_curve_fit, and plotting functions for xy data

* Refactor example CurveFitAnalysis class to use library functions

* Add curve fitting data

* Remove CurveFitAnalysis class and leave as library functions

* Linting

* Clean up curve_fit_data

* Remove unneeded check for meas level now that data processor function is an arg
* Add optional kwargs for x and series metadata keys for extracting data

* Run black

* Add filters to curve fit data

* Reorganize files

* Move curve_fit_data and mutli_curve_fit_data to curve_fitting.py
* Move other processing functions to `data_processing.py`

* Remove unneeded init import

* Initial review edits

* Separate x and series data for multi curve fit

Rename curve_fit_data to process_curve_data
Rename multi_curve_fit_data to process_multi_curve_data

* Allow passing p0, and bounds as dict to curve fit

* Add sigma to mean_xy_data

If sigma is provided the mean and variance is computed using inverse-variance weighting, otherwise it is computed as the sample mean and biased sample variance.

* Set default absolute_sigma = True

* Fix logical check on np array

* Use reduced chi-squared calculation

* fixup data processing

* Fix error in level2_probabilities multiplying by shots instead of dividing
* Add explicit method kwarg for mean_xy_data

* Add basic tests for curve fitting

* More review edits

* Change chisq -> reduced_chisq in result and docs
* add dof (degrees of freedom) to returned results
* add documentation about sigma by default being absolute sigma.

Co-authored-by: Helena Zhang <helena@astbb.com>
---
 qiskit_experiments/analysis/__init__.py       |  15 +
 qiskit_experiments/analysis/curve_fitting.py  | 304 ++++++++++++++++++
 .../analysis/data_processing.py               | 145 +++++++++
 qiskit_experiments/analysis/plotting.py       | 201 ++++++++++++
 requirements.txt                              |   1 +
 test/test_curve_fitting.py                    | 110 +++++++
 6 files changed, 776 insertions(+)
 create mode 100644 qiskit_experiments/analysis/__init__.py
 create mode 100644 qiskit_experiments/analysis/curve_fitting.py
 create mode 100644 qiskit_experiments/analysis/data_processing.py
 create mode 100644 qiskit_experiments/analysis/plotting.py
 create mode 100644 test/test_curve_fitting.py

diff --git a/qiskit_experiments/analysis/__init__.py b/qiskit_experiments/analysis/__init__.py
new file mode 100644
index 0000000000..b26812a6d9
--- /dev/null
+++ b/qiskit_experiments/analysis/__init__.py
@@ -0,0 +1,15 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Analysis helper functions
+"""
diff --git a/qiskit_experiments/analysis/curve_fitting.py b/qiskit_experiments/analysis/curve_fitting.py
new file mode 100644
index 0000000000..b2d2e83801
--- /dev/null
+++ b/qiskit_experiments/analysis/curve_fitting.py
@@ -0,0 +1,304 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Curve fitting functions for experiment analysis
+"""
+# pylint: disable = invalid-name
+
+from typing import List, Dict, Tuple, Callable, Optional, Union
+
+import numpy as np
+import scipy.optimize as opt
+from qiskit.exceptions import QiskitError
+from qiskit_experiments.base_analysis import AnalysisResult
+from qiskit_experiments.analysis.data_processing import filter_data
+
+
+def curve_fit(
+    func: Callable,
+    xdata: np.ndarray,
+    ydata: np.ndarray,
+    p0: Union[Dict[str, float], np.ndarray],
+    sigma: Optional[np.ndarray] = None,
+    bounds: Optional[Union[Dict[str, Tuple[float, float]], Tuple[np.ndarray, np.ndarray]]] = None,
+    **kwargs,
+) -> AnalysisResult:
+    r"""Perform a non-linear least squares to fit
+
+    This solves the optimization problem
+
+    .. math::
+        \Theta_{\mbox{opt}} = \arg\min_\Theta \sum_i
+            \sigma_i^{-2} (f(x_i, \Theta) -  y_i)^2
+
+    using ``scipy.optimize.curve_fit``.
+
+    Args:
+        func: a fit function `f(x, *params)`.
+        xdata: a 1D float array of x-data.
+        ydata: a 1D float array of y-data.
+        p0: initial guess for optimization parameters.
+        sigma: Optional, a 1D array of standard deviations in ydata
+               in absolute units.
+        bounds: Optional, lower and upper bounds for optimization
+                parameters.
+        kwargs: additional kwargs for scipy.optimize.curve_fit.
+
+    Returns:
+        result containing ``popt`` the optimal fit parameters,
+        ``popt_err`` the standard error estimates popt,
+        ``pcov`` the covariance matrix for the fit,
+        ``reduced_chisq`` the reduced chi-squared parameter of fit,
+        ``dof`` the degrees of freedom of the fit,
+        ``xrange`` the range of xdata values used for fit.
+
+    Raises:
+        QiskitError: if the number of degrees of freedom of the fit is
+                     less than 1.
+
+    .. note::
+        ``sigma`` is assumed to be specified in the same units as ``ydata``
+        (absolute units). If sigma is instead specified in relative units
+        the `absolute_sigma=False` kwarg of scipy curve_fit must be used.
+        This affects the returned covariance ``pcov`` and error ``popt_err``
+        parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq``
+        ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``.
+    """
+    # Format p0 parameters if specified as dictionary
+    if isinstance(p0, dict):
+        param_keys = list(p0.keys())
+        param_p0 = list(p0.values())
+
+        # Convert bounds
+        if bounds:
+            lower = [bounds[key][0] for key in param_keys]
+            upper = [bounds[key][1] for key in param_keys]
+            param_bounds = (lower, upper)
+        else:
+            param_bounds = None
+
+        # Convert fit function
+        def fit_func(x, *params):
+            return func(x, **dict(zip(param_keys, params)))
+
+    else:
+        param_keys = None
+        param_p0 = p0
+        param_bounds = bounds
+        fit_func = func
+
+    # Check the degrees of freedom is greater than 0
+    dof = len(ydata) - len(param_p0)
+    if dof < 1:
+        raise QiskitError(
+            "The number of degrees of freedom of the fit data and model "
+            " (len(ydata) - len(p0)) is less than 1"
+        )
+
+    # Override scipy.curve_fit default for absolute_sigma=True
+    # if sigma is specified.
+    if sigma is not None and "absolute_sigma" not in kwargs:
+        kwargs["absolute_sigma"] = True
+
+    # Run curve fit
+    # TODO: Add error handling so if fitting fails we can return an analysis
+    #       result containing this information
+    # pylint: disable = unbalanced-tuple-unpacking
+    popt, pcov = opt.curve_fit(
+        fit_func, xdata, ydata, sigma=sigma, p0=param_p0, bounds=param_bounds, **kwargs
+    )
+    popt_err = np.sqrt(np.diag(pcov))
+
+    # Calculate the reduced chi-squared for fit
+    yfits = fit_func(xdata, *popt)
+    residues = (yfits - ydata) ** 2
+    if sigma is not None:
+        residues = residues / (sigma ** 2)
+    reduced_chisq = np.sum(residues) / dof
+
+    # Compute xdata range for fit
+    xdata_range = [min(xdata), max(xdata)]
+
+    result = {
+        "popt": popt,
+        "popt_keys": param_keys,
+        "popt_err": popt_err,
+        "pcov": pcov,
+        "reduced_chisq": reduced_chisq,
+        "dof": dof,
+        "xrange": xdata_range,
+    }
+
+    return AnalysisResult(result)
+
+
+def multi_curve_fit(
+    funcs: List[Callable],
+    series: np.ndarray,
+    xdata: np.ndarray,
+    ydata: np.ndarray,
+    p0: np.ndarray,
+    sigma: Optional[np.ndarray] = None,
+    weights: Optional[np.ndarray] = None,
+    bounds: Optional[Union[Dict[str, Tuple[float, float]], Tuple[np.ndarray, np.ndarray]]] = None,
+    **kwargs,
+) -> AnalysisResult:
+    r"""Perform a linearized multi-objective non-linear least squares fit.
+
+    This solves the optimization problem
+
+    .. math::
+        \Theta_{\mbox{opt}} = \arg\min_\Theta \sum_{k} w_k
+            \sum_{i} \sigma_{k, i}^{-2}
+            (f_k(x_{k, i}, \Theta) -  y_{k, i})^2
+
+    for multiple series of :math:`x_k, y_k, \sigma_k` data evaluated using
+    a list of objective functions :math:`[f_k]`
+    using ``scipy.optimize.curve_fit``.
+
+    Args:
+        funcs: a list of objective functions :math:`[f_0, f_1, ...]` where
+               each function has signature :math`f_k`(x, *params)`.
+        series: a 1D int array that specifies the component objective
+                function :math:`f_k` to evaluate corresponding x and y
+                data with.
+        xdata: a 1D float array of xdata.
+        ydata: a 1D float array of ydata.
+        p0: initial guess for optimization parameters.
+        sigma: Optional, a 1D array of standard deviations in ydata
+               in absolute units.
+        weights: Optional, a 1D float list of weights :math:`w_k` for each
+                 component function :math:`f_k`.
+        bounds: Optional, lower and upper bounds for optimization
+                parameters.
+        kwargs: additional kwargs for scipy.optimize.curve_fit.
+
+    Returns:
+        result containing ``popt`` the optimal fit parameters,
+        ``popt_err`` the standard error estimates popt,
+        ``pcov`` the covariance matrix for the fit,
+        ``reduced_chisq`` the reduced chi-squared parameter of fit,
+        ``dof`` the degrees of freedom of the fit,
+        ``xrange`` the range of xdata values used for fit.
+
+    Raises:
+        QiskitError: if the number of degrees of freedom of the fit is
+                     less than 1.
+
+    .. note::
+        ``sigma`` is assumed to be specified in the same units as ``ydata``
+        (absolute units). If sigma is instead specified in relative units
+        the `absolute_sigma=False` kwarg of scipy curve_fit must be used.
+        This affects the returned covariance ``pcov`` and error ``popt_err``
+        parameters via ``pcov(absolute_sigma=False) = pcov * reduced_chisq``
+        ``popt_err(absolute_sigma=False) = popt_err * sqrt(reduced_chisq)``.
+    """
+    num_funcs = len(funcs)
+
+    # Get positions for indexes data sets
+    series = np.asarray(series, dtype=int)
+    idxs = [series == i for i in range(num_funcs)]
+
+    # Combine weights and sigma for transformation
+    if weights is None:
+        wsigma = sigma
+    else:
+        wsigma = np.zeros(ydata.size)
+        if sigma is None:
+            for i in range(num_funcs):
+                wsigma[idxs[i]] = 1 / np.sqrt(weights[i])
+        else:
+            for i in range(num_funcs):
+                wsigma[idxs[i]] = sigma[idxs[i]] / np.sqrt(weights[i])
+
+    # Define multi-objective function
+    def f(x, *params):
+        y = np.zeros(x.size)
+        for i in range(num_funcs):
+            xi = x[idxs[i]]
+            yi = funcs[i](xi, *params)
+            y[idxs[i]] = yi
+        return y
+
+    # Run linearized curve_fit
+    analysis_result = curve_fit(f, xdata, ydata, p0, sigma=wsigma, bounds=bounds, **kwargs)
+
+    return analysis_result
+
+
+def process_curve_data(
+    data: List[Dict[str, any]], data_processor: Callable, x_key: str = "xval", **filters
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Return tuple of arrays (x, y, sigma) data for curve fitting.
+
+    Args
+        data: list of circuit data dictionaries containing counts.
+        data_processor: callable for processing data to y, sigma
+        x_key: key for extracting xdata value from metadata (Default: "xval").
+        filters: additional kwargs to filter metadata on.
+
+    Returns:
+        tuple: ``(x, y, sigma)`` tuple of arrays of x-values,
+               y-values, and standard deviations of y-values.
+    """
+    filtered_data = filter_data(data, **filters)
+    size = len(filtered_data)
+    xdata = np.zeros(size, dtype=float)
+    ydata = np.zeros(size, dtype=float)
+    ydata_var = np.zeros(size, dtype=float)
+
+    for i, datum in enumerate(filtered_data):
+        metadata = datum["metadata"]
+        xdata[i] = metadata[x_key]
+        y_mean, y_var = data_processor(datum)
+        ydata[i] = y_mean
+        ydata_var[i] = y_var
+
+    return xdata, ydata, np.sqrt(ydata_var)
+
+
+def process_multi_curve_data(
+    data: List[Dict[str, any]],
+    data_processor: Callable,
+    x_key: str = "xval",
+    series_key: str = "series",
+    **filters,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Return tuple of arrays (series, x, y, sigma) data for multi curve fitting.
+
+    Args
+        data: list of circuit data dictionaries.
+        data_processor: callable for processing data to y, sigma
+        x_key: key for extracting xdata value from metadata (Default: "xval").
+        series_key: key for extracting series value from metadata (Default: "series").
+        filters: additional kwargs to filter metadata on.
+
+    Returns:
+        tuple: ``(series, x, y, sigma)`` tuple of arrays of series values,
+               x-values, y-values, and standard deviations of y-values.
+    """
+    filtered_data = filter_data(data, **filters)
+    size = len(filtered_data)
+    series = np.zeros(size, dtype=int)
+    xdata = np.zeros(size, dtype=float)
+    ydata = np.zeros(size, dtype=float)
+    ydata_var = np.zeros(size, dtype=float)
+
+    for i, datum in enumerate(filter_data):
+        metadata = datum["metadata"]
+        series[i] = metadata[series_key]
+        xdata[i] = metadata[x_key]
+        y_mean, y_var = data_processor(datum)
+        ydata[i] = y_mean
+        ydata_var[i] = y_var
+
+    return series, xdata, ydata, np.sqrt(ydata_var)
diff --git a/qiskit_experiments/analysis/data_processing.py b/qiskit_experiments/analysis/data_processing.py
new file mode 100644
index 0000000000..89cb8e299e
--- /dev/null
+++ b/qiskit_experiments/analysis/data_processing.py
@@ -0,0 +1,145 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Data processing utility functions for curve fitting experiments
+"""
+# pylint: disable = invalid-name
+
+from typing import List, Dict, Tuple, Optional
+import numpy as np
+from qiskit.exceptions import QiskitError
+
+
+def filter_data(data: List[Dict[str, any]], **filters) -> List[Dict[str, any]]:
+    """Return the list of filtered data
+
+    Args:
+        data: list of data dicts.
+        filters: kwargs for filtering based on metadata
+                 values.
+
+    Returns:
+        The list of filtered data. If no filters are provided this will be the
+        input list.
+    """
+    if not filters:
+        return data
+    filtered_data = []
+    for datum in data:
+        include = True
+        metadata = datum["metadata"]
+        for key, val in filters.items():
+            if key not in metadata or metadata[key] != val:
+                include = False
+                break
+        if include:
+            filtered_data.append(datum)
+    return filtered_data
+
+
+def mean_xy_data(
+    xdata: np.ndarray, ydata: np.ndarray, sigma: Optional[np.ndarray] = None, method: str = "sample"
+) -> Tuple[np.ndarray]:
+    r"""Return (x, y_mean, sigma) data.
+
+    The mean is taken over all ydata values with the same xdata value using
+    the specified method. For each x the mean :math:`\overline{y}` and variance
+    :math:`\sigma^2` are computed as
+
+    * ``"sample"`` (default) *Sample mean and variance*
+      :math:`\overline{y} = \sum_{i=1}^N y_i / N`,
+      :math:`\sigma^2 = \sum_{i=1}^N ((\overline{y} - y_i)^2) / N`
+    * ``"iwv"`` *Inverse-weighted variance*
+      :math:`\overline{y} = (\sum_{i=1}^N y_i / \sigma_i^2 ) \sigma^2`
+      :math:`\sigma^2 = 1 / (\sum_{i=1}^N 1 / \sigma_i^2)`
+
+    Args
+        xdata: 1D or 2D array of xdata from curve_fit_data or
+               multi_curve_fit_data
+        ydata: array of ydata returned from curve_fit_data or
+               multi_curve_fit_data
+        sigma: Optional, array of standard deviations in ydata.
+        method: The method to use for computing y means and
+                standard deviations sigma (default: "sample").
+
+    Returns:
+        tuple: ``(x, y_mean, sigma)`` if ``return_raw==False``, where
+               ``x`` is an arrays of unique x-values, ``y`` is an array of
+               sample mean y-values, and ``sigma`` is an array of sample standard
+               deviation of y values.
+
+    Raises:
+        QiskitError: if "ivw" method is used without providing a sigma.
+    """
+    x_means = np.unique(xdata, axis=0)
+    y_means = np.zeros(x_means.size)
+    y_sigmas = np.zeros(x_means.size)
+
+    # Sample mean and variance method
+    if method == "sample":
+        for i in range(x_means.size):
+            # Get positions of y to average
+            idxs = xdata == x_means[i]
+            ys = ydata[idxs]
+
+            # Compute sample mean and biased sample variance
+            y_means[i] = np.mean(ys)
+            y_sigmas[i] = np.mean((y_means[i] - ys) ** 2)
+
+        return x_means, y_means, y_sigmas
+
+    # Inverse-weighted variance method
+    if method == "iwv":
+        if sigma is None:
+            raise QiskitError(
+                "The inverse-weighted variance method cannot be used with" " `sigma=None`"
+            )
+        for i in range(x_means.size):
+            # Get positions of y to average
+            idxs = xdata == x_means[i]
+            ys = ydata[idxs]
+
+            # Compute the inverse-variance weighted y mean and variance
+            weights = 1 / sigma[idxs] ** 2
+            y_var = 1 / np.sum(weights)
+            y_means[i] = y_var * np.sum(weights * ys)
+            y_sigmas[i] = np.sqrt(y_var)
+
+        return x_means, y_means, y_sigmas
+
+    # Invalid method
+    raise QiskitError(f"Unsupported method {method}")
+
+
+def level2_probability(data: Dict[str, any], outcome: str) -> Tuple[float]:
+    """Return the outcome probability mean and variance.
+
+    Args:
+        data: A data dict containing count data.
+        outcome: bitstring for desired outcome probability.
+
+    Returns:
+        tuple: (p_mean, p_var) of the probability mean and variance
+               estimated from the counts.
+
+    .. note::
+
+        This assumes a binomial distribution where :math:`K` counts
+        of the desired outcome from :math:`N` shots the
+        mean probability is :math:`p = K / N` and the variance is
+        :math:`\\sigma^2 = p (1-p) / N`.
+    """
+    counts = data["counts"]
+    shots = sum(counts.values())
+    p_mean = counts.get(outcome, 0.0) / shots
+    p_var = p_mean * (1 - p_mean) / shots
+    return p_mean, p_var
diff --git a/qiskit_experiments/analysis/plotting.py b/qiskit_experiments/analysis/plotting.py
new file mode 100644
index 0000000000..bd9312e17a
--- /dev/null
+++ b/qiskit_experiments/analysis/plotting.py
@@ -0,0 +1,201 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Plotting functions for experiment analysis
+"""
+import functools
+from typing import Callable, Optional
+import numpy as np
+
+from qiskit_experiments.base_analysis import AnalysisResult
+
+try:
+    from matplotlib import pyplot as plt
+
+    HAS_MATPLOTLIB = True
+except ImportError:
+    HAS_MATPLOTLIB = False
+
+
+def requires_matplotlib(func):
+    """Decorator for functions requiring matplotlib"""
+
+    @functools.wraps(func)
+    def wrapped(*args, **kwargs):
+        if not HAS_MATPLOTLIB:
+            raise ImportError(
+                f"{func} requires matplotlib to generate curve fit plot."
+                ' Run "pip install matplotlib" before.'
+            )
+        return func(*args, **kwargs)
+
+    return wrapped
+
+
+@requires_matplotlib
+def plot_curve_fit(
+    func: Callable,
+    result: AnalysisResult,
+    confidence_interval: bool = True,
+    ax: Optional["AxesSubplot"] = None,
+    num_fit_points: int = 100,
+    labelsize: int = 14,
+    grid: bool = True,
+    **kwargs,
+) -> "AxesSubplot":
+    """Generate plot of a curve fit analysis result.
+
+    Wraps ``matplotlib.pyplot.plot``.
+
+    Args:
+        func: the fit funcion for curve_fit.
+        result: an AnalysisResult from curve_fit.
+        confidence_interval: if True plot the confidence interval from popt_err.
+        ax: Optional, a matplotlib axes to add the plot to.
+        num_fit_points: the number of points to plot for xrange.
+        labelsize: label size for plot
+        grid: Show grid on plot.
+        **kwargs: Additional options for matplotlib.pyplot.plot
+
+    Returns:
+        AxesSubPlot: the matplotlib axes containing the plot.
+
+    Raises:
+        ImportError: if matplotlib is not installed.
+    """
+    if ax is None:
+        plt.figure()
+        ax = plt.gca()
+
+    # Result data
+    popt = result["popt"]
+    popt_err = result["popt_err"]
+    xmin, xmax = result["xrange"]
+
+    # Default plot options
+    plot_opts = kwargs.copy()
+    if "color" not in plot_opts:
+        plot_opts["color"] = "blue"
+    if "linestyle" not in plot_opts:
+        plot_opts["linestyle"] = "-"
+    if "linewidth" not in plot_opts:
+        plot_opts["linewidth"] = 2
+
+    # Plot fit data
+    xs = np.linspace(xmin, xmax, num_fit_points)
+    ys_fit = func(xs, *popt)
+    ax.plot(xs, ys_fit, **plot_opts)
+
+    # Plot standard error interval
+    if confidence_interval:
+        ys_upper = func(xs, *(popt + popt_err))
+        ys_lower = func(xs, *(popt - popt_err))
+        ax.fill_between(xs, ys_lower, ys_upper, alpha=0.1, color=plot_opts["color"])
+
+    # Formatting
+    ax.tick_params(labelsize=labelsize)
+    ax.grid(grid)
+    return ax
+
+
+@requires_matplotlib
+def plot_scatter(
+    xdata: np.ndarray,
+    ydata: np.ndarray,
+    ax: Optional["AxesSubplot"] = None,
+    labelsize: int = 14,
+    grid: bool = True,
+    **kwargs,
+) -> "AxesSubplot":
+    """Generate a scatter plot of xy data.
+
+    Wraps ``matplotlib.pyplot.scatter``.
+
+    Args:
+        xdata: xdata used for fitting
+        ydata: ydata used for fitting
+        ax: Optional, a matplotlib axes to add the plot to.
+        labelsize: label size for plot
+        grid: Show grid on plot.
+        **kwargs: Additional options for matplotlib.pyplot.scatter
+
+    Returns:
+        AxesSubPlot: the matplotlib axes containing the plot.
+    """
+    if ax is None:
+        plt.figure()
+        ax = plt.gca()
+
+    # Default plot options
+    plot_opts = kwargs.copy()
+    if "c" not in plot_opts:
+        plot_opts["c"] = "grey"
+    if "marker" not in plot_opts:
+        plot_opts["marker"] = "x"
+
+    # Plot data
+    ax.scatter(xdata, ydata, **plot_opts)
+
+    # Formatting
+    ax.tick_params(labelsize=labelsize)
+    ax.grid(grid)
+    return ax
+
+
+@requires_matplotlib
+def plot_errorbar(
+    xdata: np.ndarray,
+    ydata: np.ndarray,
+    sigma: Optional[np.ndarray] = None,
+    ax: Optional["AxesSubplot"] = None,
+    labelsize: int = 14,
+    grid: bool = True,
+    **kwargs,
+) -> "AxesSubplot":
+    """Generate an errorbar plot of xy data.
+
+    Wraps ``matplotlib.pyplot.errorbar``
+
+    Args:
+        xdata: xdata used for fitting
+        ydata: ydata used for fitting
+        sigma: Optional, standard deviation of ydata
+        ax: Optional, a matplotlib axes to add the plot to.
+        labelsize: label size for plot
+        grid: Show grid on plot.
+        **kwargs: Additional options for matplotlib.pyplot.scatter
+
+    Returns:
+        AxesSubPlot: the matplotlib axes containing the plot.
+    """
+    if ax is None:
+        plt.figure()
+        ax = plt.gca()
+
+    # Default plot options
+    plot_opts = kwargs.copy()
+    if "color" not in plot_opts:
+        plot_opts["color"] = "red"
+    if "marker" not in plot_opts:
+        plot_opts["marker"] = "."
+    if "markersize" not in plot_opts:
+        plot_opts["markersize"] = 9
+    if "linestyle" not in plot_opts:
+        plot_opts["linestyle"] = "--"
+
+    # Plot data
+    ax.errorbar(xdata, ydata, yerr=sigma, **plot_opts)
+
+    # Formatting
+    ax.tick_params(labelsize=labelsize)
+    ax.grid(grid)
+    return ax
diff --git a/requirements.txt b/requirements.txt
index fb0a5a9e9a..9fa126e95f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,3 @@
 numpy>=1.17
+scipy>=1.4
 qiskit-terra>=0.16.0
diff --git a/test/test_curve_fitting.py b/test/test_curve_fitting.py
new file mode 100644
index 0000000000..be180d09e9
--- /dev/null
+++ b/test/test_curve_fitting.py
@@ -0,0 +1,110 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Test version string generation."""
+
+import numpy as np
+from qiskit.test import QiskitTestCase
+from qiskit import QuantumCircuit, execute
+from qiskit.providers.basicaer import QasmSimulatorPy
+from qiskit_experiments.analysis.curve_fitting import curve_fit, multi_curve_fit, process_curve_data
+from qiskit_experiments.analysis.data_processing import level2_probability
+
+
+class TestCurveFitting(QiskitTestCase):
+    """Test curve fitting functions."""
+
+    def simulate_experiment_data(self, thetas, shots=1024):
+        """Generate experiment data for Ry rotations"""
+        circuits = []
+        for theta in thetas:
+            qc = QuantumCircuit(1)
+            qc.ry(theta, 0)
+            qc.measure_all()
+            circuits.append(qc)
+
+        sim = QasmSimulatorPy()
+        result = execute(circuits, sim, shots=shots, seed_simulator=10).result()
+        data = [
+            {"counts": result.get_counts(i), "metadata": {"xval": theta}}
+            for i, theta in enumerate(thetas)
+        ]
+        return data
+
+    @property
+    def objective0(self):
+        """Objective function for P0"""
+
+        def func0(x, omega):
+            return np.cos(omega * x) ** 2
+
+        return np.vectorize(func0)
+
+    @property
+    def objective1(self):
+        """Objective function for P0"""
+
+        def func1(x, omega):
+            return np.sin(omega * x) ** 2
+
+        return np.vectorize(func1)
+
+    @staticmethod
+    def data_processor_p0(data):
+        """Return P(0) probabilities"""
+        return level2_probability(data, "0")
+
+    @staticmethod
+    def data_processor_p1(data):
+        """Return P(1) probabilities"""
+        return level2_probability(data, "1")
+
+    def test_process_curve_data(self):
+        """Test version string generation."""
+        thetas = thetas = np.linspace(0.5, 4 * np.pi - 0.5, 20)
+        data = self.simulate_experiment_data(thetas)
+        xdata, ydata, _ = process_curve_data(data, data_processor=self.data_processor_p0)
+
+        xdiff = thetas - xdata
+        ydiff = self.objective0(xdata, 0.5) - ydata
+        self.assertTrue(np.allclose(xdiff, 0))
+        self.assertTrue(np.allclose(ydiff, 0, atol=0.05))
+
+    def test_curve_fit(self):
+        """Test curve_fit function"""
+        thetas = thetas = np.linspace(0.5, 4 * np.pi - 0.5, 20)
+        data = self.simulate_experiment_data(thetas)
+        xdata, ydata, sigma = process_curve_data(data, data_processor=self.data_processor_p0)
+        p0 = [0.6]
+        bounds = ([0], [2])
+        sol = curve_fit(self.objective0, xdata, ydata, p0, sigma=sigma, bounds=bounds)
+        self.assertTrue(abs(sol["popt"][0] - 0.5) < 0.05)
+
+    def test_multi_curve_fit(self):
+        """Test multi_curve_fit function"""
+        thetas = thetas = np.linspace(0.5, 4 * np.pi - 0.5, 20)
+        data = self.simulate_experiment_data(thetas)
+        xdata0, ydata0, sigma0 = process_curve_data(data, data_processor=self.data_processor_p0)
+        xdata1, ydata1, sigma1 = process_curve_data(data, data_processor=self.data_processor_p1)
+
+        # Combine curve data
+        xdata = np.concatenate([xdata0, xdata1])
+        series = np.concatenate([np.zeros(len(xdata0)), np.ones(len(xdata1))])
+        ydata = np.concatenate([ydata0, ydata1])
+        sigma = np.concatenate([sigma0, sigma1])
+
+        p0 = [0.6]
+        bounds = ([0], [2])
+        sol = multi_curve_fit(
+            [self.objective0, self.objective1], series, xdata, ydata, p0, sigma=sigma, bounds=bounds
+        )
+        self.assertTrue(abs(sol["popt"][0] - 0.5) < 0.05)

From c7c19f985605534323dfd65a99605ef0d2b836da Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Mon, 19 Apr 2021 19:39:47 +0300
Subject: [PATCH 12/16] Example notebook

---
 .../randomized_benchmarking/rb_example.ipynb  | 603 ++++++++++++------
 1 file changed, 421 insertions(+), 182 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
index f5fe382492..950e97d95c 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
+++ b/qiskit_experiments/randomized_benchmarking/rb_example.ipynb
@@ -1,185 +1,424 @@
 {
-    "cells": [
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# Standard RB Demo\n",
-                "\n",
-                "This is a very basic implemention of a standard RB experiment\n",
-                "\n",
-                "*NOTE: the circuit generation code of this demo is quite slow*",
-            ],
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 1,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import numpy as np\n",
-                "import qiskit_experiments as qe\n",
-                "rb = qe.randomized_benchmarking\n",
-                "\n",
-                "# For simulation\n",
-                "from qiskit.test.mock import FakeParis\n",
-                "backend = FakeParis()",
-            ],
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 3,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png": "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\n",
-                        "text/plain": ["<Figure size 432x288 with 1 Axes>"],
-                    },
-                    "metadata": {"needs_background": "light"},
-                    "output_type": "display_data",
-                },
-                {
-                    "ename": "AttributeError",
-                    "evalue": "'ExperimentData' object has no attribute 'add_figure'",
-                    "output_type": "error",
-                    "traceback": [
-                        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-                        "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-                        "\u001b[0;32m<ipython-input-3-2049cb33e2e1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Run an RB experiment on qubit 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mexp1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRBExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mexpdata1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexp1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# View result data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-                        "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, experiment_data, **kwargs)\u001b[0m\n\u001b[1;32m    136\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m             \u001b[0;31m# pylint: disable = not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    139\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    140\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-                        "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     71\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m                     \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-                        "\u001b[0;31mAttributeError\u001b[0m: 'ExperimentData' object has no attribute 'add_figure'",
-                    ],
-                },
-            ],
-            "source": [
-                "lengths = [1, 20, 40, 60, 80, 100]\n",
-                "num_samples = 10\n",
-                "seed = 1010\n",
-                "\n",
-                "# Run an RB experiment on qubit 0\n",
-                "exp1 = rb.RBExperiment([0], lengths, num_samples=num_samples, seed=seed)\n",
-                "expdata1 = exp1.run(backend)\n",
-                "\n",
-                "# View result data\n",
-                "expdata1",
-            ],
-        },
-        {"cell_type": "markdown", "metadata": {}, "source": ["## Running 1-qubit RB"]},
-        {
-            "cell_type": "code",
-            "execution_count": 2,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png": "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\n",
-                        "text/plain": ["<Figure size 432x288 with 1 Axes>"],
-                    },
-                    "metadata": {"needs_background": "light"},
-                    "output_type": "display_data",
-                },
-                {
-                    "ename": "AttributeError",
-                    "evalue": "'ExperimentData' object has no attribute 'add_figure'",
-                    "output_type": "error",
-                    "traceback": [
-                        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-                        "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
-                        "\u001b[0;32m<ipython-input-2-55fcbd6a6a73>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Run an RB experiment on qubit 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mexp1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRBExperiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlengths\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mexpdata1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexp1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# View result data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-                        "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_experiment.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, backend, experiment_data, **kwargs)\u001b[0m\n\u001b[1;32m    136\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m             \u001b[0;31m# pylint: disable = not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__analysis_class__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexperiment_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    139\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    140\u001b[0m         \u001b[0;31m# Return the ExperimentData future\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-                        "\u001b[0;32m~/miniconda3/envs/qiskit-exp-dev/lib/python3.8/site-packages/qiskit_experiments/base_analysis.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, experiment_data, save, return_figures, **options)\u001b[0m\n\u001b[1;32m     71\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m                     \u001b[0mexperiment_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mreturn_figures\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0manalysis_results\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigures\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-                        "\u001b[0;31mAttributeError\u001b[0m: 'ExperimentData' object has no attribute 'add_figure'",
-                    ],
-                },
-            ],
-            "source": [
-                "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
-                "num_samples = 10\n",
-                "seed = 1010\n",
-                "\n",
-                "# Run an RB experiment on qubit 0\n",
-                "exp1 = rb.RBExperiment([0], lengths, num_samples=num_samples, seed=seed)\n",
-                "expdata1 = exp1.run(backend)\n",
-                "\n",
-                "# View result data\n",
-                "expdata1",
-            ],
-        },
-        {"cell_type": "markdown", "metadata": {}, "source": ["## Running 2-qubit RB"]},
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "lengths = [1, 10, 20, 30, 40, 50, 80, 120, 160, 200]\n",
-                "num_samples = 10\n",
-                "seed = 1010\n",
-                "\n",
-                "# Run an RB experiment on qubits 0,\n",
-                "exp2 = rb.RBExperiment([0, 1], lengths, num_samples=num_samples, seed=seed)\n",
-                "expdata2 = exp2.run(backend)\n",
-                "\n",
-                "# View result data\n",
-                "expdata2",
-            ],
-        },
-        {"cell_type": "markdown", "metadata": {}, "source": ["## Running parallel RB experiments"]},
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
-                "num_samples = 10\n",
-                "seed1 = 1010\n",
-                "\n",
-                "exps = [rb.RBExperiment([i], lengths, num_samples=num_samples, seed=seed + i)\n",
-                "        for i in range(5)]\n",
-                "\n",
-                "par_exp = qe.composite.ParallelExperiment(exps)\n",
-                "par_expdata = par_exp.run(backend)\n",
-                "\n",
-                "# View result\n",
-                "par_expdata",
-            ],
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "#### Viewing sub experiment data\n",
-                "\n",
-                "The experiment data returned from a batched experiment also contains individual experiment data for each sub experiment which can be accessed using `experiment_data(index)`",
-            ],
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# Print sub-experiment data\n",
-                "for i in range(par_exp.num_experiments):\n",
-                "    print(par_expdata.component_experiment_data(i), '\\n')",
-            ],
-        },
-    ],
-    "metadata": {
-        "kernelspec": {"display_name": "qiskit-exp", "language": "python", "name": "qiskit-exp"},
-        "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.8.8",
-        },
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Standard RB Demo\n",
+    "\n",
+    "This is a very basic implemention of a standard RB experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import qiskit_experiments as qe\n",
+    "rb = qe.randomized_benchmarking\n",
+    "\n",
+    "# For simulation\n",
+    "from qiskit.test.mock import FakeParis\n",
+    "backend = FakeParis()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running 1-qubit RB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "---------------------------------------------------\n",
+       "Experiment: RBExperiment\n",
+       "Experiment ID: ad68c446-7cb4-4b89-8c75-520b0b83902d\n",
+       "Status: COMPLETE\n",
+       "Circuits: 140\n",
+       "Analysis Results: 1\n",
+       "---------------------------------------------------\n",
+       "Last Analysis Result\n",
+       "- popt: [0.39686901 0.9968324  0.56018556]\n",
+       "- popt_keys: None\n",
+       "- popt_err: [0.00930198 0.00012858 0.00957537]\n",
+       "- pcov: [[ 8.65267737e-05  1.15558772e-06 -8.88173704e-05]\n",
+       " [ 1.15558772e-06  1.65327564e-08 -1.20201428e-06]\n",
+       " [-8.88173704e-05 -1.20201428e-06  9.16877962e-05]]\n",
+       "- reduced_chisq: 388.46076795461363\n",
+       "- dof: 11\n",
+       "- xrange: [1, 500]\n",
+       "- EPC: 0.0015838000563520027\n",
+       "- EPC_err: 6.449417510365912e-05\n",
+       "- plabels: ['A', 'alpha', 'B']"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
     },
-    "nbformat": 4,
-    "nbformat_minor": 4,
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
+    "num_samples = 10\n",
+    "seed = 1010\n",
+    "\n",
+    "# Run an RB experiment on qubit 0\n",
+    "exp1 = rb.RBExperiment([0], lengths, num_samples=num_samples, seed=seed)\n",
+    "expdata1 = exp1.run(backend)\n",
+    "\n",
+    "# View result data\n",
+    "expdata1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running 2-qubit RB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "---------------------------------------------------\n",
+       "Experiment: RBExperiment\n",
+       "Experiment ID: c133cf63-fd67-4d52-97c1-b505b099add4\n",
+       "Status: COMPLETE\n",
+       "Circuits: 100\n",
+       "Analysis Results: 1\n",
+       "---------------------------------------------------\n",
+       "Last Analysis Result\n",
+       "- popt: [0.64596559 0.96140732 0.28422628]\n",
+       "- popt_keys: None\n",
+       "- popt_err: [0.00487162 0.00058143 0.00209837]\n",
+       "- pcov: [[ 2.37327077e-05 -1.87697724e-08 -3.52987578e-06]\n",
+       " [-1.87697724e-08  3.38058778e-07 -9.09663098e-07]\n",
+       " [-3.52987578e-06 -9.09663098e-07  4.40313680e-06]]\n",
+       "- reduced_chisq: 532.6350849004282\n",
+       "- dof: 7\n",
+       "- xrange: [1, 200]\n",
+       "- EPC: 0.028944510776536536\n",
+       "- EPC_err: 0.000453575875974297\n",
+       "- plabels: ['A', 'alpha', 'B']"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lengths = [1, 10, 20, 30, 40, 50, 80, 120, 160, 200]\n",
+    "num_samples = 10\n",
+    "seed = 1010\n",
+    "\n",
+    "# Run an RB experiment on qubits 0,\n",
+    "exp2 = rb.RBExperiment([0, 1], lengths, num_samples=num_samples, seed=seed)\n",
+    "expdata2 = exp2.run(backend)\n",
+    "\n",
+    "# View result data\n",
+    "expdata2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running parallel RB experiments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "---------------------------------------------------\n",
+       "Experiment: ParallelExperiment\n",
+       "Experiment ID: d670490f-77d8-4110-ac7f-f4e611963cac\n",
+       "Status: COMPLETE\n",
+       "Component Experiments: 5\n",
+       "Circuits: 140\n",
+       "Analysis Results: 1\n",
+       "---------------------------------------------------\n",
+       "Last Analysis Result\n",
+       "- experiment_types: ['RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment', 'RBExperiment']\n",
+       "- experiment_ids: ['38052c41-b1de-4044-a7ea-351116323acb', 'deff9141-4adb-4a2a-9c26-8f1dd56d7533', 'd0d62d02-9613-4ddd-9acc-128867b66d9d', '37ad5eb7-d7eb-4e65-b46e-276b8ff8e1de', 'ea5ac2b9-3082-433a-bc06-0b636f9ff700']\n",
+       "- experiment_qubits: [(0,), (1,), (2,), (3,), (4,)]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEPCAYAAAC+35gCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABbmklEQVR4nO2dd3xUVfbAv2eSTCYFAqH3gAUBK6AiFsCGCmJfC/aCvaz7WxXX3staUGEVC1hBBddFEQWlSlNAsSMCCUU6CIT05Pz+uDPJZEjCSyMhOd/P532Sd9999507hHfm3tNEVTEMwzAML/hqWgDDMAxj78GUhmEYhuEZUxqGYRiGZ0xpGIZhGJ4xpWEYhmF4JrqmBahOmjZtqikpKRW6d+fOnSQkJFStQLUcm3P9wOZcP6jMnBcuXLhJVZuVdK1OK42UlBQWLFhQoXunT59O3759q1agWo7NuX5gc64fVGbOIpJW2jXbnjIMwzA8U6dXGkbdJiUlhbS0Ur8QGcYeoUOHDqSmpta0GHsMUxrGXktaWhqW0cCoaUSkpkXYo9j2lGEYhuEZUxqGYRiGZ0xpGIZhGJ4xpWEYhmF4xpSGYVSAESNG0LFjRwKBAD169GDWrFm7vWf48OF06dKFuLg4OnfuzFtvvVXsem5uLg899BD77LMPgUCAQw45hM8//3yXcdauXctll11Gs2bNCAQCdO3alRkzZhReT09P5+abb6Zt27aFz3ruuecqP+ndsHLlSk4//XQSEhJo2rQpt9xyCzk5OWXek52dzc0330zTpk1JSEhg0KBBrF69utzjzpgxgx49ehAIBOjUqRMvv/xyseszZ85k0KBBtGnTBhFh9OjRVTLneomq1tmjR48eWlGmTZum27ZV+Pa9kmnTptW0COXC/fnuecaOHavR0dE6cuRI/eWXX/Smm27ShIQETUtLK/WeESNGaEJCgr733nu6bNkyHTNmjCYmJuqECRMK+9xxxx3asmVL/fTTT3XZsmU6YsQIDQQCumjRosI+W7du1Y4dO+oll1yi8+fP1+XLl+uXX36pv/zyS2Gfa665Rjt27KhTp07VFStW6Jtvvql+v1/feustz3McNWqU9unTx3P/vLw8PfDAA7VPnz66cOFCnTx5srZq1UpvuummMu+77rrrtFWrVjp58mRduHCh9unTRw855BDNy8vzPO7y5cs1Pj5eb7rpJv3ll1905MiRGh0drePGjSvsM3HiRB06dKh++OGHGhcXp6NGjfI8t91RU3+Hu6My/5+BBVrKe7XGX+zVeVRGaUydOk1/+UXrleKob0ojPT1dr7nmGm3YsKE2adJE7777bt2xY4fGx8drampqqfcdccQRevXVVxdr23ffffWuu+4q9Z6jjjpKb7vttmJtt99+ux599NGF561atdLnn3++WJ+zzz5bBw8eXHg+dOhQ7d27d5nz6tatm953333F2o477ji98cYby7wvnPIqjc8++0xFRFeuXFnY9vbbb2tsbKxuK+U/0V9//aUxMTH6zjvvFLatXLlSRUQ///xzz+Pecccduu+++xYb+6qrrtJevXqV+NyEhARTGruhLKVh21O74c8/ISOjpqUwqoMrr7ySqVOn8uWXXzJmzBiGDRvGTTfdxAEHHECHDh0ASE1NLbadkZOTw8KFCzn55JOLjXXyySczZ86cUp+VnZ1NIBAo1hYXF8c333xDbm5umX2+/vrrwvOPP/6YI488kvPPP5/mzZtz6KGH8tJLLxWLVznmmGP45JNPWLVqFQBz5szh+++/55RTTinnJ+SduXPn0qVLF9q1a1fY1r9/f7Kzs1m4cGGJ9yxcuJDc3Nxin2W7du3o0qVL4WfpZdy5c+fu8u/Rv39/FixYUPjZGlWHKY0yiIqC+HhYvRqys2taGqMq2bRpEx9++CH3338/hx9+OCeddBJ/+9vfePPNNznrrLMK+8XExNC5c2eSkpIK78vPz6dFixbFxmvRogXr1q0r9Xn9+/fnjTfe4Ntvv0VVWbBgAa+99hq5ubls2rSpsM/zzz/PkiVLKCgoYMqUKXz00UesXbu2cJzly5czYsQIOnXqxBdffMGtt97KXXfdxfDhwwv7vPDCCxxyyCG0b9+emJgY+vTpw5NPPsnAgQNLlW/WrFkkJiYWHtddd90ubY899lip969bt26Xz6Rp06ZERUWV+rmsW7eOqKgomjZtWupn6WXckvq0aNGCvLy8ws/WqDo8R4SLyGXAhUB7IBBxWVV1n6oUrLYQHQ1+v1Mc7dtDTExNS2RUBX/88QeqylFHHVXYduSRRzJq1CjOPvvswrY2bdrw22+/Vfp59957L+vWraN3796oKi1atOCyyy7jqaeewudz392GDRvGNddcQ9euXRER9tlnH6644greeOONwnEKCgro2bMnjz/+OACHHXYYS5cuZfjw4dx0000AvPjii8yZM4cJEybQoUMHZs6cyf/93/+RkpJS6mqjZ8+efP/994XnH330EePHj+fdd98tbEtOTq7052Ds/XhaaYjIvcAooDXwPTAj4phZTfLVCvx+EHGKIz+/pqUxqoLY2FgA/H5/YVuLFi1o3LgxXbt2LfW+0Lfc9evXF2tfv349LVu2LPW+uLg43njjDTIyMkhNTWXlypWkpKTQoEEDmjVzGaibNWvGxx9/zM6dO0lLS+O3334jMTGRTp06FY7TqlWrXeTr0qULK1euBCAzM5OhQ4fy1FNPcfrpp3PwwQdz0003ccEFF/Dvf/+7TPn23XffwqN58+a7tJWlNFq2bLnLZxJalZX2ubRs2ZL8/PxdVgPhn6WXcUvqs379eqKjo3dZxRiVx+v21FXAMFU9WFUvUtUrIo/qFHJPE74/HDoPBJzC+PNPKCioIcGMKqNjx474fD6WLl1a2DZhwgS2bt3Ktm3bSr3P7/fTo0cPpkyZUqx9ypQp9O7de7fPjYmJoW3btkRFRTF27FgGDhxYuNIIEQgEaNOmDXl5eYwfP54zzjij8NrRRx/NkiVLivX//fffC20wubm55ObmEhUVVaxPVFQUBdX4h3vUUUfx66+/FnOXnTJlCrGxsfTo0aPEe3r06EFMTEyxz3L16tX8+uuvhZ+ll3GPOuqoEv89evbsSYxtDVQ9pVnIww9gB3C8l7616aiI99S0adN00qRJOuvD8Zo2do7+uehPHTdukk6YME3XrFFdskT1zz9VCwrKPXStp755T5177rl6/PHH686dO/W3337TBg0aaOvWrfXtt98u7LN69Wrt3LmzfvTRR4VtY8eO1ZiYGH311Vf1l19+0VtuuUUTEhKKeVxdcskleskllxSeL1myRN966y39/fffdf78+Xr++edrcnKyrlixorDPvHnzdPz48bps2TKdOXOmHn/88dqxY0fdunVrYZ9vvvlGo6Oj9ZFHHtGlS5fqBx98oA0bNtSXXnqpsE+fPn20W7duOm3aNF2+fLmOGjVKA4GAvvDCC6V+FtnZ2bp27doyjx07dpR6f8g1tl+/frpo0SKdMmWKtm7duphr7Pz587Vz5846f/78wrbrrrtO27Rpo1OmTNFFixZp3759S3S5LWvckMvtrbfeqr/88ou++uqrGhMTU8zldseOHfrdd9/pd999p3Fxcfrggw/qd999V6abtFcq+3dYXdSoyy3wKfB3L31r01FepVFQUKCTJk3S8Wedpbl+v+YlNtRcv1/Hn3WWjhs3SVevLtA1a1R/+0113bq6pzjqm9JYv369nnnmmZqcnKzJycn6zDPP6GeffaatW7fW+++/X1VVV6xYocAuLprDhw/XDh06qN/v1+7du+uMGTOKXe/Tp08xl9VffvlFDz30UI2Li9OGDRvqGWecob/99luxe6ZPn65dunTR2NhYbdKkiV5yySW6Zs2aXeT+9NNP9eCDD9bY2Fjdb7/9dNiwYVoQ9se4du1avfzyy7V169YaCAS0c+fO+vTTTxfrE8m0adMUKPMIfSalkZaWpgMGDNC4uDhNTk7Wm2++WbOysnZ5RvjfWVZWlt50002anJyscXFxOnDgwGLutV7GDX12hx12mPr9fk1JSdH//Oc/nuZ32WWXlTknL9Q3pSHuetmIyL7AR8C/gc+ALSWsWGrdpk3Pnj21vJX7dO1a8jt0JDq3yF0qz+9n47xUtEWrwrbt26FZM2jSpMrErXH2tupmIrLLVqJh7Glq699hJSv3LVTVniVd8+o99Xvw56hSrms5xqrVSGoqBdGxEKY0fLFxRK9KJTdMaTRoABs3Ou+qoDemYRhGncfri/4hnGKo82hKClH5WcXa8jMzyWuXUqxNBBITnWHc53NKxDAMo67jSWmo6gPVLEetQFX5YvFiMgYMYNDEieTlRRNbkMFv+fsxf95PnDqoZbEqXT6fUxxr1rgYjvj4GhTeMAxjD1DuiHARSRSRdiKSWB0C1SQiQiAQIH7IEOa9O4Y1b37JsLZPcZD+TMxd48nI2LWsY3jUeFZWCYMahmHUITwrDRHpLyILgL+AVOAvEflGRE6qJtlqhL59+9K/f39ymySTf8RRnDjpnzzR+Ale3H41110HeXm73hMdDbGxsGqVpRsxDKNu4zUivD8wEUgEHgZuAB4BGgCf1TXFEb4FlZwMx35yJyuSezJ1Kgy7+Q9KcpSIiXHHqlWwmxICRjVy+eWXIyK7HL169Srsk5KSUtgeHx/PgQceyMiRI4uNk5OTw9NPP81hhx1GfHw8ycnJ9OrVi1deeYXscn4z2F2th5LYkzUkfv/9d84++2waNWpEfHw83bt359dffy3XHMuL1d7Ye/G60ngAmAx0VdUHVfWVoJ2jGzAFeLB6xKsddOwIo0bBddGv8fiErkz8v2kl9vP7nZ1j9Wqw5Jo1x4knnsjatWuLHZ999lmxPvfddx9r167lhx9+4Mwzz+Taa6/l/fffB5zC6N+/P48++ihXXHEFs2fPZuHChdx+++2MGjWKuXPnepZlxYoVnHbaafTu3ZvvvvuOoUOHcvPNNzN+/PhS78nPz2fAgAHs2LGDWbNmMWbMGMaNG8c//vGPco2bnp7OgQceyLBhw4iLiytVvqOPPpqOHTsydepUfvrpJx555BESE73vPo8ePbpcrp1e5lcSt912G+PHj2fMmDHMmjWL7du3M3DgQPKDuX325OdWryktgCP8ADKAAaVcGwhkeBlnTx+VraexZInqmjVFx1vDtujPdNGtJOlbd/1c7Fr48ccfqitWqObmVvjxNUJdCO677LLLdMCAAWXe16FDB3366aeLte233356wQUXqKrqk08+qSKi33777S735ufnl1ofoiTKW+tBdc/WkLjwwgv1oosu8jqdEqnvtTdK+jusDdR0PY1soGEp1xoEr9d5Tji3MV/9YxKZxHHsE6cx/+O1JfaLi3N5qtassQSHewuBQKCw9sK7777LiSeeSM+eu8Y2+Xw+GjZ0/xVGjx6NiJCamlrquBWp9bCnakgUFBTwySef0LVrV0455RSaNWvG4YcfXrjiqi6s9sbejVelMR14WEQ6hjeKSHvc1lXJ+zV1kHNu78Cb535KMzbS4ebT+fG74n9oGjR4xMW5LSpLcLjn+fzzz4vVgUhMTOTOO+8ssW9eXh6jR4/mxx9/5IQTTgBg6dKldOnSZbfPSUpKonPnzmUmxatIrYc9VUNiw4YNpKen89hjj3HyySczZcoULrzwQgYPHszEiRNLvc9qb9RvvAb33QnMBpaIyDxgLdAS6IXzpir5f+ReTmkv+4uf68Hzaz7g57nbmHRxAZPfWkuKppLXLoW5yxfj9wfo0aMv8fGwcyesXQutWjl7h1H9HHfccbsYths1alTs/F//+hcPPPAA2dnZ+P1+/vnPf3LttdcCu2Y5Lo2zzjqrWMGmvY1Q1tszzjiD22+/HYBDDz2UBQsW8NJLLzFgwIAS77PaG/Ubr8F9v4vIwcA/gGOB7rj8U8OA51S15H2avRgRaNwYtm1zAXzh+Hxw0bunceaZmxn4wwccNOgaYhJj0ZwsZMAAcgYPcYm9REhIgPR0Uxx7kvj4ePbdd98y+9x+++1cddVVxMfH06pVq2Iec/vvv3+VeQ9VpNZDy5YtmT17drG26qgh0bRpU6Kjo0uszzF27NhS7wvV2QgRXnvDC17mV9I9odobofoj4OZ87LHHeh7Xam9UHs+vMFVdq6r/p6pHqup+wZ931EWFEaJZM7fNVFKN8NhYYdxLubzGNQTIJip9O9E5OQyaOJHenQ4p9hJKTHQrjvXrKdFd19jzNGnShH333ZfWrVsX+7cCuOiii/jyyy8pKdllQUEB27dv9/ycitR62FM1JPx+P4cffniZ9TmqA6u9sZdTmoW8LhyV8Z4KeR7k5qouW6a6fPmuXlIb/jdH8xIaqjpdoAqa1yBJN/xvToleVb/9prp2be1NqV5XvKdOPPHEXWpBbNiwobBPSd5T4WRlZemxxx6rjRo10mHDhul3332ny5cv1/Hjx+tRRx1V+Dl99NFH2rlzZ129enWpY3mp9fDiiy9q586dC8/3ZA2J//73vxoTE6OvvPKKLl26VEeOHKnR0dH66aefljonq71RnJL+DmsDe7yeBjAVOCDs97KOr0obpyaPqlAaqqrZ2aq//66allZcCfy56E/N9fuLKY1sidFV3/5Zqjvur7/W3locdUVpUELdhDZt2hT22Z3SUHWK44knntCDDz5YA4GANmrUSI888kh9+eWXNTs7W1WdqylQrJBSSeyu1sP999+/y1z2ZA2JUaNG6X777aeBQEAPOuggfe+998qcj9XeKE59Uxql1tMQkWnA9ar6m4hMZzdZblW1n6elzR6kIvU0QkTmos/MhLQ0t9Xk8zllO2/eF8i7Ixk0cSIaHSAqYwd5RHHD0V/wwNh++Hy75qoC2LEDGjWC5s2d7aS2YPU0DKP81Na/wz1eTyNcCahqxZ5ch4iLg9atXexFw4buD8XvD5AzeAgb7x1O9KpUFv3RgOn//JQ3ZvelwTPCP/9Z8lgNGsDWrU75NG1auxSHYRhGWXjynhKRS4GJqrq5hGvJwEBVfauqhattNGzoYi82bnS/9+jR1y3ZRMht0YqDesKaRt2Qa4T/Pb+cFBXOu6NjiWM1aACbg5+mKQ7DMPYWvHpPjQL2KeVaR0qv6FfnSE52rrjp6e480vPmlFOEfz9VwCeczmnDTuaT19aXMIpTEiHFsWmTeVUZhrF34FVplPU9OAEoIWF43USkyBU3M7PkPudf6GPeVa/RhjUcfv+pTBm3rdSxTHEYhrE3Uer2lIgcigviC3G6iBwY0S0OuABYWvWi1V58PmffWLXKFV4KBHbtc+pDR/HO5vFc8fEgtt92JrOSJnHsSbt2DFccYFtVhmHUbsqyaZwB3B/8XYF/ldJvM3BVVQq1NxAVBW3awMqVrn6G379rnwEvncroraO5ZsbFPHnVw8SOe5Qjjti1nymOitGhQ4ddtgcNY09TnYGQtZGylMbzwGjc1tRy4Gzgu4g+2cB6rY3+ZnuAmBho29a54vp8roJfOCJw6juDeeaCOB6efTK+S+GDD+Dgg3cdyxRH+Skru6xX9jY346rA5mxUhlJtGqq6TVXTVDUVZ+z+LHgefqyrrwojRGysUxwZGSWnQff54G9jzub40xMp2JHOJ+eM4rffiq6Hf3xm4zAMo7bjyRAeVBBWxLQU4uOdjWPnzpIz40ZFwQsvwGNtnmZ4xpV8O/ABNvxvLrJ+LfPmfcHChdML+4YUx5YtsGGDKQ7DMGoXnhMWisgQEflORDJEJD/yqE4h9wYaNoQWLZwrbkkv+pgYpfmTvVgccxB3Zj5I5xtOoNmRHZF3R5KTk1XiimPrVlMchmHULjwpjWBw34vAt0AAF5fxDrAdWAY8VJ6HisgNIrJCRLJEZKGIHLub/jeKyK8ikikiS4Ly1DoaN3a2iFAMRzgiQp+uh9INl1E0jkyic7MZ9Olnu2TFDdGwIfz1F6xbZ4rDMIzagdeVxm3A48D1wfMRqnoZ0AnIxHlQeUJEzsfV4XgMOAyYA0wKVgEsqf/1wJM4xdQN59E1XERO9/rMPUmTJi6vVEmKI3pVKr4I/9yMvFi2fZ9a6ngNGrhcVWvXWgVAwzBqHq9KYz9gJlAQPPwAqroVeBS4tRzPvB0YraqvquqvqnozrhLg9aX0vwR4VVXHqOpyVR0LjKSWVgsMBf8lJDgbRzh57VIoyM4q1hatuVz2QArrSw4cB1ySxFAhJ1MchmHUJF6VRibgC3pKrcOtMEKkA629DCIifqAHMDni0mSgdym3xQJZEW2ZwBEiUiurpvh8rkpfbGxRASdVZc7yxUwYMIA8v5+CBknkxcRyR4MnOGnl69x2dhobN5Y+ZmKiG2vNmpK9tAzDMPYEpaZGL9ZJ5CvgQ1V9WUTGAAcB1+DShwwHolS15JJbxcdpDawB+qjqzLD2+4DBqtq5hHsewwUPDgQW4JTOp0ALoLVGVA4UkSHAEIAWLVr0KKtsZVmkp6eTGFnntQLk5Dh7hM8HGRnpqBbQODuPuHVryWzZik2rd3DSP29hjbbmorafM/SZ1TRunFvqeAUFbjVTUjBhZamqOe9N2JzrBzbn8tGvX7/yp0aPYCRFq4t7gS+Br4PnO4AzKySZNx4GWuJsHwKsB94E7sBtlRVDVUcG5aVnz55a0YCeqgoGys116UZE3MpDVYsZvfdVZWNyRzpddTL/WX0+N9zzJW+OT6RJk9LHzMhwgYRt2+4aUFgZ6mMAlM25fmBzrjq8xmm8r6qPB3//A2eQ7g+cBeyrqtM9Pm8TkI9bJYTTArftVdKzM1X1SiAeSAHaA6k4ZVXGhk7tIBQ1np/vVh2RXlIiQlz/4/jz2fc5nG95bOm5DD4vpzAyvCTi4914K1c6pWQYhrGn8BynEY6q7lTVL1V1gqpuKsd9OcBC4KSISyfhVhJl3ZurqqtVNR+XJPFTVd0rzMJ+P7Rr55RGaS/52L+dwZ/3j+R4mUbikgX87W8uKrw04uLcz5UrITu76mU2DMMoibKy3JboAlsaqrrSY9dngbdF5BtgNnAdzpD+cvC5bwXHuzR4vj9wJDAPaIzzvjoQuKw88tU0sbFOcYS2qkraVooachVLjzyJzbe15/ff4LzzXK6qZs1KHjMQcApj5Uo3dknZdg3DMKqSsnbEU9lNXfAIorx0UtX3RaQJcA/QCvgJOE1V04JdIpVVFE5RdAZygWlA72BOrL2KuDi3VbVypXPJjSrhE2t8SHs++ADePvU9fL+v5txz7+CDD1y0eUnExjoje1qaUxzx8dU7B8Mw6jdlKY0rKZ/S8IyqjgBGlHKtb8T5r7ggwDpBfLxTHKtXl644mjWDf/X4nMafvs2WP5I555yr+OADoXXQsTnSmB4T41YvK1e6dO0NGuyhyRiGUe8oVWmo6ug9KEe9IjHRvdxXr3YveF8JlqXMl14neutGXpl9LeesaMr1Zx3Jmw+k0rh7CnOXL8bvD9CjR9/C/tHRTgmtWeNiRJKS9tx8DMOoP1TIEG5UngYNXGbc9PRSorxjYtgx6kO2dNqfDziXWas70vaaU0pNcghu1ZKY6CLHt2yxfFWGYVQ9nrz8ReSN3XRRVa131fsqS1KSe7GvW+eUyC45CxMSKXh9HDH9DkLIJqDZkAunf/oZm+4djpaQ5NDnc2Nt3Ah5eW6ry4o5GYZRVXgNDTueXe0byUAD4K/gYVSARo2c4li/vmTF4du+HU1sgKRvL2zLy/WxeupS2lzYqsQxRdyKY+tWF8/RokXJW2CGYRjlxWtwX4qqdow4koC+uKC8c6pTyLpO48bQvLnLZhu5pZTXLoWCnOKpt+LIpPX/XciWB19EMjNKHDNUk2PHDstXZRhG1VGp75/B/FHP4WptGJUgOdltJYUrjhKTHPr9vNboCpbTiQNH3kLj7ikE/vd+sbHCbR2JiZCdrRY9bhhGlVAVmYuWU4dcYmuSJk2cwti0KbRVJfj9AXIGD2HjvcOJXpVKXrsUGvz+A/f+51DyZ/zOv9IfR9KacxDg27yRxd9/TXp8HL07HVLYf/Hyxfh8AfLz+9KunYvtMAzDqAiVUhoiEg1cDqyuEmkMmjZ1P0OKo0ePvqgqKkJuC2fDOKZ5S3r3Fu6+uwWnvnMs0c/ACx3gkgUPc+I7r5Dati3NV61CAnEUZGchAwZQMHgIUVFKaqpYEKBhGBXGq/fU1BKa/cD+QBNcKhCjighluA1fcYQjIkRFwRNPuJKwI0bAjTdC1N9v5OJTNtBpwvsIQG4uPmDQxIlsvHc4GuvuW7nSYjkMw6gYXm0aPlxa8vBjB/ARcIKqvlo94tVPRJziaNq0ZON4eL+774a77nJ9rn22M6Mb3oomFA8J98XGEb0qFXBBgKFYjk2bLJbDMIzy4WmlEZnaw6h+QooDwlccJfe7+Wa3arj7bnjonY5c5csl3GxRkJ1JXruUwvNQLMfmzc44bi65hmF4xV4VtRivKw6ASy+F4cOVTVHNubpgJFm+APlBb6sJAwYwZ/niYl5VkS65eXl7YEKGYez1eFYaIrKfiLwpIr+LyM7gz9Eism91CljfEXFKI9IdtyTOOEO4994fGRe4kJSCFdzWeRJr35/NUWmrabxhwy62EXBbVTk5zs5hW1WGYewOT0pDRPoCi3F1uufhMtTOA04HfhSRPtUknxGkSRMXALh9e9kv92uuOYQPPogip3FLXlpwFFff34Zmf/zB0aNGlpLkyqVsF3HKI6PkWEHDMAzA+0rjGeA7oIOqXqqq/wwWSUoBvg9eN6qZ5GRnf9ixo9T3PwA9eggff+wSIk7+oRVDA88T++1sEkYPL/We2Nii9OrbtlW97IZh1A28Ko2uwJOqmh7eqKo7gCdxNcONPUBIcZSaHTfIvvvChAlwwAHw7w2X8JX/VBIfvYuolStKvSeUs2rtWpfw0LarDMOIxKvSWI2LyygJP7CmasQxvNC4sYuz2J3iaNUKPvoIevUSLs95hZ1ZUWTdcV+ZY4c8q7ZsgT//tJxVhmEUx6vSeBJ4UERahzeKSBvgfuCxqhbMKJukpKJ6HGW92JOS4N134eDT2jGAiXSfO5yPPy577JBnVWam267KyalS0Q3D2IvxqjT6AA2B5SIyXUTeF5HpwDIgEegrIm8FjzerSVYjgoYNXQXAnTvLdpkNBODll6HzVceyJa8hf78xm9H/3rTb7af4eLdFlZZmBnLDMBxec08dA+QBa4EOwYPgOcCxYX1tJ3wP0qABtGvnSsfGxbmI75KIioKHHoK2rQs49eHj2PxcE+7eNJGHH5FS7wGncPLyYNUqZ0tp1KhapmEYxl6C13oakbU0yjo6VbfQRnESEqB9e8jK2n368yHX+cg9bzCnMQl9+22uvNKtVMoiVH983TpXLKosO4phGHUbiwivI8TFOcWRkwPZ2WX37fTsTWw+4GhekFv5+au1nHOOUwhl4fO57bDt292qxiLIDaN+Up6I8HgRuUlEPhSRr4I/bxCRuOoU0PBOIOAUR0GBW3WUis9H3iuv0yAmi9HxN/Djj8rAgbB8ecJun5GQ4FYzqam7eYZhGHUSrxHhLYFFwAtATyA++PMlYJGItKg2CY1yERvrFAc476fSyN+3M+l3PMRxHVbS97BtrF0Lf//7YUydWrzyX0nExUFMjFMcFghoGPULr4bwp4DGwLGqOjvUKCK9gfE4l9zLq1w6o0LExDjFsWaN83oqreDSzmv+zqzuhzEk6xs6vHkQS75I5Y5LUzjtyq2cccYGevToW+YzoqJcIGBWlsuNZZlyDaPu4/W/+anA0HCFAaCqc4B7gAFVLZhROaKjoW1bt/IozdCtUVFkF+TR4J1hvPFlO76K6c8fug/Zry9kxIiO5OaWveIIBQJu3+68q6wGuWHUfbwqjUTgz1KurQ5eN2oZUVEujiMxseREhyJC706HcNoXX+DLzyc+dwfxZPIK1/Ld57FcdpnsdvtJxNk58vIsnsMw6gNelcYS4JJSrl0M/FY14hhVjc8HLVu6LLklpVaPXpUK8cUN4DHxMRzacAUzZsDpp8Py5bt/Tlwc+P0ugnzrVstbZRh1Fa9K49/AhSLypYhcKSKnisgVIvIFcBHwdPWJaFQWEWdzaN581wy5ee1SKMgu7gYVnbGdfz+dzwEHwLJlTnHMnLn750RHu+2q9eudrcPyVhlG3cNrcN87wHXAgcBrwETgdeBg4DpVfa/aJDSqjOTkonxVeXnOS2rO8sVMGDCAPL+f3PgE8qOjWd+sGX8kbuLjj5WTTlT++gsuvhjeeGP3KwgRF8+RkeG2q3YXM2IYxt6FZ38XVR0JtMalQT82+LONqr5aTbIZ1UDDhs6zKjMTcnMFvz+ADh7CxnmpfPfYk2z4ZiWz//MWUQ0a0SA6i082Hsnbx48iP1+591644w5vCQzj493WWGqqs6cYhlE3KFNpiMjlIvK9iKSLyGrcNtQyVZ2tqr+qqiWU2AuJj4cOHdxqo1u3vvTq1R9t0YptXbuhLVrRq1d/evToi++vLeD3c/HUK1m9bz8O9v/Ge+/B3/7m6m3sDr/fGcn//NPSjxhGXaFUpSEiFwFv4AL5JuKSE/4dS4NeJwgEnOLw+SArq3jt8FAt8YJWbdj80Uz+evpVWm1czHcFh/B0wgN8920up5wC33+/++eEpx+x7SrD2Pspa6VxK/BfoIuqnq+qhwMPAjeKSNQekc6oVmJiXIZcv9/ZOUrE5yPjoqvZMOM3sgadx3X7TqF7zyjWrYOzz4b33/f2rISgg1Zamm1XGcbeTFlKY3/gVVUN94EZAcQC7atVKmOPEYrlSEpy3k6lGboLmrXgrxffYfv4L3n/Qx83nrue57Kv59HbN3HPPd7sHLGxzjU3tF1l3lWGsfdRltJIArZEtIXOG1ePOEZN4PM5d9yYGOeSW+bLPC4Ovx8eOnEmQ3yv8RsHUDBqNOf/TdmwYffPioqy7SrD2JvZnfeUT0QKDyCqpPbgNWMvRsS90Fu3du6yu0sJknX6eWz+8nt8XQ5gNFfwxLfHc+OJS/j2W2/PS0go8q7ats2CAQ1jb2F3L/vZQG7YEcqbOj+i3apI1xFCLrk5ObtPfZ7XuRtZk2ey6t6R9Ij6nus2P8K553qL54Ai76q1a91hNToMo/ZTVpbbB/eYFEatIi7OeVbtLksuAD4fUdddw7ZBg/j+BR95b8N79/5C1ucbuHx037Lvpci7KjPTbVe1bu2ebxhG7aRUpaGqpjTqMX6/W3GsW+fsHImJbgurNKJat+AfT8B+vaHxTY9y/uz3GN/jclq9/TQpPZvu9nlxcW5LLC0NmjZ10euWat0wah/239IolZCNIzl515xVpTFoELT+7DX+0/huBm1/h/3POIDfhr7pab8qJsblrtqyxaVa9+KRZRjGnsWUhlEmoWSHrVq5WA4vNTP2OTCOE+c/yu39vmcJnTn+rcuZfO5IT55SIm5Vk58PK1aUnNLdMIyaw5SG4YmkJGfnyM31Vhs8IQHuersbMx6exZVRb3LDvEs44wxYN2upJz/bQKAoBcm6dWYkN4zagikNwzMhA7nPV3o1wHBE4PIrfZz3yaU0ax/Pbz/m0PjCU4g/6hD8c6YDu9YjDz8PGcl37nSuuV6eaRhG9WJKwygXofrjpVUDLIlDDoHPP4cTT/VznY5gy/ocmp7Xj5yLT2XR5A+Q9WuJWTAXWb+WefO+YOHC6cXuj493hvlVq2DDBkt8aBg1SVkut4ZRIqFqgLGx7iUeH+8KMJVFUhK8+iq88UZ/DnvoJ+7Me4R/TnualrOmEiOKBOIoyM5CBgwgZ/AQVLUwcSIUFXjats3ZVlq1Mtdcw6gJPK80RKSNiDwrIgtEZLmIHBhsv01EjizPQ0XkBhFZISJZIrJQRI7dTf+LginaM0RknYi8IyIty/NMo2oRcV5V7do5E4UXO4cIXHUVjJ0Qz8gOj3EiU4jOyycqNxffju1E5+QwaOJEenc6pJjCCL8/FEmelgabNtmqwzD2NJ6Uhoh0A37E1Qn/E+gA+IOXO+Ay4npCRM4HhuFSrB8GzAEmiUiJSRBF5GjgbeBNXOGnM4GuwLten2lUHwkJ5bNzQNF21ZHHxJJO8frkvugYV7e8DPz+ItfclSu9KSzDMKoGryuNZ4BfgY7A2UD418A5QK9yPPN2YLSqvhos5HQzrlbH9aX0PwpYrarPqeoKVZ0HvAiUa3VjVB+hQMCQncPLt/+GDeG2YSnERxX3pJKMncTO+Hy3xpKQa66qM5Jv2WKrDsPYE3hVGscAT6hqOhD5v3k94GmrSET8QA9gcsSlyUDvUm6bDbQSkdPF0RS4APjMo+zGHiBk52jRwls8h6oyd8ViPh10GrkxsezwJZFBgIV0p+GzD9H4skHIls27fW5srFt1bNrkVh2WNdcwqheJdHkssZPIdmCwqn4SLMCUC/RU1UUicjau7kYTD+O0BtYAfVR1Zlj7fcHxO5dy39nAaCAOZ7yfApyhqpkl9B0CDAFo0aJFj7Fjx+52fiWRnp5OYmJihe7dW6mqOasWRXOXlQokIyMd1QIaZ+cRvWodr089klGTunMzL/KM/B8rThhI2h23lOu5BQXOwyvKY5kw+3euH9icy0e/fv0WqmrPkq55VRpfAttV9ewSlMZYIF5VB3kYp9xKQ0S64pTE88AXQCtcrfLvVfXSsp7Xs2dPXbBgwW7nVxLTp0+nb9++Fbp3b6Uq55yX5zLXZmSUnbcq0kvqq6+U228X2m1axOakfbj7ySTOOHoTBY28JaNSdbYVv9+tfAKBsvvbv3P9wOZcPkSkVKXhdXvqYeB0EZmMM4YrcKKIvAmcBTzqcZxNQD7QIqK9BbCulHuGAt+o6tOq+oOqfgHcAFwiIm09PtfYw0RHQ9u20KSJy1tVWkR3pJfUCScIX34JjY/vzsptSdx8XQ4Zx55Mw4sG4Nu8cbfPjbR1mIeVYVQtnpSGqs7AeS11BN7AGcKfAI4FzlTV+R7HyQEWAidFXDoJZ1AviXicogkndG7BibUYEZextm1b5+Hk1cupWTN46y149FGIio3hqb+GED1rGkl9D8U/d4anMUK2jq1bnfLI3GUj0zCMiuD5pauqE1V1P1zt8GOALqraSVUnlfOZzwKXi8jVItJFRIYBrYGXAUTkLRF5K6z/J8AZInK9iHQKuuC+ACxS1ZXlfLZRAyQmQkqKszOkp3uLIheByy+Hz78Q5hx0HUcyn5VbEkk+73ji/v2wpwLjkXEdGzZYXXLDqCxe4zTuC9ojUNU/VHWOqi4JXmsVtEl4QlXfB24D7gG+xymg01Q1LdilffAI9R+Nc9O9CfgJGAf8Dpzh9ZlGzeP3u0DAxo091CEPY7/9YMIE6HfrIRwhC3hPL2TjiA/45XvvedNDcR3btlkOK8OoLF5XGvcDpdkPWgeve0ZVR6hqiqrGqmqPcKO4qvZV1b4R/V9U1W6qGq+qrVR1sKquLs8zjZrH53NbT23auO0ir9tVfj/ccQe8/XED7u3wNkdkz+K0c+L4z1M7iPra23ZVaNURE+NyWK1d6y3Nu2EYxfGqNMqo2UZjwLzjDc80aFD+7SqAnj1hypfCWZc3IjcXEoY9SrPz+5E79D7PudOjo4sy565Y4VY8Vq/DMLxTapo5EekLHB/WdK2IDIzoFgcMAH6ucsmMOk1ou2rLFufh5CXpIbh+jz4K/fvDPX+/lxbr1nPFWw+TOn0G/nHvuWWMB+LjncLIy3NBgaEEjIZhlE1Z/0374OwO4FxsryihTw7wC+A9Asswgvh8zrsqPt4VW8rN9Z659rjj4NNpCTz44Cimje3Hf1ZeT07vQ0l77r80P/sYT2NERTkZCgrcqqNpU2dz8RoYaBj1kVK3p1T1QVX1qaoPtz3VK3QedgRUtbuqzt1zIht1jfh4t10VCHjPXQVum+mZZ+Ckty7llKYLWZzXjfP+0Z4RI8pX6S/SPdcM5YZROl7jNHyq+k11C2PUX6KjoXVrl7tq587y5ZA64QQYOfMAXrlgOn/ktOexRwuYcvjdrJjh3SM73FC+ejWsWVOUCsUwjCLKHRwnIs1FpH3kUR3CGfULEbc9lJLizstjJE9KcquOd96BY5st4W8bXuSAiw7j8xs/KdfLP1TsKSvLsucaRkl4jdPwichjIrIZl8Z8RQmHYVQJsbGuRkejRmWnICmJfv1g5KwuPHTGIlbSnis/HsS07v9g0bzyLRvi4ty22aZNtmVlGOF4XWncBtyIq6shuAJKj+CUxTLgmuoQzqi/+HzQvLnzsMrJcYkPvdKgAfx9xH6seHcubzW4kSu2PkvuOedz333le/n7fC6aPSrKxXbYlpVheFcaVwAPAU8Gz/+rqvcDXXBZa217yqgWEhLcdlV8vDOSlycNSK++AY7+7iVeO2UcL/pu4/XXoW8fZcoUl103nLKyPcfEOKN7Vpbzstq0ydKRGPUXr0qjE7BAVfOBPFx8Bqqai0tZfmW1SGcYODtDq1bOUJ6ZWb7kg3FxcNrr53DXpD4cfDDcsPYetl1+Cxedk8amn9aS9MvPyPq1zJv3BQsXTt/tWImJzs6Rmuq2ziww0KhveAinAmAbEKpM8CfQGVdRLzRGchXLZRjFEHHf9uPiYN0698IOJSP0woEHwicTlNUXZNJ73osMnP8JrfuvRf0xxHA7MmAAOYOH7FLfoyQ5EhOdneXPP508zZvvvm6HYdQVvK40vgO6Bn//AnhQRC4UkfOAx4FF1SGcYUQSE+NSrbdo4ewcXvNXAUTHCCnjn2XZvW/QkVQCZBOXk050Tg6nf/oZvTsdUqbCKDZW0MsqP9+tOtavt1xWRv3Aq9J4HgiZIu/HFUx6F3gfiMFloDWMPYKI86xKSXEv7/T08rnFNux5AJrQoFjbztwAo+9PJT29fLKEAgN37HD2jq1bzUXXqNt4De6boqqvBH9fBxyBq6txKLC/qv5QbRIaRimE8lc1a+a8oryuOvLapVCQWzx60E8O+3zyLO/1fJbPPkgvl61CxBnq4+Nh40anPMzeYdRVvMZpXCoiTULn6vgjqCwaiEiZtboNo7oIDwiMinIv67K+6asqc5YvZsKAAeT5/eTGJ5Dn9/PhsefQLm49D+z4B2f+PYVJRz9M6ndbyyVLyEU3Jsa5565caRUDjbqH1+2pUcA+pVzrGLxuGDVGbCy0b++M0mXZOkQEvz+ADh7CxnmpfPfYk2ycl0rirYPZMOYh3r5+Dt9G9+bqtPs4aGB7PrxxerkD+0Lp11VdxUCL7zDqEl69p8qyDibg3HANo0YJrToSEpxhujQPqx49+qKqqAjbunajbYtW9Gre0hnBD4ctN0zgrjt+YP9Jz3Pvx915Yh68dMl8jj6rOQUdOnqWx+93R2am27Jq3BiSk72lgDeM2kpZ9TQOBbqHNZ0uIgdGdIsDLgCWVr1ohlEx/H7nYbV9u1MeUVG7plyP9JIKP09OhlteO5hFi96g0z2weDGkPH0DTZ9ezIYTLyL6nqHk7dfFszxxcW7VsX07/PWXS8GelGQp2I29k7K+85xBURlXBf5VSr/NwFVVKZRhVBYR92KOj4cNG9wLOyGhfC/q7t3h009h7Fi47JH/ceW2Z7n2y1eI+/Iddpx4Ftl33Edet0M8yxMf7+wtmza5AMFmzZznlddYE8OoDZT15/o8zl7RCbc9dXbwPPxoDTRX1QnVK6ZhVIyYGFfMr00bl249I6N8Xk0+H1x0EXwwpy0/X/ksnXxpPMI96FdTmfvKDy42oxw1Y0PG8thYF6RokeXG3kZZRZi2qWqaqqbiFMTE4Hn4sU7LStpjGLWEUF3yUExFeQ3TjRrBww/DmClNmXLMQ7TXNM4dfwEnnQTr7nyOpmceQ+yXEz2//aOinCzR0S6yPC2tfEkZDaOm8BqnkRbMM4WIxIrIDSLykojcLSKtq1dEw6gaoqNdJHmHDm6bqLyBfAAHHOC2q4a90ZC2KTEsXQrPjmnJlp/W0OSygTQ7+TAC/3vfc0bDUGQ5uEy65qZr1HZKVRoi8pCI/BzRFgvMB14EbsClR/9ORLy7lBhGDRMX51YdTZs65VHel7QI9O8PU6fCPffAhAYX0y5rKZfLm2xck03yDRfQ6B/lM/P5/UVpSVaudNUDy5MixTD2FGWtNE4EPotouxE4GHgaSAJ6AbnAPdUinWFUEz6f85Ly+519Yfv28hV7Anff9dfD11/DhZfE8LZcStttPzM4MJ634q8jKwt8a9eQ8NowJKMo2KOstOyhtCQ5OUUxHuUpfWsY1U1ZSmMfILIu+Jm4yn1DVXVHsG7408AJ1SOeYVQvIkWG8txcl46kvFa6pk3hiSfgyy+h3/E+3ss6m+vf7MVxx8GSx8eTdP9tND8yhcRhj7J4xqfMm/cFsn4tMQvmlpqWPRAoKju7YgWsXWvKw6gdlOVymwSsD52IiB+Xc2pchPF7MdCqesQzjOpHxL2g4+NdwsFNm9wKpLzpzjt3hrffhpkz4aGH4Ndfoe/4W7ikY3eeSHqc1k/dw4lxcSxr145mqan4YgMUZGeVmZY9Ls4dGRluNdSwoVshxcZW4QdgGOWgrJXGGiAl7PxIwA/MiegXA1gFZWOvJyrKrRo6dnSuuhXZsgI47jj44gt49llo2RLeXnEMbb6fyNXdF7HlkBPZ/48/iM7JwbdjO9E5OQyaOHG3adnj4pxiy8hwbrq28jBqirKUxizgNhFpJO6v+RagAJgY0e9QYHX1iGcYe57YWBdRHtqySk8v/5ZVVBScf76zd9x1l3vhv77oMM6cN5RMX2Kxvr7oGKJXpXoa15SHUdOUpTQexK001gN/AecAI1U1LaLfBcDX1SGcYdQUoS2rlBS3HZSeXjFX2Lg4uPlmmDMHhgyBNTEpSF7xak2+jJ0kvPxvfBvXlzJKyeOGlMeKFS7Ww7ytjD1BWcF9K3CriCeBt4DLVPWG8D4i0hK3XWVZbo06SfiWVSDgtqwqUqEvORnuu0+5+4UlPNZ+KBnE8RdJZBDHzOSjiZ08gebHdSZ+zOvlGjcuztk5MjOdt9Xq1RbnYVQvZebbVNWVwH1lXF8H3FzVQhlGbcPvd9tVGRku/UdWVvlqlINLitimDTR79nC+Yxnjnk5lzPyOrN/SkkPjfuaDRrfQOG1NheQLJWTMynJxHnFxTtnFxblVk2FUFZak2TDKQXy827LascMlQhQp34s5lJZdRPjnR604YRE89ZQya1Y39l/5Jc3eyee6RnB9209o8M1X7PjnQ2iDhp7lCwTckZ3tIsxjY11ixPh4Ux5G1WD5NQ2jnPh8LoNux47uZ3ntHeFeUt27w9ixwvvvQ48ewsat0Tz8MLx9+yIS3niBZn26EPh0XLkt8aEgQXBbVitWuK01q19uVBZTGoZRQaKj3bf4kL2jIokQQxxzDPzvfy7O4+CD4c6d99NL5/Lr5uYkX3sejQYPICptebnHDaUniY52nlYrVrhUJR5TYxnGLpjSMIxKErJ3tG/vzisa3yECxx8Pn30Gb7wB6V2P5LC8b7mN5yiYOYv5z35dYQ+pUGJEv9/Jtny5C2KsiFHfqN+Y0jCMKiIuzmXQDY/vqMh2UCgh4hdfwMuvRjO5y23sq0s5Y9wlHH00zL/1PXTa9ArJGBXlttfi4lwVwRUrnGHfYj0Mr5jSMIwqJBTf0bGj27rKzKxYPitwL/fTToPJk+GRV1vSpYuwfl0BHcc9RZuL+7H+1MvIXrWhQnL6fM44npDg5Fuxwtk+ylukyqh/lFUjfGo5xlFVtaSFhhHE54PGjZ0C+esvV9419A2/vF5MIeVxyinwxRc+rnl2Dmf88hh3/PAUO4/6hGknP0HXZ6+mYaPyfwcMeX/FxRV5XPn90KSJqzBopWiNSMr6k/DhyryGjgOAvrgo8bjgz75A5+B1wzAiiI4uCg4MVQ2saPCdzwenngofT46n/ZuPcGGXxXyvh3D2F9dy/RELefJJ2Ly54rKGPK6iopzRfPlyp+wqYp8x6i5lRYT3VdV+qtoPGIarm3GUqnZS1aNUtRNwVLB92J4R1zD2TmJiXNXAjh3dt/odOyqe9kMETjwRXpjShfXvTeXabl8zfefhvPACPNhjAo8OTWdNxWIEgSKjeSDglNCyZUUBjYbhdfH5MHCvqs4PbwyeP4Cr4GcYxm6IjYXWrZ3BPCbGKY+KGqFF4Lg+wv2Tj+bjj+H8Y9YwJvcc7nqrC0/2+i+33qIsWVJxWX0+Z/NITHR2j9RUd1TUwG/UDbwqjf2AjaVc2wDsWzXiGEb9IBCAdu2cm25UVOViPAAOPxyefb8N3z8/g7yGyYwrOJtLxw/iiuNTufxy+Oabihu4Q3aPhsHA9DVrnOF861Zz2a2PeFUaK4BrS7l2LZBaJdIYRj0jLs4pjnbt3Pn27ZVTHm3O603sjwtJvfkZToqexiK6M3fKDs46CwYNUj77rCiwL7LsrBdCwYJ+v4vzCFUVzMw0r6v6gtfcUw8C74rIT8A4XLr0FsC5OAP54OoRzzDqB/HxbssqIwM2bnQrj0DAbWGVm+ho/Hfdzl+XnEf2jHlcvaYBr72WS9ai37nnmiYc0VQ58Zq1ND3wRxo08NOjR99yPyIqym1dqTqZt21zW29Nmrj2qKgKyG3sFXhSGqo6VkQ24ZTHUFy1vlzgW6C/qn5VfSIaRv1AxL1w4+OrRnkUtGlHzEXt+D9VBkU/Rb9/30MeUWRsiif68TxuinmB7YP60rat0qJFxRwgw1128/KcwVzE5eRKSrKytHURz17Yqvqlqh6Nc7dtCcSp6jGmMAyjagkpjw4dXAVB1cptW4kIXc6+kAJfFNHk05AdxJPJK7nXM3+8nyOPFG67DX76qXJyR0c7o3l8vFN2IcP5jh1mOK9LlDt0R1ULVHWDqlb4z0BEbhCRFSKSJSILReTYMvqOFhEt4bC65EadJlx5hGweFTWYR21c7wYLI1ryOe/I1eTlQdKHrzKq/xiuPGMzn39euYSGodVHKMvun386t91NmyxdSV3Acz0NEekE/A1oDwQiLquqXuVxnPNxcR034MrE3gBMEpGuwaJPkdwK3BXRNhuY6VV2w9ibCd+2ysx0L9/t293Wj9ftn7x2KRRkZxX7lpgfE8M//9ORczOhw4BhtPnrZ/IX+PjmqiP4MOkUAuefSb/bDiEpqeKy+/3uKChwkfGbNzuZk5PN9rG34mmlISJnAr/h4jHOBPqVcHjldmC0qr6qqr+q6s3AWuD6kjqr6jZVXRc6gH2ATsCr5XimYez1iDjF0b69W31ERzvlsbugO1VlzvLFTBgwgDy/n9z4BPL8fiYMGMCc5Yvp0EGRHxaTOnYes/rcS5y/gNu2PYiOHEnPnjD0zgK2jhiDb3NpXve7J5TrqkEDN49161zE+YYNTn7zvNp7EC9udyLyI+7FPlhVK/yXIyJ+IAO4UFU/DGsfDhyoqn08jDEa6KmqB5ZyfQgwBKBFixY9xo4dWyFZ09PTSUxMrNC9eys2570PVWeADtkMSssVlZGRjmoBjbPziFq5nPz2ndgaG42Ij/j44vPPz4efpglTJjZl8s/d6Mm3fMsRFCD82bobWX17sOXII9i2f+dKLxVCcou4oapr5bG3/ztXhMrMuV+/fgtVtWdJ17wqjZ3AWao6uUISFI3TGlgD9FHVmWHt9+EUUufd3J+EU15DVXW3qUt69uypCxYsqJCs06dPp2/fvhW6d2/F5rz3kp3tgu22bSv6Vh+ZGDFUZvbnn6fTrVtR2dmy+P13GP1GAcs+WEi/7EmcyiSOZD4+lD+Gf0H8mSfj27geRCho2rzUcSKfFXmel1e0YkpIgEaNnF2kqhIm1pV/5/JQmTmLSKlKw6tN4zegSYWeXrVcjNtSe7umBTGM2kRsLLRs6eIktm1ziQbBKY/QizdSQexOYQDsvz889oSP7XcfzocfHs4lb97H1mWbOZnJfHrLsfSdBE/6X6TrR4+Sc3APsvudSla/U8ntfmThsmHhwunk5GTRu9MhRK9KJa9dCnOXL8bvDxTGiIQ8r8ApwNWr3e2NGrktLXPdrT141eN3AHcHjeGVYROQjwsMDKcFsM7D/dcA41V1SyXlMIw6SUyMy6rbqZOr55GV5TyuKpuptmFDuOoqmDEDho9pwrZTLySTOD79FM776EKeS36YdVtjSXzxMZqdeTTNj+oEBQWoKnnp25F3R9KsVwpNLj6FZr1SkHdHkpOTVWJUeijbbiDgjOepqS7yfNs2S1tSG/C60ngAt9L4VUSWApEvbfVij1DVHBFZCJwEfBh26SRgfFn3isgRwCHAbR5lNox6S3S0q+eRlOQSDG7a5Dyv/P7KjSsCxx3njj//hDFj4N13u3H7+m7cvuUeWvq38H+HTuGkA9fRRHyIwIAHhhKz9FdEFXJy8AGDJk5k473D0TJWO6FtNnBKb/16Z8MJ374y76s9j1elkQ9UIl9mMZ4F3haRb3Cus9cBrYGXAUTkLQBVvTTiviHAUlWdXkVyGEadx+dzq4QGDYrcdQsK3O+BQPkLQoXTujX84x9wyy3w5ZfwzjswfXoy//fN+fAN7DsTBl9YwM2HHEfysiXFgj98/gDRq1LJbdHK07Mit6/WrHFza9DAza8ixa2MiuE1jUjfqnqgqr4vIk2Ae4BWwE/AaaqaFuzSPvIeEWkAXAA8VFVyGEZ9Itxdd9ky9219+/aiQLzKGJxjYlxxqFNPhbQ0t/p4/3344w948GEfr0ffx1IdTYCwiMGsDPLapVToeaH4FFWXsn3btiL7R2Kiu2YKpPrwHNxXlajqCGBEKdf6ltC2A6hf/nKGUU2IFBnNd+xwRvP8/EokSAyjQwe46y63AvnqK3jvPWXatJZcUzCSV7iWPPETkEw+7HcOgeWL6Td7KprUmOzjTy33mz6k8KB48GBMjFMgCQlmQK8OPCkNETlud33CXWgNw6j9xMS4yOxGjdw39s2bnRKJji56GVdm7FNOgVNOET7/fC6TJ/fi2FnL8P+ZygrtyPopLTl43RaO3n4qLdO+IfuYE9h279PkHXhYhZ4Xbv/Iz3dz2bjRydG4sQUPViVeVxrTgd197GaSMoy9kJBtIDHReVtt3eqUh89XNbESp5xyFP37K6rCnDmtGDsWPvtM+eHHZNozi9tiX+bebx+i2Sk9yDznErbf+SgFrdtW+HmhtO3gDOibNrl8XampToHExVXeIaA+41VplJQmpAkwEOgD3FRlEhmGUSOEpznPzS2+dRUbW7kXrYggAscc445t24QJE+D99/08/d0tjORShvI4t40bxn99V3DY39vSfhfrZvmJjnaHz+eODRvcVlZsrCmQiuLVED6jlEsfichzwOnApCqTyjCMGiV86yojwymPHTvct/iq8FRKSoJLLnHH0qXw4YeNeH78kzyz7h9s/KA5fACvtHmQjj2b0ubBITRqVkljC0UKBJxSNAVSMaoiSH8iLvutYRh1DJ/PbVu1bw8pKc69NSPDxX5UVaDdfvvB3Xe7OuYvjGnO2WdDXGwBHdbM4aT/3UT0oQfy+ukf89lE3W1yRq/ExLgtrAYNilYgK1YU1T63FO6lUxVKozNgJVYMo44TGwvNm7to85YtnXF5x46qqw8eFeWCBl98Eb7/wcevz37OnV0/IR8f9y46i/2H9OGCg3/h//4Pvv66cjU/womOLlIgUVHOBpKa6rLwbtliWXgj8eo9FRloB+AHDgSuAj6qSqEMw6i9REW5FUfDhu6Fun27i5VQdYqlsm674FY3fztf4PyBrF11ChMeep0jJj/C1p0xjBkDY8a4ErWnnw5nngmHHlo1sRnhW1j5+U5pbNzo5pyUVBQHUlWJFPdGvBrCR5fSng28jyuUZBhGPSMQcEeTJs5tN9z2EQhUzcu1VbtoWr16LQV5V/Hq8mg+/hhOfPV8lqxvx6Ov/YvXXkumfXsYNMgdXbtWjQKJiipy4y0ocMpxyxY3digSPRCof6lMvCqNjiW0Zanq+qoUxjCMvZPw1Ud2tlMcf/3lvq37/VUUZBcdzf77wx1/zyVpXQMGfPAc18WM4in/PTyx8kZeeimWl16CffZxyuP006FzmcUWvBNyPwa3osrMdHME156U5BRIfTCke/oeoKppJRymMAzD2IXY2KJMu23buu2qHTvcSqRK7BAxMWx79nU2Tv6eqN5H8GD6P9jcvAv/Ou07kpNdmpTnnoPjj4e+feHf/4YVKxKqzC4h4hREYqI78vNdJcIVK+qHHaRcaUREJBSXkYzLdDtdVSdWh2CGYezd+HzOwJyQ4Dyt0tOdZ1JGhrMbVDZhYl7Xg9ny7ufEzphM4ouPc+PTKQxJhG+mpvPR5EQmTXLuvM89B3A4++wDAwYoAwYI3bpVXX6qUB10cMGEITtIKGgyVA8kukaSNlU9Xg3hDYBPgWOBPGAzLrjvdhGZBQxU1fRqk9IwjL2aUDqPRo3c9lXIeF5QUPntq+w+J5Pd52QAovPzOePpYxjQoRNfP3I2M9cdwMYf2/DHlD/4adl+vPBCS154weXICiVZ7N696gzb4YZ0Vacgt293v8fFFWXk9fv33qSKXnXfY0B34BJgrKrmi0gULvPsf4LXb6keEQ3DqCuEtnYCAbeFlZlZlLZEpAq8r/LzyRx4HonDn+CEyRPo2KEDHVetpiAmBqLzeKjtUF7cehdpabG8/DK8/DK0aAH9+zsF0qtX1dklQnMNkZvrViAFBc4GFErdsrcZ070qjXOAe1T13VCDquYD74pIU1xlP1MahmF4Jnz7Ki/P2TzC815V6GXq95N+67/IuOhqGjzyT/YZ9zYCROXmAPDAmke5+fUj+CavJx9/3ZTPvxDWrIG33nJHw4ZwwglOifTrV1TDoyqIiSlSiAUFbrsu5KocCBStQmp7anevSqMJ8Esp136hdtQPNwxjLyU62nkgJSW55ILp6c77KmT/KG9sREGzFmRccj1xk/6L7CzaOfchNL/0NAYCp8XFk9+mPX/1TOHRXp/y+ZQoEpYsZP1/s3j4vx24LaYVvY6O4uST4aSTXNGp8qCqxeqwh5+He2OBW4Vs2uQUiIhTpA0bVl3cS1XiVWmswCUnnFLCtdOC1w3DMCqN3+/yXjVu7OwfIQN6QUH5DOh57VIoyM0p5iJagLLtmdeJSt9B1Oo0otak0WBnOncMjeKOoRB7wSM0mfUxALm50aya3o5F07tz+N3jOOgguK7zNHr2UNod0wFt267UvayFC6eTk5NF706HEL0qlbx2Kcxdvhi/P0CPHn136R++ClF13lfp6e73mBi3lRWqD1LTW1lelcYrwDMikgi8C6wFWuJsGlcDt1ePeIZh1FfC7R9NmrgX6Y4dRQb0shSIqjJ3+WJkwAAGTZyIRscgeblMGDAA7dCaXr36F1sFhMh78hk2L7+WqNVp5CxNI2dRKokb44nbDD/+CIf/eAeHj1sAQAFCZqNW5J3Qn50vvAFAYOJ4CmIDxG5ZjX71Kc0mT8YXG6AgOwsZMICcwUN2WYGUNu8Q+flFgYXgFEf4Vtaejk73muX2ORFphlMOlwebBcgBnlDVYdUjnmEYRvG07U2bFqUv2bHDKZCYmOK2ABHB7w+QM3gIG+8dzqqZH9HuuLPR4Lf90l7a+R06kd+hU+F5Q+Bg4KcsmD0b3vvvOJ6csZzELWl0II0Of6Wx5r/t+XKjs4XcNexG/FvWc3L4oDlutTNo4kQ23jscLafBIpRZOETIrbcgmPEv5JUVSl9f3UrEq8ttEq4+99NAL4riNOap6tbqE88wDKM4oSp98fEugWIoOjukQEIrkB49+qKqqAjbunajbYtW9Gressxv+aURCDilcMIJHVDtwM8/u3K2I76CRYtAZ8LMmfAKC+nVMo1LWk5h4E+PE51XlC7XFxug4aN3sHPIP8jrdkiFrd2Rbr2hNO+hYML4eLedVV3BhbtVGiISjYvLOEtVP8HqZhiGUUsI98Bq3rxoBRKKjYiOlmJbPRVRGJGIwIEHuuPWW11p2enTYepUmD69DR+ta8PsdZ1YzpPFXrAFGZnEfzyGhPHvkNu5G5lnDSbzrIvIb9uhUrKEBxeGK5GcnCLDelWy24WMquYB64EqSkRsGIZR9YRWIC1bwr77Qrt27ht3RoZbgWRmFm3pVCVNmsA558Dw4bB4MXz8sXLMOenc2ehxMojjL5LIII4r8l9n/4apvN5zBJvyGtHwibtpcWQK0X/85gaqgqVBSImEyt1WB14N4e/gDN6fVZ8ohmEYVUP4FlazZrB6tXPn3bbN2QQqHAeyG6Kj4fDDBZ9vNTkXdmZFo2X8+lkqny9J4ZOvk9m2NZarF1wPXE9HVnBNm4n8+UFnjusD/f93IzGb/iTz7IvJOnFgcWt4LcKr0kgFLhKRb4H/4byniqlFVX2jakUzDMOoPCLuaNrUrQqys93q46+/3Ooj9O28KuMhQvYUEaF3l1b0Bu7PV379FWbMcNtZCxZ05O41N8FweGk4PBzVnOuiPqbpF/8jN74hOQPPIfPCK8k54piqE6wK8Ko0hgd/tgF6lHBdAVMahmHUasLdeJOT3b5/ZqZbgYTHRVRFVHak/SQqSgptITfe6BTX/PnOgD5rFtz76wPcn38v/ZjG4Ix3OfeDccz+pgE/X3MMx/QuoHPuj+R3PbjGw8UrU0/DMAxjryZkRE5KcttWIUN6SIFERVVfQF18vEtV0q+fO9+4Eb7+Ooqvvz6R+74+kRtWjyA+NYMt/4Jj+ZqZ9GFlg66kHT2Y+KsvomWvlBrRH17jNNKqWxDDMIyaJDq6qEZGQYHbxtq50ymRzEzXJ9xTqapp1gzOOssdqpCWFsfs2XHMng0/zTqI67b8h8E73uXYz/8Fn/+L+THH8PoJ79H5xHb06gUpKW4RUlb6kqqg3BneRSTS40pV62q5EcMw6iOh3FChYMLQNlb4KqQiObG8IuKUQEoKDB4Mqo35/ffrmDnnOl6fkso+89+jb9YkRn3ekrzP4QLGkNgomtRuh9Op204u659MUtrP6EGdmfzDYgKBAH379q0S2UpVGiLSEngdeF9V3wq2ReGiwMNJF5H9rZKfYRh1lfBtrPz8opxY6ekuLsLnK8ofVR1bRiKudG3nzsAVKRQU3M1vv93NfXNh3jy4bfJLHPnXHLbNbsj3sw+h+8hvyCaWgjv/QcbA02DI7tOXeKWslcYNuBoa50bKD7wK/Bn8/XzgOuDBSktjGIZRy4mKKu7Om5tbFJW+c2f120LAKamuXd1x1VVQkDuT78dNx//mSI778QMECJANuXDGxIn4hg+vsi2qspTGKcCrqpoZ0a7AK6q6CEBENgKXYkrDMIx6RnhEdlJS6baQ6OjqzQvli4mi+YUnELNfPDr4cyR9e9G1uDgkNRVataqSZ5WlNDoD95XQHqmufg/2NQzDqNdE2kJyc4tvZYUi0mNiqqfka167FApysoqng8/MxJeSssuLu6KUpTQCQLG638Eyr62ATWHNWcG+hmEYRhghO0diotu2yslxSiS0lQVOcYSUSGUoKR28Ly+X/w0YQPzixfRvWbFkjZGUpTQ2AJ2AryMEizR4dwQ2VloSwzCMOkyoBnqoHkZBQZFXVmglEupXkQj1yHTwadM/4ojzzyY+6D21J2waXwOXAG/tZoxLgdlVIo1hGEY9IZT/KhBwVQpD9pBQsamKKJHIdPDSqhX9W1XNCiNEWUrjBeBrEfk3cFcw220hwZTpTwF9gWOrTCLDMIx6SLg9pDQlorp7995IBVGVCgPKUBqqOldE7sAphotFZAqwMni5PXAS0BQYqqpzq1QqwzCMek5JSiR8OyvcJhLyztoTaUXKjAhX1WdEZBFwJ3AORQbvLGAm8JSqTq1eEQ3DMIyStrNyc91KZOdOlwAxP98pjuqKDwEPaURUdRowLRgN3iTYvFlVrSiTYRhGDeHzFRnWk5KKqvbl5Dgl4vNVz8rDc+6poJLYUPUiGIZhGJUlPNAwMbFq64OEU03xiYZhGEZdxJSGYRiG4RlTGoZhGIZnTGkYhmEYnjGlYRiGYXjGlIZhGIbhGVMahmEYhmdMaRiGYRieEVWtaRmqjWBVwbQK3t6U4nVD6gM25/qBzbl+UJk5d1DVZiVdqNNKozKIyAJV7VnTcuxJbM71A5tz/aC65mzbU4ZhGIZnTGkYhmEYnjGlUToja1qAGsDmXD+wOdcPqmXOZtMwDMMwPGMrDcMwDMMzpjQMwzAMz5jSMAzDMDxjSqMEROQGEVkhIlkislBEjq1pmSqCiBwnIhNEZI2IqIhcHnFdROQBEflTRDJFZLqIdIvo01hE3haRbcHjbRFptCfnUR5EZKiIfCsi20Vko4h8IiIHRvSpU/MWkRtF5IfgnLeLyFwRGRB2vU7NN5Lgv7mKyEthbXVuzsH5aMSxLuz6HpmzKY0IROR8YBjwGHAYMAeYJCLta1SwipEI/ATcCmSWcP0O4B/AzcDhuHK+U0SkQVif94DuwCnBozvwdjXKXFn6AiOA3sDxQB7wpYgkh/Wpa/NeDdyJk7EnMBX4WEQODl6va/MtRER6AUOAHyIu1dU5LwFahR0HhV3bM3NWVTvCDmA+8GpE21Lg8ZqWrZLzSgcuDzsXYC3wr7C2OGAHcG3wvAugwNFhfY4JtnWu6Tl5nHcikA+cXs/mvQW4ti7PF0gClgH9gOnAS3X53xh4APiplGt7bM620ghDRPxAD2ByxKXJuG+udYmOQEvC5qqqmcBMiuZ6FE7ZzAm7bzawk73n82iAW1FvDZ7X6XmLSJSIXIBTlnOo2/MdCYxT1WkR7XV5zp2C208rRGSsiHQKtu+xOZvSKE5TIApYH9G+HvcPUpcIzaesubYENmrwKwlA8PcN7D2fxzDge2Bu8LxOzltEDhKRdCAbeBk4S1V/pO7O9xpgX+CeEi7XyTnjdkEux20rXYOTc46INGEPzjm6IpIbxt6AiDyLW34fo6r5NS1PNbMEOBS3ZXMu8KaI9K1BeaoNEemMszkeo6q5NS3PnkJVJ4Wfi8g8YDlwGTBvT8lhK43ibMLtf7eIaG8BrNu1+15NaD5lzXUd0ExEJHQx+HtzavnnISLPARcCx6vq8rBLdXLeqpqjqn+o6kJVHYpbXf2dujnfo3C7Aj+LSJ6I5AF9gBuCv28O9qtLc94FVU0Hfgb2Yw/+O5vSCENVc4CFwEkRl06i+D5gXWAF7g+lcK4iEgCOpWiuc3F740eF3XcUkEAt/jxEZBhFCuO3iMt1dt4R+IBY6uZ8P8Z5DR0adiwAxgZ//526N+ddCM7pAJwBfM/9O9e0R0BtO4DzgRzgapy3wTCc8ahDTctWgbkkUvSfKgO4L/h7++D1O4FtwNnAgbj/dH8CDcLGmAT8GPzjOir4+yc1Pbcy5jwc2I5zt20ZdiSG9alT8waeCL4cUnAv08eBAuDUujjfUj6D6QS9p+rqnIF/41ZUHYEjgU+Df+sd9uSca/yDqI0HcAOQijMqLgSOq2mZKjiPvjh3ushjdPC64Nz41gJZwAzgwIgxGgPvBP84twd/b1TTcytjziXNV4EHwvrUqXkDo3EVKrNxRs0vgf51db6lfAaRSqPOzTlMCeQAa4DxQNc9PWfLcmsYhmF4xmwahmEYhmdMaRiGYRieMaVhGIZheMaUhmEYhuEZUxqGYRiGZ0xpGIZhGJ4xpWHUWkTkKBH5IJjVM0dENovIFBG5TESign0uDxajSQm7L1VERkeMdbqI/CiusJaKSCMR8YnI8yKyVkQKROTjapxLipRQCKuEfqH57FtdslQUETlTRG4vob1vUOYTa0IuY89iCQuNWomI3AY8iysodCcueK0xcDLwH+Av4H+l3H4WLnApNFY08C4uVcKNuOCoHbjEfrfiCtfMpShnkVEyZwIn4v5djHqKKQ2j1iEix+FeTC+p6i0Rl/8XzF6bUNr9qvpdRFMbXF2ND1R1ZthzugR/fV5VC6pA7lhVza7sOIZRm7HtKaM2cieu8twdJV1U1WWqGlnes5Dw7SkReQCXEgbg9eA2ynQRScWlXADID986EpFWIvKWiGwSkWxx9bcvjnhGaBvpOBH5UET+wtU7QETiRWREcDstXUQmAG0r8DmUiogMEZHFwe22TSLyekRJW4LyPSIitwSL9uwQkRmya93oqGC/tSKSISJTReSA4P0PBPuMxqXgbiNF9alTI8SKF5GXgvJsEpF3pBbX3DYqhq00jFpF0FbRD/hYVbOqYMjXcHXSPwQeASbitq5igVtwRW1CWT+XiUgCLmdPY+BuYBVwMfC2iMSr6siI8d8FxuC2ukL/n17BJb58EPgWl3n0vSqYCwAi8gRuS+0F4J+4ldQjwIEi0luL1w65GFdr41bADzyNW60doKp5wT4PBuf6NC5vVQ9gQsRjHwaa4WpPDwq2Ra6qhuGS6F0EdAaewpUauKwy8zVqF6Y0jNpGU1xt47SqGExVV4vI98HTZapaWKxGRNYE+4S33YSrT9BPVacHmyeJSAvgERF5PeKlPE5V7wi7vzPupfkvVX0i2DxZRBKB6yo7n6DB/5/Ag6r6UFj778DXwOm41OEhcoGBGixWFCyl8CFwBK7qW2PgNuBlVb0zeM8UEckBngkNoqrLRGQjkBP+eUUwU1VvDv4+OfhZXC0il6sluasz2PaUYRTnOGBNmMII8Q7um3bXiPb/Rpwfift/9UFE+9gqku+k4Pjvikh06MBtje3AyR/OFC1e3e7H4M/2wZ8H4exDH0bcN64Csk2MOP8Rt6KLLAxk7MXYSsOobWwGMoEONfT8ZFxq6UjWhV0PJ7Jvq+DPkmo1VwXNgz//KOV6k4jzLRHnoS2lQPBnSN4NEf0qIu/unmXUAUxpGLUKVc0TkenASTXkjbQFtx8fScuw6+FEbruElEgLXP1mws6rgpBb8MnA1jKueyUkb3Nc6dAQtjowSsS2p4zayBO4b8xPlXRRRDqKyMHV9OwZQFsROTqi/SLct/FfdnP/fFzVvL9FtF9QNeIxJTh+e1VdUMKxopzj/QjsBM6LaI88B7dyiCu/yEZdwlYaRq1DVWcGI4+fFZGuuMp0K3EeTSfgSvFeBJTqdlsJRuM8jT4SkX8Bq4HBOFvCtRFG8JJkXyIi7wEPiYgP5z11MnBaOeU4RUTWRbRtU9UpIvIk8FLQ0DwDV6WtXVDG11R1mteHqOpWEXkeuFtEduC8p7oDVwW7hMev/AIki8j1uJrcWar6I0a9wpSGUStR1edF5Bvg77jayE1xht4FwLXAJ9X03J0i0ge3ynkCFxS4BLhEVd/xOMy1uLry/4dzc52KU3Jfl0OUF0to+xlXvvNuEfkVF91+I26LbBXwFbC0HM8IcT+uVOhVODfk+ThX5Nm4mtMhXgN6AY8BjXAebikVeJ6xF2PlXg3D2AURORfnUXWcqs6qaXmM2oMpDcOo54jIkcAA3AojCxfcdxduhdXbYiyMcGx7yjCMdFx8x41AQ5zB/wNgqCkMIxJbaRiGYRieMZdbwzAMwzOmNAzDMAzPmNIwDMMwPGNKwzAMw/CMKQ3DMAzDM/8Pf6x02CUK65oAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lengths = [1, 20, 40, 60, 80, 100, 150, 200, 250, 300, 350, 400, 450, 500]\n",
+    "num_samples = 10\n",
+    "seed1 = 1010\n",
+    "\n",
+    "exps = [rb.RBExperiment([i], lengths, num_samples=num_samples, seed=seed + i)\n",
+    "        for i in range(5)]\n",
+    "\n",
+    "par_exp = qe.composite.ParallelExperiment(exps)\n",
+    "par_expdata = par_exp.run(backend)\n",
+    "\n",
+    "# View result\n",
+    "par_expdata"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Viewing sub experiment data\n",
+    "\n",
+    "The experiment data returned from a batched experiment also contains individual experiment data for each sub experiment which can be accessed using `experiment_data(index)`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: 38052c41-b1de-4044-a7ea-351116323acb\n",
+      "Status: COMPLETE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- popt: [0.39894313 0.99683541 0.55506056]\n",
+      "- popt_keys: None\n",
+      "- popt_err: [0.00864615 0.00013107 0.00889515]\n",
+      "- pcov: [[ 7.47558822e-05  1.07234670e-06 -7.66189222e-05]\n",
+      " [ 1.07234670e-06  1.71788812e-08 -1.11871309e-06]\n",
+      " [-7.66189222e-05 -1.11871309e-06  7.91236855e-05]]\n",
+      "- reduced_chisq: 1272.0160808279704\n",
+      "- dof: 11\n",
+      "- xrange: [1, 500]\n",
+      "- EPC: 0.0015822930393300516\n",
+      "- EPC_err: 6.574216227495952e-05\n",
+      "- plabels: ['A', 'alpha', 'B'] \n",
+      "\n",
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: deff9141-4adb-4a2a-9c26-8f1dd56d7533\n",
+      "Status: COMPLETE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- popt: [0.44218305 0.99807077 0.54973109]\n",
+      "- popt_keys: None\n",
+      "- popt_err: [0.01844602 0.00012207 0.0185208 ]\n",
+      "- pcov: [[ 3.40255831e-04  2.23678462e-06 -3.41596341e-04]\n",
+      " [ 2.23678462e-06  1.49011638e-08 -2.24689669e-06]\n",
+      " [-3.41596341e-04 -2.24689669e-06  3.43020211e-04]]\n",
+      "- reduced_chisq: 1549.0951739566842\n",
+      "- dof: 11\n",
+      "- xrange: [1, 500]\n",
+      "- EPC: 0.0009646171164408579\n",
+      "- EPC_err: 6.115314040377361e-05\n",
+      "- plabels: ['A', 'alpha', 'B'] \n",
+      "\n",
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: d0d62d02-9613-4ddd-9acc-128867b66d9d\n",
+      "Status: COMPLETE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- popt: [0.52303193 0.99915474 0.45778815]\n",
+      "- popt_keys: None\n",
+      "- popt_err: [0.13268492 0.0002403  0.13309719]\n",
+      "- pcov: [[ 1.76052888e-02  3.17884639e-05 -1.76597949e-02]\n",
+      " [ 3.17884639e-05  5.77427989e-08 -3.18957752e-05]\n",
+      " [-1.76597949e-02 -3.18957752e-05  1.77148626e-02]]\n",
+      "- reduced_chisq: 2544.227028407227\n",
+      "- dof: 11\n",
+      "- xrange: [1, 500]\n",
+      "- EPC: 0.0004226317452037942\n",
+      "- EPC_err: 0.00012025029993371939\n",
+      "- plabels: ['A', 'alpha', 'B'] \n",
+      "\n",
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: 37ad5eb7-d7eb-4e65-b46e-276b8ff8e1de\n",
+      "Status: COMPLETE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- popt: [0.48200586 0.99862884 0.51488511]\n",
+      "- popt_keys: None\n",
+      "- popt_err: [0.04031094 0.00013729 0.04035047]\n",
+      "- pcov: [[ 1.62497216e-03  5.50531363e-06 -1.62655001e-03]\n",
+      " [ 5.50531363e-06  1.88489659e-08 -5.51137888e-06]\n",
+      " [-1.62655001e-03 -5.51137888e-06  1.62816078e-03]]\n",
+      "- reduced_chisq: 2938.583948413994\n",
+      "- dof: 11\n",
+      "- xrange: [1, 500]\n",
+      "- EPC: 0.0006855812070217238\n",
+      "- EPC_err: 6.874002178346546e-05\n",
+      "- plabels: ['A', 'alpha', 'B'] \n",
+      "\n",
+      "---------------------------------------------------\n",
+      "Experiment: RBExperiment\n",
+      "Experiment ID: ea5ac2b9-3082-433a-bc06-0b636f9ff700\n",
+      "Status: COMPLETE\n",
+      "Circuits: 140\n",
+      "Analysis Results: 1\n",
+      "---------------------------------------------------\n",
+      "Last Analysis Result\n",
+      "- popt: [0.48732663 0.99746475 0.49859746]\n",
+      "- popt_keys: None\n",
+      "- popt_err: [0.02101995 0.00016439 0.02112632]\n",
+      "- pcov: [[ 4.41838395e-04  3.36684929e-06 -4.43970529e-04]\n",
+      " [ 3.36684929e-06  2.70239146e-08 -3.38901026e-06]\n",
+      " [-4.43970529e-04 -3.38901026e-06  4.46321425e-04]]\n",
+      "- reduced_chisq: 1791.8516210952346\n",
+      "- dof: 11\n",
+      "- xrange: [1, 500]\n",
+      "- EPC: 0.0012676235257643165\n",
+      "- EPC_err: 8.240367410319429e-05\n",
+      "- plabels: ['A', 'alpha', 'B'] \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Print sub-experiment data\n",
+    "for i in range(par_exp.num_experiments):\n",
+    "    print(par_expdata.component_experiment_data(i), '\\n')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qiskit-exp",
+   "language": "python",
+   "name": "qiskit-exp"
+  },
+  "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
 }

From 14d11ad5a5a84d027f97e809a2b322fb86f42184 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Mon, 19 Apr 2021 20:16:03 +0300
Subject: [PATCH 13/16] Linting and documentation

---
 .../randomized_benchmarking/rb_analysis.py    |  9 ++-----
 .../randomized_benchmarking/rb_experiment.py  | 24 +++++++++++++++++--
 2 files changed, 24 insertions(+), 9 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_analysis.py b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
index 2f5aeb1d18..aae08e9916 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_analysis.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_analysis.py
@@ -64,13 +64,7 @@ def fit_fun(x, a, alpha, b):
 
         p0 = self._p0(xdata, ydata)
         analysis_result = curve_fit(
-            fit_fun,
-            xdata,
-            ydata,
-            p0,
-            ydata_sigma,
-            bounds=([0, 0, 0], [1, 1, 1]),
-            absolute_sigma=False,
+            fit_fun, xdata, ydata, p0, ydata_sigma, bounds=([0, 0, 0], [1, 1, 1])
         )
 
         # Add EPC data
@@ -90,6 +84,7 @@ def fit_fun(x, a, alpha, b):
         return analysis_result, None
 
     def _p0(self, xdata, ydata):
+        """Initial guess for the fitting function"""
         fit_guess = [0.95, 0.99, 1 / 2 ** self._num_qubits]
         # Use the first two points to guess the decay param
         dcliff = xdata[1] - xdata[0]
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index 50b06bdbef..4d0f2a8497 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -93,7 +93,16 @@ def transpiled_circuits(self, backend=None, **kwargs):
         # on the transpiled circuit gates
         return circuits
 
-    def _sample_circuits(self, lengths, seed=None):
+    def _sample_circuits(self, lengths: Iterable[int],
+                         seed: Optional[Union[int, Generator]] = None):
+        """Return a list RB circuits for the given lengths.
+                Args:
+                    lengths: A list of RB sequences lengths.
+                    seed: Seed or generator object for random number
+                          generation. If None default_rng will be used.
+                Returns:
+                    List[QuantumCircuit]: A list of :class:`QuantumCircuit`s.
+        """
         circuits = []
         for length in lengths if self._full_sampling else [lengths[-1]]:
             elements = [random_clifford(self.num_qubits, seed=seed) for _ in range(length)]
@@ -101,7 +110,18 @@ def _sample_circuits(self, lengths, seed=None):
             circuits += self._generate_circuit(elements, element_lengths)
         return circuits
 
-    def _generate_circuit(self, elements, lengths):
+    def _generate_circuit(self, elements: Iterable[Clifford],
+                          lengths: Iterable[int]):
+        """Return the RB circuits constructed from the given element list.
+                Args:
+                    elements: A list of Clifford elements
+                    lengths: A list of RB sequences lengths.
+                Returns:
+                    List[QuantumCircuit]: A list of :class:`QuantumCircuit`s.
+                Additional information:
+                    The circuits are constructed iteratively; each circuit is obtained
+                    by extending the previous circuit (without the inversion and measurement gates)
+        """
         qubits = list(range(self.num_qubits))
         circuits = []
 

From a180c289a600d1867fd5ca13704e7bc81c92708f Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Mon, 19 Apr 2021 20:20:16 +0300
Subject: [PATCH 14/16] Some more linting

---
 qiskit_experiments/__init__.py                            | 2 +-
 .../randomized_benchmarking/rb_experiment.py              | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/qiskit_experiments/__init__.py b/qiskit_experiments/__init__.py
index 72116c35dd..712fdef734 100644
--- a/qiskit_experiments/__init__.py
+++ b/qiskit_experiments/__init__.py
@@ -20,4 +20,4 @@
 # Experiment modules
 from . import composite
 from . import analysis
-from . import randomized_benchmarking
\ No newline at end of file
+from . import randomized_benchmarking
diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index 4d0f2a8497..16f5661550 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -93,8 +93,9 @@ def transpiled_circuits(self, backend=None, **kwargs):
         # on the transpiled circuit gates
         return circuits
 
-    def _sample_circuits(self, lengths: Iterable[int],
-                         seed: Optional[Union[int, Generator]] = None):
+    def _sample_circuits(
+        self, lengths: Iterable[int], seed: Optional[Union[int, Generator]] = None
+    ):
         """Return a list RB circuits for the given lengths.
                 Args:
                     lengths: A list of RB sequences lengths.
@@ -110,8 +111,7 @@ def _sample_circuits(self, lengths: Iterable[int],
             circuits += self._generate_circuit(elements, element_lengths)
         return circuits
 
-    def _generate_circuit(self, elements: Iterable[Clifford],
-                          lengths: Iterable[int]):
+    def _generate_circuit(self, elements: Iterable[Clifford], lengths: Iterable[int]):
         """Return the RB circuits constructed from the given element list.
                 Args:
                     elements: A list of Clifford elements

From 3ec2565b38345b7cc35bae15f484287bbd1ccf33 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Mon, 19 Apr 2021 20:25:44 +0300
Subject: [PATCH 15/16] Small change

---
 qiskit_experiments/randomized_benchmarking/rb_experiment.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index 16f5661550..d919fe5554 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -89,8 +89,6 @@ def transpiled_circuits(self, backend=None, **kwargs):
                          layout must be generated from the experiment.
         """
         circuits = super().transpiled_circuits(backend=backend, **kwargs)
-        # TODO: Add functionality for gates per clifford which depends
-        # on the transpiled circuit gates
         return circuits
 
     def _sample_circuits(

From 35bc2fd20d3650718fdf139c1013d36912e664c1 Mon Sep 17 00:00:00 2001
From: Gadi Aleksandrowicz <gadial@gmail.com>
Date: Mon, 19 Apr 2021 20:31:29 +0300
Subject: [PATCH 16/16] Linting

---
 .../randomized_benchmarking/rb_experiment.py  | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/qiskit_experiments/randomized_benchmarking/rb_experiment.py b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
index d919fe5554..be6163dfdf 100644
--- a/qiskit_experiments/randomized_benchmarking/rb_experiment.py
+++ b/qiskit_experiments/randomized_benchmarking/rb_experiment.py
@@ -95,12 +95,12 @@ def _sample_circuits(
         self, lengths: Iterable[int], seed: Optional[Union[int, Generator]] = None
     ):
         """Return a list RB circuits for the given lengths.
-                Args:
-                    lengths: A list of RB sequences lengths.
-                    seed: Seed or generator object for random number
-                          generation. If None default_rng will be used.
-                Returns:
-                    List[QuantumCircuit]: A list of :class:`QuantumCircuit`s.
+        Args:
+            lengths: A list of RB sequences lengths.
+            seed: Seed or generator object for random number
+                  generation. If None default_rng will be used.
+        Returns:
+            List[QuantumCircuit]: A list of :class:`QuantumCircuit`s.
         """
         circuits = []
         for length in lengths if self._full_sampling else [lengths[-1]]:
@@ -111,14 +111,14 @@ def _sample_circuits(
 
     def _generate_circuit(self, elements: Iterable[Clifford], lengths: Iterable[int]):
         """Return the RB circuits constructed from the given element list.
-                Args:
-                    elements: A list of Clifford elements
-                    lengths: A list of RB sequences lengths.
-                Returns:
-                    List[QuantumCircuit]: A list of :class:`QuantumCircuit`s.
-                Additional information:
-                    The circuits are constructed iteratively; each circuit is obtained
-                    by extending the previous circuit (without the inversion and measurement gates)
+        Args:
+            elements: A list of Clifford elements
+            lengths: A list of RB sequences lengths.
+        Returns:
+            List[QuantumCircuit]: A list of :class:`QuantumCircuit`s.
+        Additional information:
+            The circuits are constructed iteratively; each circuit is obtained
+            by extending the previous circuit (without the inversion and measurement gates)
         """
         qubits = list(range(self.num_qubits))
         circuits = []