{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Quantum Characterisation, Verification and Validation\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "approximate-aurora", "metadata": {}, "source": [ "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Infleqtion/client-superstaq/blob/main/docs/source/apps/supermarq/qcvv/qcvv_css.ipynb)\n", "[![Launch Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Infleqtion/client-superstaq/HEAD?labpath=docs/source/apps/supermarq/qcvv/qcvv_css.ipynb)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To demonstrate how to implement new benchmarking experiments within the Superstaq QCVV framework,\n", "consider implementing a naive benchmarking routine where we try to estimate the fidelity of a single\n", "qubit Z gate by repeatedly applying the gate to a qubit in the ground state (such that the Z-gate\n", "should have no effect) and observing if any observations of the excited state occur. If the excited\n", "state is observed this indicates an error has occurred. Assuming that each time the Z-gate is\n", "applied the probability of a bit flip error is $e$ then after $d$ gates the probability of observing\n", "the ground state is $$p(0) = \\frac{1}{2}(1-e)^d + \\frac{1}{2}$$\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can create an experiment to measure this as follows\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from __future__ import annotations" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from __future__ import annotations\n", "\n", "try:\n", " import supermarq # noqa: F401\n", "except ImportError:\n", " print(\"Installing supermarq...\")\n", " %pip install --quiet supermarq\n", " print(\"Installed supermarq.\")\n", " print(\"You may need to restart the kernel to import newly installed packages.\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from collections.abc import Iterable, Sequence\n", "from dataclasses import dataclass\n", "from typing import TYPE_CHECKING, Any\n", "\n", "import cirq\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import seaborn as sns\n", "from scipy.stats import linregress\n", "from supermarq.qcvv import QCVVExperiment, QCVVResults, Sample\n", "from tqdm.contrib.itertools import product\n", "\n", "if TYPE_CHECKING:\n", " from typing_extensions import Self\n", "\n", "\n", "@dataclass(repr=False)\n", "class NaiveExperimentResult(QCVVResults):\n", " gate_fidelity: float = 1\n", " gate_error: float = 0\n", "\n", " def _analyze(self) -> None:\n", " \"\"\"To analyse the results to fit a simple exponential decay. This can be done easily\n", " by fitting a linear model to the logarithm of the equation above.\n", " \"\"\"\n", " model = linregress(x=self.data[\"depth\"], y=np.log(2 * self.data[\"0\"] - 1))\n", "\n", " self.gate_fidelity = np.exp(model.slope)\n", "\n", " self.gate_error = 1 - np.exp(model.slope)\n", "\n", " def plot_results(self, filename: str | None = None) -> None:\n", " \"\"\"Plot the data with the fit superimposed on top.\"\"\"\n", " fig, axs = plt.subplots(\n", " 1,\n", " )\n", "\n", " sns.scatterplot(self.data, x=\"depth\", y=\"0\", ax=axs)\n", "\n", " x = np.linspace(0, max(self.data.depth))\n", " y = 0.5 * self.gate_fidelity**x + 0.5\n", " axs.plot(x, y)\n", " axs.set_xlabel(\"Circuit depth\")\n", " axs.set_ylabel(\"Probability of ground state\")\n", " if filename is not None:\n", " fig.savefig(filename)\n", "\n", " def _results_msg(self) -> str:\n", " return f\"Estimated gate error: {self.gate_error}\"\n", "\n", "\n", "class NaiveExperiment(QCVVExperiment[NaiveExperimentResult]):\n", " def __init__(\n", " self,\n", " num_circuits: int,\n", " cycle_depths: Iterable[int],\n", " *,\n", " random_seed: int | np.random.Generator | None = None,\n", " _samples: list[Sample] | None = None,\n", " ) -> None:\n", " super().__init__(\n", " qubits=1,\n", " num_circuits=num_circuits,\n", " cycle_depths=cycle_depths,\n", " results_cls=NaiveExperimentResult,\n", " random_seed=random_seed,\n", " _samples=_samples,\n", " )\n", "\n", " def _build_circuits(self, num_circuits: int, layers: Iterable[int]) -> Sequence[Sample]:\n", " \"\"\"Build the circuits by composing multiple Z gates together into circuits. The\n", " number of gates to compose is given by the `layers` parameter.\n", " \"\"\"\n", " samples = []\n", " for index, depth in product(range(num_circuits), layers, desc=\"Building circuits.\"):\n", " circuit = cirq.Circuit([cirq.Z(*self.qubits) for _ in range(depth)])\n", " circuit += cirq.measure(*self.qubits)\n", " samples.append(\n", " Sample(circuit_realization=index, circuit=circuit, data={\"depth\": depth})\n", " )\n", "\n", " return samples\n", "\n", " def _json_dict_(self) -> dict[str, Any]:\n", " return super()._json_dict_()\n", "\n", " @classmethod\n", " def _from_json_dict_(\n", " cls,\n", " samples: list[Sample],\n", " qubits: int,\n", " num_circuits: int,\n", " cycle_depths: list[int],\n", " **kwargs: Any,\n", " ) -> Self:\n", " return cls(\n", " num_circuits=num_circuits,\n", " qubits=qubits,\n", " cycle_depths=cycle_depths,\n", " _samples=samples**kwargs,\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To test this basic experiment, we use a depolarising noise model and a density matrix simulator.\n", "Note that if we use a single qubit depolarising channel with pauli error rate $p$ this will result\n", "in an error with probability of $4p/3$.\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8a6d6d7b47d2454d8654999537d1c497", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Building circuits.: 0%| | 0/30 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "results.analyze()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Checking this result we have\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0100782074092588\n" ] } ], "source": [ "pauli_error_rate = results.gate_error\n", "print(pauli_error_rate)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Which agrees very closely with our channel which we set up with $p=0.01$\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "ss_results = experiment.run_on_device(target=\"ss_unconstrained_simulator\", repetitions=1000)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Estimated gate error: 0.0\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ss_results.analyze()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As expected, since the Superstaq simulator is exact, we obtain a gate fidelity of 1.0\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.16" } }, "nbformat": 4, "nbformat_minor": 2 }