{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6f136ac3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-26T18:21:20.042386Z",
     "iopub.status.busy": "2024-04-26T18:21:20.042092Z",
     "iopub.status.idle": "2024-04-26T18:21:20.045747Z",
     "shell.execute_reply": "2024-04-26T18:21:20.045319Z"
    },
    "nbsphinx": "hidden"
   },
   "outputs": [],
   "source": [
    "# Copyright 2024 Keysight Technologies Inc."
   ]
  },
  {
   "cell_type": "raw",
   "id": "c5479d6e",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "Example: Writing Custom Noise Sources\n",
    "=====================================\n",
    "\n",
    "This example demonstrates how to write a custom noise source for the simulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cfb65781",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-26T18:21:20.047669Z",
     "iopub.status.busy": "2024-04-26T18:21:20.047399Z",
     "iopub.status.idle": "2024-04-26T18:21:22.342609Z",
     "shell.execute_reply": "2024-04-26T18:21:22.342077Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import trueq as tq\n",
    "import trueq.simulation as tqs"
   ]
  },
  {
   "cell_type": "raw",
   "id": "70e8e32c",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "A custom noise source can be implemented by subclassing\n",
    ":py:class:`~trueq.simulation.noise_source.NoiseSource` and overriding its\n",
    ":py:meth:`~trueq.simulation.noise_source.NoiseSource.apply` method.\n",
    "\n",
    "The :py:meth:`~trueq.simulation.noise_source.NoiseSource.apply` method will be passed\n",
    "three arguments: ``cycle_wrapper``, ``backend``, and ``circuit_cache``. The job of\n",
    "apply is to give instructions to the ``backend`` based on the contents of\n",
    "``cycle_wrapper``. The ``backend`` is an instance of\n",
    ":py:class:`~trueq.simulation.backend.SimulationBackend` whose runner contains methods\n",
    "like :py:meth:`~trueq.simulation.backend.SimulationBackend.Runner.process_gate` and\n",
    ":py:meth:`~trueq.simulation.backend.SimulationBackend.Runner.process_superop` which\n",
    "the noise source's :py:meth:`~trueq.simulation.noise_source.NoiseSource.apply` can\n",
    "use.\n",
    "\n",
    "Note that ``cycle_wrapper`` is not a :py:class:`~trueq.Cycle` instance as one\n",
    "might expect, but instead a thin wrapper called\n",
    ":py:class:`~trueq.simulation.match.CycleWrapper` which in turn wraps each cycle\n",
    "operation as :py:class:`~trueq.simulation.match.OpWrapper`\\.\n",
    "\n",
    "These wrapper types are required to store metadata on each operation (also discussed\n",
    "further below). However, noise sources will rarely need to deal with these wrapper\n",
    "objects directly. This is because noise sources (by strongly encouraged convention,\n",
    "though not by contract) own a :py:class:`~trueq.simulation.match.Match` instance which\n",
    "takes ownership of the mechanics of these wrappers. This is seen in the example below,\n",
    "where the :py:class:`~trueq.simulation.match.Match.iter_gates` method is used to yield\n",
    "gate objects with their corresponding gate labels.\n",
    "\n",
    "predefine noise matrices to be applied to qubits following ideal gates\n",
    "note that rowstack_subsys is the superoperator convention required by the simulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4068528a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-26T18:21:22.346284Z",
     "iopub.status.busy": "2024-04-26T18:21:22.345827Z",
     "iopub.status.idle": "2024-04-26T18:21:22.352051Z",
     "shell.execute_reply": "2024-04-26T18:21:22.351594Z"
    }
   },
   "outputs": [],
   "source": [
    "p = 0.01\n",
    "s1 = tq.math.Superop.from_kraus(\n",
    "    [np.sqrt(1 - p) * np.eye(2), np.sqrt(p) * tq.Gate.x.mat]\n",
    ")\n",
    "\n",
    "p = 0.02\n",
    "s2 = tq.math.Superop.from_kraus(\n",
    "    [np.sqrt(1 - p) * np.eye(4), np.sqrt(p) * tq.math.random_unitary(4)]\n",
    ")\n",
    "\n",
    "\n",
    "class ExampleNoise(tqs.NoiseSource):\n",
    "    def __init__(self, match=None):\n",
    "        # this simulator hardcodes the subsystem dimension to 2\n",
    "        super().__init__(dim=2, match=match)\n",
    "\n",
    "    def make_circuit_cache(self, circuit):\n",
    "        # this return will be made available to apply() as circuit_cache for every\n",
    "        # cycle in the circuit\n",
    "        return set(circuit.labels)\n",
    "\n",
    "    def apply(self, cycle_wrappers, backend, circuit_cache):\n",
    "        # in this method we ask the backend to process certain operations\n",
    "\n",
    "        used_labels = set()\n",
    "        # loop through the gates in the cycle and ask the backend to process them\n",
    "        # note that we must set noise_only=False since we are simulating each gate\n",
    "        for labels, gate in self.match.iter_gates(cycle_wrappers, noise_only=False):\n",
    "            used_labels.update(labels)\n",
    "            # first do ideal simulation of this gate\n",
    "            backend.process_gate(labels, gate)\n",
    "\n",
    "            # now add some superoperator noise to each qubit the gate acts on\n",
    "            if len(labels) == 1:\n",
    "                backend.process_superop(labels, s1)\n",
    "            elif len(labels) == 2:\n",
    "                backend.process_superop(labels, s2)\n",
    "\n",
    "        # apply a 20 degree Z rotation to every qubit without a gate in this cycle\n",
    "        for label in circuit_cache.difference(used_labels):\n",
    "            backend.process_gate((label,), tq.Gate.rp(\"Z\", 20))"
   ]
  },
  {
   "cell_type": "raw",
   "id": "27f32eb4",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "Now we can instantiate a simulator that uses this noise source and do any simulator\n",
    "calculation. Here, we use the simulator to predict the output of a hypothetical\n",
    "KNR experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e97d7a59",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-26T18:21:22.354009Z",
     "iopub.status.busy": "2024-04-26T18:21:22.353706Z",
     "iopub.status.idle": "2024-04-26T18:21:22.644584Z",
     "shell.execute_reply": "2024-04-26T18:21:22.644090Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x148 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sim = tq.Simulator().append_noise_source(ExampleNoise())\n",
    "\n",
    "cycle = {(0, 1): tq.Gate.cnot, 2: tq.Gate.x}\n",
    "fit = sim.predict_knr(cycle, twirl=tq.Twirl(\"P\", range(5)))\n",
    "fit.plot.knr_heatmap()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "56c7a200",
   "metadata": {
    "raw_mimetype": "text/restructuredtext"
   },
   "source": [
    "Caching\n",
    "-------\n",
    "\n",
    "There are two distinct caches available to a noise source. The first is a private\n",
    "noise source attribute that is called ``_cache`` (by convention, not by contract) in\n",
    "built-in noise models which persists throughout the lifetime of the noise source. For\n",
    "example, a gate-dependent noise model may consider caching gate noise if it is\n",
    "expensive to recompute everytime the same gate is encountered.\n",
    "\n",
    "The second cache comes as the third argument to the\n",
    ":py:meth:`~trueq.simulation.noise_source.NoiseSource.apply` method. This cache is\n",
    "instantiated by\n",
    ":py:meth:`~trueq.simulation.noise_source.NoiseSource.make_circuit_cache` just before a\n",
    "new circuit is simulated and is presented as the third argument to the apply method\n",
    "for every cycle within that circuit. It typically stores information about the circuit\n",
    "that is not available in every cycle, such as all of the labels the circuit acts on,\n",
    "or which measurements it performs at the end.\n",
    "\n",
    "Wrappers and metadata\n",
    "---------------------\n",
    "\n",
    "The variable ``cycle_wrapper`` in the example above has type\n",
    ":py:class:`~trueq.simulation.match.CycleWrapper` which is a thin wrapper for a cycle\n",
    "and also wraps every cycle operation with\n",
    ":py:class:`~trueq.simulation.match.OpWrapper`\\.  During simulation, everytime a new\n",
    "cycle is encountered it is wrapped once, and the same wrapped cycle instance is passed\n",
    "to all noise sources.  The cycle wrapper exists to enable efficient looping logic used\n",
    "by :py:class:`~trueq.simulation.match.Match` and to persist operation wrappers for\n",
    "multiple noise sources\\. The operation wrapper exists to store\n",
    "two important pieces of information:\n",
    "\n",
    " 1. Whether some noise source has previously simulated the same operation of the\n",
    "    cycle. This is stored as a boolean called  ``has_been_simulated`` and is set to\n",
    "    true whenever a match method is called with the  argument ``noise_only=False``, as\n",
    "    it is in the above example.\n",
    " 2. Whether no noise sources (except the ideal final simulation if relevant) should\n",
    "    touch the operation again. This is stored as a boolean called ``no_more_noise``\n",
    "    and is set to true whenever it is yielded by a match method whose ``exclusive``\n",
    "    value is true."
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "nbsphinx,raw_mimetype,-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all",
   "text_representation": {
    "extension": ".py",
    "format_name": "percent"
   }
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}