{ "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": [ "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\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 print_results(self) -> None:\n", " print(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": 4, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a6c23a1f3f634c4dafbcce0f33720ce5", "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": 6, "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": 7, "metadata": {}, "outputs": [], "source": [ "ss_results = experiment.run_on_device(target=\"ss_unconstrained_simulator\", repetitions=1000)" ] }, { "cell_type": "code", "execution_count": 8, "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 }