diff --git a/cirq-superstaq/cirq_superstaq/qcvv/__init__.py b/cirq-superstaq/cirq_superstaq/qcvv/__init__.py index b530814bd..acff2b136 100644 --- a/cirq-superstaq/cirq_superstaq/qcvv/__init__.py +++ b/cirq-superstaq/cirq_superstaq/qcvv/__init__.py @@ -10,4 +10,10 @@ # 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. \ No newline at end of file +# limitations under the License. +"""A module of tools for quantum characterisation, validation and verification. +""" + +from .xeb import XEB + +__all__ = ["XEB"] diff --git a/cirq-superstaq/cirq_superstaq/qcvv/test_xeb.py b/cirq-superstaq/cirq_superstaq/qcvv/test_xeb.py new file mode 100644 index 000000000..9eb39e4b3 --- /dev/null +++ b/cirq-superstaq/cirq_superstaq/qcvv/test_xeb.py @@ -0,0 +1,238 @@ +# 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 +# mypy: disable-error-code=method-assign +from __future__ import annotations + +import itertools +import os +from unittest.mock import patch + +import cirq +import numpy as np +import pandas as pd +import pytest + +from cirq_superstaq.qcvv.xeb import XEB, XEBSample + + +@pytest.fixture(scope="session", autouse=True) +def patch_tqdm() -> None: + os.environ["TQDM_DISABLE"] = "1" + + +def test_xeb_init() -> None: + experiment = XEB() + assert experiment.num_qubits == 2 + assert experiment.two_qubit_gate == cirq.CZ + assert experiment.single_qubit_gate_set == [ + cirq.PhasedXZGate( + z_exponent=z, + x_exponent=0.5, + axis_phase_exponent=a, + ) + for a, z in itertools.product(np.linspace(start=0, stop=7 / 4, num=8), repeat=2) + ] + + with pytest.raises( + RuntimeError, match="No samples to retrieve. The experiment has not been run." + ): + experiment.samples # pylint: disable=W0104 + + with pytest.raises(RuntimeError, match="No data to retrieve. The experiment has not been run."): + experiment.circuit_fidelities # pylint: disable=W0104 + + experiment = XEB(two_qubit_gate=cirq.CX) + assert experiment.num_qubits == 2 + assert experiment.two_qubit_gate == cirq.CX + assert experiment.single_qubit_gate_set == [ + cirq.PhasedXZGate( + z_exponent=z, + x_exponent=0.5, + axis_phase_exponent=a, + ) + for a, z in itertools.product(np.linspace(start=0, stop=7 / 4, num=8), repeat=2) + ] + + experiment = XEB(single_qubit_gate_set=[cirq.X]) + assert experiment.num_qubits == 2 + assert experiment.two_qubit_gate == cirq.CZ + assert experiment.single_qubit_gate_set == [cirq.X] + + +@pytest.fixture +def xeb_experiment() -> XEB: + return XEB(single_qubit_gate_set=[cirq.X, cirq.Y, cirq.Z]) + + +def test_build_xeb_circuit(xeb_experiment: XEB) -> None: + with patch("cirq_superstaq.qcvv.xeb.random.choices") as random_choice: + random_choice.side_effect = [ + [cirq.X, cirq.Y], + [cirq.Z, cirq.Y], + [cirq.Y, cirq.Z], + [cirq.X, cirq.Z], + [cirq.X, cirq.X], + [cirq.Y, cirq.Y], + ] + circuits = xeb_experiment.build_circuits(num_circuits=2, layers=[2]) + + assert len(circuits) == 2 + + qbs = xeb_experiment.qubits + cirq.testing.assert_same_circuits( + circuits[0].circuit, + cirq.Circuit( + [ + cirq.X(qbs[0]), + cirq.Y(qbs[1]), + cirq.CZ(*qbs), + cirq.Z(qbs[0]), + cirq.Y(qbs[1]), + cirq.CZ(*qbs), + cirq.Y(qbs[0]), + cirq.Z(qbs[1]), + ] + ), + ) + assert circuits[0].data == {"circuit_depth": 5, "num_cycles": 2, "two_qubit_gate": "CZ"} + cirq.testing.assert_same_circuits( + circuits[1].circuit, + cirq.Circuit( + [ + cirq.X(qbs[0]), + cirq.Z(qbs[1]), + cirq.CZ(*qbs), + cirq.X(qbs[0]), + cirq.X(qbs[1]), + cirq.CZ(*qbs), + cirq.Y(qbs[0]), + cirq.Y(qbs[1]), + ] + ), + ) + assert circuits[1].data == {"circuit_depth": 5, "num_cycles": 2, "two_qubit_gate": "CZ"} + + +def test_xeb_analyse_results(xeb_experiment: XEB) -> None: + + # Choose example data to give perfect fit with fidelity=0.95 + xeb_experiment._raw_data = pd.DataFrame( + [ + { + "cycle_depth": 1, + "circuit_depth": 3, + "sum_p(x)p(x)": 0.3, + "sum_p(x)p^(x)": 0.95**1 * 0.3, + }, + { + "cycle_depth": 1, + "circuit_depth": 3, + "sum_p(x)p(x)": 0.5, + "sum_p(x)p^(x)": 0.95**1 * 0.5, + }, + { + "cycle_depth": 5, + "circuit_depth": 11, + "sum_p(x)p(x)": 0.3, + "sum_p(x)p^(x)": 0.95**5 * 0.3, + }, + { + "cycle_depth": 5, + "circuit_depth": 11, + "sum_p(x)p(x)": 0.5, + "sum_p(x)p^(x)": 0.95**5 * 0.5, + }, + { + "cycle_depth": 10, + "circuit_depth": 21, + "sum_p(x)p(x)": 0.3, + "sum_p(x)p^(x)": 0.95**10 * 0.3, + }, + { + "cycle_depth": 10, + "circuit_depth": 21, + "sum_p(x)p(x)": 0.5, + "sum_p(x)p^(x)": 0.95**10 * 0.5, + }, + ] + ) + results = xeb_experiment.analyse_results() + + assert xeb_experiment.results.layer_fidelity_estimate == pytest.approx(0.95) + assert xeb_experiment.results.layer_fidelity_estimate_std == pytest.approx(0.0, abs=1e-8) + + assert results == xeb_experiment.results + + # Call plotting function to test no errors are raised. + xeb_experiment.plot_results() + + +def test_xeb_process_probabilities(xeb_experiment: XEB) -> None: + qubits = cirq.LineQubit.range(2) + + xeb_experiment._samples = [ + XEBSample( + circuit=cirq.Circuit( + [ + cirq.X(qubits[0]), + cirq.X(qubits[1]), + cirq.CX(qubits[0], qubits[1]), + cirq.X(qubits[0]), + cirq.X(qubits[1]), + cirq.measure(qubits), + ] + ), + data={"circuit_depth": 3, "num_cycles": 1, "two_qubit_gate": "CX"}, + ) + ] + xeb_experiment._samples[0].probabilities = {"00": 0.1, "01": 0.3, "10": 0.4, "11": 0.2} + + xeb_experiment.process_probabilities() + + expected_data = pd.DataFrame( + [ + { + "cycle_depth": 1, + "circuit_depth": 3, + "p(00)": 0.0, + "p(01)": 1.0, + "p(10)": 0.0, + "p(11)": 0.0, + "p^(00)": 0.1, + "p^(01)": 0.3, + "p^(10)": 0.4, + "p^(11)": 0.2, + "sum_p(x)p(x)": 1.0, + "sum_p(x)p^(x)": 0.3, + } + ] + ) + + pd.testing.assert_frame_equal(expected_data, xeb_experiment.raw_data) + + +def test_xebsample_sum_probs_square_no_values() -> None: + sample = XEBSample(circuit=cirq.Circuit(), data={}) + with pytest.raises(RuntimeError, match="`target_probabilities` have not yet been initialised"): + sample.sum_target_probs_square() + + +def test_xebsample_sum_cross_sample_probs_no_values() -> None: + sample = XEBSample(circuit=cirq.Circuit(), data={}) + with pytest.raises(RuntimeError, match="`target_probabilities` have not yet been initialised"): + sample.sum_target_cross_sample_probs() + + sample.target_probabilities = {"example": 0.6} + with pytest.raises(RuntimeError, match="`sample_probabilities` have not yet been initialised"): + sample.sum_target_cross_sample_probs() diff --git a/cirq-superstaq/cirq_superstaq/qcvv/xeb.py b/cirq-superstaq/cirq_superstaq/qcvv/xeb.py new file mode 100644 index 000000000..2ac441f20 --- /dev/null +++ b/cirq-superstaq/cirq_superstaq/qcvv/xeb.py @@ -0,0 +1,347 @@ +# 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 cross entropy benchmark experiments. +""" +from __future__ import annotations + +import itertools +import random +from collections.abc import Iterable, Sequence +from dataclasses import dataclass, field +from typing import NamedTuple, cast + +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 cirq_superstaq.qcvv.base_experiment import BenchmarkingExperiment, Sample + + +@dataclass +class XEBSample(Sample): + """The samples used in XEB experiments.""" + + target_probabilities: dict[str, float] = field(init=False) + """The target probabilities obtained through a noiseless simulator""" + sample_probabilities: dict[str, float] = field(init=False) + """The sample probabilities obtained from the chosen target""" + + def sum_target_probs_square(self) -> float: + """Compute the sum of the squared target probabilities. + + Raises: + RuntimeError: If no target probabilities have been initialised. + + Returns: + float: The sum of squared target probabilities. + """ + if not hasattr(self, "target_probabilities"): + raise RuntimeError("`target_probabilities` have not yet been initialised") + + return sum(prob**2 for prob in self.target_probabilities.values()) + + def sum_target_cross_sample_probs(self) -> float: + """Compute the dot product between the sample and target probabilities + + Raises: + RuntimeError: If either the target or sample probabilities have not yet been + initialised. + + Returns: + float: The dot product between the sample and target probabilities. + """ + if not hasattr(self, "target_probabilities"): + raise RuntimeError("`target_probabilities` have not yet been initialised") + + if not hasattr(self, "sample_probabilities"): + raise RuntimeError("`sample_probabilities` have not yet been initialised") + + return sum( + self.target_probabilities[state] * self.sample_probabilities[state] + for state in self.target_probabilities + ) + + +class XEBResults(NamedTuple): + """Results from an XEB experiment.""" + + layer_fidelity_estimate: float + """Estimated layer fidelity.""" + layer_fidelity_estimate_std: float + """Standard deviation for the layer fidelity estimate.""" + + +class XEB(BenchmarkingExperiment): + r"""Cross-entropy benchmarking (XEB) experiment. + + The XEB experiment can be used to estimate the combined fidelity of a repeating + layer of gates. In our case, where we restrict ourselves to two qubits, we use + layers made up of two randomly selected single qubit phased XZ gates and a constant + two qubit gate. This is illustrated as follows: + + .. image:: ../../superstaq/qcvv/XEB_Random_Circuit.png + + For each randomly generated circuit, with a given number of layers, we compare the + simulated state probabilities, :math:`p(x)` with those achieved by running the circuit + on a given target, :math:`\hat{p}(x)`. The fidelity of a circuit containing :math:`d` + layers, :math:`f_d` can then be estimated as + + .. math:: + + \sum_{x \in \{0, 1\}^n} p(x) \hat{p}(x) - \frac{1}{2^n} = + f_d \left(\sum_{x \in \{0, 1\}^n} p(x)^2 - \frac{1}{2^n}\right) + + We can therefore fit a linear model to estimate the value of :math:`f_d`. We the estimate + the fidelity of the layer, :math:`f_{\mathrm{layer}}` as + + .. math:: + + f_d = A(f_{layer})^d + + Thus fitting another linear model to :math:`\log(f_d) \sim d` provides us with an estimate + of the layer fidelity. + """ + + def __init__( + self, + single_qubit_gate_set: list[cirq.Gate] | None = None, + two_qubit_gate: cirq.Gate | None = cirq.CZ, + ): + """Args: + single_qubit_gate_set: Optional list of single qubit gates to randomly sample + from when generating random circuits. If not provided defaults to phased + XZ gates with + 1/4 pi intervals. + two_qubit_gate: The two qubit gate to interleave between the single qubit gates. If + None then no two qubit gate is used. Defaults to control-Z gate. + """ + super().__init__(num_qubits=2) + + self._circuit_fidelities: pd.DataFrame | None = None + + self._samples: Sequence[XEBSample] | None = None # Overwrite with modified sampled object + + self.two_qubit_gate: cirq.Gate | None = two_qubit_gate + """The two qubit get to use for interleaving""" + + self.single_qubit_gate_set: list[cirq.Gate] + """The single qubit gates to randomly sample from""" + + if single_qubit_gate_set is None: + gate_exponents = np.linspace(start=0, stop=7 / 4, num=8) + self.single_qubit_gate_set = [ + cirq.PhasedXZGate( + z_exponent=z, # 1) Choose an axis in the xy-plane, zπ from the +x-axis. + x_exponent=0.5, # 2) Rotate about the axis in 1) by a fixed π/2. + axis_phase_exponent=a, # 3) Rotate about the +z-axis by aπ (a final phasing). + ) + for a, z in itertools.product( + gate_exponents, repeat=2 + ) # enumerates every possible (a, z) + ] + else: + self.single_qubit_gate_set = single_qubit_gate_set + + @property + def samples(self) -> Sequence[XEBSample]: # Overwrite with XEBSample return type + """The samples generated during the experiment. + + Raises: + RuntimeError: If no samples are available. + """ + if self._samples is None: + raise RuntimeError("No samples to retrieve. The experiment has not been run.") + + return self._samples + + @property + def results(self) -> XEBResults: + """The results from the most recently run experiment""" + return cast("XEBResults", super().results) + + @property + def circuit_fidelities(self) -> pd.DataFrame: + """The circuit fidelity calculations from the most recently run experiment. + + Raises: + RuntimeError: If no data is available. + """ + if self._circuit_fidelities is None: + raise RuntimeError("No data to retrieve. The experiment has not been run.") + + return self._circuit_fidelities + + def build_circuits( + self, + num_circuits: int, + layers: Iterable[int], + ) -> Sequence[Sample]: + """Build a list of random circuits to perform the XEB experiment with + + Args: + num_circuits: Number of circuits to generate. + layers: An iterable of the different numbers of layers to include in each circuit. + + Returns: + A list of randomly generated circuit samples. + """ + random_circuits = [] + for _, depth in product(range(num_circuits), layers, desc="Building circuits"): + circuit = cirq.Circuit() + for _ in range(depth + int(self.two_qubit_gate is not None)): + circuit.append( + [ + gate(qubit) + for gate, qubit in zip( + random.choices(self.single_qubit_gate_set, k=2), self.qubits + ) + ] + ) + + if self.two_qubit_gate is not None: + circuit = self._interleave_gate(circuit, self.two_qubit_gate) + + random_circuits.append( + XEBSample( + circuit=circuit, + data={ + "circuit_depth": len(circuit), + "num_cycles": depth, + "two_qubit_gate": str(self.two_qubit_gate), + }, + ) + ) + + return random_circuits + + def process_probabilities(self) -> None: + """Processes the probabilities generated by sampling the circuits into the data structures + needed for analyzing the results. + """ + super().process_probabilities() + + for sample in self.samples: + sample.sample_probabilities = sample.probabilities + sample.probabilities = {} + + self.sample_circuits_with_simulator( + target=cirq.Simulator(), + shots=10_000, + ) + + for sample in self.samples: + sample.target_probabilities = sample.probabilities + sample.probabilities = {} + + records = [] + for sample in self.samples: + target_probabilities = { + f"p({key})": value for key, value in sample.target_probabilities.items() + } + sample_probabilities = { + f"p^({key})": value for key, value in sample.sample_probabilities.items() + } + records.append( + { + "cycle_depth": sample.data["num_cycles"], + "circuit_depth": sample.data["circuit_depth"], + **target_probabilities, + **sample_probabilities, + "sum_p(x)p(x)": sample.sum_target_probs_square(), + "sum_p(x)p^(x)": sample.sum_target_cross_sample_probs(), + } + ) + self._raw_data = pd.DataFrame(records) + + def plot_results(self) -> None: + """Plot the experiment data and the corresponding fits.""" + plot_1 = sns.lmplot( + data=self.raw_data, + x="sum_p(x)p(x)", + y="sum_p(x)p^(x)", + hue="cycle_depth", + palette="dark:r", + legend="full", + ci=None, + ) + sns.move_legend(plot_1, "center right") + ax_1 = plot_1.axes.item() + plot_1.tight_layout() + ax_1.set_xlabel(r"$\sum p(x)^2$", fontsize=15) + ax_1.set_ylabel(r"$\sum p(x) \hat{p}(x)$", fontsize=15) + ax_1.set_title(r"Linear fit per cycle depth", fontsize=15) + + plot_2 = sns.lmplot( + data=self.circuit_fidelities, + x="cycle_depth", + y="log_fidelity_estimate", + ) + ax_2 = plot_2.axes.item() + plot_2.tight_layout() + ax_2.set_xlabel(r"Cycle depth", fontsize=15) + ax_2.set_ylabel(r"Log Circuit fidelity", fontsize=15) + ax_2.set_title(r"Exponential decay of circuit fidelity", fontsize=15) + + def analyse_results(self, plot_results: bool = True) -> XEBResults: + """Analyse the results and calculate the estimated circuit fidelity. + + Args: + plot_results (optional): Whether to generate the data plots. Defaults to True. + + Returns: + XEBResults: The final results from the experiment. + """ + + # Fit a linear model for each cycle depth to estimate the circuit fidelity + records = [] + for depth in set(self.raw_data.cycle_depth): + df = self.raw_data[self.raw_data.cycle_depth == depth] + fit = linregress( + x=df["sum_p(x)p(x)"] - 1 / 2**self.num_qubits, + y=df["sum_p(x)p^(x)"] - 1 / 2**self.num_qubits, + ) + + records.append( + { + "cycle_depth": depth, + "circuit_fidelity_estimate": fit.slope, + "circuit_fidelity_estimate_std": fit.stderr, + } + ) + + self._circuit_fidelities = pd.DataFrame(records) + + self.circuit_fidelities["log_fidelity_estimate"] = np.log( + self.circuit_fidelities.circuit_fidelity_estimate + ) + + # Fit a linear model to the depth ~ log(fidelity) to approximate the layer fidelity + layer_fit = linregress( + x=self.circuit_fidelities.cycle_depth, + y=np.log(self.circuit_fidelities.circuit_fidelity_estimate), + ) + layer_fidelity_estimate = np.exp(layer_fit.slope) + layer_fidelity_estimate_std = layer_fidelity_estimate * layer_fit.stderr + + self._results = XEBResults( + layer_fidelity_estimate=layer_fidelity_estimate, + layer_fidelity_estimate_std=layer_fidelity_estimate_std, + ) + + if plot_results: + self.plot_results() + + return self.results diff --git a/docs/source/apps/qcvv/qcvv.rst b/docs/source/apps/qcvv/qcvv.rst index 963ceed6d..da3a1157f 100644 --- a/docs/source/apps/qcvv/qcvv.rst +++ b/docs/source/apps/qcvv/qcvv.rst @@ -12,6 +12,13 @@ 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_xeb_css + .. note:: At present the QCVV library is only available in :code:`cirq-superstaq`. \ No newline at end of file diff --git a/docs/source/apps/qcvv/qcvv_xeb_css.ipynb b/docs/source/apps/qcvv/qcvv_xeb_css.ipynb new file mode 100644 index 000000000..d5573f4ed --- /dev/null +++ b/docs/source/apps/qcvv/qcvv_xeb_css.ipynb @@ -0,0 +1,210 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cross Entropy Benchmarking (XEB)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To demonstrate the cross entropy benchmarking routine, consider a noise model with two independent\n", + "depolarising channels, one which only effects single qubit gates and a second that only effects\n", + "two qubit gates." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "import cirq\n", + "\n", + "\n", + "class IndependentDepolariseNoiseModel(cirq.NoiseModel):\n", + " \"\"\"Applies single and two qubit depolarising channels independently\"\"\"\n", + "\n", + " def __init__(self, single_qubit_error: float, two_qubit_error: float) -> None:\n", + " \"\"\"Args:\n", + " single_qubit_error: Single qubit error\n", + " two_qubit_error: Two qubit error\n", + " \"\"\"\n", + " super().__init__()\n", + " self.single_qubit_error = single_qubit_error\n", + " self.two_qubit_error = two_qubit_error\n", + "\n", + " self.single_qubit_depolarise = cirq.DepolarizingChannel(p=single_qubit_error, n_qubits=1)\n", + " self.two_qubit_depolarise = cirq.DepolarizingChannel(p=two_qubit_error, n_qubits=2)\n", + "\n", + " def noisy_operation(self, operation: cirq.Operation) -> list[cirq.Operation]:\n", + " \"\"\"Produces a list of operations by applying each noise model\n", + " to the provided operation depending on the number of qubits it acts on.\n", + " \"\"\"\n", + " if operation._num_qubits_() == 1:\n", + " return [operation, self.single_qubit_depolarise(*operation.qubits)]\n", + "\n", + " if operation._num_qubits_() == 2:\n", + " return [operation, self.two_qubit_depolarise(*operation.qubits)]\n", + "\n", + " return [operation]\n", + "\n", + "\n", + "noise = IndependentDepolariseNoiseModel(single_qubit_error=0.005, two_qubit_error=0.02)\n", + "simulator = cirq.DensityMatrixSimulator(\n", + " noise=noise,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The XEB experiment allows us to estimate the fidelity of a \"layer\" composed of pair of single \n", + "qubit gates followed by a two qubit gate. If each single qubit gate is effected by a depolarising\n", + "channel with rate $p_1$ and each two qubit gate is effected by a two qubit \n", + "depolarising channel with rate $p_2$ the overall layer fidelity is\n", + "$$\\frac{16}{15}\\left( 1 - \\left(1- p_1\\right)^2 \\left(1-p_2\\right) \\right) $$" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "77bc4eec3a2e4d4fa6a5f2b69a9dd08f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Building circuits: 0%| | 0/600 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "experiment.analyse_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Layer fidelity: 0.9682394666666667\n", + "Estimated layer fidelity: 0.968576181672473\n" + ] + } + ], + "source": [ + "layer_fidelity = 1 - 16 / 15 * (1 - (1 - 0.005) ** 2 * (1 - 0.02))\n", + "print(\"Layer fidelity: \", layer_fidelity)\n", + "print(\"Estimated layer fidelity: \", experiment.results.layer_fidelity_estimate)" + ] + } + ], + "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/docs/source/cirq_superstaq.qcvv.rst b/docs/source/cirq_superstaq.qcvv.rst index ac9398a95..e915f9777 100644 --- a/docs/source/cirq_superstaq.qcvv.rst +++ b/docs/source/cirq_superstaq.qcvv.rst @@ -12,6 +12,14 @@ cirq\_superstaq.qcvv.base\_experiment module :undoc-members: :show-inheritance: +cirq\_superstaq.qcvv.xeb module +------------------------------- + +.. automodule:: cirq_superstaq.qcvv.xeb + :members: + :undoc-members: + :show-inheritance: + Module contents ---------------