{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Two-particle bosonic-fermionic quantum walk\n", "We provide an implementation of the two-particle quantum walk. The aim is to reproduce the results of \"Two-particle bosonic-fermionic quantum walk via integrated photonics\" by L. Sansoni et al. [[1]] with Perceval.\n", "\n", "[1]: https://arxiv.org/pdf/1106.5713.pdf" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# imports\n", "import matplotlib.pyplot as plt\n", "import matplotlib as mpl\n", "\n", "import numpy as np\n", "\n", "import perceval as pcvl\n", "from perceval.components.unitary_components import BS\n", "from perceval.backends import NaiveBackend\n", "from perceval.simulators import Simulator\n", "from perceval.components import Source\n", "\n", "## Use the symbolic skin for display\n", "from perceval.rendering.circuit import DisplayConfig, SymbSkin\n", "DisplayConfig.select_skin(SymbSkin)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Building an array of beam splitters \n", "The dynamics of a quantum walk can be achieved by an array of beam splitters (BSs) as in figure. Here we reproduce a four steps quantum walk, we highlight the difference between the optical spatial modes (in red) and the walk positions (in blue)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"Quantum" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "" ], "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# number of steps\n", "steps = 4\n", "# spatial modes are twice the number of steps\n", "n = 2*steps\n", "\n", "# BS_array contains the input modes of the BSs at each step\n", "BS_array = [[[0]*2]*(i+1) for i in range(steps)]\n", "\n", "i_0 = n/2\n", "for s in range(steps):\n", " if s==0:\n", " BS_array[s][0] = [i_0, i_0-1]\n", " else:\n", " z = 0\n", " for i, j in BS_array[s-1]:\n", " if [i+1, i] not in BS_array[s]:\n", " BS_array[s][z] = [i+1, i]\n", " z += 1\n", " if [j, j-1] not in BS_array[s]:\n", " BS_array[s][z] = [j, j-1]\n", " z += 1\n", "\n", "# build the circuit\n", "circuit = pcvl.Circuit(n)\n", "for s in range(steps):\n", " for bs in BS_array[s]:\n", " circuit.add(int(bs[1]), BS())\n", "\n", "# display the circuit\n", "pcvl.pdisplay(circuit)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Single photon quantum walk\n", "We can check the functioning of the BSs array as a quantum walk simulator putting a single photon in the first input position (mode 3 <-> walk position 0) of the array. Then we can check the output probability distribution of the photon in the corresponding walk positions." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "output distribution: {\n", " |1,0,0,0,0,0,0,0>: 0.0625\n", " |0,1,0,0,0,0,0,0>: 0.0625\n", " |0,0,1,0,0,0,0,0>: 0.0625\n", " |0,0,0,1,0,0,0,0>: 0.0625\n", " |0,0,0,0,1,0,0,0>: 0.0625\n", " |0,0,0,0,0,1,0,0>: 0.5625000000000001\n", " |0,0,0,0,0,0,1,0>: 0.0625\n", " |0,0,0,0,0,0,0,1>: 0.0625\n", "}\n" ] } ], "source": [ "# define input state by inserting a photon in the first mode\n", "mode = 3\n", "in_list = [0]*n\n", "in_list[mode] = 1\n", "in_state = pcvl.BasicState(in_list)\n", "\n", "# select a backend and define the simulator on the circuit\n", "simulator = Simulator(NaiveBackend())\n", "simulator.set_circuit(circuit)\n", "\n", "#Define a source and input distribution due to source noise\n", "source = Source(losses=0, indistinguishability=1)\n", "input_distribution = source.generate_distribution(expected_input=in_state)\n", "\n", "prob_dist = simulator.probs_svd(input_distribution)\n", "print(\"output distribution:\", prob_dist[\"results\"])\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From the corresponding states of the distribution we have direct access to the output modes. What we want though, is to check the output probability distribution of the photon in the corresponding walk positions. From the initial figure we can define the mapping mode -> walk position. Then, we just have to take care of taking the modes probability distribution and and, for each walk position, sum the probabilities of the corresponding modes." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# function that takes a state and returns the modes of the photons\n", "def get_mode(state):\n", " modes = [i for i, x in enumerate(state) if x >= 1]\n", " return modes if len(modes) > 1 else modes[0]\n", "# dictionary to map the mode to the position\n", "mode_to_walk_pos_mapping = {\n", " 0: 4,\n", " 1: 2,\n", " 2: 2,\n", " 3: 0,\n", " 4: 0,\n", " 5: -2,\n", " 6: -2,\n", " 7: -4\n", "}" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "|1,0,0,0,0,0,0,0>\n", "|0,1,0,0,0,0,0,0>\n", "|0,0,1,0,0,0,0,0>\n", "|0,0,0,1,0,0,0,0>\n", "|0,0,0,0,1,0,0,0>\n", "|0,0,0,0,0,1,0,0>\n", "|0,0,0,0,0,0,1,0>\n", "|0,0,0,0,0,0,0,1>\n" ] } ], "source": [ "for state in prob_dist[\"results\"].keys():\n", " print(state)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mode: 0, Probability: 0.0625\n", "Mode: 1, Probability: 0.0625\n", "Mode: 2, Probability: 0.0625\n", "Mode: 3, Probability: 0.0625\n", "Mode: 4, Probability: 0.0625\n", "Mode: 5, Probability: 0.5625000000000001\n", "Mode: 6, Probability: 0.0625\n", "Mode: 7, Probability: 0.0625\n" ] } ], "source": [ "# get output modes from the distribution\n", "modes = [get_mode(state) for state in prob_dist[\"results\"].keys()]\n", "\n", "# get the probabilities of the modes\n", "probs = np.array([0]*n, dtype=np.float64)\n", "\n", "for mode,prob in zip(modes, prob_dist[\"results\"].values()):\n", " probs[mode] = prob\n", "\n", "# print modes and probabilities\n", "for mode, prob in zip(modes, probs):\n", " print(\"Mode: {}, Probability: {}\".format(mode, prob))" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Walk position: -4, Probability: 0.0625\n", "Walk position: -3, Probability: 0\n", "Walk position: -2, Probability: 0.6250000000000001\n", "Walk position: -1, Probability: 0\n", "Walk position: 0, Probability: 0.125\n", "Walk position: 1, Probability: 0\n", "Walk position: 2, Probability: 0.125\n", "Walk position: 3, Probability: 0\n", "Walk position: 4, Probability: 0.0625\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# get the walk positions distribution\n", "walk_pos = range(-steps, steps+1)\n", "walk_probs = [0]*(2*steps+1)\n", "\n", "\n", "for i, w_p in enumerate(walk_pos):\n", " idxs = [index for (index, mode) in enumerate(modes) if mode_to_walk_pos_mapping[mode] == w_p]\n", " if len(idxs) > 0:\n", " walk_probs[i] = sum([probs[idx] for idx in idxs])\n", " else:\n", " walk_probs[i] = 0\n", "\n", "# print walk positions and probabilities\n", "for w_p, w_p_p in zip(walk_pos, walk_probs):\n", " print(\"Walk position: {}, Probability: {}\".format(w_p, w_p_p))\n", "\n", "# plot the walk positions distribution\n", "plt.bar(walk_pos, walk_probs)\n", "plt.xticks(walk_pos)\n", "plt.xlabel(\"position\")\n", "plt.ylabel(\"probability\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Two photons quantum walk\n", "Now we can follow the same procedure as before, but with two input photons in the two input modes (3 and 4)." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "output distribution: {\n", " |2,0,0,0,0,0,0,0>: 0.0078124999999999965\n", " |1,1,0,0,0,0,0,0>: 0.015624999999999997\n", " |1,0,1,0,0,0,0,0>: 0.062499999999999986\n", " |1,0,0,0,1,0,0,0>: 0.015624999999999997\n", " |1,0,0,0,0,1,0,0>: 0.015624999999999997\n", " |0,2,0,0,0,0,0,0>: 0.0078124999999999965\n", " |0,1,1,0,0,0,0,0>: 0.062499999999999986\n", " |0,1,0,0,1,0,0,0>: 0.015624999999999997\n", " |0,1,0,0,0,1,0,0>: 0.015624999999999997\n", " |0,0,2,0,0,0,0,0>: 0.07031249999999999\n", " |0,0,1,1,0,0,0,0>: 0.015624999999999997\n", " |0,0,1,0,1,0,0,0>: 0.062499999999999986\n", " |0,0,1,0,0,1,0,0>: 0.25000000000000006\n", " |0,0,1,0,0,0,1,0>: 0.015625000000000003\n", " |0,0,1,0,0,0,0,1>: 0.015625000000000003\n", " |0,0,0,2,0,0,0,0>: 0.0078125\n", " |0,0,0,1,0,1,0,0>: 0.06250000000000001\n", " |0,0,0,1,0,0,1,0>: 0.015624999999999997\n", " |0,0,0,1,0,0,0,1>: 0.015624999999999997\n", " |0,0,0,0,2,0,0,0>: 0.0078124999999999965\n", " |0,0,0,0,1,1,0,0>: 0.015624999999999997\n", " |0,0,0,0,0,2,0,0>: 0.07031250000000003\n", " |0,0,0,0,0,1,1,0>: 0.06250000000000001\n", " |0,0,0,0,0,1,0,1>: 0.06250000000000001\n", " |0,0,0,0,0,0,2,0>: 0.0078124999999999965\n", " |0,0,0,0,0,0,1,1>: 0.015624999999999997\n", " |0,0,0,0,0,0,0,2>: 0.0078124999999999965\n", "}\n" ] } ], "source": [ "# two photons input state\n", "in_list = [0]*n\n", "in_list[3], in_list[4] = 1, 1\n", "in_state = pcvl.BasicState(in_list)\n", "\n", "# select a backend and define the simulator on the circuit\n", "simulator = Simulator(NaiveBackend())\n", "simulator.set_circuit(circuit)\n", "\n", "# define a source and input distribution due to source noise\n", "source = Source(losses=0, indistinguishability=1)\n", "input_distribution = source.generate_distribution(expected_input=in_state)\n", "\n", "prob_dist = simulator.probs_svd(input_distribution)\n", "print(\"output distribution:\", prob_dist[\"results\"])" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# get output modes from the distribution\n", "modes = [get_mode(state) for state in prob_dist[\"results\"].keys()]\n", "## take care of the case where there is only one mode\n", "modes = [m if isinstance(m, list) else [m,m] for m in modes]\n", "\n", "# get the probabilities of the modes\n", "probs = np.array([[0]*n]*n, dtype=np.float64)\n", "\n", "for m, prob in zip(modes, prob_dist[\"results\"].values()):\n", " probs[m[0], m[1]] = prob" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# get the walk positions distribution\n", "walk_pos = range(-steps, steps+1)\n", "\n", "walk_probs = np.array([[0]*(2*steps+1)]*(2*steps+1), dtype=np.float64)\n", "for i in range(n):\n", " for j in range(n):\n", " w_i = mode_to_walk_pos_mapping[i]+steps\n", " w_j = mode_to_walk_pos_mapping[j]+steps\n", " walk_probs[w_i, w_j] += probs[i,j]" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# plot as 3dbar\n", "x, y = np.meshgrid(walk_pos, walk_pos)\n", "cmap = plt.get_cmap('jet') # Get desired colormap\n", "max_height = np.max(walk_probs.flatten()) \n", "min_height = np.min(walk_probs.flatten())\n", "# scale each z to [0,1], and get their rgb values\n", "rgba = [cmap((k-min_height)/max_height) if k!=0 else (0,0,0,0) for k in walk_probs.flatten()] \n", "fig = plt.figure(figsize=(6, 8))\n", "ax = fig.add_subplot(111, projection='3d')\n", "ax.bar3d(x.flatten(), y.flatten(), np.zeros((2*steps+1)*(2*steps+1)), 1, 1, walk_probs.flatten(), color=rgba)\n", "ax.set_xlabel(\"position\")\n", "ax.set_ylabel(\"position\")\n", "ax.set_zlabel(\"probability\")\n", "ax.set_box_aspect(aspect=None, zoom=0.8)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Bosonic-fermionic quantum walks\n", "Moreover, we can select an entangled state as the input state and observe that the output distribution behaves differently with respect to the state statistic." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "bosonic output distribution: {\n", " |2,0,0,0,0,0,0,0>: 0.0078125\n", " |0,0,0,2,0,0,0,0>: 0.007812500000000002\n", " |1,1,0,0,0,0,0,0>: 0.015625\n", " |0,0,0,1,0,0,0,1>: 0.015625\n", " |0,0,1,1,0,0,0,0>: 0.015625\n", " |1,0,1,0,0,0,0,0>: 0.0625\n", " |1,0,0,0,1,0,0,0>: 0.015625\n", " |1,0,0,0,0,1,0,0>: 0.015625\n", " |0,0,1,0,0,1,0,0>: 0.25\n", " |0,0,1,0,0,0,0,1>: 0.015625\n", " |0,2,0,0,0,0,0,0>: 0.0078125\n", " |0,1,1,0,0,0,0,0>: 0.0625\n", " |0,0,1,0,0,0,1,0>: 0.015625\n", " |0,1,0,0,1,0,0,0>: 0.015625\n", " |0,1,0,0,0,1,0,0>: 0.015625\n", " |0,0,0,0,2,0,0,0>: 0.0078125\n", " |0,0,0,1,0,1,0,0>: 0.06250000000000001\n", " |0,0,2,0,0,0,0,0>: 0.0703125\n", " |0,0,1,0,1,0,0,0>: 0.0625\n", " |0,0,0,1,0,0,1,0>: 0.015625\n", " |0,0,0,0,0,0,0,2>: 0.0078125\n", " |0,0,0,0,0,1,0,1>: 0.0625\n", " |0,0,0,0,0,0,1,1>: 0.015625\n", " |0,0,0,0,1,1,0,0>: 0.015625\n", " |0,0,0,0,0,0,2,0>: 0.0078125\n", " |0,0,0,0,0,2,0,0>: 0.07031250000000003\n", " |0,0,0,0,0,1,1,0>: 0.0625\n", "}\n", "fermionic output distribution: {\n", " |1,0,0,1,0,0,0,0>: 0.015624999999999997\n", " |0,0,1,1,0,0,0,0>: 0.062499999999999986\n", " |1,0,1,0,0,0,0,0>: 0.015624999999999997\n", " |1,0,0,0,0,0,0,1>: 0.015624999999999997\n", " |0,0,0,1,1,0,0,0>: 0.015624999999999997\n", " |1,0,0,0,0,1,0,0>: 0.062499999999999986\n", " |0,0,0,0,1,0,1,0>: 0.015624999999999997\n", " |1,0,0,0,0,0,1,0>: 0.015624999999999997\n", " |0,0,1,0,0,1,0,0>: 0.39062500000000006\n", " |0,0,1,0,0,0,0,1>: 0.062499999999999986\n", " |0,1,1,0,0,0,0,0>: 0.015624999999999997\n", " |0,1,0,1,0,0,0,0>: 0.015624999999999997\n", " |0,0,1,0,0,0,1,0>: 0.062499999999999986\n", " |0,1,0,0,0,0,0,1>: 0.015624999999999997\n", " |0,1,0,0,0,1,0,0>: 0.062499999999999986\n", " |0,0,0,1,0,1,0,0>: 0.015625000000000007\n", " |0,1,0,0,0,0,1,0>: 0.015624999999999997\n", " |0,0,1,0,1,0,0,0>: 0.015624999999999997\n", " |0,0,0,0,1,0,0,1>: 0.015624999999999997\n", " |0,0,0,0,0,1,0,1>: 0.015624999999999997\n", " |0,0,0,0,1,1,0,0>: 0.062499999999999986\n", " |0,0,0,0,0,1,1,0>: 0.015624999999999997\n", "}\n" ] } ], "source": [ "# two entangled input states\n", "bosonic_state = pcvl.StateVector(\"|0,0,0,{A:1},{A:2},0,0,0>\") + pcvl.StateVector(\"|0,0,0,{A:2},{A:1},0,0,0>\")\n", "fermionic_state = pcvl.StateVector(\"|0,0,0,{A:1},{A:2},0,0,0>\") - pcvl.StateVector(\"|0,0,0,{A:2},{A:1},0,0,0>\")\n", "\n", "\n", "# select a backend and define the simulator on the circuit\n", "simulator = Simulator(NaiveBackend())\n", "simulator.set_circuit(circuit)\n", "\n", "bosonic_prob_dist = simulator.probs(bosonic_state)\n", "fermionic_prob_dist = simulator.probs(fermionic_state)\n", "\n", "print(\"bosonic output distribution:\", bosonic_prob_dist)\n", "print(\"fermionic output distribution:\", fermionic_prob_dist)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "# get output modes from the distributions\n", "bosonic_modes = [get_mode(state) for state, _ in bosonic_prob_dist.items()]\n", "bosonic_modes = [m if isinstance(m, list) else [m,m] for m in bosonic_modes]\n", "fermionic_modes = [get_mode(state) for state, _ in fermionic_prob_dist.items()]\n", "fermionic_modes = [m if isinstance(m, list) else [m,m] for m in fermionic_modes]\n", "\n", "# get the probabilities of the modes\n", "bosonic_probs = np.array([[0]*n]*n, dtype=np.float64)\n", "for m, (_, prob) in zip(bosonic_modes, bosonic_prob_dist.items()):\n", " bosonic_probs[m[0], m[1]] = prob\n", "\n", "fermionic_probs = np.array([[0]*n]*n, dtype=np.float64)\n", "for m, (_, prob) in zip(fermionic_modes, fermionic_prob_dist.items()):\n", " fermionic_probs[m[0], m[1]] = prob\n", "\n", "# get the walk positions distributions\n", "walk_pos = range(-steps, steps+1)\n", "\n", "bosonic_walk_probs = np.array([[0]*(2*steps+1)]*(2*steps+1), dtype=np.float64)\n", "fermionic_walk_probs = np.array([[0]*(2*steps+1)]*(2*steps+1), dtype=np.float64)\n", "for i in range(n):\n", " for j in range(n):\n", " w_i = mode_to_walk_pos_mapping[i]+steps\n", " w_j = mode_to_walk_pos_mapping[j]+steps\n", " bosonic_walk_probs[w_i, w_j] += bosonic_probs[i,j]\n", " fermionic_walk_probs[w_i, w_j] += fermionic_probs[i,j]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# plot the two distributions as 3dbar subplots\n", "x, y = np.meshgrid(walk_pos, walk_pos)\n", "cmap = plt.get_cmap('jet') # Get desired colormap\n", "bosonic_max_height = np.max(bosonic_walk_probs.flatten())\n", "bosonic_min_height = np.min(bosonic_walk_probs.flatten())\n", "fermionic_max_height = np.max(fermionic_walk_probs.flatten())\n", "fermionic_min_height = np.min(fermionic_walk_probs.flatten())\n", "# scale each z to [0,1], and get their rgb values\n", "bosonic_rgba = [cmap((k-bosonic_min_height)/bosonic_max_height) if k!=0 else (0,0,0,0) for k in bosonic_walk_probs.flatten()]\n", "fermionic_rgba = [cmap((k-fermionic_min_height)/fermionic_max_height) if k!=0 else (0,0,0,0) for k in fermionic_walk_probs.flatten()]\n", "fig = plt.figure(figsize=(10, 16))\n", "ax = plt.subplot(1, 2, 1, projection='3d')\n", "ax.bar3d(x.flatten(), y.flatten(), np.zeros((2*steps+1)*(2*steps+1)), 1, 1, bosonic_walk_probs.flatten(), color=bosonic_rgba)\n", "ax.set_xlabel(\"position\")\n", "ax.set_ylabel(\"position\")\n", "ax.set_zlabel(\"probability\")\n", "ax.set_box_aspect(aspect=None, zoom=0.8)\n", "ax.set_title(\"bosonic\")\n", "ax = plt.subplot(1, 2, 2, projection='3d')\n", "ax.bar3d(x.flatten(), y.flatten(), np.zeros((2*steps+1)*(2*steps+1)), 1, 1, fermionic_walk_probs.flatten(), color=fermionic_rgba)\n", "ax.set_xlabel(\"position\")\n", "ax.set_ylabel(\"position\")\n", "ax.set_zlabel(\"probability\")\n", "ax.set_box_aspect(aspect=None, zoom=0.8)\n", "ax.set_title(\"fermionic\")\n", "plt.show()" ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 2 }