{ "cells": [ { "cell_type": "markdown", "id": "345cdcd4fc84356", "metadata": {}, "source": [ "# Local Computing" ] }, { "cell_type": "markdown", "id": "6ba3240f621f8ae4", "metadata": {}, "source": [ "This tutorial shows how to simulate a quantum experiment with Perceval running locally, on the user computer.\n", "\n", "Up to this point, we have focused on creating circuits.\n", "It's time to learn how to sample from them or describe their output distribution, from one or many different input states." ] }, { "cell_type": "markdown", "id": "5f1aced257345540", "metadata": {}, "source": [ "## I. Different layers of simulation\n", "\n", "Perceval computation classes are organised in three different layers, each having a specific role and set of features:\n", "\n", "A **Processor** relies on a **Simulator** which uses a **Backend** in order to compute results.\n", "\n", "Let's describe the intent behind each layer.\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
Layer descriptionLocal simulationsRemote computations
\n", "The **processor** layer is the high level interface designed as Perceval entry point to describe and run linear optics experiments.\n", "It supports the optical hardware capabilities available in actual single photons-based QPU. As such, only sampling and measurements are available\n", "and not probability amplitudes or state evolutions.\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", "is to perform sampling in the **Sampler** class.
\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", "**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", "(TimeDelay, LossChannel) and feed-forward. It simulates real life noise.\n", "\n", "It is aimed at being usable by a Perceval *beginner*, up to an expert.\n", "\n", "**RemoteProcessor** uses the same syntax to create linear optics experiments. It then connects to a Quandela compatible Cloud provider.\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", "simulator based on a strong simulation algorithm can output exact probabilities, whereas a QPU can only acquire samples).\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", "can be a raw \"perfect\" back-end, the implementation of an algorithm simulating a real life setup, or even an actual QPU.\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", "users.\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", "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", "their own simulator class.\n", "\n", "Cloud **platforms** (simulator or actual QPU) embody this layer to produce results.\n", "
\n", "The back-end is the low level method to compute data.\n", "\n", "Locally, **Backend classes** are state-of-the-art implementations of published algorithms able to simulate perfect results,\n", "from a perfect input state in a purely unitary linear optics circuit.\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", "Cloud QPU use their hardware to acquire data.\n", "\n", "Cloud simulators rely on algorithms that are specifically optimized for a given classical hardware (multithreaded, GPU, etc.).\n", "
\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "1305dd0510f1fecb", "metadata": {}, "outputs": [], "source": [ "import perceval as pcvl\n", "from perceval import BS, BasicState, Circuit, Processor\n", "from perceval.algorithm import Sampler" ] }, { "cell_type": "markdown", "id": "3846837bc2c71ee2", "metadata": {}, "source": [ "## II. Computing probabilities\n", "\n", "For this part, we will take the [Hong-Ou-Mandel](https://en.wikipedia.org/wiki/Hong%E2%80%93Ou%E2%80%93Mandel_effect) experience as an example.\n", "\n", "It's one of the simplest experiments and yet it is very useful.\n", "\n", "Making two indistinguishable photons, one in each mode, enter one balanced beamsplitter $BS=\\frac{1}{\\sqrt{2}} \\left[\\begin{matrix}1 & 1\\\\1& -1\\end{matrix}\\right]$, we expect the outcome to be:\n", "\n", "$$|1,1\\rangle \\mapsto \\frac{|2,0\\rangle - |0,2\\rangle}{\\sqrt{2}} $$\n", "\n", "We will show how to verify this in the next steps using the Naive backend to recover the full probability distribution." ] }, { "cell_type": "code", "execution_count": 2, "id": "initial_id", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\\\\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}\\end{matrix}\\right]$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Such a circuit can be created as follows\n", "circuit = BS.H()\n", "pcvl.pdisplay(circuit.compute_unitary())" ] }, { "cell_type": "code", "execution_count": 3, "id": "7febc504ba84b0d7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Amplitude of |1,1> giving |2,0> through H = (0.7071067811865477+0j)\n", "Amplitude of |1,1> giving |0,2> through H = (-0.7071067811865477+0j)\n", "Probability of |1,1> giving |0,2> through H = 0.5000000000000002\n" ] } ], "source": [ "# Let's compute the amplitudes in a perfect simulation (no noise) allowing us to use the low level SLOS back-end\n", "backend = pcvl.BackendFactory.get_backend(\"SLOS\")\n", "backend.set_circuit(circuit)\n", "backend.set_input_state(BasicState([1, 1])) # Only FockStates are accepted here\n", "print(\"Amplitude of |1,1> giving |2,0> through H =\", backend.prob_amplitude(BasicState([2, 0]))) # note that it's the amplitude !\n", "print(\"Amplitude of |1,1> giving |0,2> through H =\", backend.prob_amplitude(BasicState([0, 2])))\n", "print(\"Probability of |1,1> giving |0,2> through H =\", backend.probability(BasicState([0, 2])))" ] }, { "cell_type": "markdown", "id": "7465458dc2e8d4dd", "metadata": {}, "source": [ "The same simulation can also be achieved through a `Processor` using the `Sampler` algorithm to compute a table of probabilities\n", "A Processor consists of a simulation backend and a circuit (or an experiment). Even though the `Processor` is able to simulate noise, the default is to run\n", "perfect simulations." ] }, { "cell_type": "code", "execution_count": 4, "id": "7cb540128520e808", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
state probability
|2,0> 1/2
|0,2> 1/2
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "p = Processor(\"SLOS\", circuit)\n", "p.with_input(BasicState([1, 1]))\n", "sampler = Sampler(p)\n", "# The result of an algorithm, such as the Sampler, is a Python dictionary containing at least a \"results\" key.\n", "# Other fields will be explained later in the tutorial.\n", "pcvl.pdisplay(sampler.probs()[\"results\"])" ] }, { "cell_type": "code", "execution_count": 5, "id": "5b27c78ea7bc5f64", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
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
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Exercise: Create a random 3x3 unitary, and output the table probabilities when the input |1,1,0> passes through the LO-Circuit it represents.\n", "\n", "## Solution:\n", "random_unitary = pcvl.Unitary(pcvl.Matrix.random_unitary(3))\n", "input_state = BasicState([1, 1, 0])\n", "\n", "p = Processor(\"SLOS\", random_unitary)\n", "p.with_input(input_state)\n", "sampler = Sampler(p)\n", "pcvl.pdisplay(sampler.probs()[\"results\"])" ] }, { "cell_type": "markdown", "id": "5fd7e9c4ee649485", "metadata": {}, "source": [ "## III. Sampling\n", "\n", "Although it's sometimes crucial to compute the output distribution, it's not what we can expect from a photonic chip. Indeed, realistically, we only can obtain a single sample from the distribution each time we run the circuit. From any strong simulation result, sampling data can be extrapolated. However, specialised sampling algorithms, such as Clifford & Clifford 2017, are more optimised computing samples on bigger systems rather than \"solving the whole quantum system\" as strong simulation would.\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "cbc17e6567dc41cb", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
states
|0,2>
|0,2>
|0,2>
|0,2>
|2,0>
|0,2>
|0,2>
|2,0>
|2,0>
|2,0>
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# As before, the low level back-end can be used directly\n", "sampling_backend = pcvl.Clifford2017Backend()\n", "sampling_backend.set_circuit(circuit)\n", "sampling_backend.set_input_state(BasicState([1, 1]))\n", "pcvl.pdisplay(sampling_backend.samples(10))" ] }, { "cell_type": "code", "execution_count": 7, "id": "354a78972a0a92c", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
state count
|0,2> 511
|2,0> 489
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "p = Processor(\"CliffordClifford2017\", circuit)\n", "p.min_detected_photons_filter(0) # Do not filter out any output state\n", "# A Processor input can be FockState, NoisyFockState, LogicalState (if ports are defined), StateVector, or SVDistribution\n", "p.with_input(pcvl.BasicState([1, 1]))\n", "\n", "# The sampler holds 'probs', 'sample_count' and 'samples' calls. You can use the one that fits your needs!\n", "sampler = Sampler(p)\n", "\n", "# A sampler call will return a Python dictionary containing sampling results, and a performance score\n", "sample_count = sampler.sample_count(1000)\n", "# sample_count contains {'results': , 'global_perf': float [0.0 - 1.0]}\n", "pcvl.pdisplay(sample_count['results'])\n", "# Only FockStates (they are the result of a measure on detectors)" ] }, { "cell_type": "code", "execution_count": 8, "id": "b41cf47239178fcc", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
state count
|0,2,0> 468
|2,0,0> 449
|0,1,1> 57
|1,0,1> 25
|1,1,0> 1
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Exercise: Implement the code to compute 1000 samples from the 3x3 Unitary we used earlier\n", "\n", "#Solution:\n", "p = pcvl.Processor(\"CliffordClifford2017\", random_unitary)\n", "p.min_detected_photons_filter(0) # Do not filter out any output state\n", "p.with_input(pcvl.BasicState([1, 1, 0]))\n", "\n", "sampler = pcvl.algorithm.Sampler(p)\n", "sample_count = sampler.sample_count(1000)\n", "pcvl.pdisplay(sample_count['results'])\n", "\n", "## Question: How many states do we have for 3 modes and 2 photons?\n", "## Answer: There are 6 different states\n", "\n", "\n", "## Question: How many states do we have for m modes and n photons?\n", "## Answer: There are m+n-1 choose n different states (cf Bar and Star problems)." ] }, { "cell_type": "markdown", "id": "9e646b8343e3005a", "metadata": {}, "source": [ "Note : to approximate with decent precision a distribution over $M$ different states, we would need $M^2$ samples. This can be shown by [Hoeffding's inequality](https://en.wikipedia.org/wiki/Hoeffding%27s_inequality)." ] }, { "cell_type": "markdown", "id": "b111e68673d71981", "metadata": {}, "source": [ "## IV. Performance and output state filtering\n", "\n", "Perceval Processors have a built-in way of computing performance scores.\n", "\n", "There are three different performance scores:\n", "* Global performance\n", "* Physical performance\n", "* Logical performance\n", "\n", "These performance scores help measure the real duration of a data acquisition on a real QPU.\n", "\n", "The global performance, which is the product of both physical and logical performances, is always returned.\n", "The physical and logical performances can be returned by setting:\n", "> proc.compute_physical_logical_perf(True)\n", "\n", "Leaving this parameter as default can speed up the computation is some situations.\n", "\n", "#### a. Physical performance\n", "\n", "This score is related to the number of detections (on a QPU: number of clicks). It drops output states where photons have been lost, or finish in the same mode.\n", "\n", "For instance, an imperfect source makes this score drop.\n", "\n", "However, you can choose not to filter any output state by lowering the expected clicks with:\n", "> proc.min_detected_photons_filter(0)\n", "\n", "##### Processor.min_detected_photons_filter method\n", "\n", "Perceval aims at being an interface for the QPU and as such, proc.min_detected_photons_filter(int k) post selects on having at least k photons detected (for threshold detection: photons on at least k different modes). By default, this value is set to n where n is the expected number of input photons. This is useful for retrieving a logical interpretation, making sure that no photon has been lost due to noise and coherent with the use of threshold detectors. However, for various applications (for instance machine learning where we use the full Fock space and resolve the number of photons), you will have to set it to 0 (and you may introduce you own post selection scheme if needed)." ] }, { "cell_type": "code", "execution_count": 9, "id": "5e5161b2728d6fa8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Physical perf of perfect processor = 1.0\n", "Physical perf of imperfect processor = 0.09\n", "Physical perf of imperfect processor (without selection) = 0.9999999999999999\n" ] } ], "source": [ "# Create an empty circuit (each input mode is directly connected to a detector without interacting with any other)\n", "empty_circuit = Circuit(4)\n", "\n", "perfect_proc = Processor(\"SLOS\", empty_circuit)\n", "imperfect_proc = Processor(\"SLOS\", empty_circuit, noise=pcvl.NoiseModel(brightness=0.3))\n", "\n", "# We need to specify how many photons we want\n", "perfect_proc.min_detected_photons_filter(2)\n", "imperfect_proc.min_detected_photons_filter(2)\n", "\n", "# Set the same input in both processors\n", "input_state = BasicState([1, 0, 1, 0])\n", "perfect_proc.with_input(input_state)\n", "imperfect_proc.with_input(input_state)\n", "\n", "# Enable the computation of physical performance\n", "perfect_proc.compute_physical_logical_perf(True)\n", "imperfect_proc.compute_physical_logical_perf(True)\n", "\n", "perfect_sampler = Sampler(perfect_proc)\n", "perfect_probs = perfect_sampler.probs()\n", "imperfect_sampler = Sampler(imperfect_proc)\n", "imperfect_probs = imperfect_sampler.probs()\n", "\n", "print('Physical perf of perfect processor =', perfect_probs['physical_perf'])\n", "print('Physical perf of imperfect processor =', imperfect_probs['physical_perf']) # source emission probability**2\n", "\n", "# You can still disable output state filtering\n", "imperfect_proc.min_detected_photons_filter(0)\n", "imperfect_probs = imperfect_sampler.probs()\n", "print('Physical perf of imperfect processor (without selection) =', imperfect_probs['physical_perf'])" ] }, { "cell_type": "markdown", "id": "37976ce3a22f13c1", "metadata": {}, "source": [ "#### b. Logical performance\n", "\n", "This performance computation is set up by heralded modes and/or post-selection function set in a processor.\n", "\n", "Depending on the circuit used, on the post-selection function, you may observe that physical and logical performance score interact. So, if you're interested on a theoretical gate performance, you should disable physical post-selection with:\n", "> proc.min_detected_photons_filter(- sum(proc.heralds.values()))\n", "\n", "Here is a quick example of the heralding / post-selection syntax in Perceval. You will see the result later on in this notebook." ] }, { "cell_type": "code", "execution_count": 10, "id": "9ad20a20b967c7f4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "With herald only\n", "Logical perf = 0.7500000000000003\n", "{\n", "\t|1,0>: 0.02859547920896832\n", "\t|0,1>: 0.9714045207910317\n", "}\n", "With herald + post-selection function\n", "Logical perf = 0.7285533905932741\n", "{\n", "\t|0,1>: 1\n", "}\n" ] } ], "source": [ "circuit = Circuit(3) // BS() // (1, BS()) // BS()\n", "p = Processor(\"SLOS\", circuit)\n", "p.add_herald(2, 0) # Third mode is heralded (0 photon in, 0 photon expected out)\n", "\n", "p.min_detected_photons_filter(1) # Only non-heralded modes must be taken into account in this filter\n", "\n", "# Enable the computation of logical performance\n", "p.compute_physical_logical_perf(True)\n", "\n", "# After a mode is heralded, you must not take it into account when setting an input to the processor\n", "p.with_input(pcvl.BasicState([1, 0]))\n", "sampler = Sampler(p)\n", "probs = sampler.probs()\n", "print(\"With herald only\")\n", "print(\"Logical perf =\", probs['logical_perf'])\n", "print(probs['results'])\n", "\n", "# A post-selection function can be created like this:\n", "postselect_func = pcvl.PostSelect(\"[1] == 1\") # meaning we required 1 photon detection in mode #1\n", "\n", "p.set_postselection(postselect_func) # Add post-selection\n", "probs = sampler.probs()\n", "print(\"With herald + post-selection function\")\n", "print(\"Logical perf =\", probs['logical_perf'])\n", "print(probs['results'])" ] }, { "cell_type": "markdown", "id": "994f2f5f5bfd9479", "metadata": {}, "source": [ "Now that you know the basics of local computing, let's see how to execute jobs remotely using Perceval." ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }