{ "cells": [ { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# Density matrices in Fock space" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "In this notebook we introduce our new feature: __density matrices__ in __fock space__. This space is a mathematical framework to describe the quantum states of a system with variable number of particles, __photons__ in our case. Note that this space is much larger than the computational/logical space. Fock space is native to _Perceval_ and hence these matrices can be indispensable for linear optic computations.\n", "\n", "The difference in the basis is demonstrated in the following example of 1-qubit X gate. In logical space, the basic states of the system will be $|0\\rangle$, and $|1\\rangle$. The linear optical circuit implementation for this gate consists of a 2 mode circuit with the following basic states in the fock space - $|00\\rangle$, $|10\\rangle$, $|01\\rangle$, and, $|11\\rangle$.\n", "\n", "We will demonstrate how to create density matrices in _Perceval_ and the different methods can be applied on them for computation using @ simple examples - Bell State generation and Hong-Ou_Mandel effect.\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import perceval as pcvl\n", "import numpy as np\n", "from perceval.components import BS, Source, Circuit, catalog\n", "from perceval.utils import BasicState, DensityMatrix\n", "from perceval import Simulator\n", "from perceval.backends import SLOSBackend" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "## Generating and Evolving a Bell State density matrix" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ " In _Perceval_, a density matrix is created by simply converting from the corresponding BasicState or StateVector Distribution." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "input_dm = DensityMatrix.from_svd(BasicState([1,0,1,0,0,0]))\n", "pcvl.pdisplay(input_dm)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "The next step in applying the evolution operator is to define the LO circuit corresponding to the operation. Here, it is demonstrated by a Linear Optical circuit consisting of a Hadamard gate and a post-processed CNOT gate used for Bell State generation." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Θ=1.910633\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "Θ=1.910633\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Θ=1.910633\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "H\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "" ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bell_circ = Circuit(m=6)\n", "\n", "bell_circ.add(0, BS.H())\n", "bell_circ.add(0, catalog['postprocessed cnot'].build_circuit(), merge=True)\n", "pcvl.pdisplay(bell_circ)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "To perform the computation on the input density matrix, a simulator is constructed with the circuit and the necessary post-selection function." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Output Density matrix - Bell State\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cnot = catalog['postprocessed cnot'].build_processor() # creating a postprocessed cnot from catalog for the heralding and the post-selection function\n", "\n", "bell_simulator = Simulator(SLOSBackend())\n", "bell_simulator.set_circuit(bell_circ)\n", "bell_simulator.set_selection(heralds=cnot.heralds, postselect=cnot.post_select_fn)\n", "\n", "# Applying the evolution\n", "bell_out_dm = bell_simulator.evolve_density_matrix(input_dm) # apply evolution on the density matrix\n", "print('Output Density matrix - Bell State')\n", "pcvl.pdisplay(bell_out_dm)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This output density matrix corresponds identically to evolving a statevector through the circuit and then converting the output SVD into a density matrix." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The output statevector distribution: sqrt(2)/2*|1,0,1,0,0,0>+sqrt(2)/2*|0,1,0,1,0,0>\n", "The density matrix converted from the output SVD\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "output_svd = bell_simulator.evolve(BasicState([1,0,1,0,0,0]))\n", "print('The output statevector distribution:', output_svd)\n", "\n", "print('The density matrix converted from the output SVD')\n", "pcvl.pdisplay(DensityMatrix.from_svd(output_svd))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "## Investigating the Hong-Ou-Mandel effect using Density Matrix" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "For this we create a simulator with a 2 mode circuit consisting of a beam splitter. The output density matrix demonstrates quantum coherence through the non-zero off-diagonal coefficients." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "output density matrix without any loss\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sim = Simulator(SLOSBackend())\n", "sim.set_circuit(BS.H())\n", "\n", "# generate input density matrix\n", "source = Source() # perfect source\n", "input_density_matrix = DensityMatrix.from_svd(source.generate_distribution(BasicState([1, 1])))\n", "\n", "# evolution of density matrix\n", "output_density_matrix = sim.evolve_density_matrix(input_density_matrix)\n", "print('output density matrix without any loss')\n", "pcvl.pdisplay(output_density_matrix)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Apply a Loss operator on density matrix\n", "\n", "The density matrices allow for application of a loss operator by defining the modes on which photons are lost and the probability of loss. The application of the loss operator and its effect are illustrated below using a simple 2 mode LO circuit with a beam splitter and a noisy source with emission probability of 0.6. Computationally, this is equivalent to a perfect source with a probaility of 0.4 for loosing a photon at each input mode before the circuit.\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "output density matrix with loss\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "input_density_matrix.apply_loss([0, 1], 0.4) # this loss operator is equivalent to 0.6 emission probability from source\n", "\n", "lossy_output_density_matrix = sim.evolve_density_matrix(input_density_matrix) # evolving this lossy density matrix\n", "print('output density matrix with loss')\n", "pcvl.pdisplay(lossy_output_density_matrix)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Computing the expectation value of an operator" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "The expectation value of an operator $\\hat{O}$ over a quantum system represented by a density matrix $\\rho$ is given by the nice formula :\n", "\n", "$$ \\langle\\hat{O}\\rangle = Tr (\\hat{O}\\rho) $$\n", "\n", "In the next cell, we evaluate the expectation value of the number operator $\\hat{N}$ using the previous lossy density matrix generated by evolving through the beamsplitter." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The expectation value obtained (expected, there is a 60% chance of photons passing through the circuit): (1.2000000000000004+0j)\n" ] } ], "source": [ "dm_shape = lossy_output_density_matrix.shape\n", "\n", "# Constructing the number operator\n", "number_operator = np.zeros(dm_shape)\n", "for state, index in lossy_output_density_matrix.index.items():\n", " number_operator[index, index] = state.n\n", "\n", "expectation_value = (number_operator @ lossy_output_density_matrix.mat).trace()\n", "print('The expectation value obtained (expected, there is a 60% chance of photons passing through the circuit):', expectation_value)\n" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "## Performing measurements on density matrix" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "A measurement on density matrix in _Perceval_ is performed by defining the modes to be measured. The process returns a dictionary with the measured states as keys with values - probability of measuring the corresponding state and remaining density matrix. In T=the following cell, measurements on the output density matrix after the beam splitter (above) is demonstrated." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The output density matrix 0.50+0.00j*|2,0><2,0|+-0.50+0.00j*|0,2><2,0|+-0.50+0.00j*|2,0><0,2|+0.50+0.00j*|0,2><0,2|\n", "state measured: |0> with probability 0.5000000000000001 and the remaining density matrix 1.00+0.00j*|2><2|\n", "state measured: |2> with probability 0.5000000000000001 and the remaining density matrix 1.00+0.00j*|0><0|\n" ] } ], "source": [ "print('The output density matrix', output_density_matrix)\n", "\n", "res = output_density_matrix.measure([0]) # performing measurements define the modes to measure\n", "for keys, values in res.items():\n", " measured_state = keys\n", " prob_meas = values[0]\n", " remaining_dm = values[1]\n", " print('state measured:', measured_state, 'with probability', prob_meas, 'and the remaining density matrix', remaining_dm)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "Let's see the difference if this measurement was performed on the lossy case" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The lossy output density matrix 0.16+0.00j*|0,0><0,0|+0.24+0.00j*|1,0><1,0|+0.00+0.00j*|0,1><1,0|+0.00+0.00j*|1,0><0,1|+0.24+0.00j*|0,1><0,1|+0.18+0.00j*|2,0><2,0|+-0.18+0.00j*|0,2><2,0|+-0.18+0.00j*|2,0><0,2|+0.18+0.00j*|0,2><0,2|\n", "state measured: |0> with probability 0.5800000000000002\n", "state measured: |1> with probability 0.24000000000000005\n", "state measured: |2> with probability 0.18000000000000008\n" ] } ], "source": [ "print('The lossy output density matrix', lossy_output_density_matrix)\n", "\n", "lossy_res = lossy_output_density_matrix.measure([0]) # choose modes to measure\n", "for keys, values in lossy_res.items():\n", " print('state measured:', keys, 'with probability', values[0]) # key: measured basic state, values[0]: probability of measuring the state" ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 0 }