Chapter 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ddac4653",
   "metadata": {},
   "source": [
    "# Introduction to Quantum Mechanics and Linear Algebra\n",
    "    \n",
    "In quantum mechanics, states and observables are represented using the mathematics of Hilbert spaces. \n",
    "However, their infinite dimensions is incompatible with numerical simulations, that always requires finite elements. \n",
    "Hence, we truncate Hilbert spaces to a finite size, allowing us to run the quantum calculation on a computer.\n",
    "We can thus say that the whole problem of numerical quantum mechanics is then reduced to a problem of multilinear algebra, which is a generalization of linear algebra in tensor products of vector spaces.\n",
    "\n",
    "The art of numerical quantum optics stands almost entirely in finding algorthms that allows us to arrive to the aimed result with the smallest possible truncated Hilbert space.\n",
    "However, beside having efficient algorithms, the intricated tensor structures of many-body Hilbert spaces requires also a powerful organization of the code and an easy way to access relevant information."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "236c579b",
   "metadata": {},
   "source": [
    "## Quantum States and Operators for Dimension $N$=7\n",
    "\n",
    "In a Hilbert space of dimension $N$=7, quantum states can still be represented as vectors, and operators as matrices. Here we demonstrate the destroy operator, $a$, which lowers the state by one quantum number.\n",
    "\n",
    "The matrix representation of the destroy operator in a 7-dimensional Hilbert space is:\n",
    "\n",
    "$$\n",
    "\\hat{a} = \\begin{pmatrix}\n",
    "0 & \\sqrt{1} & 0 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & \\sqrt{2} & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & \\sqrt{3} & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & \\sqrt{4} & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 0 & \\sqrt{5} & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & \\sqrt{6} \\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 0\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "This operator acts on Fock states to lower their quantum number by one, with a factor of $\\sqrt{n}$, where $n$ is the quantum number of the initial state.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7f8166a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "N = 7\n",
    "\n",
    "def destroy(N):\n",
    "    a = np.zeros((N, N))\n",
    "    for i in range(N-1):\n",
    "        a[i, i+1] = np.sqrt(i+1)\n",
    "    return a\n",
    "\n",
    "# Define the fock states\n",
    "def fock(N, i):\n",
    "    res = np.zeros(N)\n",
    "    res[i] = 1\n",
    "    return res\n",
    "\n",
    "zero_state = fock(N, 0)\n",
    "one_state = fock(N, 1)\n",
    "two_state = fock(N, 2)\n",
    "three_state = fock(N, 3)\n",
    "\n",
    "destroy_operator = destroy(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75bd8512",
   "metadata": {},
   "source": [
    "## Action of the Destroy Operator on a Fock State\n",
    "\n",
    "The action of the destroy operator $a$ on a Fock state $|n\\rangle$ lowers the state by one quantum number, multiplied by a factor $\\sqrt{n}$. For example, applying $a$ to the state $|3\\rangle$ yields:\n",
    "\n",
    "$$ \\hat{a}|3\\rangle = \\sqrt{3}|2\\rangle $$\n",
    "\n",
    "This demonstrates the lowering action of the destroy operator with a specific factor, dependent on the quantum number of the state being acted upon.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fb8ae2f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resulting State:\n",
      " [0.         0.         1.73205081 0.         0.         0.\n",
      " 0.        ]\n",
      "Expectation Value: 0.0\n"
     ]
    }
   ],
   "source": [
    "# Apply the destroy operator on the one state\n",
    "result_state = np.dot(destroy_operator, three_state)\n",
    "\n",
    "# Calculate expectation value of the destroy operator on the one state\n",
    "expectation_value = np.dot(three_state.T.conj(), np.dot(destroy_operator, three_state))\n",
    "\n",
    "print(\"Resulting State:\\n\", result_state)\n",
    "print(\"Expectation Value:\", expectation_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bab7f981",
   "metadata": {},
   "source": [
    "## Tensor Products in Matrix Form\n",
    "\n",
    "The tensor product of two matrices expands the dimensionality of the space, allowing us to describe composite systems. For two 3x3 matrices, A and B, their tensor product results in a 9x9 matrix. The calculation is as follows, given:\n",
    "\n",
    "$$\n",
    "A = \\begin{pmatrix}\n",
    "a_{11} & a_{12} & a_{13} \\\\\n",
    "a_{21} & a_{22} & a_{23} \\\\\n",
    "a_{31} & a_{32} & a_{33}\n",
    "\\end{pmatrix},\\,\n",
    "B = \\begin{pmatrix}\n",
    "b_{11} & b_{12} & b_{13} \\\\\n",
    "b_{21} & b_{22} & b_{23} \\\\\n",
    "b_{31} & b_{32} & b_{33}\n",
    "\\end{pmatrix},\\,\n",
    "A \\otimes B = \\begin{pmatrix}\n",
    "a_{11}B & a_{12}B & a_{13}B \\\\\n",
    "a_{21}B & a_{22}B & a_{23}B \\\\\n",
    "a_{31}B & a_{32}B & a_{33}B\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "The tensor product, $A \\otimes B$, results in a 9x9 matrix. This process combines each element of A with the entire matrix B, expanding the representation of the composite system.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9e0278d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor Product of A and B:\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 9,  8,  7, 18, 16, 14, 27, 24, 21],\n",
       "       [ 6,  5,  4, 12, 10,  8, 18, 15, 12],\n",
       "       [ 3,  2,  1,  6,  4,  2,  9,  6,  3],\n",
       "       [36, 32, 28, 45, 40, 35, 54, 48, 42],\n",
       "       [24, 20, 16, 30, 25, 20, 36, 30, 24],\n",
       "       [12,  8,  4, 15, 10,  5, 18, 12,  6],\n",
       "       [63, 56, 49, 72, 64, 56, 81, 72, 63],\n",
       "       [42, 35, 28, 48, 40, 32, 54, 45, 36],\n",
       "       [21, 14,  7, 24, 16,  8, 27, 18,  9]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define two 3x3 matrices\n",
    "A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "B = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])\n",
    "\n",
    "# Perform tensor product\n",
    "tensor_product = np.kron(A, B)\n",
    "\n",
    "print(\"Tensor Product of A and B:\\n\")\n",
    "tensor_product"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83751bf0",
   "metadata": {},
   "source": [
    "## Partial Trace\n",
    "\n",
    "The **partial trace** over a subsystem, say $B$, of a composite system $AB$, mathematically expresses as \"tracing out\" $B$, leaving the reduced state of $A$. For a bipartite state $\\rho_{AB}$, the partial trace over $B$ is:\n",
    "\n",
    "$$\n",
    "\\text{Tr}_B(\\hat{\\rho}_{AB}) = \\sum_{i \\in \\mathcal{H}_B} \\langle i| \\hat{\\rho}_{AB} |i\\rangle\n",
    "$$\n",
    "\n",
    "where $\\{|i\\rangle\\}$ forms a complete basis for subsystem $B$.\n",
    "\n",
    "Let's try it with an entangled Bell's state between two qubits:\n",
    "\n",
    "$$\n",
    "\\vert \\phi^+ \\rangle = \\frac{1}{\\sqrt{2}} \\left( \\vert 0, 0 \\rangle + \\vert 1, 1 \\rangle \\right)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f640a6f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5, 0. ],\n",
       "       [0. , 0.5]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def ptrace(psi, subspace_to_keep, dim_subspace):\n",
    "    dim1, dim2 = dim_subspace\n",
    "\n",
    "    rho = np.outer(psi, psi.conj())\n",
    "\n",
    "    # Reshape rho to separate the subsystems' degrees of freedom\n",
    "    rho_reshaped = rho.reshape(dim1, dim2, dim1, dim2)\n",
    "\n",
    "    if subspace_to_keep == 1:\n",
    "        # Perform the trace over the second subsystem\n",
    "        traced_out = np.trace(rho_reshaped, axis1=1, axis2=3)\n",
    "    elif subspace_to_keep == 2:\n",
    "        # Perform the trace over the first subsystem\n",
    "        traced_out = np.trace(rho_reshaped, axis1=0, axis2=2)\n",
    "    else:\n",
    "        raise ValueError(\"subspace_to_keep must be either 1 or 2.\")\n",
    "\n",
    "    return traced_out\n",
    "\n",
    "# Bell state between two qubits\n",
    "phi_plus = ( np.kron(fock(2, 1), fock(2, 1)) + np.kron(fock(2, 0), fock(2, 0)) ) / np.sqrt(2)\n",
    "\n",
    "# Reduced density matrix of the first qubit\n",
    "rho_1 = ptrace(phi_plus, 1, (2, 2))\n",
    "rho_1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8692fc24",
   "metadata": {},
   "source": [
    "## Why QuTiP?\n",
    "\n",
    "While NumPy and SciPy are powerful tools for numerical computations, they lack specific functionalities for efficiently handling complex quantum systems. QuTiP is designed to fill this gap, offering features such as:\n",
    "- Easy manipulation and visualization of quantum objects.\n",
    "- Support for operations on states and operators in different Hilbert spaces.\n",
    "- Tools for dealing with composite systems, partial traces, and superoperators.\n",
    "It is like to have the book \"Quantum noise\" (by Gardiner and Zoller) already implemented in your laptop!\n",
    "\n",
    "\n",
    "In the next chapter, we'll explore how QuTiP simplifies these tasks, making it an invaluable tool for quantum optics simulations.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c559c3b1",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}