![](\"logo-perceval.png\")
\n\n\n\nThrough a simple object-oriented python API, Perceval provides tools for building a circuit with linear optics components,\ndefining single-photon sources and their error model, manipulating Fock states, running simulations, reproducing published experimental papers results,\nand experimenting with a new generation of quantum algorithms.\n\nIt is interfaced with the available QPUs on\nthe [Quandela cloud](https://cloud.quandela.com/webide/), so it is possible to run computations on an\nactual photonic computer.\n\nPerceval aims to be a companion tool for developing discrete-variable photonics circuits\n- while simulating their design, modelling their ideal and real-life behaviour;\n- and proposing a normalized interface to control photonic quantum computers;\n- while using powerful simulation backends to get state-of-the-art simulation;\n- and also allowing direct access to the QPUs of Quandela.\n\nPerceval has been developed as a complete toolkit for physicists and quantum computational students, researchers and\npractitioners.\n\n# Key Features\n\n* Powerful Circuit designer making use of predefined components\n* Simple python API and powerful simulation backends optimized in C\n* Misc technical utilities to manipulate State Vector, Unitary Matrices, and circuit Parameters\n* Transversal tools for visualization compatible with notebooks or local development environments\n* Numerical and symbolical computation\n* Modular architecture welcoming contributions from the community\n\n# Installation\n\nPerceval requires:\n\n* Python between 3.10 and 3.14\n\n## PIP\nWe recommend installing it with `pip`:\n\n```bash\npip install --upgrade pip\npip install perceval-quandela\n```\n\nOur qiskit, qutip, cqasm or myqlm bridges have been moved to a separate\ninteroperability package `perceval-interop` (https://perceval.quandela.net/interopdocs/).\n\n## GitHub\n```bash\ngit clone https://github.com/quandela/Perceval\n```\nthen to install Perceval:\n```bash\npip install .\n```\nOr for developers:\n```bash\npip install -e .\n```\n\n# Running tests and benchmarks\n\nUnit tests files are part of the repository in `tests/` and can be run with:\n\n```\npip install -r tests/requirements.txt\npytest\n```\n\nAdditionally, you can see a coverage report with the command:\n\n```\npytest --cov=perceval\n```\n\nBenchmark tests for computing-intensive functions are in `benchmark/` and can be run with:\n\n```\npytest benchmark/benchmark_*.py\n```\n\nComparison benchmarks for different platforms are also committed in `.benchmarks/` - see [pytest-benchmark documentation](https://pytest-benchmark.readthedocs.io/en/stable/usage.html) for more information.\n\n# Documentation and Forum\n\n* The [documentation](https://perceval.quandela.net/docs)\n* The [Community Forum](https://perceval.quandela.net/forum)\n\n#\n[![](\"logo-quandela.png\")
](https://www.quandela.com/)\n\n[](https://twitter.com/Quandela_SAS)\n[](https://www.youtube.com/channel/UCl5YMpSqknJ1n-IT-XWfLsQ)\n"
},
{
"path": "benchmark/benchmark-circuit-building.py",
"content": "# MIT License\n#\n# Copyright (c) 2022 Quandela\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# As a special exception, the copyright holders of exqalibur library give you\n# permission to combine exqalibur with code included in the standard release of\n# Perceval under the MIT license (or modified versions of such code). You may\n# copy and distribute such a combined system following the terms of the MIT\n# license for both exqalibur and Perceval. This exception for the usage of\n# exqalibur is limited to the python bindings used by Perceval.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nimport perceval as pcvl\nfrom perceval.components.unitary_components import BS, PS, PERM\nimport random\nimport time\n\nt_build = 0\nt_set = 0\nt_compute = 0\nt_get = 0\n\nfor _ in range(1000):\n start = time.time()\n #List of the parameters φ1,φ2,...,φ8\n List_Parameters = []\n\n # VQE is a 6 optical mode circuit\n VQE = pcvl.Circuit(6)\n\n VQE.add((1, 2), BS.H())\n VQE.add((3, 4), BS.H())\n List_Parameters.append(pcvl.Parameter(\"φ1\"))\n VQE.add((2,), PS(phi=List_Parameters[-1]))\n List_Parameters.append(pcvl.Parameter(\"φ3\"))\n VQE.add((4,), PS(phi=List_Parameters[-1]))\n VQE.add((1, 2), BS.H())\n VQE.add((3, 4), BS.H())\n List_Parameters.append(pcvl.Parameter(\"φ2\"))\n VQE.add((2,), PS(phi=List_Parameters[-1]))\n List_Parameters.append(pcvl.Parameter(\"φ4\"))\n VQE.add((4,), PS(phi=List_Parameters[-1]))\n\n\n # CNOT ( Post-selected with a success probability of 1/9)\n VQE.add([0,1,2,3,4,5], PERM([0,1,2,3,4,5]))#Identity PERM (permutation) for the purpose of drawing a nice circuit\n VQE.add((3, 4), BS.H())\n VQE.add([0,1,2,3,4,5], PERM([0,1,2,3,4,5]))#Identity PERM (permutation) for the same purpose\n VQE.add((0, 1), BS.H(theta=BS.r_to_theta(1/3)))\n VQE.add((2, 3), BS.H(theta=BS.r_to_theta(1/3)))\n VQE.add((4, 5), BS.H(theta=BS.r_to_theta(1/3)))\n VQE.add([0,1,2,3,4,5], PERM([0,1,2,3,4,5]))#Identity PERM (permutation) for the same purpose\n VQE.add((3, 4), BS.H())\n VQE.add([0,1,2,3,4,5], PERM([0,1,2,3,4,5]))#Identity PERM (permutation) for the same purpose\n\n List_Parameters.append(pcvl.Parameter(\"φ5\"))\n VQE.add((2,), PS(phi=List_Parameters[-1]))\n List_Parameters.append(pcvl.Parameter(\"φ7\"))\n VQE.add((4,), PS(phi=List_Parameters[-1]))\n VQE.add((1, 2), BS.H())\n VQE.add((3, 4), BS.H())\n List_Parameters.append(pcvl.Parameter(\"φ6\"))\n VQE.add((2,), PS(phi=List_Parameters[-1]))\n List_Parameters.append(pcvl.Parameter(\"φ8\"))\n VQE.add((4,), PS(phi=List_Parameters[-1]))\n VQE.add((1, 2), BS.H())\n VQE.add((3, 4), BS.H())\n\n t_build += time.time()-start\n start = time.time()\n init_param = [random.random() for _ in List_Parameters]\n\n for idx, p in enumerate(List_Parameters):\n p.set_value(init_param[idx])\n\n t_set += time.time()-start\n start = time.time()\n\n VQE.compute_unitary(use_symbolic = False)\n\n t_compute += time.time()-start\n start = time.time()\n\n for i in range(len(List_Parameters)):\n init_param[i] = VQE.get_parameters()[i]._value\n\n t_get += time.time()-start\n\nprint(\"TOTAL=\", t_build+t_set+t_compute+t_get, \"DETAIL=\", t_build, t_set, t_compute, t_get)\n"
},
{
"path": "benchmark/benchmark-unitary.py",
"content": "# MIT License\n#\n# Copyright (c) 2022 Quandela\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# As a special exception, the copyright holders of exqalibur library give you\n# permission to combine exqalibur with code included in the standard release of\n# Perceval under the MIT license (or modified versions of such code). You may\n# copy and distribute such a combined system following the terms of the MIT\n# license for both exqalibur and Perceval. This exception for the usage of\n# exqalibur is limited to the python bindings used by Perceval.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nr\"\"\"\nThis script compares building of unitary when using Circuit or directly by building matrix.\n\"\"\"\n\nimport perceval as pcvl\nimport perceval.components.unitary_components as comp\nimport time\nimport numpy as np\n\nm = 8\n\n\ndef phase_shift(n_mode, theta):\n # phase shift in m x m unitary in mode 1 of angle theta\n ps_matrix = np.eye(n_mode, dtype=complex)\n ps_matrix[0, 0] = np.cos(theta) + 1j * np.sin(theta)\n return ps_matrix\n\n\nu1 = pcvl.Matrix.random_unitary(m)\nu2 = pcvl.Matrix.random_unitary(m)\n\npx = pcvl.P(\"x\")\nc = comp.Unitary(u2) // (0, comp.PS(px)) // comp.Unitary(u1)\n\ndt_circuit = 0\ndt_raw = 0\n\nfor _ in range(1000):\n top0 = time.time_ns()\n px.set_value(1)\n c.compute_unitary(use_symbolic=False)\n top1 = time.time_ns()\n dt_circuit += top1-top0\n\n top0 = time.time_ns()\n U = u1 @ phase_shift(m, 1) @ u2\n top1 = time.time_ns()\n dt_raw += top1-top0\n\n\nif dt_circuit/dt_raw > 2.5:\n print(\"TOO_SLOW\", \"circuit\", dt_circuit, \"raw\", dt_raw, \"factor\", dt_circuit/dt_raw)\nelse:\n print(\"OK\", \"circuit\", dt_circuit, \"raw\", dt_raw, \"factor\", dt_circuit/dt_raw)\n"
},
{
"path": "benchmark/benchmark_QML-DE-solver.py",
"content": "# MIT License\n#\n# Copyright (c) 2022 Quandela\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# As a special exception, the copyright holders of exqalibur library give you\n# permission to combine exqalibur with code included in the standard release of\n# Perceval under the MIT license (or modified versions of such code). You may\n# copy and distribute such a combined system following the terms of the MIT\n# license for both exqalibur and Perceval. This exception for the usage of\n# exqalibur is limited to the python bindings used by Perceval.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\nimport random\n\nimport perceval as pcvl\nimport perceval.components.unitary_components as comp\nimport numpy as np\nfrom math import comb\nfrom scipy.optimize import minimize\n\n# Differential equation parameters\nlambd = 8\nkappa = 0.1\n\n\ndef F(u_prime, u, x): # DE: F(u_prime, u, x) = 0\n # Must work with numpy arrays\n return (u_prime + lambd * u * (kappa + np.tan(lambd * x)))\n\n\n# Boundary condition (f(x_0)=f_0)\nx_0 = 0\nf_0 = 1\n\n# Modeling parameters\nn_grid = 50 # number of grid points of the discretized differential equation\nrange_min = 0 # minimum of the interval on which we wish to approximate our function\nrange_max = 1 # maximum of the interval on which we wish to approximate our function\nX = np.linspace(range_min, range_max, n_grid) # Optimisation grid\n\n# Parameters of the quantum machine learning procedure\neta = 5 # weight granted to the initial condition\na = 200 # Approximate boundaries of the interval that the image of the trial function can cover\n\nN = m = 6\nN2 = N ** 2\n\ninput_state = pcvl.BasicState([1] * N + [0] * (m - N))\ns1 = pcvl.SLOSBackend()\ns1.set_circuit(pcvl.Unitary(pcvl.Matrix.random_unitary(m)))\ns1.preprocess([input_state])\n\nrandom.seed(0)\nnp.random.seed(0)\npcvl.random_seed(0)\n\nfock_dim = comb(N + m - 1, N)\nlambda_random = np.random.rand(fock_dim)\nlambda_random = a * (lambda_random - np.mean(lambda_random)) / np.std(lambda_random)\n\ndx = (range_max - range_min) / (n_grid - 1)\nparameters = np.random.normal(size=4 * N2)\n\n\ndef calc(circuit, input_state, coefs):\n s1.set_circuit(circuit)\n probs = s1.all_prob(input_state)\n return np.sum(np.multiply(probs, coefs))\n\n\ndef computation(params):\n \"\"\"compute the loss function of a given differential equation in order for it to be optimized\"\"\"\n coefs = lambda_random # coefficients of the M observable\n # initial condition with the two universal interferometers and the phase shift in the middle\n\n U_1 = pcvl.Matrix.parametrized_unitary(N, params[:2 * N2])\n U_2 = pcvl.Matrix.parametrized_unitary(N, params[2 * N2:4 * N2])\n\n # Circuit creation\n px = pcvl.P(\"px\")\n c = (comp.Unitary(U_2)\n // (0, comp.PS(px))\n // comp.Unitary(U_1))\n\n px.set_value(x_0)\n f_theta_0 = calc(c, input_state, coefs)\n\n # boundary condition given a weight eta\n loss = eta * (f_theta_0 - f_0) ** 2 * n_grid\n\n # Warning : Y[0] is before the domain we are interested in (used for differentiation), the domain begins at Y[1]\n Y = np.zeros(n_grid + 2)\n\n # Small optimisation working if x_0 == range_min\n if x_0 == range_min:\n Y[1] = f_theta_0\n assigned = 1\n\n else:\n assigned = 0\n\n px.set_value(range_min - dx)\n Y[0] = calc(c, input_state, coefs)\n\n for i in range(assigned, n_grid):\n x = X[i]\n\n px.set_value(x)\n Y[i + 1] = calc(c, input_state, coefs)\n\n # Y_prime[0] is the beginning of the domain /!\\ not the same for Y\n px.set_value(range_max + dx)\n Y[n_grid + 1] = calc(c, input_state, coefs)\n\n Y_prime = (Y[2:] - Y[:-2]) / (2 * dx)\n\n # This method is apparently the fastest to calculate the L2 norm squared\n loss += np.sum((F(Y_prime, Y[1:-1], X)) ** 2)\n\n current_loss = loss / n_grid\n return current_loss\n\n\ndef test_QML_DE_solver(benchmark):\n benchmark(minimize, computation, parameters,\n method='BFGS', options={'gtol': 1E-2})\n"
},
{
"path": "benchmark/benchmark_bosonsampling.py",
"content": "# MIT License\n#\n# Copyright (c) 2022 Quandela\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# As a special exception, the copyright holders of exqalibur library give you\n# permission to combine exqalibur with code included in the standard release of\n# Perceval under the MIT license (or modified versions of such code). You may\n# copy and distribute such a combined system following the terms of the MIT\n# license for both exqalibur and Perceval. This exception for the usage of\n# exqalibur is limited to the python bindings used by Perceval.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nimport math\n\nimport perceval as pcvl\nfrom perceval.components.unitary_components import BS, PS, Unitary\n\ndef get_interferometer(n):\n def _gen_mzi(i: int):\n return pcvl.catalog[\"mzi phase last\"].build_circuit(theta_a=0.42, theta_b=0.42,\n phi_a=math.pi+i*0.1, phi_b=math.pi/2)\n return pcvl.GenericInterferometer(n, _gen_mzi)\n\n\ndef simulate_sampling(shots, circuit, input_state):\n clifford = pcvl.Clifford2017Backend()\n clifford.set_circuit(circuit)\n clifford.set_input_state(input_state)\n for i in range(shots):\n clifford.sample()\n\n\ndef test_bosonsampling_clifford_6(benchmark):\n benchmark(simulate_sampling, shots=100,\n circuit=get_interferometer(6), input_state=pcvl.BasicState([1] * 6))\n\n\ndef test_bosonsampling_clifford_8(benchmark):\n benchmark(simulate_sampling, shots=20,\n circuit=get_interferometer(8), input_state=pcvl.BasicState([1] * 8))\n"
},
{
"path": "benchmark/benchmark_pdisplay.py",
"content": "# MIT License\n#\n# Copyright (c) 2022 Quandela\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# As a special exception, the copyright holders of exqalibur library give you\n# permission to combine exqalibur with code included in the standard release of\n# Perceval under the MIT license (or modified versions of such code). You may\n# copy and distribute such a combined system following the terms of the MIT\n# license for both exqalibur and Perceval. This exception for the usage of\n# exqalibur is limited to the python bindings used by Perceval.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nr\"\"\"\nThis script times the execution of pdisplay for circuits.\n\"\"\"\n\nimport perceval as pcvl\nimport perceval.components.unitary_components as comp\n\ntrials = 2\n\n\ndef generate_circuit(n_mode):\n u = pcvl.Matrix.random_unitary(n_mode)\n mzi = (pcvl.Circuit(2)\n // comp.BS()\n // (0, comp.PS(phi=pcvl.P(\"φ_a\")))\n // comp.BS()\n // (0, comp.PS(phi=pcvl.P(\"φ_b\"))))\n return pcvl.Circuit.decomposition(u, mzi, shape=pcvl.InterferometerShape.TRIANGLE)\n\n\nc6 = generate_circuit(6)\nc12 = generate_circuit(12)\n\n\ndef run_pdisplay(c, t, f):\n for _ in range(t):\n pcvl.pdisplay(c, output_format=f, mplot_noshow=True)\n\n\ndef _run_pdisplay_mplot_6():\n run_pdisplay(c6, trials, pcvl.Format.MPLOT)\n\n\ndef _run_pdisplay_mplot_12():\n run_pdisplay(c12, trials, pcvl.Format.MPLOT)\n\n\ndef _run_pdisplay_svg_6():\n run_pdisplay(c6, trials, pcvl.Format.HTML)\n\n\ndef _run_pdisplay_svg_12():\n run_pdisplay(c12, trials, pcvl.Format.HTML)\n\n\ndef test_pdisplay_mplot_6(benchmark):\n benchmark(_run_pdisplay_mplot_6)\n\n\ndef test_pdisplay_mplot_12(benchmark):\n benchmark(_run_pdisplay_mplot_12)\n\n\ndef test_pdisplay_svg_6(benchmark):\n benchmark(_run_pdisplay_svg_6)\n\n\ndef test_pdisplay_svg_12(benchmark):\n benchmark(_run_pdisplay_svg_12)\n"
},
{
"path": "benchmark/benchmark_stepper.py",
"content": "# MIT License\n#\n# Copyright (c) 2022 Quandela\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# As a special exception, the copyright holders of exqalibur library give you\n# permission to combine exqalibur with code included in the standard release of\n# Perceval under the MIT license (or modified versions of such code). You may\n# copy and distribute such a combined system following the terms of the MIT\n# license for both exqalibur and Perceval. This exception for the usage of\n# exqalibur is limited to the python bindings used by Perceval.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nimport random\n\nimport perceval as pcvl\nfrom perceval.backends import SLOSBackend, NaiveBackend\nfrom perceval.simulators import Stepper\nfrom perceval.components import BS, PS\nfrom perceval.utils import BasicState\n\n# definition of the circuit\nC = pcvl.Circuit(2)\nC.add((0, 1), BS())\nC.add(1, PS(1))\nC.add((0, 1), BS())\n\nN = 100\n\n\ndef get_sample_from_statevector(sv):\n p = random.random()\n state = None\n for state, pa in sv:\n proba = abs(pa)**2\n if p > proba:\n p -= proba\n continue\n break\n return state\n\n\ndef run_stepper():\n samples = []\n stepper = Stepper(SLOSBackend())\n stepper.set_circuit(C)\n for i in range(N):\n sv = pcvl.StateVector(pcvl.BasicState([1, 0]))\n for r, c in C:\n sv = stepper.apply(sv, r, c)\n samples.append(get_sample_from_statevector(sv))\n return samples\n\n\ndef run_direct():\n bs = C._components[0][1]\n sim_bs = NaiveBackend()\n sim_bs.set_circuit(bs)\n ps = C._components[1][1]\n sim_ps = NaiveBackend()\n sim_ps.set_circuit(ps)\n samples = []\n bs10 = BasicState([1,0])\n bs01 = BasicState([0,1])\n for i in range(N):\n # apply first bs\n sim_bs.set_input_state(bs10)\n sv_a0 = sim_bs.prob_amplitude(bs10)\n sv_a1 = sim_bs.prob_amplitude(bs01)\n # apply ps\n sv_b0 = sv_a0\n sim_ps.set_input_state(BasicState([1]))\n sv_b1 = sv_a1*sim_ps.prob_amplitude(BasicState([1]))\n # apply second bs\n sv_c0 = sv_b0*sim_bs.prob_amplitude(bs10)\n sv_c1 = sv_b0*sim_bs.prob_amplitude(bs01)\n sim_bs.set_input_state(bs01)\n sv_c0 += sv_b1*sim_bs.prob_amplitude(bs10)\n sv_c1 += sv_b1*sim_bs.prob_amplitude(bs01)\n # sampling from there\n samples.append(bs10 if random.random() > abs(sv_c0)**2 else bs01)\n return samples\n\n\ndef test_stepper(benchmark):\n benchmark(run_stepper)\n\n\ndef test_stepper_comp_direct(benchmark):\n benchmark(run_direct)\n"
},
{
"path": "conftest.py",
"content": "import pytest\n\n\ndef pytest_addoption(parser):\n parser.addoption(\"--skip-long-test\", action=\"store_true\",\n help=\"do not run long tests\")\n parser.addoption(\"--save_figs\", action=\"store_true\",\n help=\"use to generate new test figures\")\n\n\ndef pytest_runtest_setup(item):\n if 'long_test' in item.keywords and item.config.getoption(\"--skip-long-test\"):\n pytest.skip(\"ignored per user request\")\n"
},
{
"path": "docs/Makefile",
"content": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line, and also\n# from the environment for the first two.\nSPHINXOPTS ?=\nSPHINXBUILD ?= sphinx-build\nSOURCEDIR = source\nBUILDDIR = build\n\n# Put it first so that \"make\" without argument is like \"make help\".\nhelp:\n\t@$(SPHINXBUILD) -M help \"$(SOURCEDIR)\" \"$(BUILDDIR)\" $(SPHINXOPTS) $(O)\n\n.PHONY: help Makefile\n\n# Catch-all target: route all unknown targets to Sphinx using the new\n# \"make mode\" option. $(O) is meant as a shortcut for $(SPHINXOPTS).\n%: Makefile\n\t@$(SPHINXBUILD) -M $@ \"$(SOURCEDIR)\" \"$(BUILDDIR)\" $(SPHINXOPTS) $(O)\n\nmultiversion:\n\tpython -m sphinx_multiversion -f multiversion_config source build/html\n\nclean:\n\trm -rf build\n\n.PHONY: clean\n"
},
{
"path": "docs/make.bat",
"content": "@ECHO OFF\r\n\r\npushd %~dp0\r\n\r\nREM Command file for Sphinx documentation\r\n\r\nif \"%SPHINXBUILD%\" == \"\" (\r\n\tset SPHINXBUILD=sphinx-build\r\n)\r\nset SOURCEDIR=source\r\nset BUILDDIR=build\r\n\r\nif \"%1\" == \"\" goto help\r\n\r\n%SPHINXBUILD% >NUL 2>NUL\r\nif errorlevel 9009 (\r\n\techo.\r\n\techo.The 'sphinx-build' command was not found. Make sure you have Sphinx\r\n\techo.installed, then set the SPHINXBUILD environment variable to point\r\n\techo.to the full path of the 'sphinx-build' executable. Alternatively you\r\n\techo.may add the Sphinx directory to PATH.\r\n\techo.\r\n\techo.If you don't have Sphinx installed, grab it from\r\n\techo.https://www.sphinx-doc.org/\r\n\texit /b 1\r\n)\r\n\r\n%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%\r\ngoto end\r\n\r\n:help\r\n%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%\r\n\r\n:end\r\npopd\r\n"
},
{
"path": "docs/multiversion_config/conf.py",
"content": "# MIT License\n#\n# Copyright (c) 2022 Quandela\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# As a special exception, the copyright holders of exqalibur library give you\n# permission to combine exqalibur with code included in the standard release of\n# Perceval under the MIT license (or modified versions of such code). You may\n# copy and distribute such a combined system following the terms of the MIT\n# license for both exqalibur and Perceval. This exception for the usage of\n# exqalibur is limited to the python bindings used by Perceval.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\n# Configuration file for the Sphinx documentation builder.\n#\n# This file only contains a selection of the most common options. For a full\n# list see the documentation:\n# https://www.sphinx-doc.org/en/master/usage/configuration.html\n\n# -- Path setup --------------------------------------------------------------\n\n# If extensions (or modules to document with autodoc) are in another directory,\n# add these directories to sys.path here. If the directory is relative to the\n# documentation root, use os.path.abspath to make it absolute, like shown here.\n#\nimport os\nimport sys\nimport re\nfrom pathlib import Path\nfrom git import Repo\n\nfrom perceval.utils.versions.version_utils import keep_latest_versions\n\nsys.path.insert(0, os.path.relpath(\"../\"))\n\nREPO_PATH = Path(__file__).parent.parent.parent.resolve()\n\nrepo = Repo(REPO_PATH)\ntags = [tag.name for tag in repo.tags]\nversions = keep_latest_versions(tags, \"v0.6\")\nversions_string = \"|\".join([f\"({one_version})\" for one_version in versions])\nversions_regex = re.compile(f\"^{versions_string}$\")\n\nprint(f\"Building {versions_regex}\")\n\n# Whitelist pattern for tags (set to None to ignore all tags)\nsmv_tag_whitelist = versions_regex\n\n# Whitelist pattern for branches (set to None to ignore all branches)\nsmv_branch_whitelist = None\n\n# Whitelist pattern for remotes (set to None to use local branches only)\nsmv_remote_whitelist = None\n\n# Pattern for released versions\nsmv_released_pattern = r\".*\"\n\nsmv_regex_name = r\"(.*)\\..*\"\n"
},
{
"path": "docs/requirements.txt",
"content": "wheel\nsphinx==6.2.1\nsphinx_rtd_theme\nsphinxcontrib-bibtex\nsphinx_autodoc_typehints\nenum-tools[sphinx]\nnbsphinx\njinja2==3.0.0\nipython\nipykernel\ngitpython\ngit+https://github.com/Quandela/sphinx-multiversion-contrib.git@1.1.1\n"
},
{
"path": "docs/source/_static/css/style.css",
"content": "@import url(\"theme.css\");\n\n.wy-nav-content {\n max-width: 1200px !important;\n}\n"
},
{
"path": "docs/source/_templates/layout.html",
"content": "{% extends \"!layout.html\" %}\n\n{% block extrahead %}\n{{ super() }}\n\n\n\n{% endblock %}\n\n{% block extrabody %}\n\n\n\n{{ super() }}\n{% endblock %}\n"
},
{
"path": "docs/source/_templates/page.html",
"content": "{% extends \"!page.html\" %} {% block body %} {% if current_version and\nlatest_version and current_version != latest_version %}\n\n \n You're reading the documentation of the\n {{current_version.name}}. For the latest released version,\n please have a look at\n {{latest_version.name}}.\n \n
\n{% endif %} {{ super() }} {% endblock %}%\n" }, { "path": "docs/source/_templates/versions.html", "content": "{%- if current_version %}\n| state | probability |
|---|---|
| |0,{_:0},{_:0},0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> | 0.731684 |
| |0,0,{_:0},0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> | 0.0855385 |
| |0,{_:0},0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> | 0.0855385 |
| |0,{_:0}{_:2},{_:0},0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> | 0.0381629 |
| |0,{_:0},{_:0}{_:4},0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> | 0.0381629 |
| |0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> | 0.01 |
| |0,0,{_:0}{_:4},0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> | 0.0044615 |
| |0,{_:0}{_:2},0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> | 0.0044615 |
| |0,{_:0}{_:2},{_:0}{_:4},0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0> | 0.0019905 |
| state | probability |
|---|---|
| |0,0,0,0,0,0,1,1,1,0> | 0.027285 |
| |0,0,0,0,0,1,1,1,0,0> | 0.026835 |
| |0,1,0,0,0,0,1,0,1,0> | 0.025997 |
| |0,1,0,0,0,0,1,1,0,0> | 0.024874 |
| |0,1,0,1,0,0,0,0,1,0> | 0.023755 |
| |0,1,0,0,0,0,0,1,1,0> | 0.023057 |
| |0,0,0,1,0,0,1,1,0,0> | 0.022692 |
| |0,0,1,0,0,0,1,1,0,0> | 0.022161 |
| |0,1,0,1,0,0,1,0,0,0> | 0.021077 |
| |0,1,0,0,1,0,0,0,1,0> | 0.020601 |
All circuits and components can be displayed with `pcvl.pdisplay`
\\n\",\n \"A *LO circuit* (just called \\\"circuit\\\" here) isn't the same as a\\n\",\n \"*quantum circuit*. Quantum circuits act on *qubits*, i.e. abstract systems in a 2-dimensional\\n\",\n \"Hilbert space (or \\\"computational space\\\"); while optical circuits act on *photons*\\n\",\n \"distributed in spatial modes (in the \\\"Fock space\\\"). It is possible to simply encode\\n\",\n \"qubits with photons in an optical circuit; some encodings are\\n\",\n \"presented in a later tutorial.
|  | \\n\",\n \" | \\n\",\n \"
\\n\",\n \"Even if it is a good example to show how to decompose an arbitrary unitary matrix to a generic interferometer using Perceval, it is also possible to compute results without doing so. As the decomposition step is quite time-consuming, it's often better to skip this step when you're not sure if you require it.
| Layer description | Local simulations | Remote computations |
|---|---|---|
| \\n\",\n \"The **processor** layer is the high level interface designed as Perceval entry point to describe and run linear optics experiments.\\n\",\n \"It supports the optical hardware capabilities available in actual single photons-based QPU. As such, only sampling and measurements are available\\n\",\n \"and not probability amplitudes or state evolutions.\\n\",\n \"\\n\",\n \"Processors are meant to be used by *quantum algorithm classes* that would use them once or multiple times to achieve a goal. The simplest use\\n\",\n \"is to perform sampling in the **Sampler** class. \\n\",\n \"This layer is designed so that a user doesn't have to change all their code to swap from a local to a remote computation.\\n\",\n \" | \\n\",\n \"\\n\",\n \"**Processor** is the go-to class for a simulation directly on the user machine. It can simulate any unitary circuit, a small set of non-unitary components\\n\",\n \"(TimeDelay, LossChannel) and feed-forward. It simulates real life noise.\\n\",\n \"\\n\",\n \"It is aimed at being usable by a Perceval *beginner*, up to an expert.\\n\",\n \" | \\n\",\n \"\\n\",\n \"**RemoteProcessor** uses the same syntax to create linear optics experiments. It then connects to a Quandela compatible Cloud provider.\\n\",\n \"\\n\",\n \"It targets a computation *platform* which can be a remote simulator or an actual QPU. Available features are defined on a per-platform basis (e.g. a remote\\n\",\n \"simulator based on a strong simulation algorithm can output exact probabilities, whereas a QPU can only acquire samples).\\n\",\n \" |
| \\n\",\n \"On the receiving end of the experiment, a system has to compute results in order to send them back to the user. The **computation** layer is very diverse as it\\n\",\n \"can be a raw \\\"perfect\\\" back-end, the implementation of an algorithm simulating a real life setup, or even an actual QPU.\\n\",\n \" | \\n\",\n \"\\n\",\n \"**Simulator classes** are the Swiss army knife of the local simulation algorithms. They are the most versatile, and as such, the harder to use. They target *advanced*\\n\",\n \"users.\\n\",\n \"\\n\",\n \"They can simulate a large variety of noise, any type of input (noisy, superposed, mixed, etc.) and can compute a sampling as well as a state evolution (using strong simulation).\\n\",\n \"\\n\",\n \"They are built as an onion, where different **Simulator** layers can handle a particular non-unitary problem so that it can be extended by *expert* developers writing\\n\",\n \"their own simulator class.\\n\",\n \" | \\n\",\n \"\\n\",\n \"Cloud **platforms** (simulator or actual QPU) embody this layer to produce results.\\n\",\n \" |
| \\n\",\n \"The back-end is the low level method to compute data.\\n\",\n \" | \\n\",\n \"\\n\",\n \"Locally, **Backend classes** are state-of-the-art implementations of published algorithms able to simulate perfect results,\\n\",\n \"from a perfect input state in a purely unitary linear optics circuit.\\n\",\n \"\\n\",\n \"These are optimised algorithms, which can definitely be used by a Perceval *beginner* as long as they only require perfect simulations.\\n\",\n \" | \\n\",\n \"\\n\",\n \"Cloud QPU use their hardware to acquire data.\\n\",\n \"\\n\",\n \"Cloud simulators rely on algorithms that are specifically optimized for a given classical hardware (multithreaded, GPU, etc.).\\n\",\n \" |
| state | probability |
|---|---|
| |2,0> | 1/2 |
| |0,2> | 1/2 |
| state | probability |
|---|---|
| |2,0,0> | 0.466531 |
| |0,2,0> | 0.455058 |
| |0,1,1> | 0.045284 |
| |1,0,1> | 0.031179 |
| |1,1,0> | 0.001716 |
| |0,0,2> | 0.000232062 |
| states |
|---|
| |0,2> |
| |0,2> |
| |0,2> |
| |0,2> |
| |2,0> |
| |0,2> |
| |0,2> |
| |2,0> |
| |2,0> |
| |2,0> |
| state | count |
|---|---|
| |0,2> | 511 |
| |2,0> | 489 |
| state | count |
|---|---|
| |0,2,0> | 468 |
| |2,0,0> | 449 |
| |0,1,1> | 57 |
| |1,0,1> | 25 |
| |1,1,0> | 1 |
\\n\",\n \"$\\\\left|G\\\\right\\\\rangle = \\\\prod_{(a,b)\\\\in E} CZ^{\\\\{a,b\\\\}} \\\\left|+\\\\right\\\\rangle^{\\\\otimes V}$\\n\",\n \"
\\n\",\n \"\\n\",\n \"where $|+\\\\rangle = \\\\frac{|0\\\\rangle + |1\\\\rangle}{\\\\sqrt2}$ and $CZ^{\\\\{a,b\\\\}}$ is the controlled-Z interaction between the two vertices (corresponding to two qubits) $a$ and $b$. The operators order in the product doesn't matter since CZ gates commute between themselves. We can write the CZ gate with the following matrix :\\n\",\n \"\\n\",\n \"$CZ = \\\\begin{bmatrix}\\n\",\n \"1 & 0 & 0 & 0 \\\\\\\\\\n\",\n \"0 & 1 & 0 & 0 \\\\\\\\\\n\",\n \"0 & 0 & 1 & 0 \\\\\\\\\\n\",\n \"0 & 0 & 0 & -1 \\\\\\\\\\n\",\n \"\\\\end{bmatrix}$\\n\",\n \"
\\n\",\n \"\\n\",\n \"| state | probability |
|---|---|
| |1,0,1,1,1,0,0,0> | 0.018002 |
| |0,0,0,1,2,1,0,0> | 0.015395 |
| |0,0,0,0,0,0,4,0> | 0.015104 |
| |0,0,0,0,1,3,0,0> | 0.015061 |
| |1,1,0,0,2,0,0,0> | 0.014839 |
| |1,0,0,1,0,0,0,2> | 0.013904 |
| |0,0,0,0,1,2,0,1> | 0.011317 |
| |0,1,0,1,0,0,2,0> | 0.011303 |
| |1,0,0,0,0,1,2,0> | 0.011015 |
| |1,2,0,0,0,1,0,0> | 0.010701 |
| state | probability |
|---|---|
| |0,0,0,0,1,2> | 0.078508 |
| |0,0,0,0,0,3> | 0.053524 |
| |2,1,0,0,0,0> | 0.051962 |
| |0,0,0,0,2,1> | 0.042042 |
| |3,0,0,0,0,0> | 0.036251 |
| |0,0,1,1,0,1> | 0.033647 |
| |1,0,1,0,1,0> | 0.032665 |
| |1,1,0,0,0,1> | 0.032312 |
| |1,2,0,0,0,0> | 0.028953 |
| |2,0,0,0,1,0> | 0.028039 |
| |0,1,2,0,0,0> | 0.027845 |
| |0,1,1,1,0,0> | 0.026747 |
| |0,0,1,0,2,0> | 0.02671 |
| |0,0,0,0,3,0> | 0.026532 |
| |1,0,1,0,0,1> | 0.026327 |
| |1,0,0,1,1,0> | 0.024339 |
| |0,0,2,1,0,0> | 0.023886 |
| |1,0,0,0,0,2> | 0.023375 |
| |1,1,0,1,0,0> | 0.021942 |
| |1,0,0,1,0,1> | 0.021592 |
| state | probability |
|---|---|
| |0,0,0,0,1,2> | 0.078508 |
| |0,0,0,0,0,3> | 0.053524 |
| |2,1,0,0,0,0> | 0.051962 |
| |0,0,0,0,2,1> | 0.042042 |
| |3,0,0,0,0,0> | 0.036251 |
| |0,0,1,1,0,1> | 0.033647 |
| |1,0,1,0,1,0> | 0.032665 |
| |1,1,0,0,0,1> | 0.032312 |
| |1,2,0,0,0,0> | 0.028953 |
| |2,0,0,0,1,0> | 0.028039 |
| |0,1,2,0,0,0> | 0.027845 |
| |0,1,1,1,0,0> | 0.026747 |
| |0,0,1,0,2,0> | 0.02671 |
| |0,0,0,0,3,0> | 0.026532 |
| |1,0,1,0,0,1> | 0.026327 |
| |1,0,0,1,1,0> | 0.024339 |
| |0,0,2,1,0,0> | 0.023886 |
| |1,0,0,0,0,2> | 0.023375 |
| |1,1,0,1,0,0> | 0.021942 |
| |1,0,0,1,0,1> | 0.021592 |
\\n\",\n \"If you need to use multiple authentication information within the same script, you will have to enter the token value for each RemoteProcessor, as shown in the updated Hello World.
| state | count |
|---|---|
| |1,0> | 95051 |
| |0,1> | 94441 |
| |1,1> | 5465 |
| |0,2> | 2551 |
| |2,0> | 2484 |
| |2,1> | 5 |
| |1,2> | 3 |
| state | count |
|---|---|
| |0,1> | 97117 |
| |1,0> | 96864 |
| |1,1> | 3234 |
| |0,2> | 1395 |
| |2,0> | 1388 |
| |1,2> | 2 |
| |0010> | |1110> | |0001> | |1101> | |
|---|---|---|---|---|
| |0001> | 1/4 | 1/4 | 1/4 | 1/4 |
| state | probability |
|---|---|
| |1,0> | 1/4 |
| |0,1> | 1/4 |
| |0,0> | 1/4 |
| |2,0> | 1/8 |
| |0,2> | 1/8 |
| state | probability |
|---|---|
| |0,0> | 0.532246 |
| |0,1> | 0.197039 |
| |1,0> | 0.197039 |
| |2,0> | 0.036545 |
| |0,2> | 0.036545 |
| |1,1> | 0.000388059 |
| |3,0> | 4.94304e-05 |
| |0,3> | 4.94304e-05 |
| |2,1> | 4.94304e-05 |
| |1,2> | 4.94304e-05 |
| state | probability |
|---|---|
| |0,0> | 0.532247 |
| |1,0> | 0.197038 |
| |0,1> | 0.197038 |
| |0,2> | 0.036545 |
| |2,0> | 0.036545 |
| |1,1> | 0.000388116 |
| |0,3> | 4.94378e-05 |
| |3,0> | 4.94378e-05 |
| |1,2> | 4.94378e-05 |
| |2,1> | 4.94378e-05 |
| |2,2> | 0 |
| |0,4> | 0 |
| |4,0> | 0 |
| state | probability |
|---|---|
| |0,0> | 0.280276 |
| |0,1> | 0.249513 |
| |1,0> | 0.248671 |
| |0,2> | 0.114143 |
| |2,0> | 0.107397 |
| state | probability |
|---|---|
| |0,0> | 0.532246 |
| |0,1> | 0.197039 |
| |1,0> | 0.197039 |
| |2,0> | 0.036545 |
| |0,2> | 0.036545 |
| |1,1> | 0.000388059 |
| |3,0> | 4.94304e-05 |
| |0,3> | 4.94304e-05 |
| |2,1> | 4.94304e-05 |
| |1,2> | 4.94304e-05 |
| state | probability |
|---|---|
| |0> | 0.694948 |
| |1> | 0.257271 |
| |2> | 0.047717 |
| |3> | 6.45407e-05 |
| state | probability |
|---|---|
| |0> | 0.694948 |
| |1> | 0.257271 |
| |2> | 0.047717 |
| |3> | 6.45407e-05 |
\\n\",\n \"Modes are using [0-based numbering](https://en.wikipedia.org/wiki/Zero-based_numbering) - so mode 0 is\\n\",\n \"corresponding to the first one, and mode $(m-1)$ is corresponding to the $m$-th.
![\\\"Quantum](\\\"../_static/img/quantum_walk_pretty.png\\\")
\"\r\n ]\r\n },\r\n {\r\n \"cell_type\": \"code\",\r\n \"execution_count\": 2,\r\n \"metadata\": {},\r\n \"outputs\": [\r\n {\r\n \"data\": {\r\n \"image/svg+xml\": [\r\n \"\\n\",\r\n \"\"\r\n ],\r\n \"text/plain\": [\r\n \"| 00 | 01 | 10 | 11 | |
|---|---|---|---|---|
| 00 | 1 | 0 | 0 | 0 |
| 01 | 0 | 1 | 0 | 0 |
| 10 | 0 | 0 | 0 | 1 |
| 11 | 0 | 0 | 1 | 0 |
| state | probability |
|---|---|
| |0,0,0,0,0,0> | 9/25 |
| |{0},0,0,0,0,0> | 0.2395 |
| |0,0,{0},0,0,0> | 0.2395 |
| |{0},0,{0},0,0,0> | 0.1594 |
| |0,0,{0}{4},0,0,0> | 4.8193e-4 |
| |{0}{2},0,0,0,0,0> | 4.8193e-4 |
| |{0},0,{0}{4},0,0,0> | 3.2064e-4 |
| |{0}{2},0,{0},0,0,0> | 3.2064e-4 |
| |{0}{2},0,{0}{4},0,0,0> | 0 |
| state | probability |
|---|---|
| |0,1,0,1> | 0.495518 |
| |1,0,1,0> | 0.495518 |
| |0,1,1,0> | 0.00747 |
| |1,0,0,1> | 0.001494 |