docs/examples/direct_fidelity_estimation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Direct Fidelity Estimation\n",
    "\n",
    "Using a method known as direct fidelity estimation (DFE), see [DFE1] and [DFE2], it is possible to estimate the fidelity between \n",
    "* a target pure state $\\rho_\\psi = |\\psi\\rangle\\langle \\psi|$ and its experimental realization $\\sigma$,\n",
    "* a target unitary $U$ and its experimental realization $U_e$.\n",
    " \n",
    "This can be done with a small number (relative to state and process tomography) of simple experimental settings that is independent of the system size. Such methods are useful for the experimental study of larger quantum information processing units.\n",
    "\n",
    "In this notebook we explore some state and process DFE using the forest.benchmarking module `direct_fidelity_estimation.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| [DFE1] *Practical Characterization of Quantum Devices without Tomography.*  \n",
    "|        Silva et al.  \n",
    "|        PRL 107, 210404 (2011).  \n",
    "|        https://doi.org/10.1103/PhysRevLett.107.210404  \n",
    "|        https://arxiv.org/abs/1104.3835  \n",
    "\n",
    "| [DFE2]  *Direct Fidelity Estimation from Few Pauli Measurements.*  \n",
    "|        Flammia et al.  \n",
    "|        PRL 106, 230501 (2011).  \n",
    "|        https://doi.org/10.1103/PhysRevLett.106.230501  \n",
    "|        https://arxiv.org/abs/1104.4695  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simplistic state DFE example\n",
    "\n",
    "Suppose we have tried to prepare the state $|0\\rangle$, with state matrix $\\rho_0 = |0\\rangle \\langle 0 |$, but in fact prepared the state\n",
    "\n",
    "$$\\sigma = \\frac 1 2 (I + x X + y Y + z Z)$$\n",
    "\n",
    "\n",
    "The usual way to quantify how close $\\sigma$ and $\\rho_0$ are is to use quantum state tomography \n",
    "to estimate $\\sigma$ and then calculate the fidelity between $\\sigma$ and $\\rho_0$.\n",
    "\n",
    "\n",
    "DFE provides a way to directly estimate the fidelity without first estimating the state $\\sigma$. To see this, first note that since $\\rho_0$ is a pure state (our estimate $\\sigma$ in general is not) we can write the [fidelity](https://en.wikipedia.org/wiki/Fidelity_of_quantum_states#Definition) as $F(\\rho_0, \\sigma) = \\langle 0 |\\sigma|0 \\rangle$. This is equivalent to \n",
    "\n",
    "$$F(\\rho_0, \\sigma) = {\\rm Tr}[\\rho_0  \\sigma]$$\n",
    "\n",
    "using the [cyclic property of the trace](https://en.wikipedia.org/wiki/Trace_(linear_algebra%29#Cyclic_property). \n",
    "Next we parameterize the pure state as\n",
    "\n",
    "$$\\rho_0= |0\\rangle \\langle 0| =  \\frac 1 2 \\big (I + (0) X + (0) Y + (+1) Z \\big)=  \\frac 1 2 (I +  Z )$$\n",
    "\n",
    "Finally we arrive at\n",
    "\n",
    "$$F(\\rho_0, \\sigma)= {\\rm Tr}[\\rho_0 \\sigma] = \\frac 1 4 {\\rm Tr}[(1+z)I]= \\frac{(1+z)}{2}$$\n",
    "\n",
    "This result shows that we only need to estimate one observable expectation $\\langle Z \\rangle \\rightarrow \\tilde z$ in order to estimate the fidelity between $\\rho_0$ and $\\sigma$ in this particular example.\n",
    "\n",
    "## Generalizing state DFE, somewhat\n",
    "\n",
    "The code that we've developed has some assumptions baked in that are important to understand. We have implemented DFE for a restricted subset of states and processes using these assumptions.\n",
    "\n",
    "To start, we assume that our start state is always the pure state $|0 \\rangle$ on all qubits. On $n$ qubits this state can be decomposed as\n",
    "\n",
    "$$\\rho_0^{\\otimes n} = \\left(I_0 + Z_0\\right) \\otimes \\left(I_1 + Z_1\\right) \\otimes \\dots \\left(I_n + Z_n\\right) / 2^n  = \\frac{1}{2^n} \\sum_{k=1}^{2^n} P^{(IZ)}_k$$\n",
    "\n",
    "where we have expanded the tensor multiplication into one large sum over all possible of combinations $P^{(IZ)}_k$ of I and Z Pauli terms. From this start point we apply the user specified program $U$, or rather the noisy implementation $\\mathcal E( \\cdot )$, to prepare the state $\\sigma$. \n",
    "\n",
    "$$\\sigma = \\mathcal E(\\rho_0^{\\otimes n})$$\n",
    "\n",
    "Meanwhile we want to calculate the fidelity between $\\sigma$ and the ideally prepared state $\\rho = U \\rho_0^{\\otimes n} U^\\dagger$. By linearity we can calculate $\\rho$ by conjugating each Pauli term $P^{(IZ)}$ in the sum above by the ideal program $U$.\n",
    "\n",
    "$$\\rho = \\frac{1}{2^n} \\sum_k U P^{(IZ)}_k U^\\dagger$$\n",
    "\n",
    "**The assumption** we make is that the ideal prep program $U$ is an element of the Clifford group. Since the Clifford group is the [normalizer](https://en.wikipedia.org/wiki/Centralizer_and_normalizer) of the Pauli group, these conjugated terms $U P^{(IZ)}_k U^\\dagger$ will again be some Pauli $P'_k$ (in the code we use a `pyquil.BenchmarkConnection` to quickly calculate the resultant Pauli). Following the example above we arrive at the set of $2^n$ Paulis $\\{P'_k\\}_k$ whose expectations we need to estimate with respect to the physical state $\\sigma$. The estimate is the average of all these Pauli expectations (see Eqn. 1 of [DFE1]). \n",
    "\n",
    "$$F(\\rho_0^{\\otimes n}, \\sigma)= {\\rm Tr}[\\rho_0^{\\otimes n} \\sigma] = \\frac{1}{2^n} \\sum_{k=1}^{2^n} {\\rm Tr}[ \\mathcal E(\\rho_0^{\\otimes n}) P'_k]$$\n",
    "\n",
    "Note that we don't need to estimate the expectation of the trivial all $I$ term since we know its expectation is 1. We exclude this term in experiment generation but include it in the analysis 'by hand'. \n",
    "\n",
    "## Process DFE\n",
    "\n",
    "The [average gate fidelity](https://arxiv.org/pdf/quant-ph/0205035.pdf) between an experimental process $\\mathcal E$ and the ideal (unitary) process $\\mathcal U$ is given by\n",
    "\n",
    "$$F(\\mathcal U,\\mathcal E) = \\frac{ {\\rm Tr} [\\mathcal E \\mathcal U^\\dagger] + d} {d^2+d}$$\n",
    "\n",
    "where the processes are represented by linear superoperators acting on vectorized\n",
    "density matrices, and d is the dimension of the Hilbert space $\\mathcal H$ that $\\mathcal E$ and $\\mathcal U$ act on. If you are unfamiliar with these terms look at [superoperator tools notebook](superoperator_tools.ipynb) and [superoperator_representations.md](../superoperator_representations.rst)\n",
    "\n",
    "Using the $d^2$ dimensional orthonormal Pauli basis $\\{P_k\\}$ for superoperators on $\\mathcal H$--e.g. $\\{I/\\sqrt{2}, X/\\sqrt{2}, Y/\\sqrt{2}, Z/\\sqrt{2} \\}$ for a single qubit--we can expand the trace and insert an identity superoperator between $\\mathcal U$ and $\\mathcal E$; this amounts to re-casting these superoperators in the Pauli-Liouville representation (aka Pauli Transfer Matrix). (again, see [superoperator_representations.md](../superoperator_representations.rst) if you are unfamiliar with vec notation $P_k \\iff \\left| P_k \\rangle\\rangle\\langle\\langle P_k\\right|$):\n",
    "\n",
    "$${\\rm Tr} [\\mathcal E \\mathcal U^\\dagger] = {\\rm Tr} [\\mathcal E   \\left( \\sum_k \\left| P_k \\rangle\\rangle\\langle\\langle P_k\\right| \\right) \\mathcal U^\\dagger]$$\n",
    "\n",
    "$$= \\sum_k {\\rm Tr} [  \\left( \\langle\\langle P_k | \\mathcal U^\\dagger \\right) \\left(\\mathcal E | P_k \\rangle\\rangle \\right) ]$$\n",
    "\n",
    "$$= \\sum_k {\\rm Tr} [  \\left( \\mathcal U |  P_k \\rangle\\rangle  \\right)^\\dagger \\left(\\mathcal E | P_k \\rangle\\rangle \\right) ]$$\n",
    "\n",
    "Now we switch representations by unveccing  $|  P_k \\rangle\\rangle$ and representing $\\mathcal U$ by its unitary action on the matrix $P_k$.\n",
    "\n",
    "$$= \\sum_k {\\rm Tr} [  \\left( U P_k U^\\dagger \\right)^\\dagger \\cdot \\mathcal E \\left( P_k \\right) ]$$\n",
    "\n",
    "Finally we can decompose the $P_k$ acted on by $\\mathcal E$ into a sum over projectors onto each eigenvector $\\left|\\phi_j \\rangle\\langle \\phi_j \\right|$ with the correct sign for the eigenvalue (which is $\\pm 1$ for Paulis).\n",
    "\n",
    "$$= \\sum_k \\left( \\sum_{\\phi_j^{(+)} \\in \\{\\phi\\}_k^+} \\frac{1}{\\sqrt{d}} {\\rm Tr} [  \\left( U P_k U^\\dagger \\right) \\cdot \\mathcal E \\left( \\left|\\phi_j^{(+)}\\rangle\\langle\\phi_j^{(+)}\\right| \\right) ]\n",
    "- \\sum_{\\phi_j^{(-)} \\in \\{\\phi\\}_k^-} \\frac{1}{\\sqrt{d}} {\\rm Tr} [  \\left( U P_k U^\\dagger \\right) \\cdot \\mathcal E \\left( \\left|\\phi_j^{(-)}\\rangle\\langle\\phi_j^{(-)}\\right| \\right) ]\\right)$$\n",
    "\n",
    "At this point our **assumption** that $U$ is a Clifford element again comes into play and allows us to easily compute the conjugated Pauli $U P_k U^\\dagger = \\sigma_k / \\sqrt{d}$. Inserting this assumption gives a simple picture where we need to estimate the expectation of each $\\sigma_k$ Pauli for the state which results from applying our noisy circuit $\\mathcal E$ to each eigenstate $\\left| \\phi_j \\rangle \\right.$ of $P_k$.\n",
    "\n",
    "$$= \\frac{1}{d} \\sum_k \\left( \\sum_{\\phi_j^{(+)} \\in \\{\\phi\\}_k^+} {\\rm Tr} [ \\sigma_k \\cdot \\mathcal E \\left( \\left|\\phi_j^{(+)}\\rangle\\langle\\phi_j^{(+)}\\right| \\right) ]\n",
    "- \\sum_{\\phi_j^{(-)} \\in \\{\\phi\\}_k^-} {\\rm Tr} [  \\sigma_k \\cdot \\mathcal E \\left( \\left|\\phi_j^{(-)}\\rangle\\langle\\phi_j^{(-)}\\right| \\right) ]\\right)$$\n",
    "\n",
    "The final estimate of $F(\\mathcal U,\\mathcal E)$ follows from estimating these expectations, plugging them in to the sum to get ${\\rm Tr} [\\mathcal E \\mathcal U^\\dagger]$ which we insert into the equation at the beginning of the section. Note that moving a factor of $1/d$ from the Fidelity expression into the trace expression allows us to re-interpret the trace as an average of all of the $d^3$ Pauli expectations. Further, again note that we do not need to estimate the all identity Pauli expectations, which will all be 1. This reduces the number of experiment settings to $(d^2-1)d$.\n",
    "\n",
    "\n",
    "## Process DFE by reduction to state DFE\n",
    "\n",
    "We can also understand process DFE by appealing to the [Choi–Jamiołkowski isomorphism](https://en.wikipedia.org/wiki/Channel-state_duality) which says that we can represent our channel superoperators as state matrices (i.e. density matrices)  $J(\\mathcal E)$ and $J(\\mathcal U)$. This allows us to rewrite the average gate fidelity as \n",
    "\n",
    "$$F(\\mathcal U,\\mathcal E)= \\frac{d^2 {\\rm Tr}[ J(\\mathcal E)⋅J(\\mathcal U)] + d}{d^2+d}$$\n",
    "\n",
    "Finally, since $J(\\mathcal U)$ is a pure state, we employ the same fact from above about fidelity between states to note that ${\\rm Tr}[ J(\\mathcal E)⋅J(\\mathcal U)] = F(J(\\mathcal E),J(\\mathcal U))$. We have reduced process DFE to state DFE, but we need to dive into the particulars of $J(\\cdot)$ to understand what we actually need to measure.\n",
    "\n",
    "For $U$ acting on $n$ qubits the state $J(\\mathcal U)$ over $2n$ qubits is given by \n",
    "\n",
    "$$J(\\mathcal U) = \\left(\\textrm{Id} \\otimes \\mathcal U\\right) \\left(\\sum_{k=0}^{2^n-1}\\sum_{k'=0}^{2^n-1} |k\\rangle \\langle k'| \\otimes |k \\rangle \\langle k'|\\right) = \\sum_{k=0}^{2^n-1}\\sum_{k'=0}^{2^n-1} |k\\rangle \\langle k'| \\otimes U |k \\rangle   \\langle k'| U^\\dagger$$\n",
    "\n",
    "where $|k \\rangle$ is the state over $n$ qubits corresponding to the binary representation of $k$. The state matrix for the maximally entangled state on which $\\textrm{Id} \\otimes \\mathcal U$ acts can be decomposed as:\n",
    "\n",
    "$$\\sum_{k=0}^{d-1} \\sum_{k'=0}^{d-1} | k k \\rangle \\langle k' k'| = \\frac{1}{d}\\sum_j P_j^* \\otimes P_j$$\n",
    "\n",
    "where the sum is over the complete orthonormal Pauli basis $\\{P_j\\}$ (i.e. $\\sigma_j/\\sqrt{d}$) for a $d$ dimensional Hilbert space. This gives us\n",
    "\n",
    "$$d^2 {\\rm Tr}[ J(\\mathcal E)⋅J(\\mathcal U)] = d^2{\\rm Tr}[ \\left(\\frac{1}{d}\\sum_k P_k^* \\otimes \\mathcal E(P_k)\\right) \\left(\\frac{1}{d}\\sum_j P_j^* \\otimes U P_j U^\\dagger\\right)]$$\n",
    "\n",
    "If we partially evaluate the trace over the first subsystem and use ${\\rm Tr}[P_k^* P_j^*] = {\\rm Tr}[\\left(P_k P_j\\right)^*] = {\\rm Tr}[P_k P_j]^* = {\\rm Tr}[P_k^\\dagger P_j]^* = \\delta_{jk}$ we get \n",
    "\n",
    "$$= \\sum_k {\\rm Tr} [  \\left( U P_k U^\\dagger \\right)^\\dagger \\cdot \\mathcal E \\left( P_k \\right) ]$$\n",
    "\n",
    "This is the same expression as from the last section, so we can proceed identically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyquil.paulis import ID\n",
    "from pyquil.gates import I, X, MEASURE, H, CNOT, RY, CZ\n",
    "from pyquil import Program, get_qc\n",
    "from pyquil.api import BenchmarkConnection\n",
    "from forest.benchmarking.direct_fidelity_estimation import ( generate_exhaustive_state_dfe_experiment, \n",
    "                                                             generate_exhaustive_process_dfe_experiment,\n",
    "                                                             generate_monte_carlo_state_dfe_experiment, \n",
    "                                                             generate_monte_carlo_process_dfe_experiment,\n",
    "                                                             acquire_dfe_data,\n",
    "                                                             estimate_dfe )\n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# noiseless QVM\n",
    "qvm = get_qc(\"9q-square-qvm\", noisy=False)\n",
    "\n",
    "# noisy QVM\n",
    "noisy_qvm = get_qc(\"9q-square-qvm\", noisy=True)\n",
    "\n",
    "bm = BenchmarkConnection()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Direct fidelity estimation in `forest.benchmarking`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic workflow is:\n",
    "\n",
    "1. Prepare a *state* or a *process* by specifying a pyQuil program.\n",
    "2. Construct a list of observables that are needed to estimate the state; we collect this into an object called an `ObservablesExperiment`.\n",
    "3. Acquire the data by running the program on a QVM or QPU.\n",
    "4. Apply an estimator to the data to obtain an estimate of the fidelity between the ideal and measured state or process.\n",
    "5. Visualize if you wish."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two quick examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1. Specify a state preparation or unitarty process with a `Program`\n",
    "\n",
    "This is the object we will do DFE on.\n",
    "\n",
    "The process we choose is \n",
    "\n",
    "$$U = {\\rm CNOT}(H\\otimes I)=\\frac{1}{\\sqrt{2}}\n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 1 & 0\\\\\n",
    "0 & 1 & 0 & 1\\\\\n",
    "0 & 1 & 0 & -1\\\\\n",
    "1 & 0 & -1 & 0\n",
    "\\end{pmatrix}$$\n",
    "\n",
    "and the state is\n",
    "\n",
    "$$|\\Psi\\rangle = {\\rm CNOT}(H\\otimes I)|00\\rangle = \\frac{1}{\\sqrt{2}} \\begin{pmatrix} 1\\\\0\\\\0\\\\ 1\\end{pmatrix}$$\n",
    "\n",
    "Perhaps we should emphasize that while the `Program` that we pass into the DFE module is the same whether we are doing process DFE on $\\tilde U$ or state DFE on $\\tilde \\Psi$, the specific experiment construction method we choose in the next step selects one or the other and results in different `ExperimentSettings` around the same `Program`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H 0\n",
      "CNOT 0 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "p = Program()\n",
    "prep_prog = p.inst(H(0), CNOT(0,1))\n",
    "print(prep_prog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.70710678  0.          0.70710678  0.        ]\n",
      " [ 0.          0.70710678  0.          0.70710678]\n",
      " [ 0.          0.70710678  0.         -0.70710678]\n",
      " [ 0.70710678  0.         -0.70710678  0.        ]]\n",
      "[[0.5 0.  0.  0.5]\n",
      " [0.  0.  0.  0. ]\n",
      " [0.  0.  0.  0. ]\n",
      " [0.5 0.  0.  0.5]]\n"
     ]
    }
   ],
   "source": [
    "from pyquil.simulation.matrices import I as Imatrix, H as Hmatrix, CNOT as CNOTmatrix\n",
    "\n",
    "U_ideal = CNOTmatrix @ np.kron(Hmatrix, Imatrix)\n",
    "print(U_ideal)\n",
    "\n",
    "rho_ideal = U_ideal @ np.array([[1], [0], [0], [0]]) @ np.array([[1], [0], [0], [0]]).T @ U_ideal.conj().T\n",
    "print(rho_ideal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2. Construct an `ObservablesExperiment` for DFE\n",
    "\n",
    "We use the helper functions\n",
    "\n",
    "* `generate_exhaustive_state_dfe_experiment` \n",
    "* `generate_exhaustive_process_dfe_experiment`\n",
    "\n",
    "to construct a (tomographically incomplete) set of preparations + measurements (i.e. `ExperimentSettings`) for state and process DFE respectively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "qubits = [0,1]\n",
    "\n",
    "# state dfe\n",
    "state_exp = generate_exhaustive_state_dfe_experiment(bm, prep_prog, qubits)\n",
    "\n",
    "# process dfe\n",
    "process_exp = generate_exhaustive_process_dfe_experiment(bm, prep_prog, qubits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For state DFE we can print this experiment object out to see the $d - 1 = 2^2-1= 3$ observables whose expectation we will estimate (i.e. the measurements we will perform). Note that we could have included an additional observable `->I0I1`, but since this trivially gives an expectation of 1 we instead omit this observable in experiment generation and include its contribution by hand in the estimation methods. Be mindful of this if generating your own settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of the object is: <class 'forest.benchmarking.observable_estimation.ObservablesExperiment'> \n",
      "\n",
      "The program is:\n",
      "H 0\n",
      "CNOT 0 1\n",
      "\n",
      "There are three different settings:\n",
      "0: Z+_0 * Z+_1→(1+0j)*Z0Z1\n",
      "1: Z+_0 * Z+_1→(1+0j)*X0X1\n",
      "2: Z+_0 * Z+_1→(-1+0j)*Y0Y1\n"
     ]
    }
   ],
   "source": [
    "# Let's take a look into one of these experiment objects\n",
    "\n",
    "print('The type of the object is:', type(state_exp),'\\n')\n",
    "print('The program is:')\n",
    "print(state_exp.program)\n",
    "print('There are three different settings:')\n",
    "print(state_exp.settings_string())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also look at a few of the settings for process DFE. Here our omission of trivial Identity terms means that we are summing over only the $d^2 - 1 = 15$ total unique observables measured. For each of these observables we prepare the $d = 4$ different initial preparations of eigenstates of the pre-circuit-conjugated observable. (For each Identity term of the pre-conjugated observable we still prepare two separate eigenstates, which we arbitrarily choose to be the two computational basis states on that qubit.) This gives us $60$ total settings.\n",
    "\n",
    "Note that we have incorporated the minus sign into the observables paired with preparations of the negative eigenstates. This means that for ideal no-noise data collection we will get expectations all equal to positive 1. (we have chosen our observables so that the ideal state is always in the positive eigenvalue subspace). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The program is, again:\n",
      "H 0\n",
      "CNOT 0 1\n",
      "\n",
      "There are more settings:\n",
      "0: Z+_0 * X+_1→(1+0j)*X1\n",
      "1: Z+_0 * X-_1→(-1+0j)*X1\n",
      "2: Z-_0 * X+_1→(1+0j)*X1\n",
      "3: Z-_0 * X-_1→(-1+0j)*X1\n",
      "4: Z+_0 * Y+_1→(1+0j)*Z0Y1\n",
      "5: Z+_0 * Y-_1→(-1+0j)*Z0Y1\n",
      "6: Z-_0 * Y+_1→(1+0j)*Z0Y1\n",
      "7: Z-_0 * Y-_1→(-1+0j)*Z0Y1\n",
      "8: Z+_0 * Z+_1→(1+0j)*Z0Z1\n",
      "9: Z+_0 * Z-_1→(-1+0j)*Z0Z1\n",
      "10: Z-_0 * Z+_1→(1+0j)*Z0Z1\n",
      "11: Z-_0 * Z-_1→(-1+0j)*Z0Z1\n",
      "12: X+_0 * Z+_1→(1+0j)*Z0\n",
      "13: X+_0 * Z-_1→(1+0j)*Z0\n",
      "14: X-_0 * Z+_1→(-1+0j)*Z0\n",
      "15: X-_0 * Z-_1→(-1+0j)*Z0\n",
      "16: X+_0 * X+_1→(1+0j)*Z0X1\n",
      "17: X+_0 * X-_1→(-1+0j)*Z0X1\n",
      "18: X-_0 * X+_1→(-1+0j)*Z0X1\n",
      "19: X-_0 * X-_1→(1+0j)*Z0X1\n",
      "20: X+_0 * Y+_1→(1+0j)*Y1\n",
      "21: X+_0 * Y-_1→(-1+0j)*Y1\n",
      "22: X-_0 * Y+_1→(-1+0j)*Y1\n",
      "23: X-_0 * Y-_1→(1+0j)*Y1\n",
      "24: X+_0 * Z+_1→(1+0j)*Z1\n",
      "25: X+_0 * Z-_1→(-1+0j)*Z1\n",
      "26: X-_0 * Z+_1→(-1+0j)*Z1\n",
      "27: X-_0 * Z-_1→(1+0j)*Z1\n",
      "28: Y+_0 * Z+_1→(-1+0j)*Y0X1\n",
      "29: Y+_0 * Z-_1→(-1+0j)*Y0X1\n",
      "30: Y-_0 * Z+_1→(1-0j)*Y0X1\n",
      "31: Y-_0 * Z-_1→(1-0j)*Y0X1\n",
      "32: Y+_0 * X+_1→(-1+0j)*Y0\n",
      "33: Y+_0 * X-_1→(1-0j)*Y0\n",
      "34: Y-_0 * X+_1→(1-0j)*Y0\n",
      "35: Y-_0 * X-_1→(-1+0j)*Y0\n",
      "36: Y+_0 * Y+_1→(1+0j)*X0Z1\n",
      "37: Y+_0 * Y-_1→(-1+0j)*X0Z1\n",
      "38: Y-_0 * Y+_1→(-1+0j)*X0Z1\n",
      "39: Y-_0 * Y-_1→(1+0j)*X0Z1\n",
      "40: Y+_0 * Z+_1→(-1+0j)*X0Y1\n",
      "41: Y+_0 * Z-_1→(1-0j)*X0Y1\n",
      "42: Y-_0 * Z+_1→(1-0j)*X0Y1\n",
      "43: Y-_0 * Z-_1→(-1+0j)*X0Y1\n",
      "44: Z+_0 * Z+_1→(1+0j)*X0X1\n",
      "45: Z+_0 * Z-_1→(1+0j)*X0X1\n",
      "46: Z-_0 * Z+_1→(-1+0j)*X0X1\n",
      "47: Z-_0 * Z-_1→(-1+0j)*X0X1\n",
      "48: Z+_0 * X+_1→(1+0j)*X0\n",
      "49: Z+_0 * X-_1→(-1+0j)*X0\n",
      "50: Z-_0 * X+_1→(-1+0j)*X0\n",
      "51: Z-_0 * X-_1→(1+0j)*X0\n",
      "52: Z+_0 * Y+_1→(1+0j)*Y0Z1\n",
      "53: Z+_0 * Y-_1→(-1+0j)*Y0Z1\n",
      "54: Z-_0 * Y+_1→(-1+0j)*Y0Z1\n",
      "55: Z-_0 * Y-_1→(1+0j)*Y0Z1\n",
      "56: Z+_0 * Z+_1→(-1+0j)*Y0Y1\n",
      "57: Z+_0 * Z-_1→(1-0j)*Y0Y1\n",
      "58: Z-_0 * Z+_1→(1-0j)*Y0Y1\n",
      "59: Z-_0 * Z-_1→(-1+0j)*Y0Y1\n"
     ]
    }
   ],
   "source": [
    "print('The program is, again:')\n",
    "print(process_exp.program)\n",
    "print('There are more settings:')\n",
    "print(process_exp.settings_string())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3. Acquire the data\n",
    "\n",
    "We will use the QVM, but at this point you could use a QPU.\n",
    "\n",
    "We use a simple wrapper, `acquire_dfe_data`, around the standard `estimate_observables` method to run each `ExperimentSetting` in our `ObservablesExperiment`. By default `acquire_dfe_data` includes an additional error mitigation step that attempts to calibrate estimation of each observable expectation in order to combat readout error.\n",
    "\n",
    "Note that `acquire_dfe_data` returns a `list` of `ExperimentResult`s which is a dataclass defined in the module `observable_estimation.py`.\n",
    "\n",
    "The details of the dataclass and error mitigation strategies are given in the [observable estimation ipython notebook](observable_estimation.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get some NOISELESS data\n",
    "results = acquire_dfe_data(qvm, process_exp, num_shots=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Operator Expectations\n",
      "[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]\n",
      "\n",
      "\n",
      "Calibration Expectations\n",
      "[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]\n"
     ]
    }
   ],
   "source": [
    "# look at the results -- we expect all expectations to be one since there is no noise.\n",
    "print(\"Operator Expectations\")\n",
    "print([res.expectation for res in results])\n",
    "print('\\n')\n",
    "print(\"Calibration Expectations\")\n",
    "print([res.calibration_expectation for res in results])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get some NOISY data\n",
    "n_results_proce = acquire_dfe_data(noisy_qvm, process_exp, num_shots=1000)\n",
    "\n",
    "n_results_state = acquire_dfe_data(noisy_qvm, state_exp, num_shots=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Noisy Operator Expectations\n",
      "[1.0023, 0.9792, 1.0324, 0.9861, 0.9893, 1.0295, 1.0295, 1.0134, 0.932, 0.9924, 0.9698, 0.9975, 0.9817, 1.0252, 0.9908, 0.9908, 0.9676, 0.9925, 0.9551, 1.0, 0.9954, 0.9977, 0.9586, 0.9977, 0.9729, 0.9412, 0.9593, 0.9751, 0.9123, 0.9699, 0.9323, 0.9574, 0.9726, 0.9954, 0.9772, 1.0, 1.0026, 0.9896, 1.026, 0.9557, 0.9631, 0.9409, 0.9113, 0.9138, 0.9843, 1.0313, 1.0522, 0.9765, 0.9636, 0.9818, 0.9636, 1.0023, 0.9751, 0.9428, 0.9851, 0.9279, 1.0187, 0.9627, 0.9973, 0.984]\n",
      "\n",
      "\n",
      "Noisy Calibration Expectations\n",
      "[0.864, 0.864, 0.864, 0.864, 0.746, 0.746, 0.746, 0.746, 0.794, 0.794, 0.794, 0.794, 0.874, 0.874, 0.874, 0.874, 0.802, 0.802, 0.802, 0.802, 0.87, 0.87, 0.87, 0.87, 0.884, 0.884, 0.884, 0.884, 0.798, 0.798, 0.798, 0.798, 0.876, 0.876, 0.876, 0.876, 0.768, 0.768, 0.768, 0.768, 0.812, 0.812, 0.812, 0.812, 0.766, 0.766, 0.766, 0.766, 0.88, 0.88, 0.88, 0.88, 0.804, 0.804, 0.804, 0.804, 0.75, 0.75, 0.75, 0.75]\n"
     ]
    }
   ],
   "source": [
    "# look at it\n",
    "print(\"Noisy Operator Expectations\")\n",
    "print([np.round(res.expectation, 4) for res in n_results_proce])\n",
    "print('\\n')\n",
    "# given some readout noise we scale up our estimates by the inverse calibration expectation\n",
    "print(\"Noisy Calibration Expectations\")\n",
    "print([res.calibration_expectation for res in n_results_proce])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4. Apply some estimators to the data \"do DFE\"\n",
    "This just performs the calculations we did at the top of the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Process DFE**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fidelity point estimate is:  1.0\n",
      "The standard error of the fidelity point estimate is:  0.0\n"
     ]
    }
   ],
   "source": [
    "# estimate using NOISELESS data\n",
    "fid_est, fid_std_err = estimate_dfe(results, 'process')\n",
    "\n",
    "print('Fidelity point estimate is: ',fid_est)\n",
    "print('The standard error of the fidelity point estimate is: ', fid_std_err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fidelity point estimate is 0.9853\n",
      "The std error of the fidelity point estimate is 0.0031\n"
     ]
    }
   ],
   "source": [
    "# estimate using NOISY data\n",
    "nfid_est, nfid_std_err = estimate_dfe(n_results_proce, 'process')\n",
    "\n",
    "print('Fidelity point estimate is', np.round(nfid_est, 4))\n",
    "print('The std error of the fidelity point estimate is', np.round(nfid_std_err, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**State DFE**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fidelity point estimate is 1.0141\n",
      "The std error of the fidelity point estimate is 0.0165\n"
     ]
    }
   ],
   "source": [
    "# estimate using NOISY data\n",
    "nfid_est_state, nfid_std_err_state = estimate_dfe(n_results_state, 'state')\n",
    "\n",
    "print('Fidelity point estimate is', np.round(nfid_est_state, 4))\n",
    "print('The std error of the fidelity point estimate is', np.round(nfid_std_err_state, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 5. Visualize\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**State DFE**\n",
    "\n",
    "We will start with state DFE as it is the simplest case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our strategy here will be to try to reconstruct the state using a state tomography estimator. This is possible\n",
    "since the settings used in DFE are a strict subset of the tomography settings. In fact, this makes the strategy of DFE clear-- we only need to estimate those components of the ideal state that are non-zero in order to compute the fidelity. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from forest.benchmarking.tomography import iterative_mle_state_estimate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.497+0.j, 0.   +0.j, 0.   +0.j, 0.497+0.j],\n",
       "       [0.   +0.j, 0.003+0.j, 0.002+0.j, 0.   +0.j],\n",
       "       [0.   +0.j, 0.002+0.j, 0.003+0.j, 0.   +0.j],\n",
       "       [0.497+0.j, 0.   +0.j, 0.   +0.j, 0.497+0.j]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rho_est = iterative_mle_state_estimate(n_results_state, qubits=[0,1])\n",
    "\n",
    "np.round(rho_est, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from forest.benchmarking.utils import n_qubit_pauli_basis\n",
    "from forest.benchmarking.operator_tools.superoperator_transformations import vec, computational2pauli_basis_matrix\n",
    "from forest.benchmarking.plotting.state_process import plot_pauli_rep_of_state, plot_pauli_bar_rep_of_state\n",
    "\n",
    "# convert to pauli representation\n",
    "n_qubits = 2\n",
    "pl_basis = n_qubit_pauli_basis(n_qubits)\n",
    "c2p = computational2pauli_basis_matrix(2*n_qubits)\n",
    "\n",
    "rho_true_pauli = np.real(c2p @ vec(rho_ideal))\n",
    "rho_mle_pauli = np.real(c2p @ vec(rho_est)) \n",
    "\n",
    "fig1, (ax3, ax4) = plt.subplots(1, 2, figsize=(10,5))\n",
    "title_res = f\"Estimated via DFE data using MLE \\n\" f\"DFE Fidelity = {np.round(nfid_est_state, 5)} ± {np.round(nfid_std_err_state, 6)}\"\n",
    "plot_pauli_bar_rep_of_state(rho_true_pauli.flatten(), ax=ax3, labels=pl_basis.labels, title='Ideal State')\n",
    "plot_pauli_bar_rep_of_state(rho_mle_pauli.flatten(), ax=ax4, labels=pl_basis.labels, title=title_res)\n",
    "fig1.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To be clear, each entry on the X axis corresponds to an observable. If we ran full state tomography on the noisy state then the plot on the right would likely have small values for each entry due to noise. However, we note that to compute the fidelity we only need to estimate those entries for which the ideal state is non-zero. The plot on the right shows that we estimated exactly these four entries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Process DFE**\n",
    "\n",
    "The same principle applies to process DFE, but now we must remember that for processes we vary over input states and measurements both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.5, -0. , -0. ,  0.5, -0. ,  0.5,  0.5, -0. ,  0.5, -0. ,  0. ,\n",
       "        -0.5, -0. ,  0.5, -0.5,  0. ],\n",
       "       [-0. , -0. ,  0. , -0. , -0. ,  0. , -0. ,  0. , -0. , -0. , -0. ,\n",
       "         0. , -0. , -0. ,  0. ,  0. ],\n",
       "       [-0. ,  0. , -0. , -0. ,  0. , -0. , -0. ,  0. , -0. ,  0. , -0. ,\n",
       "         0. ,  0. , -0. ,  0. , -0. ],\n",
       "       [ 0.5, -0. , -0. ,  0.5, -0. ,  0.5,  0.5,  0. ,  0.5, -0. ,  0. ,\n",
       "        -0.5, -0. ,  0.5, -0.5,  0. ]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from forest.benchmarking.tomography import pgdb_process_estimate\n",
    "\n",
    "choi_mle_est = pgdb_process_estimate(n_results_proce, qubits)\n",
    "\n",
    "# sneak peak at part of the estimated process\n",
    "np.real_if_close(np.round(choi_mle_est, 2))[0:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from forest.benchmarking.plotting.state_process import plot_pauli_transfer_matrix\n",
    "from forest.benchmarking.operator_tools import choi2pauli_liouville, kraus2pauli_liouville\n",
    "\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,5))\n",
    "title_res = f\"Estimated via DFE data using MLE \\n\" f\"DFE Fidelity = {np.round(nfid_est, 5)} ± {np.round(nfid_std_err, 6)}\"\n",
    "plot_pauli_transfer_matrix(np.real(kraus2pauli_liouville(U_ideal)), ax1, title='Ideal')\n",
    "plot_pauli_transfer_matrix(np.real(choi2pauli_liouville(choi_mle_est)), ax2, title=title_res)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## State fidelity between $\\left|1\\right\\rangle$ and $|\\theta\\rangle = R_y(\\theta)\\left|1\\right\\rangle$\n",
    "\n",
    "\n",
    "In this section we check that state DFE is working correctly by comparing with an analytical calculation. \n",
    "Essentially we would like to prepare $|1\\rangle$ but we simulate an incorrect preparation $|\\theta\\rangle = R_y(\\theta)|1\\rangle$. The fidelity in that case is\n",
    "\n",
    "$$\\begin{align}\n",
    "F\\big(|1\\rangle, |\\theta\\rangle \\big) &= |\\langle 1|R_y(\\theta) |1\\rangle |^2\\\\\n",
    "&= \\cos^2(\\theta/2)\\\\\n",
    "&= \\frac{1}{2} \\big (1 +\\cos(\\theta) \\big). \n",
    "\\end{align}$$\n",
    "\n",
    "So the point of this section is to try to \"experimentally\" plot the fidelity expression as a function of $\\theta$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "qubit = 0\n",
    "ideal_prep_program = Program(X(qubit))\n",
    "\n",
    "# generate state dfe experiment to estimate fidelity to |1 >\n",
    "experiment = generate_exhaustive_state_dfe_experiment(bm, ideal_prep_program, [qubit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To simulate the error we will modify the ideal program in the experiment to be `RY(theta, 0) X(0)` for various angles $\\theta$; this is the case of unitary rotation error occurring after our ideal preparation `X(0)`.\n",
    "\n",
    "Of course, for characterizing the actual noise on a real QPU our program would simply remain `X(0)` since this is the state preparation we hope will prepare the state $|1 \\rangle$ but which in practice will be affected by noise. Here we must append our own noise `RY(theta)` to the program for the purposes of simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "points = 10\n",
    "res = []\n",
    "res_std_err = []\n",
    "\n",
    "\n",
    "# loop over different angles\n",
    "for theta in np.linspace(0, np.pi, points):\n",
    "    # reuse the same experiment object but modify its program\n",
    "    # field to do the \"noisy\" program\n",
    "    experiment.program = ideal_prep_program + RY(theta, qubit)\n",
    "    ry_state_data = acquire_dfe_data(qvm, experiment, num_shots=1000)\n",
    "    fid_est, fid_std_err = estimate_dfe(ry_state_data, 'state')\n",
    "    res.append(fid_est)\n",
    "    res_std_err.append(2*fid_std_err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pyplot.errorbar(np.linspace(0, np.pi, points), res, res_std_err, fmt=\".\", label=\"Simulation\")\n",
    "pyplot.plot(np.linspace(0, np.pi, points), (1/2+1/2*np.cos(np.linspace(0, np.pi, points))), label=\"Theory\")\n",
    "pyplot.xlabel(r\"$\\theta$\")\n",
    "pyplot.ylabel(\"Fidelity\")\n",
    "pyplot.legend()\n",
    "pyplot.title(r\"State fidelity between $\\left|1\\right\\rangle$ and $R_y(\\theta)\\left|1\\right\\rangle$\")\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as expected, the fidelity decays from the ideal with increasing values of theta."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Process fidelity between $I$ and $R_y(\\theta)$\n",
    "\n",
    "Like the state fidelity example above we will construct a DFE experiment to estimate the fidelity between the ideal identity operation and a 'noisy identity' where we insert the unitary error $R_y(\\theta)$. Then we will show that process DFE is consistent with the analytical calculation.\n",
    "\n",
    "The process fidelity is easy to calculate using Eqn 5 from [arXiv:quant-ph/0701138](https://arxiv.org/pdf/quant-ph/0701138.pdf). The fidelity between the unitary $U_0$ and the quantum operation specified by the Kraus operators $\\{ G_k \\}$ is \n",
    "\n",
    "$$F(\\{ G_k \\}, U_0) \n",
    "= \\frac{1}{d(d+1)} \\big ( {\\rm Tr}\\big [\\sum_k M_k^\\dagger M_k \\big ] + \\sum_k |{\\rm Tr}[ M_k]|^2 \\big )$$\n",
    "\n",
    "where $M_k = U_0^\\dagger G_k$.\n",
    "\n",
    "In the context we care about we have a single Kraus operator $\\{ G_k \\} = \\{R_y(\\theta)\\}$ and $U_0=I \\implies M_k = R_y(\\theta)$. So the fidelity becomes\n",
    "\n",
    "$$F\\big(R_y(\\theta), I \\big) \n",
    "= \\frac{1}{3} \\big (1 +2\\cos^2(\\theta/2) \\big )$$\n",
    "\n",
    "where we used $R_y(\\theta) = \\exp[-i \\theta Y /2]= \\cos(\\theta/2) I - i \\sin(\\theta/2)Y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here our ideal program is the Identity process\n",
    "qubit = 0\n",
    "ideal_process_program = Program(I(qubit))\n",
    "\n",
    "# generate process DFE experiment to estimate fidelity to I\n",
    "expt = generate_exhaustive_process_dfe_experiment(bm, ideal_process_program, [qubit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, as with state dfe, we will simulate noisy implementation of the identity by modifying the program that is actually run in the experiment to be `RY(theta,0)` instead of just the identity. \n",
    "\n",
    "As above we emphasize that modifying the program in this way only makes sense if you are inserting your own simulation of noise. To characterize real noise on a QPU the program should not be changed after generating the experiment, since the generation code tailors the experiment to the provided program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** in some of the cells below there is a comment `# NBVAL_SKIP` that is used to speed up our tests by skipping that particular cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NBVAL_SKIP\n",
    "num_points = 10\n",
    "thetas = np.linspace(0, np.pi, num_points)\n",
    "res = []\n",
    "res_std_err = []\n",
    "for theta in thetas: \n",
    "    # modify the experiment object to do the noisy program instead\n",
    "    expt.program = ideal_process_program + RY(theta, qubit)\n",
    "    ry_proc_data = acquire_dfe_data(qvm, expt, num_shots=500)\n",
    "    fid_est, fid_std_err = estimate_dfe(ry_proc_data, 'process')\n",
    "    res.append(fid_est)\n",
    "    res_std_err.append(2*fid_std_err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# NBVAL_SKIP\n",
    "pyplot.errorbar(thetas, res, res_std_err, fmt=\".\", label=\"Simulation\")\n",
    "pyplot.plot(thetas, (1 + 2*np.cos(thetas/2)**2)/3,\n",
    "            label=\"theory\")\n",
    "pyplot.xlabel(r\"$\\theta$\")\n",
    "pyplot.ylabel(\"Fidelity\")\n",
    "pyplot.legend()\n",
    "pyplot.ylim(0.25, 1.05)\n",
    "pyplot.title(r\"Process fidelity between $I$ and $R_y(\\theta)$\")\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monte Carlo Sampling of large graph states\n",
    "\n",
    "We can do [Monte Carlo](https://en.wikipedia.org/wiki/Monte_Carlo_method) or random sampling of `ExperimentSettings` for large states or processes.\n",
    "\n",
    "* `generate_monte_carlo_state_dfe_experiment`\n",
    "* `generate_monte_carlo_process_dfe_experiment`\n",
    "\n",
    "generally you need to specify the number of terms you would like to sample for the desired time savings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "from matplotlib import pyplot as plt\n",
    "from forest.benchmarking.entangled_states import create_graph_state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will demonstrate state DFE on a graph state over 5 qubits. First, we will take some subgraph of the larger QC topology. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/kylegulshen/anaconda3/lib/python3.6/site-packages/networkx/drawing/nx_pylab.py:518: MatplotlibDeprecationWarning: \n",
      "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n",
      "  if not cb.iterable(width):\n",
      "/home/kylegulshen/anaconda3/lib/python3.6/site-packages/networkx/drawing/nx_pylab.py:565: MatplotlibDeprecationWarning: \n",
      "The is_numlike function was deprecated in Matplotlib 3.0 and will be removed in 3.2. Use isinstance(..., numbers.Number) instead.\n",
      "  if cb.is_numlike(alpha):\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nx.draw(noisy_qvm.qubit_topology(), with_labels=True)\n",
    "\n",
    "# we will do a subgraph\n",
    "graph = nx.from_edgelist([(0, 1), (0, 3), (1, 2), (1, 4), (3, 4)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use a helper to create the prep program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H 0\n",
      "H 1\n",
      "H 3\n",
      "H 2\n",
      "H 4\n",
      "CZ 0 1\n",
      "CZ 0 3\n",
      "CZ 1 2\n",
      "CZ 1 4\n",
      "CZ 3 4\n",
      "\n"
     ]
    }
   ],
   "source": [
    "graph_prep_prog = create_graph_state(graph)\n",
    "\n",
    "qubits = list(graph_prep_prog.get_qubits())\n",
    "print(graph_prep_prog)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate both exhaustive and monte_carlo experiments for comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "gstate_exp_exh = generate_exhaustive_state_dfe_experiment(bm, graph_prep_prog, qubits)\n",
    "gstate_exp_mc = generate_monte_carlo_state_dfe_experiment(bm, graph_prep_prog, qubits, n_terms=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In exhaustive state DFE there are 31 experiments.\n",
      "\n",
      "In monte carlo state DFE we chose 8 experiments.\n"
     ]
    }
   ],
   "source": [
    "num_exh_exp = len(list(gstate_exp_exh.setting_strings()))\n",
    "num_mc_exp = len(list(gstate_exp_mc.setting_strings()))\n",
    "\n",
    "print(f'In exhaustive state DFE there are {num_exh_exp} experiments.\\n' )\n",
    "\n",
    "print(f'In monte carlo state DFE we chose {num_mc_exp} experiments.' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run each experiment and compare estimates and runtimes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The five qubit graph fidelity estimate is 0.9234208202870585.\n",
      "\n",
      "Monte-Carlo took  41.18 seconds.\n"
     ]
    }
   ],
   "source": [
    "# NBVAL_SKIP\n",
    "\n",
    "# because of the #NBVAL_SKIP `%%time` wont work\n",
    "from time import time\n",
    "start_time = time()\n",
    "\n",
    "graph_state_mc_data = acquire_dfe_data(noisy_qvm, gstate_exp_mc, num_shots=500)\n",
    "\n",
    "fid_est, fid_std_err = estimate_dfe(graph_state_mc_data, 'state')\n",
    "print(f'The five qubit graph fidelity estimate is {fid_est}.\\n')\n",
    "print('Monte-Carlo took ', np.round(time()-start_time, 2), 'seconds.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The five qubit graph fidelity estimate is 0.9395043896868677.\n",
      "\n",
      "Exhaustive took  204.76 seconds.\n"
     ]
    }
   ],
   "source": [
    "# NBVAL_SKIP\n",
    "\n",
    "start_time = time()\n",
    "\n",
    "graph_state_exh_data = acquire_dfe_data(noisy_qvm, gstate_exp_exh, num_shots=500)\n",
    "\n",
    "fid_est, fid_std_err = estimate_dfe(graph_state_exh_data, 'state')\n",
    "print(f'The five qubit graph fidelity estimate is {fid_est}.\\n')\n",
    "print('Exhaustive took ', np.round(time()-start_time, 2), 'seconds.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DFE measurements that include spectator qubits to signal cross talk.\n",
    "\n",
    "Suppose you wanted to do process tomography on a CZ gate.\n",
    "\n",
    "It turns out in many superconducting qubits there are many kinds of cross-talk at play, that is, noise which affects qubits not directly involved in the gate.\n",
    "\n",
    "\n",
    "One way to measure such noise is to do the gate you care about and additionally specify spectator qubits not involved in the gate when creating the experiment.\n",
    "If the actual process is not Identity on those qubits then DFE will pick it up.\n",
    "\n",
    "Of course, such experiments are best done on the QPU or at the least with a noise model that includes these effects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "prog = Program(CZ(0,1))\n",
    "qubits = [0,1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The CZ gate is: CZ(0,1)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/kylegulshen/anaconda3/lib/python3.6/site-packages/networkx/drawing/nx_pylab.py:518: MatplotlibDeprecationWarning: \n",
      "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n",
      "  if not cb.iterable(width):\n",
      "/home/kylegulshen/anaconda3/lib/python3.6/site-packages/networkx/drawing/nx_pylab.py:565: MatplotlibDeprecationWarning: \n",
      "The is_numlike function was deprecated in Matplotlib 3.0 and will be removed in 3.2. Use isinstance(..., numbers.Number) instead.\n",
      "  if cb.is_numlike(alpha):\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('The CZ gate is: CZ(0,1)')\n",
    "nx.draw(nx.from_edgelist([(0, 1), (1, 2)]), with_labels=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "xtalk_proc_exp = generate_monte_carlo_process_dfe_experiment(bm, prog, qubits, n_terms=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list(xtalk_proc_exp.setting_strings()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "xtalk_data = acquire_dfe_data(qvm, xtalk_proc_exp, num_shots=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fid_est, fid_std_err = estimate_dfe(xtalk_data, 'process')\n",
    "fid_est"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, we expect this to be 1.0 unless we are running on a real QPU or incorporate cross-talk into the QVM noise model.\n",
    "\n",
    "If we wanted to we could \"amplify\" the cross talk error by applying the gate many times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "prog = Program([CZ(0,1)]*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parallel state and process DFE\n",
    "\n",
    "The `ObservablesExperiment` [framework](observable_estimation.ipynb) allows for easy parallelization of experiments that operate on disjoint sets of qubits. Below we will demonstrate the simple example of performing process DFE on two separate bit flip processes `Program(X(0))` and `Program(X(1))`. To run each experiment in serial would require $n_1 + n_2 = 2n$ experimental runs ($n_1 = n_2 = n$ in this case), but when we run a 'parallel' experiment we need only $n$ runs. \n",
    "\n",
    "Note that the parallel experiment is not the same as doing DFE on the program `Program(X(0), X(1))` because in the later case we need to do more data acquisition runs on the qc and we get more information back; even if each process perfectly transforms the 1q states it could still behave erroneously on some 2q states but we would only catch that if we did 2q DFE. The `ExperimentSetting`s for the 2q experiment are a superset of the parallel 1q settings. We also cannot directly compare a parallel experiment with two serial experiments, because in a parallel experiment 'cross-talk' and other multi-qubit effects can impact the overall process; that is, the physics of 'parallel' experiments cannot in general be neatly factored into two serial experiments. \n",
    "\n",
    "See the linked [notebook](observable_estimation.ipynb) for more explanation and words of caution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original number of runs: 12\n",
      "Parallelized number of runs: 6\n",
      "\n",
      "X 0; X 1\n",
      "0: X+_0→(1+0j)*X0, X+_1→(1+0j)*X1\n",
      "1: X-_0→(-1+0j)*X0, X-_1→(-1+0j)*X1\n",
      "2: Y+_0→(-1+0j)*Y0, Y+_1→(-1+0j)*Y1\n",
      "3: Y-_0→(1-0j)*Y0, Y-_1→(1-0j)*Y1\n",
      "4: Z+_0→(-1+0j)*Z0, Z+_1→(-1+0j)*Z1\n",
      "5: Z-_0→(1-0j)*Z0, Z-_1→(1-0j)*Z1\n"
     ]
    }
   ],
   "source": [
    "from forest.benchmarking.observable_estimation import ObservablesExperiment, merge_disjoint_experiments\n",
    "\n",
    "disjoint_sets_of_qubits = [(0,),(1,)]\n",
    "programs = [Program(X(*q)) for q in disjoint_sets_of_qubits]\n",
    "\n",
    "expts_to_parallelize = []\n",
    "for qubits, program in zip(disjoint_sets_of_qubits, programs):\n",
    "    expt = generate_exhaustive_process_dfe_experiment(bm, program, qubits)\n",
    "    expts_to_parallelize.append(expt)\n",
    "\n",
    "# get a merged experiment with grouped settings for parallel data acquisition\n",
    "parallel_expt = merge_disjoint_experiments(expts_to_parallelize)\n",
    "\n",
    "print(f'Original number of runs: {sum(len(expt) for expt in expts_to_parallelize)}')\n",
    "print(f'Parallelized number of runs: {len(parallel_expt)}\\n')\n",
    "print(parallel_expt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Collect the data. Separate the results by qubit to get back estimates for each process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.9988672847543816, 0.007037532516941518)\n",
      "(1.0156912964835694, 0.0074100435152986465)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from forest.benchmarking.observable_estimation import get_results_by_qubit_groups\n",
    "\n",
    "parallel_results = acquire_dfe_data(noisy_qvm, parallel_expt, num_shots = 500)\n",
    "\n",
    "individual_results = get_results_by_qubit_groups(parallel_results, disjoint_sets_of_qubits)\n",
    "\n",
    "fidelity_estimates = []\n",
    "process_estimates = []\n",
    "for q in disjoint_sets_of_qubits:\n",
    "    fidelity_estimate = estimate_dfe(individual_results[q], 'process')\n",
    "    fidelity_estimates.append(fidelity_estimate)\n",
    "    print(fidelity_estimate)\n",
    "    \n",
    "    proc_estimate = pgdb_process_estimate(individual_results[q], q)\n",
    "    process_estimates.append(proc_estimate)\n",
    "\n",
    "fig, axes = plt.subplots(1, len(process_estimates), figsize=(12,5))\n",
    "for idx, est in enumerate(process_estimates):\n",
    "    plot_pauli_transfer_matrix(choi2pauli_liouville(est), axes[idx], title=f'Estimate {idx}')\n",
    "\n",
    "plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}