{ "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": 5, "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": 6, "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": 6, "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": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "output distribution: {\n", " |1,0,0,0,0,0,0,0>: 0.06249999999999997\n", " |0,1,0,0,0,0,0,0>: 0.0625\n", " |0,0,1,0,0,0,0,0>: 0.06250000000000006\n", " |0,0,0,1,0,0,0,0>: 0.06249999999999996\n", " |0,0,0,0,1,0,0,0>: 0.06250000000000008\n", " |0,0,0,0,0,1,0,0>: 0.5625\n", " |0,0,0,0,0,0,1,0>: 0.06249999999999997\n", " |0,0,0,0,0,0,0,1>: 0.06249999999999996\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": 8, "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": 9, "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": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mode: 0, Probability: 0.06249999999999997\n", "Mode: 1, Probability: 0.0625\n", "Mode: 2, Probability: 0.06250000000000006\n", "Mode: 3, Probability: 0.06249999999999996\n", "Mode: 4, Probability: 0.06250000000000008\n", "Mode: 5, Probability: 0.5625\n", "Mode: 6, Probability: 0.06249999999999997\n", "Mode: 7, Probability: 0.06249999999999996\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": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Walk position: -4, Probability: 0.06249999999999996\n", "Walk position: -3, Probability: 0\n", "Walk position: -2, Probability: 0.625\n", "Walk position: -1, Probability: 0\n", "Walk position: 0, Probability: 0.12500000000000006\n", "Walk position: 1, Probability: 0\n", "Walk position: 2, Probability: 0.12500000000000006\n", "Walk position: 3, Probability: 0\n", "Walk position: 4, Probability: 0.06249999999999997\n" ] }, { "data": { "image/png": "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", "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": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "output distribution: {\n", " |2,0,0,0,0,0,0,0>: 0.007812499999999991\n", " |1,1,0,0,0,0,0,0>: 0.015624999999999986\n", " |1,0,1,0,0,0,0,0>: 0.06249999999999997\n", " |1,0,0,0,1,0,0,0>: 0.015624999999999993\n", " |1,0,0,0,0,1,0,0>: 0.015624999999999983\n", " |0,2,0,0,0,0,0,0>: 0.0078124999999999965\n", " |0,1,1,0,0,0,0,0>: 0.0625\n", " |0,1,0,0,1,0,0,0>: 0.015625\n", " |0,1,0,0,0,1,0,0>: 0.01562499999999998\n", " |0,0,2,0,0,0,0,0>: 0.07031250000000004\n", " |0,0,1,1,0,0,0,0>: 0.015624999999999972\n", " |0,0,1,0,1,0,0,0>: 0.06250000000000006\n", " |0,0,1,0,0,1,0,0>: 0.24999999999999994\n", " |0,0,1,0,0,0,1,0>: 0.01562499999999998\n", " |0,0,1,0,0,0,0,1>: 0.015624999999999983\n", " |0,0,0,2,0,0,0,0>: 0.007812499999999998\n", " |0,0,0,1,0,1,0,0>: 0.06250000000000006\n", " |0,0,0,1,0,0,1,0>: 0.015625\n", " |0,0,0,1,0,0,0,1>: 0.015624999999999993\n", " |0,0,0,0,2,0,0,0>: 0.007812500000000003\n", " |0,0,0,0,1,1,0,0>: 0.015624999999999962\n", " |0,0,0,0,0,2,0,0>: 0.07031250000000004\n", " |0,0,0,0,0,1,1,0>: 0.0625\n", " |0,0,0,0,0,1,0,1>: 0.06249999999999997\n", " |0,0,0,0,0,0,2,0>: 0.0078124999999999965\n", " |0,0,0,0,0,0,1,1>: 0.015624999999999986\n", " |0,0,0,0,0,0,0,2>: 0.007812499999999991\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": 13, "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": 14, "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": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "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 = mpl.cm.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": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "bosonic output distribution: {\n", " |2,0,0,0,0,0,0,0>: 0.00781249999999999\n", " |1,1,0,0,0,0,0,0>: 0.01562499999999999\n", " |1,0,1,0,0,0,0,0>: 0.06249999999999998\n", " |1,0,0,0,1,0,0,0>: 0.01562499999999999\n", " |1,0,0,0,0,1,0,0>: 0.01562499999999999\n", " |0,2,0,0,0,0,0,0>: 0.007812499999999997\n", " |0,1,1,0,0,0,0,0>: 0.06249999999999999\n", " |0,1,0,0,1,0,0,0>: 0.015624999999999998\n", " |0,1,0,0,0,1,0,0>: 0.01562499999999998\n", " |0,0,2,0,0,0,0,0>: 0.07031250000000006\n", " |0,0,1,1,0,0,0,0>: 0.015624999999999974\n", " |0,0,1,0,1,0,0,0>: 0.06250000000000006\n", " |0,0,1,0,0,1,0,0>: 0.24999999999999997\n", " |0,0,1,0,0,0,1,0>: 0.01562499999999998\n", " |0,0,1,0,0,0,0,1>: 0.01562499999999999\n", " |0,0,0,2,0,0,0,0>: 0.007812499999999999\n", " |0,0,0,1,0,1,0,0>: 0.06250000000000004\n", " |0,0,0,1,0,0,1,0>: 0.015624999999999998\n", " |0,0,0,1,0,0,0,1>: 0.01562499999999999\n", " |0,0,0,0,2,0,0,0>: 0.007812500000000003\n", " |0,0,0,0,1,1,0,0>: 0.01562499999999996\n", " |0,0,0,0,0,2,0,0>: 0.07031250000000006\n", " |0,0,0,0,0,1,1,0>: 0.06249999999999999\n", " |0,0,0,0,0,1,0,1>: 0.06249999999999998\n", " |0,0,0,0,0,0,2,0>: 0.007812499999999997\n", " |0,0,0,0,0,0,1,1>: 0.01562499999999999\n", " |0,0,0,0,0,0,0,2>: 0.00781249999999999\n", "}\n", "fermionic output distribution: {\n", " |1,0,1,0,0,0,0,0>: 0.015624999999999988\n", " |1,0,0,1,0,0,0,0>: 0.015624999999999988\n", " |1,0,0,0,0,1,0,0>: 0.06249999999999997\n", " |1,0,0,0,0,0,1,0>: 0.015624999999999988\n", " |1,0,0,0,0,0,0,1>: 0.015624999999999977\n", " |0,1,1,0,0,0,0,0>: 0.015624999999999997\n", " |0,1,0,1,0,0,0,0>: 0.015624999999999997\n", " |0,1,0,0,0,1,0,0>: 0.062499999999999986\n", " |0,1,0,0,0,0,1,0>: 0.015624999999999988\n", " |0,1,0,0,0,0,0,1>: 0.015624999999999988\n", " |0,0,1,1,0,0,0,0>: 0.062499999999999986\n", " |0,0,1,0,1,0,0,0>: 0.015625000000000028\n", " |0,0,1,0,0,1,0,0>: 0.39062500000000006\n", " |0,0,1,0,0,0,1,0>: 0.062499999999999986\n", " |0,0,1,0,0,0,0,1>: 0.06249999999999997\n", " |0,0,0,1,1,0,0,0>: 0.015625000000000003\n", " |0,0,0,1,0,1,0,0>: 0.015625000000000017\n", " |0,0,0,0,1,1,0,0>: 0.062499999999999986\n", " |0,0,0,0,1,0,1,0>: 0.015624999999999997\n", " |0,0,0,0,1,0,0,1>: 0.015624999999999993\n", " |0,0,0,0,0,1,1,0>: 0.015624999999999997\n", " |0,0,0,0,0,1,0,1>: 0.015624999999999988\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": 17, "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": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "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 = mpl.cm.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 }