Repository: Infleqtion/client-superstaq (language: python)

Issue:
Feature/base qcvv framework
In preparation for the XEB/IRB benchmarking routines, this PR implements some common functionality that can form the basis of a wide QCVV within superstaq.


Discussion / hints:
Check out this pull request on&nbsp; <a href="https://app.reviewnb.com/Infleqtion/client-superstaq/pull/992"><img align="absmiddle"  alt="ReviewNB" height="28" class="BotMessageButtonImage" src="https://raw.githubusercontent.com/ReviewNB/support/master/images/button_reviewnb.png"/></a> 

 See visual diffs & provide feedback on Jupyter Notebooks. 

---

 <i>Powered by <a href='https://www.reviewnb.com/?utm_source=gh'>ReviewNB</a></i>

Fix patch:
diff --git a/docs/source/apps/supermarq/qcvv/qcvv.rst b/docs/source/apps/supermarq/qcvv/qcvv.rst
index be220eb31..363104316 100644
--- a/docs/source/apps/supermarq/qcvv/qcvv.rst
+++ b/docs/source/apps/supermarq/qcvv/qcvv.rst
@@ -11,14 +11,14 @@ For a demonstration of how to implement a new experiment take a look at the foll
 
     qcvv_css
 
-
 Alternatively for pre-build experiments that can be used out of the box see
 
 .. toctree::
     :maxdepth: 1
-
+    
+    qcvv_irb_css
     qcvv_xeb_css
 
 .. note::
 
-    At present the QCVV library is only available in :code:`cirq-superstaq`.
\ No newline at end of file
+    At present the QCVV library is only available in :code:`cirq-superstaq`.
diff --git a/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb b/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb
new file mode 100644
index 000000000..793bf499c
--- /dev/null
+++ b/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb
@@ -0,0 +1,188 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Interleaved Randomized Benchmarking (IRB)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The interleaved randomized benchmarking routine allows us to estimate the gate fidelity of single\n",
+    "qubit Clifford gates. To demonstrate this routine, consider device noise modelled by an amplitude \n",
+    "damping channel with decay probability $\\gamma=0.01$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cirq\n",
+    "import numpy as np\n",
+    "import supermarq"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "decay_prob = 0.025\n",
+    "noise = cirq.AmplitudeDampingChannel(gamma=decay_prob)\n",
+    "simulator = cirq.DensityMatrixSimulator(noise=noise)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can calculate the average fidelity of this channel [as](https://quantumcomputing.stackexchange.com/questions/16074/how-to-calculate-the-average-fidelity-of-an-amplitude-damping-channel):\n",
+    "$$\\begin{align}\n",
+    "\\overline{F} &= \\int\\langle\\psi|\\mathcal{N_\\gamma}(|\\psi\\rangle\\langle\\psi|)|\\psi\\rangle d\\psi\\\\\n",
+    "&=\\int\\langle\\psi|K_0|\\psi\\rangle\\langle\\psi|K_0^\\dagger|\\psi\\rangle + \\langle\\psi|K_1|\\psi\\rangle\\langle\\psi|K_1^\\dagger|\\psi\\rangle d\\psi\\\\\n",
+    "& =\\frac{1}{4\\pi}\\int_0^\\pi\\int_0^{2\\pi}\\left|\\begin{pmatrix}\\cos\\frac{\\theta}{2}&e^{-i\\phi}\\sin\\frac{\\theta}{2}\\end{pmatrix}\\begin{pmatrix}1 & 0 \\\\0 & \\sqrt{1 - \\gamma}\\end{pmatrix}\\begin{pmatrix}\\cos\\frac{\\theta}{2}\\\\e^{i\\phi}\\sin\\frac{\\theta}{2}\\end{pmatrix}\\right|^2\\sin\\theta \\\\\n",
+    "& + \\left|\\begin{pmatrix}\\cos\\frac{\\theta}{2}&e^{-i\\phi}\\sin\\frac{\\theta}{2}\\end{pmatrix}\\begin{pmatrix}0 & \\sqrt{\\gamma} \\\\0 & 0\\end{pmatrix}\\begin{pmatrix}\\cos\\frac{\\theta}{2}\\\\e^{i\\phi}\\sin\\frac{\\theta}{2}\\end{pmatrix}\\right|^2\\sin\\theta d\\phi d\\theta \\\\\n",
+    "&=\\frac{1}{4\\pi}\\int_0^\\pi\\int_0^{2\\pi}\\left|\\cos^2\\frac{\\theta}{2}+\\sqrt{1-\\gamma}\\sin^2\\frac{\\theta}{2}\\right|^2\\sin\\theta + \\left|\\sqrt{\\gamma}e^{i\\phi}\\sin\\frac{\\theta}{2}\\cos\\frac{\\theta}{2}\\right|^2\\sin\\theta d\\phi d\\theta \\\\\n",
+    "&=\\frac{1}{2}\\int_0^\\pi\\left(\\cos^4\\frac{\\theta}{2}+(1-\\gamma)\\sin^4\\frac{\\theta}{2}+\\frac{\\sqrt{1-\\gamma}}{2}\\sin^2\\theta + \\frac{\\gamma}{4}\\sin^2\\theta\\right)\\sin\\theta d\\theta \\\\\n",
+    "&=\\frac{1}{2}\\int_0^\\pi\\sin\\theta\\cos^4\\frac{\\theta}{2}+(1-\\gamma)\\sin\\theta\\sin^4\\frac{\\theta}{2}+\\frac{\\gamma+2\\sqrt{1-\\gamma}}{4}\\sin^3\\theta d\\theta \\\\\n",
+    "&=\\frac{1}{2}\\left(\\frac{2}{3} + (1-\\gamma)\\frac{2}{3} + \\frac{\\gamma+2\\sqrt{1-\\gamma}}{4}\\frac{4}{3}\\right) \\\\\n",
+    "&=\\frac{1}{2}\\left(\\frac{4}{3} - \\frac{\\gamma}{3} + \\frac{2\\sqrt{1-\\gamma}}{3}\\right) \\\\\n",
+    "&=\\frac{2}{3}-\\frac{\\gamma}{6} + \\frac{\\sqrt{1-\\gamma}}{3}.\n",
+    "\\end{align}$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Thus we have a gate error $$\\frac{1}{3}+\\frac{\\gamma}{6} - \\frac{\\sqrt{1-\\gamma}}{3}$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "expected_gate_error = 1 / 3 + decay_prob / 6 - np.sqrt(1 - decay_prob) / 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3707426ff75d42b18b4f7329a12bd870",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Building circuits:   0%|          | 0/400 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3f98bdcc70504c759ea0583c79dab7c9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Simulating circuits:   0%|          | 0/800 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "experiment = supermarq.qcvv.IRB(interleaved_gate=cirq.ops.SingleQubitCliffordGate.Y)\n",
+    "experiment.prepare_experiment(100, [1, 5, 10, 15])\n",
+    "experiment.run_with_simulator(simulator=simulator)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "IRBResults(target='Local simulator', total_circuits=800, experiment_name='IRB', rb_layer_fidelity=0.9835345476930657, rb_layer_fidelity_std=0.0004865849120610916, irb_layer_fidelity=0.9672464523458026, irb_layer_fidelity_std=0.000336442324359281, average_interleaved_gate_error=0.008280388007451123, average_interleaved_gate_error_std=0.0002973777530802783)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 590.861x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if experiment.collect_data():\n",
+    "    results = experiment.analyze_results(plot_results=True)\n",
+    "    print(results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Expected gate error: 0.008360\n",
+      "Measured gate error: 0.008280 +/- 0.000297\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Expected gate error: {expected_gate_error:.6f}\")\n",
+    "print(\n",
+    "    f\"Measured gate error: {results.average_interleaved_gate_error:.6f} +/- {results.average_interleaved_gate_error_std:.6f}\"\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "client_superstaq",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/supermarq-benchmarks/supermarq/qcvv/__init__.py b/supermarq-benchmarks/supermarq/qcvv/__init__.py
index 14297c050..15a1c194a 100644
--- a/supermarq-benchmarks/supermarq/qcvv/__init__.py
+++ b/supermarq-benchmarks/supermarq/qcvv/__init__.py
@@ -1,12 +1,15 @@
 """A toolkit of QCVV routines."""
 
 from .base_experiment import BenchmarkingExperiment, BenchmarkingResults, Sample
+from .irb import IRB, IRBResults
 from .xeb import XEB, XEBResults, XEBSample
 
 __all__ = [
     "BenchmarkingExperiment",
     "BenchmarkingResults",
     "Sample",
+    "IRB",
+    "IRBResults",
     "XEB",
     "XEBResults",
     "XEBSample",
diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py
index 3d7edd2fd..a812ab25a 100644
--- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py
+++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py
@@ -345,7 +345,7 @@ def _retrieve_jobs(self) -> dict[str, str]:
 
         return statuses
 
-    def _run_check(self) -> None:
+    def _has_raw_data(self) -> None:
         """Checks if any of the samples already have probabilities stored. If so raises a runtime
         error to prevent them from being overwritten.
 
@@ -523,7 +523,7 @@ def run_on_device(
             The superstaq job containing all the circuits submitted as part of the experiment.
         """
         if not overwrite:
-            self._run_check()
+            self._has_raw_data()
 
         experiment_job = self._service.create_job(
             [sample.circuit for sample in self.samples],
@@ -556,7 +556,7 @@ def run_with_simulator(
                 be over written in the process. Defaults to False.
         """
         if not overwrite:
-            self._run_check()
+            self._has_raw_data()
 
         if simulator is None:
             simulator = cirq.Simulator()
@@ -593,7 +593,7 @@ def run_with_callable(
             RuntimeError: If the returned probabilities dictionary values do not sum to 1.0.
         """
         if not overwrite:
-            self._run_check()
+            self._has_raw_data()
         for sample in tqdm(self.samples, desc="Running circuits"):
             probability = circuit_eval_func(sample.circuit, **kwargs)
             if not all(len(key) == self.num_qubits for key in probability.keys()):
diff --git a/supermarq-benchmarks/supermarq/qcvv/irb.py b/supermarq-benchmarks/supermarq/qcvv/irb.py
new file mode 100644
index 000000000..dbd8824c3
--- /dev/null
+++ b/supermarq-benchmarks/supermarq/qcvv/irb.py
@@ -0,0 +1,292 @@
+# Copyright 2021 The Cirq Developers
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tooling for interleaved randomised benchmarking
+"""
+
+from __future__ import annotations
+
+import random
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+
+import cirq
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from scipy.stats import linregress
+from tqdm.contrib.itertools import product
+
+from supermarq.qcvv.base_experiment import BenchmarkingExperiment, BenchmarkingResults, Sample
+
+
+@dataclass(frozen=True)
+class IRBResults(BenchmarkingResults):
+    """Data structure for the IRB experiment results."""
+
+    rb_layer_fidelity: float
+    """Layer fidelity estimate without the interleaving gate."""
+    rb_layer_fidelity_std: float
+    """Standard deviation of the layer fidelity estimate without the interleaving gate."""
+    irb_layer_fidelity: float
+    """Layer fidelity estimate with the interleaving gate."""
+    irb_layer_fidelity_std: float
+    """Standard deviation of the layer fidelity estimate with the interleaving gate."""
+    average_interleaved_gate_error: float
+    """Estimate of the interleaving gate error."""
+    average_interleaved_gate_error_std: float
+    """Standard deviation of the estimate for the interleaving gate error."""
+
+    experiment_name = "IRB"
+
+
+class IRB(BenchmarkingExperiment[IRBResults]):
+    r"""Interleaved random benchmarking (IRB) experiment.
+
+    IRB estimates the gate error of specified Clifford gate, :math:`\mathcal{C}^*`.
+    This is achieved by first choosing a random sequence, :math:`\{\mathcal{C_i}\}_m`
+    of :math:`m` Clifford gates and then using this to generate two circuits. The first
+    is generated by appending to this sequence the single gate that corresponds to the
+    inverse of the original sequence. The second circuit it obtained by inserting the
+    interleaving gate, :math:`\mathcal{C}^*` after each gate in the sequence and then
+    again appending the corresponding inverse element of the new circuit. Thus both
+    circuits correspond to the identity operation.
+
+    We run both circuits on the specified target and calculate the probability of measuring
+    the resulting state in the ground state, :math:`p(0...0)`. This gives the circuit fidelity
+
+    .. math::
+
+        f(m) = 2p(0...0) - 1
+
+    We can then fit an exponential decay :math:`\log(f) \sim m` to this circuit fidelity
+    for each circuit, with decay rates :math:`\alpha` and :math:`\tilde{\alpha}` for the circuit
+    without and with interleaving respectively. Finally the gate error of the
+    specified gate, :math:`\mathcal{C}^*` is estimated as
+
+    .. math::
+
+        e_{\mathcal{C}^*} = \frac{1}{2} \left(1 - \frac{\tilde{\alpha}}{\alpha}\right)
+
+    For more details see: https://arxiv.org/abs/1203.4550
+    """
+
+    def __init__(
+        self,
+        interleaved_gate: cirq.ops.SingleQubitCliffordGate = cirq.ops.SingleQubitCliffordGate.Z,
+        num_qubits: int = 1,
+    ) -> None:
+        """Constructs an IRB experiment.
+
+        Args:
+            interleaved_gate: The single qubit Clifford gate to measure the gate error of.
+            num_qubits: The number of qubits to experiment on
+        """
+        if num_qubits != 1:
+            raise NotImplementedError(
+                "IRB experiment is currently only implemented for single qubit use"
+            )
+        super().__init__(num_qubits=1)
+
+        self.interleaved_gate = interleaved_gate
+        """The gate being interleaved"""
+
+    @staticmethod
+    def _reduce_clifford_seq(
+        gate_seq: list[cirq.ops.SingleQubitCliffordGate],
+    ) -> cirq.ops.SingleQubitCliffordGate:
+        """Reduces a list of single qubit clifford gates to a single gate.
+
+        Args:
+            gate_seq: The list of gates.
+            The single reduced gate.
+        Returns:
+            The single reduced gate
+        """
+        cur = gate_seq[0]
+        for gate in gate_seq[1:]:
+            cur = cur.merged_with(gate)
+        return cur
+
+    @classmethod
+    def _random_single_qubit_clifford(cls) -> cirq.ops.SingleQubitCliffordGate:
+        """Choose a random single qubit clifford gate.
+
+        Returns:
+            The random clifford gate.
+        """
+        Id = cirq.ops.SingleQubitCliffordGate.I
+        H = cirq.ops.SingleQubitCliffordGate.H
+        S = cirq.ops.SingleQubitCliffordGate.Z_sqrt
+        X = cirq.ops.SingleQubitCliffordGate.X
+        Y = cirq.ops.SingleQubitCliffordGate.Y
+        Z = cirq.ops.SingleQubitCliffordGate.Z
+
+        set_A = [
+            Id,
+            S,
+            H,
+            cls._reduce_clifford_seq([H, S]),
+            cls._reduce_clifford_seq([S, H]),
+            cls._reduce_clifford_seq([H, S, H]),
+        ]
+
+        set_B = [Id, X, Y, Z]
+
+        return cls._reduce_clifford_seq([random.choice(set_A), random.choice(set_B)])
+
+    def _invert_clifford_circuit(self, circuit: cirq.Circuit) -> cirq.Circuit:
+        """Given a Clifford circuit find and append the corresponding inverse Clifford gate.
+
+        Args:
+            circuit: The Clifford circuit to invert.
+
+        Returns:
+            A copy of the original Clifford circuit with the inverse element appended.
+        """
+        clifford_gates = [op.gate for op in circuit.all_operations()]
+        inv_element = self._reduce_clifford_seq(
+            cirq.inverse(clifford_gates)  # type: ignore[arg-type]
+        )
+        return circuit + inv_element(*self.qubits)
+
+    def _build_circuits(self, num_circuits: int, cycle_depths: Iterable[int]) -> Sequence[Sample]:
+        """Build a list of randomised circuits required for the IRB experiment.
+
+        Args:
+            num_circuits: Number of circuits to generate.
+            cycle_depths: An iterable of the different cycle depths to use during the experiment.
+
+        Returns:
+            The list of experiment samples.
+        """
+        samples = []
+        for _, depth in product(range(num_circuits), cycle_depths, desc="Building circuits"):
+            base_circuit = cirq.Circuit(
+                *[self._random_single_qubit_clifford()(*self.qubits) for _ in range(depth)]
+            )
+            rb_circuit = self._invert_clifford_circuit(base_circuit)
+            irb_circuit = self._invert_clifford_circuit(
+                self._interleave_op(
+                    base_circuit, self.interleaved_gate(*self.qubits), include_final=True
+                )
+            )
+            samples += [
+                Sample(
+                    raw_circuit=rb_circuit + cirq.measure(sorted(rb_circuit.all_qubits())),
+                    data={
+                        "num_cycles": depth,
+                        "circuit_depth": len(rb_circuit),
+                        "experiment": "RB",
+                    },
+                ),
+                Sample(
+                    raw_circuit=irb_circuit + cirq.measure(sorted(irb_circuit.all_qubits())),
+                    data={
+                        "num_cycles": depth,
+                        "circuit_depth": len(irb_circuit),
+                        "experiment": "IRB",
+                    },
+                ),
+            ]
+
+        return samples
+
+    def _process_probabilities(self, samples: Sequence[Sample]) -> pd.DataFrame:
+        """Processes the probabilities generated by sampling the circuits into the data structures
+        needed for analyzing the results.
+
+        Args:
+            samples: The list of samples to process the results from.
+
+        Returns:
+            A data frame of the full results needed to analyse the experiment.
+        """
+
+        records = []
+        for sample in samples:
+            records.append(
+                {
+                    "clifford_depth": sample.data["num_cycles"],
+                    "circuit_depth": sample.data["circuit_depth"],
+                    "experiment": sample.data["experiment"],
+                    **sample.probabilities,
+                }
+            )
+
+        return pd.DataFrame(records)
+
+    def plot_results(self) -> None:
+        """Plot the exponential decay of the circuit fidelity with cycle depth."""
+        plot = sns.lmplot(
+            data=self.raw_data,
+            x="clifford_depth",
+            y="log_fidelity",
+            hue="experiment",
+        )
+        ax = plot.axes.item()
+        plot.tight_layout()
+        ax.set_xlabel(r"Cycle depth", fontsize=15)
+        ax.set_ylabel(r"Log Circuit fidelity", fontsize=15)
+        ax.set_title(r"Exponential decay of circuit fidelity", fontsize=15)
+
+    def analyze_results(self, plot_results: bool = True) -> IRBResults:
+        """Analyse the experiment results and estimate the interleaved gate error.
+
+        Args:
+            plot_results: Whether to generate plots of the results. Defaults to False.
+
+        Returns:
+            A named tuple of the final results from the experiment.
+        """
+
+        self.raw_data["fidelity"] = 2 * self.raw_data["0"] - 1
+        self.raw_data["log_fidelity"] = np.log(self.raw_data["fidelity"])
+        self.raw_data.dropna(axis=0, inplace=True)  # Remove any NaNs coming from the P(0) < 0.5
+
+        rb_model = linregress(
+            self.raw_data.query("experiment == 'RB'")["clifford_depth"],
+            np.log(self.raw_data.query("experiment == 'RB'")["fidelity"]),
+        )
+        irb_model = linregress(
+            self.raw_data.query("experiment == 'IRB'")["clifford_depth"],
+            np.log(self.raw_data.query("experiment == 'IRB'")["fidelity"]),
+        )
+
+        # Extract fit values.
+        rb_layer_fidelity = np.exp(rb_model.slope)
+        rb_layer_fidelity_std = rb_model.stderr * rb_layer_fidelity
+        irb_layer_fidelity = np.exp(irb_model.slope)
+        irb_layer_fidelity_std = irb_model.stderr * irb_layer_fidelity
+
+        interleaved_gate_error = (1 - irb_layer_fidelity / rb_layer_fidelity) / 2
+
+        interleaved_gate_error_std = np.sqrt(
+            (irb_layer_fidelity_std / (2 * rb_layer_fidelity)) ** 2
+            + ((irb_layer_fidelity * rb_layer_fidelity_std) / (2 * rb_layer_fidelity**2)) ** 2
+        )
+
+        self._results = IRBResults(
+            target="& ".join(self.targets),
+            total_circuits=len(self.samples),
+            rb_layer_fidelity=rb_layer_fidelity,
+            rb_layer_fidelity_std=rb_layer_fidelity_std,
+            irb_layer_fidelity=irb_layer_fidelity,
+            irb_layer_fidelity_std=irb_layer_fidelity_std,
+            average_interleaved_gate_error=interleaved_gate_error,
+            average_interleaved_gate_error_std=interleaved_gate_error_std,
+        )
+
+        if plot_results:
+            self.plot_results()
+
+        return self.results
diff --git a/supermarq-benchmarks/supermarq/qcvv/xeb.py b/supermarq-benchmarks/supermarq/qcvv/xeb.py
index f3c2a5ddb..dfc23d29e 100644
--- a/supermarq-benchmarks/supermarq/qcvv/xeb.py
+++ b/supermarq-benchmarks/supermarq/qcvv/xeb.py
@@ -117,6 +117,8 @@ class XEB(BenchmarkingExperiment[XEBResults]):
 
     Thus fitting another linear model to :math:`\log(f_d) \sim d` provides us with an estimate
     of the cycle fidelity.
+
+    For more details see: https://www.nature.com/articles/s41586-019-1666-5
     """
 
     def __init__(


Test patch:
diff --git a/supermarq-benchmarks/supermarq/qcvv/irb_test.py b/supermarq-benchmarks/supermarq/qcvv/irb_test.py
new file mode 100644
index 000000000..0106dc11c
--- /dev/null
+++ b/supermarq-benchmarks/supermarq/qcvv/irb_test.py
@@ -0,0 +1,281 @@
+# Copyright 2021 The Cirq Developers
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# pylint: disable=missing-function-docstring
+# pylint: disable=missing-return-doc
+# mypy: disable-error-code=method-assign
+from __future__ import annotations
+
+import os
+from unittest.mock import MagicMock, patch
+
+import cirq
+import pandas as pd
+import pytest
+
+from supermarq.qcvv.base_experiment import Sample
+from supermarq.qcvv.irb import IRB
+
+
+@pytest.fixture(scope="session", autouse=True)
+def patch_tqdm() -> None:
+    os.environ["TQDM_DISABLE"] = "1"
+
+
+def test_irb_init() -> None:
+    with patch("cirq_superstaq.service.Service"):
+        experiment = IRB()
+        assert experiment.num_qubits == 1
+        assert experiment.interleaved_gate == cirq.ops.SingleQubitCliffordGate.Z
+
+        experiment = IRB(interleaved_gate=cirq.ops.SingleQubitCliffordGate.X)
+        assert experiment.num_qubits == 1
+        assert experiment.interleaved_gate == cirq.ops.SingleQubitCliffordGate.X
+
+        with pytest.raises(NotImplementedError):
+            IRB(num_qubits=2)
+
+
+@pytest.fixture
+def irb_experiment() -> IRB:
+    with patch("cirq_superstaq.service.Service"):
+        return IRB()
+
+
+def test_reduce_clifford_sequence() -> None:
+    sequence = [
+        cirq.ops.SingleQubitCliffordGate.X,
+        cirq.ops.SingleQubitCliffordGate.X,
+        cirq.ops.SingleQubitCliffordGate.Z,
+    ]
+
+    combined_gate = IRB._reduce_clifford_seq(sequence)
+    assert combined_gate == cirq.ops.SingleQubitCliffordGate.Z
+
+
+def test_random_single_qubit_clifford() -> None:
+    gate = IRB._random_single_qubit_clifford()
+    assert isinstance(gate, cirq.ops.SingleQubitCliffordGate)
+
+
+def test_invert_clifford_circuit(irb_experiment: IRB) -> None:
+    circuit = cirq.Circuit(
+        [
+            cirq.ops.SingleQubitCliffordGate.X(irb_experiment.qubits[0]),
+            cirq.ops.SingleQubitCliffordGate.Y(irb_experiment.qubits[0]),
+        ]
+    )
+    inverse = irb_experiment._invert_clifford_circuit(circuit)
+    expected_inverse = circuit + cirq.ops.SingleQubitCliffordGate.Z(irb_experiment.qubits[0])
+
+    cirq.testing.assert_same_circuits(inverse, expected_inverse)
+
+
+def test_irb_process_probabilities(irb_experiment: IRB) -> None:
+    samples = [
+        Sample(
+            raw_circuit=cirq.Circuit(),
+            data={
+                "num_cycles": 20,
+                "circuit_depth": 23,
+                "experiment": "example",
+            },
+        )
+    ]
+    samples[0].probabilities = {"00": 0.1, "01": 0.2, "10": 0.3, "11": 0.4}
+
+    data = irb_experiment._process_probabilities(samples)
+
+    expected_data = pd.DataFrame(
+        [
+            {
+                "clifford_depth": 20,
+                "circuit_depth": 23,
+                "experiment": "example",
+                "00": 0.1,
+                "01": 0.2,
+                "10": 0.3,
+                "11": 0.4,
+            }
+        ]
+    )
+
+    pd.testing.assert_frame_equal(expected_data, data)
+
+
+def test_irb_build_circuit(irb_experiment: IRB) -> None:
+    irb_experiment._random_single_qubit_clifford = (mock_random_clifford := MagicMock())
+    mock_random_clifford.side_effect = [
+        cirq.ops.SingleQubitCliffordGate.Z,
+        cirq.ops.SingleQubitCliffordGate.Z,
+        cirq.ops.SingleQubitCliffordGate.Z,
+        cirq.ops.SingleQubitCliffordGate.X,
+        cirq.ops.SingleQubitCliffordGate.X,
+        cirq.ops.SingleQubitCliffordGate.X,
+    ]
+
+    circuits = irb_experiment._build_circuits(2, [3])
+    expected_circuits = [
+        Sample(
+            raw_circuit=cirq.Circuit(
+                [
+                    cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits),
+                    cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits),
+                    cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits),
+                    cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits),
+                    cirq.measure(irb_experiment.qubits),
+                ]
+            ),
+            data={
+                "num_cycles": 3,
+                "circuit_depth": 4,
+                "experiment": "RB",
+            },
+        ),
+        Sample(
+            raw_circuit=cirq.Circuit(
+                [
+                    cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits),
+                    cirq.TaggedOperation(
+                        cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile"
+                    ),
+                    cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits),
+                    cirq.TaggedOperation(
+                        cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile"
+                    ),
+                    cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits),
+                    cirq.TaggedOperation(
+                        cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile"
+                    ),
+                    cirq.ops.SingleQubitCliffordGate.I(*irb_experiment.qubits),
+                    cirq.measure(irb_experiment.qubits),
+                ]
+            ),
+            data={
+                "num_cycles": 3,
+                "circuit_depth": 7,
+                "experiment": "IRB",
+            },
+        ),
+        Sample(
+            raw_circuit=cirq.Circuit(
+                [
+                    cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits),
+                    cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits),
+                    cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits),
+                    cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits),
+                    cirq.measure(irb_experiment.qubits),
+                ]
+            ),
+            data={
+                "num_cycles": 3,
+                "circuit_depth": 4,
+                "experiment": "RB",
+            },
+        ),
+        Sample(
+            raw_circuit=cirq.Circuit(
+                [
+                    cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits),
+                    cirq.TaggedOperation(
+                        cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile"
+                    ),
+                    cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits),
+                    cirq.TaggedOperation(
+                        cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile"
+                    ),
+                    cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits),
+                    cirq.TaggedOperation(
+                        cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile"
+                    ),
+                    cirq.ops.SingleQubitCliffordGate.Y(*irb_experiment.qubits),
+                    cirq.measure(irb_experiment.qubits),
+                ]
+            ),
+            data={
+                "num_cycles": 3,
+                "circuit_depth": 7,
+                "experiment": "IRB",
+            },
+        ),
+    ]
+
+    assert len(circuits) == 4
+
+    cirq.testing.assert_same_circuits(circuits[0].circuit, expected_circuits[0].circuit)
+    assert circuits[0].data == expected_circuits[0].data
+    cirq.testing.assert_same_circuits(circuits[1].circuit, expected_circuits[1].circuit)
+    assert circuits[1].data == expected_circuits[1].data
+    cirq.testing.assert_same_circuits(circuits[2].circuit, expected_circuits[2].circuit)
+    assert circuits[2].data == expected_circuits[2].data
+    cirq.testing.assert_same_circuits(circuits[3].circuit, expected_circuits[3].circuit)
+    assert circuits[3].data == expected_circuits[3].data
+
+
+def test_analyse_results(irb_experiment: IRB) -> None:
+    irb_experiment._samples = MagicMock()
+    irb_experiment._raw_data = pd.DataFrame(
+        [
+            {
+                "clifford_depth": 1,
+                "circuit_depth": 2,
+                "experiment": "RB",
+                "0": 0.5 * 0.95**1 + 0.5,
+                "1": 0.5 - 0.5 * 0.95**1,
+            },
+            {
+                "clifford_depth": 1,
+                "circuit_depth": 3,
+                "experiment": "IRB",
+                "0": 0.5 * 0.8**1 + 0.5,
+                "1": 0.5 - 0.5 * 0.8**1,
+            },
+            {
+                "clifford_depth": 5,
+                "circuit_depth": 6,
+                "experiment": "RB",
+                "0": 0.5 * 0.95**5 + 0.5,
+                "1": 0.5 - 0.5 * 0.95**5,
+            },
+            {
+                "clifford_depth": 5,
+                "circuit_depth": 11,
+                "experiment": "IRB",
+                "0": 0.5 * 0.8**5 + 0.5,
+                "1": 0.5 - 0.5 * 0.8**5,
+            },
+            {
+                "clifford_depth": 10,
+                "circuit_depth": 11,
+                "experiment": "RB",
+                "0": 0.5 * 0.95**10 + 0.5,
+                "1": 0.5 - 0.5 * 0.95**10,
+            },
+            {
+                "clifford_depth": 10,
+                "circuit_depth": 21,
+                "experiment": "IRB",
+                "0": 0.5 * 0.8**10 + 0.5,
+                "1": 0.5 - 0.5 * 0.8**10,
+            },
+        ]
+    )
+    irb_experiment.analyze_results()
+
+    assert irb_experiment.results.rb_layer_fidelity == pytest.approx(0.95)
+    assert irb_experiment.results.irb_layer_fidelity == pytest.approx(0.8)
+    assert irb_experiment.results.average_interleaved_gate_error == pytest.approx(
+        0.5 * (1 - 0.8 / 0.95)
+    )
+
+    # Test that plotting results doesn't introduce any errors.
+    irb_experiment.plot_results()