QuTiP_Reference_Doc.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#QuTiP Reference Doc\n",
        "This is a compilation of information gathered from the [QuTiP Website](https://qutip.org), [QuTiP API Documentation](https://qutip.org/docs/latest/apidoc/apidoc.html), and [QuTiP Support Group](https://groups.google.com/g/qutip). This document should serve as a digest of information relevant to this (Rabi Oscillation Fitting) project found in tutorials and documentation. Enjoy!\n",
        "\n",
        "---\n"
      ],
      "metadata": {
        "id": "GplJtTckqecX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#The Basics\n",
        "The following is a quick overview of basic functions, operations, and capabilities of QuTiP. For a comprehensive dive into basic applications, see [this](https://nbviewer.org/urls/qutip.org/qutip-tutorials/tutorials-v4/python-introduction/004_link_to_lecture_0.ipynb) page. Since QuTiP is a python library, a refresher of basic python syntax and functions can be found [here](https://docs.python.org/3/tutorial/)."
      ],
      "metadata": {
        "id": "BfTDeSMusKXL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Importing\n",
        "QuTiP is a library that must be installed if not done already. Many applications of QuTiP require the accompaniment of **matplotlib** and **numpy** as well.\n",
        "\n",
        "QuTiP requires specific importing of functions and modules, which will be included throughout this document. The following is an example relevant to this section:"
      ],
      "metadata": {
        "id": "brXBHjUovXjv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install qutip #Install QuTiP if needed\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from IPython.display import Image\n",
        "from qutip import (Qobj, about, basis, coherent, coherent_dm, create, destroy,\n",
        "                   expect, fock, fock_dm, mesolve, qeye, sigmax, sigmay,\n",
        "                   sigmaz, tensor, thermal_dm)"
      ],
      "metadata": {
        "id": "2kzdoQi6qmnH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Defining Objects - Qobj\n",
        "QuTiP intuitively defines *Quantum Objects* using the built in **Qobj** class.\n",
        "\n",
        "**Qobj(data(array), dimensions(list), shape(list), type(string), hermitian boolean(boolean))**"
      ],
      "metadata": {
        "id": "TEAN0K8HsoeU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "q = Qobj([[1],[0]]) #Define a 1x2 quantum object with entries 1 and 0\n",
        "\n",
        "#Examples of Qobj properties\n",
        "q.dims #Access dimensions\n",
        "q.shape #Access shape\n",
        "q.data #Access the entries of the object as a sparse matrix\n",
        "q.full() #Access dense matrix representation of the object\n",
        "q.isherm #Evaluate if the object is hermitian\n",
        "q.type #Access object type (ie. ket, bra, operator)"
      ],
      "metadata": {
        "id": "NGj2KlO1sr-a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Qobjs are very versatile and can be operated on by many built in methods. For a comprehensive list, see the class documentation [here](https://qutip.org/docs/latest/apidoc/classes.html)."
      ],
      "metadata": {
        "id": "C2XAt-Srbm9d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Some commonly used Qobj methods\n",
        "q.copy() #Create a copy of a Qobj\n",
        "q.conj() #Generate conjugate of Qobj\n",
        "q.dag() #Generate adjoint of Qobj\n",
        "q.proj() #Generate the projector of a ket or bra vector\n",
        "q.tidyup(lim) #Remove elements below the value of lim\n",
        "q.trans() #Generate transpose of the Qobj\n",
        "q.eigenenergies() #Returns eigenenergies of Qobj\n",
        "q.eigenstates() #Returns eigenstates and eigenenergies of Qobj"
      ],
      "metadata": {
        "id": "b4Qsw4Grb4Gr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Built in Operators\n",
        "The pauli operators are built in Qobj functions.\n",
        "\n"
      ],
      "metadata": {
        "id": "o0arDtu7dF7X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sigmax() #Pauli X\n",
        "sigmay() #Pauil Y\n",
        "sigmaz() #Pauli Z"
      ],
      "metadata": {
        "id": "qTCpZ61NdN1Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Specific Objects\n",
        "QuTiP has several built in functions that allow for Qobjs with specific properties and purposes to be built. All methods that apply to the general Qobj class can be applied to these."
      ],
      "metadata": {
        "id": "uMEt2uV3dfIj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#State generation\n",
        "basis(N,n) #Build a basis state with dimensions (N,n)\n",
        "coherent(N,a) #Build a coherent state with dimensions (N,1) and coefficient a\n",
        "  coherent_dm(N,a) #Generate a coherent state density matrix\n",
        "fock(N,n) #Build a fock state with dimensions (N,n) (Similar to basis)\n",
        "  fock_dm(N,n) #Generate a fock state density matrix\n",
        "thermal_dm(N,n) #Generate a thermal state with dimensions (N,N) and n thermal photons\n",
        "qeye(N) #Generate a matrix with unity diagonal entries\n",
        "\n",
        "#Operator generation\n",
        "destroy(N) #Generate annihilation operator with dimensions (N,N)\n",
        "create(N) #Generate a creation operator with dimensions (N,N)"
      ],
      "metadata": {
        "id": "jOiidnlydo_M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Important Functions"
      ],
      "metadata": {
        "id": "HBSkqqxLs9Na"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor(mat1, mat2) #Compute the tensor product of two matrices\n",
        "mesolve(H,psi0,tlist, cops, eops) #A master equation solver (see Master Equations)\n",
        "expect(operators, state) #Compute the expectation values with a list of operators and a list of states"
      ],
      "metadata": {
        "id": "8OYrGKHCs-lA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#A Note on Units and Hamiltonians"
      ],
      "metadata": {
        "id": "BKW9LcC4yaUs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "QuTiP operates on the assumption, for the most part, that parameters are input in terms of **Natural Units.**\n",
        "\n",
        "Natural units are defined based on the assignment of $\\hbar = c = eV = 1$. Generally, SI and natural units can be exchanged according to the following convention:\n",
        "\n",
        "$kg^\\alpha m^\\beta s^\\gamma → E^{\\alpha - \\beta - \\gamma} \\hbar^{\\beta + \\gamma} c^{\\beta -2\\alpha}$\n",
        "\n",
        "The following is a basic conversion factor calculator."
      ],
      "metadata": {
        "id": "Er70YFtDydL5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "#Values\n",
        "SI_val = int(input(\"Input initial value in SI units:\"))\n",
        "c_val = 299792458 #m/s\n",
        "hbar_val =1.054571817e-34 #kg m^2/s\n",
        "eV_val = 1.602176463e-19 #kg m^2/s^2\n",
        "\n",
        "#SI exponents according to the above notation\n",
        "alpha = int(input(\"Input kg exponent:\"))\n",
        "beta = int(input(\"Input m exponent:\"))\n",
        "gamma1 = int(input(\"Input s exponent:\"))\n",
        "\n",
        "#Natural Unit exponent calculation according to the above notation\n",
        "E_exp = alpha-beta-gamma1\n",
        "hbar_exp = beta+gamma1\n",
        "c_exp = beta-2*alpha\n",
        "\n",
        "#unit display\n",
        "print('kg^%a m^%s s^%i is expressed in natural units of eV^%d ℏ^%e c^%f' %(alpha, beta, gamma1, E_exp, hbar_exp, c_exp))\n",
        "\n",
        "#Conversion factor calculation\n",
        "SI_unit_val = (eV_val**E_exp)*(hbar_val**hbar_exp)*(c_val**c_exp)\n",
        "nat_conv_val = 1/SI_unit_val\n",
        "\n",
        "#Value of 1 unit of interest\n",
        "print(\"The conversion factor is\",nat_conv_val)\n",
        "\n",
        "#Obtain final value\n",
        "nat_val = SI_val*nat_conv_val\n",
        "print(\"The converted value is %s\" %(nat_val))"
      ],
      "metadata": {
        "id": "nQNlEC3x0SFg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Temperature\n",
        "Although it is possible to define temperatures in natural units, temperatures implemented in QuTiP must be defined in **the energy/frequency units of the Hamitonian.** Ie. if the hamiltonian is defined in terms of a frequency in GHz, temperature should be converted from Kelvin to GHz.\n",
        "\n",
        "A general conversion from K to GHz is shown below and can be scaled as needed."
      ],
      "metadata": {
        "id": "wnCt4w5NPL7N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "temperature = 25e-3\n",
        "h = 6.626e-34\n",
        "kB = 1.38e-23\n",
        "w_th = temperature * (kB/h) * 2 * np.pi * 1e-9\n",
        "\n",
        "print(w_th)"
      ],
      "metadata": {
        "id": "eXICNf24P4Er"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Hamiltonians\n",
        "Defining Hamiltonians in QuTiP is very straight forward. The most important thing to note is that, since QuTiP operates in natural units, $\\hbar$ should not be included in any Hamiltonian expressions. This should be accounted for to ensure accuracy of the system and the factors interacting with it."
      ],
      "metadata": {
        "id": "f_XJDOROtmrN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Circuits"
      ],
      "metadata": {
        "id": "z-Kpol9xvfLX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are many common gates built into QuTiP, but they must be imported individually to be implemented.\n",
        "\n",
        "**Note** Circuit visualization is easy to do, but requires the installation of LaTeX and ImageMagick"
      ],
      "metadata": {
        "id": "rlGFt1YkwSVL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Importing"
      ],
      "metadata": {
        "id": "gxeibh7Ix3e_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "If not done already, install the QuTiP Quantum Information Processing Module"
      ],
      "metadata": {
        "id": "JmEr7DKVycAy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install qutip_qip"
      ],
      "metadata": {
        "id": "0g_D2I2bxepB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from numpy import pi\n",
        "from qutip import Qobj, about\n",
        "#Import circuit representation module\n",
        "from qutip_qip.circuit import QubitCircuit\n",
        "#Import desired gates (See next section for breakdown)\n",
        "from qutip_qip.operations import (Gate, berkeley, cnot, cphase, csign, fredkin,\n",
        "                                  gate_sequence_product, globalphase, iswap,\n",
        "                                  molmer_sorensen, phasegate, qrot, rx, ry, rz,\n",
        "                                  snot, sqrtiswap, sqrtnot, sqrtswap, swap,\n",
        "                                  swapalpha, toffoli)"
      ],
      "metadata": {
        "id": "UHE282tOypUr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Built in Gates\n",
        "Since gates are predefined objects, their output follow the same syntax as QObj:\n",
        "\n",
        "**Quantum Object: dimensions, shape, type, hermitian boolean, matrix representation**\n",
        "\n",
        "**Note** Changing the **dimension** *N* of a gate creates a $2^N$ dimensional matrix.\n",
        "\n"
      ],
      "metadata": {
        "id": "QY-v1EQ5xKpS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Controlled phase gate\n",
        "cphase(pi/2, 2) #Input: desired phase (radians), desired dimension\n",
        "\n",
        "#Rotation about the X-axis\n",
        "rx(pi/2, 2) #Input: desired rotation angle (radians), desired dimension\n",
        "\n",
        "#Rotation about the Y-axis\n",
        "ry(pi/2, 2) #Input: desired rotation angle (radians), desired dimension\n",
        "\n",
        "#Rotation about the Z-axis\n",
        "rz(pi/2, 2) #Input: desired rotation angle (radians), desired dimension\n",
        "\n",
        "#Controlled-Not (CNOT) gate\n",
        "cnot(2) #Input: desired dimension (null = 4x4)\n",
        "\n",
        "#Controlled-Z (CSIGN) gate\n",
        "csign(2) #Input: desired dimension (null = 4x4)\n",
        "\n",
        "#TOffoli Gate\n",
        "toffoli(3) #Input: desired dimension (must be >= 3, null = 8x8)\n",
        "\n",
        "#SWAP and iSWAP Gates\n",
        "swap(2) #Input: desired dimension (null = 4x4)\n",
        "iswap(2) #Input: desired dimension (null = 4x4)\n",
        "\n",
        "#Sqrt Swap and iSqrt Swap\n",
        "sqrtswap(2) #Input: desired dimension (null = 4x4)\n",
        "sqrtiswap(2) #Input: desired dimension (null = 4x4)\n",
        "\n",
        "#Hadamard Gate\n",
        "snot(1) #Input: desired dimension (null = 2x2)\n",
        "\n",
        "#Phase Gate\n",
        "phasegate(pi/2, 2) #Input:desired phase (radians), desired dimension (null = 4x4)\n",
        "\n",
        "#Global Phase Gate\n",
        "globalphase(pi/2, 2) #Input:desired phase (radians), desired dimension (null = 4x4)\n"
      ],
      "metadata": {
        "id": "H5Y4YXK2viAt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##User Defined Gates\n",
        "Custom gates can be generated using a single-parameter python function definition that generates a Qobj."
      ],
      "metadata": {
        "id": "A5WDivpyzjSq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def custom_gate(arg):\n",
        "  #Create an empty matrix of desired dimensions and type\n",
        "  mat = np.zeros((4,4), dtype = complex)\n",
        "  #Customize matrix entries as needed\n",
        "  mat[0,0] = mat[1,1] = 1 #Input values to certain positions\n",
        "  mat[2:4, 2:4] = rx(arg) #Input built-in gate to certain places\n",
        "  return Qobj(mat, dims=[[2,2], [2,2]])\n",
        "\n",
        "cust = custom_gate(2)\n",
        "print(cust)"
      ],
      "metadata": {
        "id": "SkbpHlwg0DKL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Circuit Building\n",
        "Circuit building depends on the **QubitCircuit** module imported in the *importing* section of this document.\n",
        "\n",
        "Visual display of defined circuits can be done using **LaTeX** and **ImageMagick.** Most windows machines will also require the installation of **Perl** and **Ghostscript** to properly generate images. If only the matrix representation of the sequence is desired, the included **IPython** import suffices."
      ],
      "metadata": {
        "id": "cvJHT8N0s7hW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!apt install imagemagick\n",
        "!pip install perl\n",
        "!pip install Ghostscript"
      ],
      "metadata": {
        "id": "uHcBqNrSwu97"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.display import display\n",
        "\n",
        "#Initialize a 3 wire circuit\n",
        "qc3 = QubitCircuit(3) #Input: Number of wires (indexes at 0)\n",
        "#Add 5 gates\n",
        "qc3.add_gate(\"CNOT\", 1, 0) #Input: Gate type, wire 1, wire 2)\n",
        "qc3.add_gate(\"RX\", 0, None, pi/2, r\"\\pi/2\") #Input: Gate type, wire, NONE, desired phase, label\n",
        "qc3.add_gate(\"RY\", 1, None, pi/2, r\"\\pi/2\")\n",
        "qc3.add_gate(\"RZ\", 2, None, pi/2, r\"\\pi/2\")\n",
        "qc3.add_gate(\"ISWAP\", [1, 2]) #Input: Gate type, wires\n",
        "#Output final operation\n",
        "prod = gate_sequence_product(qc3.propagators()) #Input: Circuit (.propagators() feeds gates in)\n",
        "display(prod[3]) #Display the final result in matrix form"
      ],
      "metadata": {
        "id": "VxtpkqpruRxm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Master Equations"
      ],
      "metadata": {
        "id": "tbCSSsHNvtq7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##mesolve\n",
        "QuTiP has a built in master equation solver *qutip.mesolve* that enables easy interaction with dynamic systems. This function accepts input in the following sequence:\n",
        "\n",
        "**qutip.mesolve(Hamiltonian, initial state vector/density matrix, time interval, collapse operators(list), evolution operators(list))**\n",
        "\n",
        "The output of the function will be expectation values of the evolution operators OR the state vector at certain points in the time interval.\n",
        "\n",
        "More information about the mesolve function can be found [here](https://qutip.org/docs/4.0.2/modules/qutip/mesolve.html)"
      ],
      "metadata": {
        "id": "AmcuPHjjeWNS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from qutip import Bloch, about, basis, mesolve, sigmax, sigmay, sigmaz\n",
        "\n",
        "delta = 2*np.pi #amplitude (Hz?)\n",
        "g = 0.25 #dissipation coefficient\n",
        "H = delta/2 * sigmax() #Define the Hamiltonian\n",
        "col = [np.sqrt(g)*sigmaz()] #Define the collapse operators for energy dissipation (Must be a list even if there is only one)\n",
        "\n",
        "#define initial state (assume ground at t=0)\n",
        "psi0 = basis(2,0)\n",
        "tlist = np.linspace(0,5,100)\n",
        "\n",
        "#Initialize master equation solver to obtain expectation values for sigmaz\n",
        "res = mesolve(H, psi0, tlist, col, [sigmaz()])\n",
        "\n",
        "#**Obtain expectation values and plot**\n",
        "res.expect[0]\n",
        "plt.scatter(tlist, res.expect[0], c=\"r\", marker=\"x\", label=\"mesolve\")"
      ],
      "metadata": {
        "id": "316gDAtzvxtT"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}