NoisySimulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hello, and welcome to this tutorial on simulating circuit noise in Tequila! In this tutorial, we will briefly detail what quantum noise is, its mathematical modeling, and how specific popular simulation packages handle noisy simulation, before diving in to building Tequila `NoiseModel`s and applying them to sampling different circuits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> What is noise?</center>\n",
    "\n",
    "In case you need a quick refresher: Real quantum systems undergo the effects of noise, a catch-all term for 'anything the user didn't ask the computer to do'. Such noise can be caused by a number of physical processes, including but not limited to: \n",
    "\n",
    " - **Thermal fluctuations**\n",
    " - **Interaction with the environment**\n",
    " - **Uncontrolled interaction between qubits (cross-talk)**\n",
    " - **Imperfections in gate implementation**\n",
    " \n",
    "\n",
    "\n",
    "# <center> How is noise represented mathematically?</center>\n",
    "\n",
    "\n",
    "Commonly, the effects of noise on quantum systems are treated as the evolution of the system's density matrix under Krauss maps. Krauss maps are mappings of the form $ A: \\rho \\rightarrow \\rho' = \\sum_{i} A_i \\rho A_{i}^{\\dagger}$, where $\\sum_{i} A_i  A_{i}^{\\dagger} = I$. These Krauss maps are parametrized, in general by probabilities.\n",
    "\n",
    "For example, bit flip noise -- which takes qubits from the 0 to the 1 state and vice versa-- is a krauss map with two operators, and a single probabilistic parameter, p. The operators are:\n",
    "$$A_0 = \\sqrt{1-p} I,  A_1 = \\sqrt{p} X$$\n",
    "**Note that the square root is present, so that bit flip map is:**\n",
    "$$ A_{bf}(p): \\rho \\rightarrow (1-p) * I\\rho I + p * X\\rho X$$\n",
    "other noise operations may be defined similarly.\n",
    "\n",
    "**Note that such krauss operators may only affect subsystems of the system;** one can have a single qubit undergo bit-flip noise in an 8 qubit state. In such cases, the krauss maps are merely the 1-qubit maps tensored with the identity on all other qubits. Multi-qubit krauss operators will involve tensor products of single qubit krauss operators.\n",
    "\n",
    "For example, the 2-qubit bit flip krauss map has 4 operators:\n",
    "$$A_{00}=(1-p)I\\otimes I, A_{01}=\\sqrt{p-p^2}I\\otimes X,A_{10}=\\sqrt{p-p^2}X \\otimes I,A_{11}=pX\\otimes X$$\n",
    "Which are just all the tensor products of $A_{0}$ and $A_{1}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> 3. How is noise simulated? </center>\n",
    "\n",
    "Different simulation packages handle noise in radically different ways.\n",
    "\n",
    "*Cirq* and *Qulacs*, for example, use noise channels, parametrized operations which are inserted into circuits the same way regular, unitary gates are. \n",
    "\n",
    "*Pyquil* asks its users to define noisy gate operations, and then instantiate those. \n",
    "\n",
    "*Qiskit*, meanwhile, simply takes a dictionary-like object as an argument to its simulator, and applies the noise on the user-chosen gates.\n",
    "\n",
    "In tequila, we try to hew toward making users write as few lines of code as possible. We therefore implement a simple framework for the application of noise, meant to be compatible with all our supported platforms. To do this, we make a few assumptions:\n",
    "\n",
    "1. If noise is present, any gate may be affected by noise.\n",
    "2. The noise that affects 1..k..n-qubit gates is independent of the noise on 1...k-1,k+1...n qubit gates.\n",
    "3. Noise probabilities are independent of position in the circuit.\n",
    "4. The number of qubits involved in a gate, not the operation performed, dictates what noises may occur.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center>  Noise in Tequila: Overview </center>\n",
    "\n",
    "noise in Tequila is centered upon the `NoiseModel` class, itself used to store and combine `QuantumNoise` objects. \n",
    "Each `QuantumNoise` internally designates what operation it will perform, with what probability (or probabilities), and on how many qubits. Only at the time of translation to a backend -- or in the case of *Qiskit*, at time of simulation -- do`NoiseModel`s and simulateables -- circuits, ExpectationValues, Objectives -- interact.\n",
    "\n",
    "Tequila at present supports six common quantum noise operations, all of which can at present be employed by all the noise-supporting simulation backgrounds. These six operations are:\n",
    "\n",
    "1. Bit flips, a probabilistic application of pauli X;\n",
    "2. Phase flips, a probablistic application of pauli Z;\n",
    "3. Amplitude damps, which take qubits in state |1> to |0>;\n",
    "4. Phase damps, which are a different formalization of the phase flip;\n",
    "5. Phase-Amplitude damps, which simultaneously perform said operations;\n",
    "6. (Symmetric) depolarizing, which (equi)probabilistically performs pauli X, Y, and Z.\n",
    "\n",
    "in Tequila, custom members of the `QuantumNoise` class are not possible, and so they should be initialized by the constructor function for each supported channel, which creates a `NoiseModel` containing one operation. all six of which are shown in the import statement below.\n",
    "\n",
    "`NoiseModel`s combine with eachother through addition, creating a new `NoiseModel` with all the operations of the two summands. Note that in those simulators which employ noise channels, the order of the noises in the noise model will dictate the order of application in the circuit; users should be mindful of this.\n",
    "\n",
    "To use a `NoiseModel` to apply noise, one may provide a noise model to the *tq.compile*, *tq.simulate*, and optimization calls like *tq.minimize*, through the keyword `noise=my_noise_model`. Noise is only supported when sampling; if in the above functions the keyword *samples* is `None` (defaullt), noise cannot function.\n",
    "\n",
    "additionally, Tequila supports the use of device-noise-emulation for those backends which allow the emulation of specific real devices. If in compilation, simulation, or optimization, emulated backends have been selected (such as 'fake_vigo', for IBMQ), the known noise of this device may be employed. In these cases, the keyword assignment *noise='device'* should be used, if these known noise models are desired.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "### first, we import tequila!\n",
    "import tequila as tq\n",
    "from tequila.circuit.noise import BitFlip,PhaseFlip,AmplitudeDamp,PhaseDamp,PhaseAmplitudeDamp,DepolarizingError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will first examine bit flip noise on a simple circuit with a simple Hamiltonian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulating:  +0.5000-0.5000Z(1)\n",
      "acting on: \n",
      "0: ───X───@───\n",
      "          │\n",
      "1: ───────X───\n"
     ]
    }
   ],
   "source": [
    "H=tq.paulis.Qm(1) ### this hamiltonian is 0 for a qubit that is 0, and 1 for a qubit that is 1.\n",
    "U=tq.gates.X(0)+tq.gates.CNOT(0,1)\n",
    "O1=tq.ExpectationValue(U=U,H=H)\n",
    "\n",
    "print('simulating: ',H)\n",
    "print('acting on: ')\n",
    "tq.draw(U)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Say that we wanted a noise model where 1-qubit gates and 2-qubit gates undergo bit flips, but with different probabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "bf_1=BitFlip(p=0.1,level=1)\n",
    "bf_2=BitFlip(p=0.3,level=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " `NoiseModel` objects, like those initialized above, can be combined into new `NoiseModel`s by simple addition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "applying: NoiseModel with: \n",
      "bit flip on 1 qubit gates, probs = [0.1],\n",
      "bit flip on 2 qubit gates, probs = [0.3],\n",
      "\n"
     ]
    }
   ],
   "source": [
    "my_nm=bf_1+bf_2\n",
    "print('applying:',my_nm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we will now sample our `Objective` O1, both with and without noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without noise, E = 1.0\n",
      "With noise, E = 0.6664\n"
     ]
    }
   ],
   "source": [
    "E=tq.simulate(O1)\n",
    "### noise models are fed to tequila functions with the noise keyword.\n",
    "E_noisy=tq.simulate(O1,samples=5000,noise=my_nm)\n",
    "print('Without noise, E =',E)\n",
    "print('With noise, E =',E_noisy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Because noise is stochastic, results may vary wildly if the number of samples is low.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round 1 sampling with 5 samples, E =  0.8\n",
      "round 2 sampling with 5 samples, E =  1.0\n",
      "round 3 sampling with 5 samples, E =  0.6\n",
      "round 4 sampling with 5 samples, E =  0.6\n",
      "round 5 sampling with 5 samples, E =  0.4\n",
      "round 6 sampling with 5 samples, E =  0.2\n",
      "round 7 sampling with 5 samples, E =  0.8\n",
      "round 8 sampling with 5 samples, E =  0.4\n",
      "round 9 sampling with 5 samples, E =  0.8\n",
      "round 10 sampling with 5 samples, E =  0.6\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    print('round',i,'sampling with 5 samples, E = ', tq.simulate(O1,samples=5,noise=my_nm))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the *BitFlip* functions returned applicable `NoiseModel`s in their own right:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With 1-qubit noise only, E = 0.9139999999999999\n",
      "With 2-qubit noise only, E = 0.69\n"
     ]
    }
   ],
   "source": [
    "E_1_only=tq.simulate(O1,samples=1000,noise=bf_1)\n",
    "print('With 1-qubit noise only, E =',E_1_only)\n",
    "E_2_only=tq.simulate(O1,samples=1000,noise=bf_2)\n",
    "print('With 2-qubit noise only, E =',E_2_only)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we demonstrate the effects of the ordering of the noise operations applied. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING - WARNING: all-qubit error already exists for instruction \"x\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"y\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"z\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"u3\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"u1\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"u2\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"h\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"x\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"y\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"z\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"u3\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"u1\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"u2\", composing with additional error.\n",
      "WARNING - WARNING: all-qubit error already exists for instruction \"h\", composing with additional error.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amplitude damping before bit flip leads to E =  -0.08186\n",
      "amplitude damping after bit flip leads to E =  0.15744\n"
     ]
    }
   ],
   "source": [
    "amp=AmplitudeDamp(0.3,1)\n",
    "bit=BitFlip(0.4,1)\n",
    "forward=amp+bit\n",
    "backward=bit+amp\n",
    "\n",
    "H = tq.paulis.Z(0)\n",
    "U = tq.gates.X(target=0)\n",
    "O = tq.ExpectationValue(U=U, H=H)\n",
    "\n",
    "E_1 = tq.simulate(O,samples=100000,noise=forward)\n",
    "E_2 = tq.simulate(O,samples=100000,noise=backward)\n",
    "print('amplitude damping before bit flip leads to E = ',E_1)\n",
    "print('amplitude damping after bit flip leads to E = ',E_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tequila will *always* attempt to apply noise to the circuit *in the order each noise was added to the noise model*. Some backends have behavior which is harder to control than others, but in general, this order will be preserved."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we will optimize a noisy circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the 1-qubit expectation value, $<0|U^{\\dagger}\\hat{Y}U|0>$, with $U=H Rz(\\theta) H $. In the absence of noise, this expectation value just yields $Sin(\\theta)$. This circuit therefore has a minimum at $\\theta = -\\pi$. We can minimize this circuit under phase flip noise -- which is probabilistic application of pauli Z -- and see what happens!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimizing expectation value with phase flip probability 0.08991331275688234.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "U=tq.gates.H(0) +tq.gates.Rz('a',0)+tq.gates.H(0)\n",
    "H=tq.paulis.Y(0)\n",
    "O=tq.ExpectationValue(U=U,H=H)\n",
    "\n",
    "### we pick a random, small probability to apply noise\n",
    "p=np.random.uniform(0,.1)\n",
    "NM=PhaseFlip(p,1)\n",
    "\n",
    "print('optimizing expectation value with phase flip probability {}.'.format(str(p)))\n",
    "result=tq.minimize(objective=O,lr=0.5,maxiter=60,initial_values={'a':np.pi},method='adam',samples=5000,noise=NM,silent=True)\n",
    "\n",
    "result.history.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final energy is not -1.0, because the application of noise leads the expected output to be $(-1+2*p)^{3} Sin(\\theta)$. One sees that this is approximately the value reached by minimizing $\\theta$. Because the number of samples is not infinite, the 'expected' best energy may be exceeded:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best energy:  -0.5688\n",
      "expected best  -0.5517178049632779\n"
     ]
    }
   ],
   "source": [
    "out=result.energy\n",
    "best=((-1+2*p)**3)*np.sin(np.pi/2)\n",
    "print('best energy: ',out)\n",
    "print('expected best ',best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## This concludes our brief tutorial on Noise. Stay tuned (and up to date) for more exciting noise features in the future!"
   ]
  },
  {
   "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}