CodeFiles/3._Random_number_generator_final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5595a0b1",
   "metadata": {},
   "source": [
    "$\\textbf{Random Number Generator based on Boson Sampling}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b8b9f97",
   "metadata": {},
   "source": [
    "Using all the information in the latest notebooks here we present a Random Quantum Number Generator.\n",
    "\n",
    "Let's consider the problem in which we need a random string S of length L composed by $0's$ and $1's$. \n",
    "This is the scenario for some cryptography protocols. \n",
    "\n",
    "We are presenting a random number, based on the simulation of fock Boson Sampling.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3db8c1a",
   "metadata": {},
   "source": [
    "$\\textbf{Simulating the Boson Sampling for RN generation }$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e48cd1ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import unitary_group\n",
    "import numpy as np\n",
    "import strawberryfields as sf\n",
    "from strawberryfields.ops import *\n",
    "from random import randrange\n",
    "\n",
    "# creating a Haar random unitary Matrix using scipy\n",
    "#--------------------------------------\n",
    "np.random.seed(42)\n",
    "\n",
    "# define the random unitary for the linear interferometer\n",
    "U = unitary_group.rvs(5)\n",
    "\n",
    "#We're gonna use the same interferometer for the QRNG based on BS and based on GBS.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3521e8f6",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "039a74ee",
   "metadata": {},
   "source": [
    "$\\textbf{Random number generator using Fock Boson Sampling simulator}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "0384cf8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# States preparation\n",
    "#--------------------------------------\n",
    "\n",
    "# initialize a 5 mode program\n",
    "boson_sampling = sf.Program(5)\n",
    "\n",
    "# prepare the state\n",
    "# 2 first modes 1 photon state\n",
    "# Other modes in vaccuumù\n",
    "with boson_sampling.context as q:\n",
    "    for i in range (5):\n",
    "        if i<3:\n",
    "            Fock(1) | q[i]\n",
    "        else :\n",
    "            Vac     | q[i]\n",
    "            \n",
    "#---------------------------------------------------------------\n",
    "\n",
    "    # apply the unitary transformation\n",
    "    Interferometer(U) | q\n",
    "    \n",
    "#----------------------------------------------------------\n",
    "    # Measure the ouput state\n",
    "    MeasureFock() | q\n",
    "\n",
    "# Measurement results\n",
    "# -----------------------------\n",
    "\n",
    "#Definition of the post-process.\n",
    "def post_process(S1,S2):\n",
    "    S=[] # create an empty list\n",
    "    # fill that list by comparing bit by bit\n",
    "    for i in range (len(S1)):\n",
    "        if S1[i]!=0 and S2[i]==0:\n",
    "            S = S + ['0']\n",
    "        if S1[i]==0 and S2[i]!=0:\n",
    "            S = S + ['1']\n",
    "    Sample = np.array(S) # turn list in to array\n",
    "    return S\n",
    "\n",
    "\n",
    "#Function that generates the Fock random number\n",
    "#-------------------------------------------\n",
    "def Rstr_fock(L):\n",
    "    rn=''\n",
    "    eng = sf.Engine(backend=\"fock\", backend_options={\"cutoff_dim\":3})\n",
    "    sampl=[]\n",
    "    i=0\n",
    "    j=0\n",
    "    while j<L:\n",
    "        i+=1\n",
    "        a=eng.run(boson_sampling)\n",
    "        b=np.ravel(a.samples)\n",
    "        sampl.append(b)\n",
    "        #print('i=',i)\n",
    "        if i>2:\n",
    "            s1=sampl[randrange(i-1)]\n",
    "            s2=sampl[randrange(i-1)]\n",
    "            RN =post_process(s1,s2)\n",
    "            if RN!=[]:   \n",
    "                rn+=''.join(RN)\n",
    "                j=len(rn)\n",
    "    return rn\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51aee7ff",
   "metadata": {},
   "source": [
    "So in order to generate a random string of length L you just need to run the code \n",
    "\n",
    "$\\textit{RN=Rstr_fock(L)}$\n",
    "\n",
    "$\\textit{print(RN[0:L])}$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "8ae4ac94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100110111010101101101010110100\n"
     ]
    }
   ],
   "source": [
    "#Fock random number generator\n",
    "\n",
    "\n",
    "L=30\n",
    "RN=Rstr_fock(L)\n",
    "print(RN[0:L])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74487332",
   "metadata": {},
   "source": [
    "This code is not in the final version since we spent most time in the understanding, the generation of random numbers is ricght now slow, but since we can garantee the unbiased distribution it's only a matter of time to improve the code, also if we have acces to a real hardware we could expect better times that in the simulation of BS. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fcd6f3b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}