examples/photonics/2_Gaussian_boson_sampling_and_the_Hafnian.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This cell is added by sphinx-gallery\n",
    "# It can be customized to whatever you like\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Gaussian boson sampling and the Hafnian\n",
    "=======================================\n",
    "\n",
    "> \"The extended Church-Turing thesis states that *'Any algorithmic process can be simulated efficiently using a probabilistic Turing machine'.* This ad-hoc modification of the Church-Turing thesis should leave you feeling rather queasy.\" --- Nielsen and Chuang [1].\n",
    "\n",
    "In this tutorial, we will walk through the application of Gaussian boson sampling.$\\newcommand{\\ket}[1]{\\left|{#1}\\right\\rangle}$$\\newcommand{\\bra}[1]{\\left\\langle{#1}\\right|}$\n",
    "\n",
    "Background theory\n",
    "-----------------\n",
    "\n",
    "Introduced by Hamilton et al. [2], and inspired by an earlier approach of Aaronson and Arkhipov [3], Gaussian boson sampling (GBS) presented a slight deviation from the general approach in quantum computation. Rather than presenting a theoretical model of universal quantum computation (i.e., a framework that enables quantum simulation of any arbitrary Hamiltonian [1]), Gaussian boson sampling-based devices are instead an example of an **intermediate quantum computer**, designed to experimentally implement a computation that is thought to be intractable classically.\n",
    "\n",
    "Gaussian boson sampling proposes the following [quantum linear optics](https://en.wikipedia.org/wiki/Linear_optical_quantum_computing) scheme:\n",
    "\n",
    "* $N$ single mode squeezed states $\\newcommand{\\ket}[1]{\\left|{#1}\\right\\rangle}$$\\newcommand{\\bra}[1]{\\left\\langle{#1}\\right|}$$\\ket{z}$, with squeezing parameter\n",
    "  $z=re^{i\\phi}$, enter an $N$ mode linear interferometer described by unitary $U$\n",
    "  simultaneously.\n",
    "\n",
    "* Each output mode of the [interferometer](https://en.wikipedia.org/wiki/Interferometry) (denoted by state $\\ket{\\psi'}$) is then measured in the Fock basis, $\\bigotimes_i n_i\\ket{n_i}\\bra{n_i}$.\n",
    "\n",
    "Without loss of generality, we can absorb the squeezing phase parameter $\\phi$ into the\n",
    "interferometer, and set $\\phi=0$ for convenience.\n",
    "\n",
    "Using phase space methods, Hamilton et al. [2] showed that the probability of\n",
    "measuring a Fock state containing only 0 or 1 photons per mode is given by\n",
    "\n",
    "$$\n",
    "\\left|\\left\\langle{n_1,n_2,\\dots,n_N}\\middle|{\\psi'}\\right\\rangle\\right|^2 =\n",
    "    \\frac{\\left|\\text{Haf}[(U(\\bigoplus_i\\tanh(r_i))U^T)]_{st}\\right|^2}{\\prod_{i=1}^N \\cosh(r_i)}\n",
    "$$\n",
    "\n",
    "i.e., the sampled single photon probability distribution is proportional to the **hafnian** of a\n",
    "submatrix of $U(\\bigoplus_i\\tanh(r_i))U^T$, dependent upon the output covariance matrix.\n",
    "\n",
    "### **Note:** \n",
    "\n",
    "The hafnian of a matrix is defined by\n",
    "\n",
    "$$\n",
    "\\text{Haf}(A) = \\frac{1}{n!2^n}\\sum_{\\sigma \\in S_{2N}}\\prod_{i=1}^N A_{\\sigma(2i-1)\\sigma(2i)}\n",
    "$$\n",
    "\n",
    "where $S_{2N}$ is the set of all permutations of $2N$ elements. In graph theory, the\n",
    "hafnian calculates the number of perfect [matchings](https://en.wikipedia.org/wiki/Matching_(graph_theory)) in an **arbitrary graph** with adjacency matrix $A$.\n",
    "\n",
    "Computing the hafnian, even approximately, belongs to the computational complexity class of #P-Hard problems [4], which are strongly believed to be classically hard to calculate. [2] gives strong theoretical arguments that the hafnians arising from the GBS probability distributions are also #P-hard to approximate. This implies that simulating Gaussian boson sampling cannot be done efficiently on a classical computer, providing a potential challenge to the extended Church-Turing thesis, and demonstrating the power of (non-universal) quantum computation."
   ]
  },
  {
   "attachments": {
    "gaussian_boson_sampling.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Circuit construction and simulation\n",
    "-----------------------------------\n",
    "\n",
    "In quantum linear optics, the multimode linear interferometer is commonly decomposed into two-mode\n",
    "beamsplitters ([``BSgate``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.ops.BSgate.html)) and single-mode phase shifters ([``Rgate``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.ops.Rgate.html))\n",
    "[5], allowing for a straightforward translation into a CV quantum circuit.\n",
    "\n",
    "For example, in the case of a 4 mode interferometer, with arbitrary $4\\times 4$ unitary\n",
    "$U$, the CV quantum circuit for Gaussian boson sampling is given by\n",
    "\n",
    "![gaussian_boson_sampling.png](attachment:gaussian_boson_sampling.png)\n",
    "\n",
    "In the above, the single mode squeeze states all apply identical squeezing $z=r$, the\n",
    "parameters of the beamsplitters and the rotation gates determine the unitary $U$, and finally\n",
    "the detectors perform Fock state measurements on the output modes. Note that, in order to allow for arbitrary\n",
    "linear unitaries for $m$ imput modes, we must have a minimum of $m+1$ columns in the\n",
    "beamsplitter array [6].\n",
    "\n",
    "Simulating this circuit using Strawberry Fields is easy; we can simply read off the gates from left\n",
    "to right, and convert it into the Blackbird circuit language.\n",
    "\n",
    "To begin, we create the Gaussian boson sampling quantum program using Strawberry Fields:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# set the random seed\n",
    "np.random.seed(42)\n",
    "\n",
    "# import Strawberry Fields\n",
    "import strawberryfields as sf\n",
    "from strawberryfields.ops import *\n",
    "\n",
    "# initialize a 4 mode program\n",
    "gbs = sf.Program(4)\n",
    "\n",
    "with gbs.context as q:\n",
    "    # prepare the input squeezed states\n",
    "    S = Sgate(1)\n",
    "    S | q[0]\n",
    "    S | q[1]\n",
    "    S | q[2]\n",
    "    S | q[3]\n",
    "\n",
    "    # rotation gates\n",
    "    Rgate(0.5719)  | q[0]\n",
    "    Rgate(-1.9782) | q[1]\n",
    "    Rgate(2.0603)  | q[2]\n",
    "    Rgate(0.0644)  | q[3]\n",
    "\n",
    "    # beamsplitter array\n",
    "    BSgate(0.7804, 0.8578)  | (q[0], q[1])\n",
    "    BSgate(0.06406, 0.5165) | (q[2], q[3])\n",
    "    BSgate(0.473, 0.1176)   | (q[1], q[2])\n",
    "    BSgate(0.563, 0.1517)   | (q[0], q[1])\n",
    "    BSgate(0.1323, 0.9946)  | (q[2], q[3])\n",
    "    BSgate(0.311, 0.3231)   | (q[1], q[2])\n",
    "    BSgate(0.4348, 0.0798)  | (q[0], q[1])\n",
    "    BSgate(0.4368, 0.6157)  | (q[2], q[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A couple of things to note in this particular example:\n",
    "\n",
    "1. To prepare the input single mode squeezed vacuum state $\\ket{z}$ where $z = 1$, we\n",
    "   apply a squeezing gate [``Sgate``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.ops.Sgate.html) to each of the modes (initially in the vacuum state).\n",
    "\n",
    "2. Next we apply the rotation gates, [``Rgate``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.ops.Rgate.html), to each mode. The resulting rotation in the phase space occurs in the anticlockwise direction, with angle $\\phi$.\n",
    "\n",
    "3. Finally, we apply the array of beamsplitters, using the [``BSgate``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.ops.BSgate.html) operator, with arguments ``(theta,phi)``.\n",
    "\n",
    "   * The transmission amplitude is then given by $t=\\cos\\theta$\n",
    "   * The reflection amplitude is given by $r=e^{i\\phi}\\sin{\\theta}$\n",
    "\n",
    "\n",
    "4. The rotation gate and beamsplitter parameters have been chosen at random, leading to an\n",
    "   arbitrary unitary $U$ acting on the input modes annihilation and creation operators.\n",
    "   After leaving the beamsplitter array, we will denote the output state by $\\ket{\\psi'}$.\n",
    "\n",
    "5. We are **not** performing Fock measurements at the output; this is to ensure the state is\n",
    "   preserved, so we can extract the joint Fock state probabilities after the beamsplitter array.\n",
    "\n",
    "   If we wish to simulate Fock measurements, we can additionally include\n",
    "\n",
    "   ```\n",
    "       MeasureFock() | q\n",
    "   ```\n",
    "\n",
    "   after the beamsplitter array. After constructing the circuit and running the engine, the values of\n",
    "   the Fock state measurements will be available within the ``samples`` attribute of the\n",
    "   [``Result``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.Result.html) object returned by the engine.\n",
    "\n",
    "Now that the program is created, we can initialize an engine, and execute the program\n",
    "on one of the built-in Strawberry Fields state simulators.  We will use the Numpy-based ``'gaussian'`` backend, along with a 4-mode register. The Gaussian backend is perfectly suited for simulation of Gaussian boson sampling, as all initial states are Gaussian, and all the required operators transform Gaussian states to other Gaussian states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng = sf.Engine(backend=\"gaussian\")\n",
    "results = eng.run(gbs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The state method [``fock_prob()``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.backends.BaseState.html#strawberryfields.backends.BaseState.fock_prob) accepts a list or a tuple containing the Fock state to be measured and returns the probability of that measurement. For example, ``[1,2,0,1]`` represents the measurement resulting in the detection of 1 photon at mode ``q[0]`` and mode ``q[3]``, and 2 photons at mode ``q[1]``, and would return the value\n",
    "\n",
    "$$\n",
    "\\text{prob}(1,2,0,1) = \\left|\\langle 1,2,0,1 \\vert \\psi'\\rangle\\right|^2\n",
    "$$\n",
    "\n",
    "The Fock state method [``all_fok_probs()``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.backends.BaseFockState.html#strawberryfields.backends.BaseFockState.all_fock_probs), used\n",
    "previously to return *all* Fock state probabilities as an array, is **not supported** by the\n",
    "Gaussian backend. This is because computing the Fock probabilities of states in the Gaussian\n",
    "representation has exponential scaling - while this is fine for computing particular Fock basis\n",
    "probabilities, it becomes computationally demanding to return *all* Fock state probabilities using\n",
    "the Gaussian backend.\n",
    "\n",
    "Let's use [``fock_prob()``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.backends.BaseState.html#strawberryfields.backends.BaseState.fock_prob) in a for-loop to extract the probabilities of measuring various Fock states:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|0000>: 0.17637844761413482\n",
      "|1100>: 0.06855956371222356\n",
      "|0101>: 0.0020560972589773983\n",
      "|1111>: 0.0083429463998675\n",
      "|2000>: 0.010312945253454915\n"
     ]
    }
   ],
   "source": [
    "# Fock states to measure at output\n",
    "measure_states = [[0,0,0,0], [1,1,0,0], [0,1,0,1], [1,1,1,1], [2,0,0,0]]\n",
    "\n",
    "# extract the probabilities of calculating several\n",
    "# different Fock states at the output, and print them to the terminal\n",
    "for i in measure_states:\n",
    "    prob = results.state.fock_prob(i)\n",
    "    print(\"|{}>: {}\".format(\"\".join(str(j) for j in i), prob))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculating the unitary\n",
    "-----------------------\n",
    "\n",
    "Let's explore these results further. To do so, however, we'll need to compute\n",
    "the unitary that is being applied by our beamsplitters and rotation gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy.linalg import multi_dot\n",
    "from scipy.linalg import block_diag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To start with, let's generate the matrix representing the unitary transformation of the input mode\n",
    "annihilation and creation operators. The rotation gates simply act as follows,\n",
    "\n",
    "$$\n",
    "R(\\phi)\\hat{a} = \\hat{a}e^{i\\phi},\n",
    "$$\n",
    "\n",
    "and thus the column of rotation gates has the following block diagonal form:\n",
    "\n",
    "$$\n",
    "U_\\phi = \\left[\\begin{matrix}\n",
    "            e^{i\\phi_1} & 0 & \\cdots\\\\\n",
    "            0 & e^{i\\phi_2}  & \\cdots \\\\\n",
    "            \\vdots & \\vdots & \\ddots \\\\\n",
    "        \\end{matrix}\\right]\n",
    "$$\n",
    "\n",
    "Generating this in NumPy:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "Uphase = np.diag([np.exp(0.5719*1j),np.exp(-1.9782*1j),np.exp(2.0603*1j),np.exp(0.0644*1j)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A single beamsplitter, acting on two input modes $(\\hat{a}_1,\\hat{a}_2)$, instead acts as\n",
    "follows:\n",
    "\n",
    "$$\n",
    "BS(\\theta, \\phi) (\\hat{a}_1,\\hat{a}_2) = \\left[\\begin{matrix}\n",
    "            t & -r^*\\\\\n",
    "            r & t\\\\\n",
    "        \\end{matrix}\\right] \\left[\\begin{matrix}\n",
    "            \\hat{a}_1\\\\\n",
    "            \\hat{a}_2\n",
    "        \\end{matrix}\\right]\n",
    "$$\n",
    "\n",
    "where $t=\\cos(\\theta)$ and $r=e^{i\\phi}\\sin(\\theta)$. Again, like the rotation gate,\n",
    "they combine as block diagonal matrices.\n",
    "\n",
    "First of all, we need to convert the ``BSgate`` arguments, ``theta`` and ``phi`` (reproduced below\n",
    "for convenience),\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "BSargs = [\n",
    "    (0.7804, 0.8578),\n",
    "    (0.06406, 0.5165),\n",
    "    (0.473, 0.1176),\n",
    "    (0.563, 0.1517),\n",
    "    (0.1323, 0.9946),\n",
    "    (0.311, 0.3231),\n",
    "    (0.4348, 0.0798),\n",
    "    (0.4368, 0.6157)\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "into transmission and reflection amplitudes $t$ and $r$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_r_amplitudes = [(np.cos(q), np.exp(p*1j)*np.sin(q)) for q,p in BSargs]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we generate the individual beamsplitter unitary transformations,\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "BSunitaries = [np.array([[t, -np.conj(r)], [r, t]]) for t,r in t_r_amplitudes]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "before using the SciPy function ``scipy.linalg.block_diag`` to calculate the resulting\n",
    "$U_{BS_i}$, i.e., the unitary corresponding to each column of 'independent' beamsplitters in\n",
    "the above circuit diagram:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "UBS1 = block_diag(*BSunitaries[0:2])\n",
    "UBS2 = block_diag([[1]], BSunitaries[2], [[1]])\n",
    "UBS3 = block_diag(*BSunitaries[3:5])\n",
    "UBS4 = block_diag([[1]], BSunitaries[5], [[1]])\n",
    "UBS5 = block_diag(*BSunitaries[6:8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we combine the unitaries to form a single $4\\times 4$ unitary via matrix\n",
    "multiplication; $U = U_{BS_5}U_{BS_4}U_{BS_3}U_{BS_2}U_{BS_1}U_{\\phi}$. Since\n",
    "``numpy.dot`` only supports matrix multiplication of two arrays, we instead use\n",
    "``numpy.linalg.multi_dot``:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.2195-0.2565j  0.6111+0.5242j -0.1027+0.4745j -0.0273+0.0373j]\n",
      " [ 0.4513+0.6026j  0.457 +0.0123j  0.1316-0.4504j  0.0353-0.0532j]\n",
      " [ 0.0387+0.4927j -0.0192-0.3218j -0.2408+0.5244j -0.4584+0.3296j]\n",
      " [-0.1566+0.2246j  0.11  -0.1638j -0.4212+0.1836j  0.8188+0.068j ]]\n"
     ]
    }
   ],
   "source": [
    "U = multi_dot([UBS5, UBS4, UBS3, UBS2, UBS1, Uphase])\n",
    "print(np.round(U, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We find that\n",
    "\n",
    "\\begin{align}U = \\left[\\begin{matrix}\n",
    "        0.2195-0.2565i & 0.6111+0.5242i & -0.1027+0.4745i & -0.0273+0.0373i\\\\\n",
    "        0.4513+0.6026i & 0.4570+0.0123i & 0.1316-0.4504i & 0.0353-0.0532i\\\\\n",
    "        0.0387+0.4927i & -0.0192-0.3218i & -0.2408+0.5244i & -0.4584+0.3296i\\\\\n",
    "        -0.1566+0.2246i & 0.1100-0.1638i & -0.4212+0.1836i & 0.8188+0.068i\n",
    "    \\end{matrix}\\right]\\end{align}\n",
    "\n",
    "The Gaussian compiler\n",
    "----------------------\n",
    "\n",
    "While we have done it by hand, Strawberry Fields also supports a Gaussian unitary\n",
    "compiler, that allows us to compile our program into a single Gaussian unitary.\n",
    "\n",
    "Note that we create a new program that excludes the initial squeezing operations, because we want to extract the unitary corresponding to the interferometers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "prog_unitary = sf.Program(4)\n",
    "prog_unitary.circuit = gbs.circuit[4:]\n",
    "prog_compiled = prog_unitary.compile(compiler=\"gaussian_unitary\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Printing ``prog_compiled``, we see it now consists of a single [``GaussianTransform``](https://strawberryfields.readthedocs.io/en/stable/code/api/strawberryfields.ops.GaussianTransform.html) operation, consisting of a single symplectic matrix:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GaussianTransform([[ 0.2195  0.6111 -0.1027 -0.0273  0.2565 -0.5242 -0.4745 -0.0373]\n",
      " [ 0.4513  0.457   0.1316  0.0353 -0.6026 -0.0123  0.4504  0.0532]\n",
      " [ 0.0387 -0.0192 -0.2408 -0.4584 -0.4927  0.3218 -0.5244 -0.3296]\n",
      " [-0.1566  0.11   -0.4212  0.8188 -0.2246  0.1638 -0.1836 -0.068 ]\n",
      " [-0.2565  0.5242  0.4745  0.0373  0.2195  0.6111 -0.1027 -0.0273]\n",
      " [ 0.6026  0.0123 -0.4504 -0.0532  0.4513  0.457   0.1316  0.0353]\n",
      " [ 0.4927 -0.3218  0.5244  0.3296  0.0387 -0.0192 -0.2408 -0.4584]\n",
      " [ 0.2246 -0.1638  0.1836  0.068  -0.1566  0.11   -0.4212  0.8188]]) | (q[0], q[1], q[2], q[3])\n"
     ]
    }
   ],
   "source": [
    "prog_compiled.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily extract this symplectic matrix, and rewrite it as a unitary\n",
    "matrix:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.2195-0.2565j  0.6111+0.5242j -0.1027+0.4745j -0.0273+0.0373j]\n",
      " [ 0.4513+0.6026j  0.457 +0.0123j  0.1316-0.4504j  0.0353-0.0532j]\n",
      " [ 0.0387+0.4927j -0.0192-0.3218j -0.2408+0.5244j -0.4584+0.3296j]\n",
      " [-0.1566+0.2246j  0.11  -0.1638j -0.4212+0.1836j  0.8188+0.068j ]]\n"
     ]
    }
   ],
   "source": [
    "S = prog_compiled.circuit[0].op.p[0]\n",
    "U = S[:4, :4] + 1j*S[4:, :4]\n",
    "print(U)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which agrees with the result above.\n",
    "\n",
    "Equally squeezed inputs\n",
    "-----------------------\n",
    "\n",
    "As shown earlier, the formula for calculating the output\n",
    "Fock state probability in Gaussian boson sampling is given by\n",
    "\n",
    "$$\n",
    "\\left|\\left\\langle{n_1,n_2,\\dots,n_N}\\middle|{\\psi'}\\right\\rangle\\right|^2 =\n",
    "    \\frac{\\left|\\text{Haf}[(U\\bigoplus_i\\tanh(r_i)U^T)]_{st}\\right|^2}{n_1!n_2!\\cdots n_N!\n",
    "    \\cosh(r_i)}\n",
    "$$\n",
    "\n",
    "where $U$ is the rotation/beamsplitter unitary transformation on the input and output mode\n",
    "annihilation and creation operators.\n",
    "\n",
    "However, in this particular example, we are using **the same** squeezing parameter, $z=r$, for\n",
    "all input states - this allows us to simplify this equation. To start with, the hafnian expression\n",
    "simply becomes $\\text{Haf}[(UU^T\\tanh(r))]_{st}$, removing the need for the tensor sum.\n",
    "\n",
    "Thus, we have\n",
    "\n",
    "$$\n",
    "\\left|\\left\\langle{n_1,n_2,\\dots,n_N}\\middle|{\\psi'}\\right\\rangle\\right|^2 =\n",
    "    \\frac{\\left|\\text{Haf}[(UU^T\\tanh(r))]_{st}\\right|^2}{n_1!n_2!\\cdots n_N!\\cosh^N(r)}.\n",
    "$$\n",
    "\n",
    "Now that we have the interferometer unitary transformation $U$, as well as the 'experimental'\n",
    "results, let's compare the two, and see if the Gaussian boson sampling result in the case of equally\n",
    "squeezed input modes, agrees with the Strawberry Fields simulation probabilities.\n",
    "\n",
    "Calculating the hafnian\n",
    "------------------------\n",
    "\n",
    "Before we can calculate the right hand side of the Gaussian boson sampling equation, we need a\n",
    "method of calculating the hafnian. Since the hafnian is classically hard to compute, it is not\n",
    "provided in either NumPy *or* SciPy, so we will use [The Walrus](https://the-walrus.readthedocs.io/) library, installed alongside Strawberry Fields:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from thewalrus import hafnian as haf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, for the right hand side numerator, we first calculate the submatrix\n",
    "$[(UU^T\\tanh(r))]_{st}$:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = (np.dot(U, U.T) * np.tanh(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Gaussian boson sampling, we determine the submatrix by taking the rows and columns corresponding to the measured Fock state. For example, to calculate the submatrix in the case of the output measurement $\\left|{1,1,0,0}\\right\\rangle$,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.1022+0.3263j  0.5542+0.2856j]\n",
      " [ 0.5542+0.2856j -0.1051+0.3296j]]\n"
     ]
    }
   ],
   "source": [
    "print(B[:, [0, 1]][[0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing to Strawberry Fields\n",
    "------------------------------\n",
    "\n",
    "Now that we have a method for calculating the hafnian, let's compare the output to that provided by\n",
    "Strawberry Fields.\n",
    "\n",
    "**Measuring** $\\ket{0,0,0,0}$ **at the output**\n",
    "\n",
    "This corresponds to the hafnian of an *empty* matrix, which is simply 1:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1763784476141347\n",
      "0.17637844761413482\n"
     ]
    }
   ],
   "source": [
    "print(1 / np.cosh(1) ** 4)\n",
    "\n",
    "print(results.state.fock_prob([0, 0, 0, 0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Measuring** $\\ket{1,1,0,0}$ **at the output**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.06855956371222349\n",
      "0.06855956371222356\n"
     ]
    }
   ],
   "source": [
    "B = (np.dot(U, U.T) * np.tanh(1))[:, [0, 1]][[0, 1]]\n",
    "print(np.abs(haf(B)) ** 2 / np.cosh(1) ** 4)\n",
    "\n",
    "print(results.state.fock_prob([1, 1, 0, 0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Measuring** $\\ket{0,1,0,1}$ **at the output**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0020560972589774\n",
      "0.0020560972589773983\n"
     ]
    }
   ],
   "source": [
    "B = (np.dot(U, U.T) * np.tanh(1))[:, [1, 3]][[1, 3]]\n",
    "print(np.abs(haf(B)) ** 2 / np.cosh(1) ** 4)\n",
    "\n",
    "print(results.state.fock_prob([0, 1, 0, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Measuring** $\\ket{1,1,1,1}$ **at the output**\n",
    "\n",
    "This corresponds to the hafnian of the full matrix $B=UU^T\\tanh(r)$:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.008342946399867483\n",
      "0.0083429463998675\n"
     ]
    }
   ],
   "source": [
    "B = (np.dot(U, U.T) * np.tanh(1))\n",
    "print(np.abs(haf(B)) ** 2 / np.cosh(1) ** 4)\n",
    "\n",
    "print(results.state.fock_prob([1, 1, 1, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Measuring** $\\ket{2,0,0,0}$ **at the output**\n",
    "\n",
    "Since we have two photons in mode ``q[0]``, we take two copies of the\n",
    "first row and first column, making sure to divide by $2!$:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010312945253454883\n",
      "0.010312945253454915\n"
     ]
    }
   ],
   "source": [
    "B = (np.dot(U, U.T) * np.tanh(1))[:, [0, 0]][[0, 0]]\n",
    "print(np.abs(haf(B)) ** 2 / (2 * np.cosh(1) ** 4))\n",
    "\n",
    "print(results.state.fock_prob([2, 0, 0, 0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Strawberry Field simulation results agree (with almost negligible numerical error) to the\n",
    "expected result from the Gaussian boson sampling equation!\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "Repeat this tutorial with\n",
    "    \n",
    "1. A Fock backend such as ``'fock'`` instead of the Gaussian backend.\n",
    "\n",
    "2. Different beamsplitter and rotation parameters.\n",
    "\n",
    "3. Input states with *differing* squeezed values\n",
    "$r_i$. You will need to modify the code to take into account the fact that the output\n",
    "covariance matrix determinant must now be calculated.\n",
    "</div>\n",
    "\n",
    "\n",
    "References\n",
    "----------\n",
    "\n",
    "[1] M.A. Nielsen and I.L. Chuang. Quantum Computation and Quantum Information. Cambridge\n",
    "    University Press, 2010. ISBN 9780511992773. URL:\n",
    "    https://books.google.ca/books?id=JRz3jgEACAAJ.\n",
    "\n",
    "[2] Craig S. Hamilton, Regina Kruse, Linda Sansoni, Sonja Barkhofen, Christine Silberhorn,\n",
    "       and Igor Jex. Gaussian boson sampling. Physical Review Letters, 119:170501, Oct 2017.\n",
    "       arXiv:1612.01199, doi:10.1103/PhysRevLett.119.170501.\n",
    "       \n",
    "[3] Scott Aaronson and Alex Arkhipov. The computational complexity of linear optics. Theory of\n",
    "    Computing, 9(1):143–252, 2013. doi:10.4086/toc.2013.v009a004.\n",
    "    \n",
    "[4] L.G. Valiant. The complexity of computing the permanent. Theoretical Computer Science,\n",
    "    8(2):189–201, 1979. doi:10.1016/0304-3975(79)90044-6.\n",
    "\n",
    "[5] Michael Reck, Anton Zeilinger, Herbert J. Bernstein, and Philip Bertani. Experimental\n",
    "       realization of any discrete unitary operator. Physical Review Letters, 73(1):58–61, Jul 1994.\n",
    "       doi:10.1103/physrevlett.73.58.\n",
    "\n",
    "[6] William R Clements, Peter C Humphreys, Benjamin J Metcalf, W Steven Kolthammer, and\n",
    "       Ian A Walsmley. Optimal design for universal multiport interferometers. Optica,\n",
    "       3(12):1460–1465, 2016. doi:10.1364/OPTICA.3.001460.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "3590edbdefbafa5e6a8d4ecea734e61404ecae2aa6c016f6bc57b492c6374672"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}