Through a simple object-oriented python API, Perceval provides tools for building a circuit with linear optics components,
defining single-photon sources and their error model, manipulating Fock states, running simulations, reproducing published experimental papers results,
and experimenting with a new generation of quantum algorithms.
It is interfaced with the available QPUs on
the [Quandela cloud](https://cloud.quandela.com/webide/), so it is possible to run computations on an
actual photonic computer.
Perceval aims to be a companion tool for developing discrete-variable photonics circuits
- while simulating their design, modelling their ideal and real-life behaviour;
- and proposing a normalized interface to control photonic quantum computers;
- while using powerful simulation backends to get state-of-the-art simulation;
- and also allowing direct access to the QPUs of Quandela.
Perceval has been developed as a complete toolkit for physicists and quantum computational students, researchers and
practitioners.
# Key Features
* Powerful Circuit designer making use of predefined components
* Simple python API and powerful simulation backends optimized in C
* Misc technical utilities to manipulate State Vector, Unitary Matrices, and circuit Parameters
* Transversal tools for visualization compatible with notebooks or local development environments
* Numerical and symbolical computation
* Modular architecture welcoming contributions from the community
# Installation
Perceval requires:
* Python between 3.10 and 3.14
## PIP
We recommend installing it with `pip`:
```bash
pip install --upgrade pip
pip install perceval-quandela
```
Our qiskit, qutip, cqasm or myqlm bridges have been moved to a separate
interoperability package `perceval-interop` (https://perceval.quandela.net/interopdocs/).
## GitHub
```bash
git clone https://github.com/quandela/Perceval
```
then to install Perceval:
```bash
pip install .
```
Or for developers:
```bash
pip install -e .
```
# Running tests and benchmarks
Unit tests files are part of the repository in `tests/` and can be run with:
```
pip install -r tests/requirements.txt
pytest
```
Additionally, you can see a coverage report with the command:
```
pytest --cov=perceval
```
Benchmark tests for computing-intensive functions are in `benchmark/` and can be run with:
```
pytest benchmark/benchmark_*.py
```
Comparison 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.
# Documentation and Forum
* The [documentation](https://perceval.quandela.net/docs)
* The [Community Forum](https://perceval.quandela.net/forum)
#
[
](https://www.quandela.com/)
[](https://twitter.com/Quandela_SAS)
[](https://www.youtube.com/channel/UCl5YMpSqknJ1n-IT-XWfLsQ)
================================================
FILE: benchmark/benchmark-circuit-building.py
================================================
# MIT License
#
# Copyright (c) 2022 Quandela
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# As a special exception, the copyright holders of exqalibur library give you
# permission to combine exqalibur with code included in the standard release of
# Perceval under the MIT license (or modified versions of such code). You may
# copy and distribute such a combined system following the terms of the MIT
# license for both exqalibur and Perceval. This exception for the usage of
# exqalibur is limited to the python bindings used by Perceval.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import perceval as pcvl
from perceval.components.unitary_components import BS, PS, PERM
import random
import time
t_build = 0
t_set = 0
t_compute = 0
t_get = 0
for _ in range(1000):
start = time.time()
#List of the parameters φ1,φ2,...,φ8
List_Parameters = []
# VQE is a 6 optical mode circuit
VQE = pcvl.Circuit(6)
VQE.add((1, 2), BS.H())
VQE.add((3, 4), BS.H())
List_Parameters.append(pcvl.Parameter("φ1"))
VQE.add((2,), PS(phi=List_Parameters[-1]))
List_Parameters.append(pcvl.Parameter("φ3"))
VQE.add((4,), PS(phi=List_Parameters[-1]))
VQE.add((1, 2), BS.H())
VQE.add((3, 4), BS.H())
List_Parameters.append(pcvl.Parameter("φ2"))
VQE.add((2,), PS(phi=List_Parameters[-1]))
List_Parameters.append(pcvl.Parameter("φ4"))
VQE.add((4,), PS(phi=List_Parameters[-1]))
# CNOT ( Post-selected with a success probability of 1/9)
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
VQE.add((3, 4), BS.H())
VQE.add([0,1,2,3,4,5], PERM([0,1,2,3,4,5]))#Identity PERM (permutation) for the same purpose
VQE.add((0, 1), BS.H(theta=BS.r_to_theta(1/3)))
VQE.add((2, 3), BS.H(theta=BS.r_to_theta(1/3)))
VQE.add((4, 5), BS.H(theta=BS.r_to_theta(1/3)))
VQE.add([0,1,2,3,4,5], PERM([0,1,2,3,4,5]))#Identity PERM (permutation) for the same purpose
VQE.add((3, 4), BS.H())
VQE.add([0,1,2,3,4,5], PERM([0,1,2,3,4,5]))#Identity PERM (permutation) for the same purpose
List_Parameters.append(pcvl.Parameter("φ5"))
VQE.add((2,), PS(phi=List_Parameters[-1]))
List_Parameters.append(pcvl.Parameter("φ7"))
VQE.add((4,), PS(phi=List_Parameters[-1]))
VQE.add((1, 2), BS.H())
VQE.add((3, 4), BS.H())
List_Parameters.append(pcvl.Parameter("φ6"))
VQE.add((2,), PS(phi=List_Parameters[-1]))
List_Parameters.append(pcvl.Parameter("φ8"))
VQE.add((4,), PS(phi=List_Parameters[-1]))
VQE.add((1, 2), BS.H())
VQE.add((3, 4), BS.H())
t_build += time.time()-start
start = time.time()
init_param = [random.random() for _ in List_Parameters]
for idx, p in enumerate(List_Parameters):
p.set_value(init_param[idx])
t_set += time.time()-start
start = time.time()
VQE.compute_unitary(use_symbolic = False)
t_compute += time.time()-start
start = time.time()
for i in range(len(List_Parameters)):
init_param[i] = VQE.get_parameters()[i]._value
t_get += time.time()-start
print("TOTAL=", t_build+t_set+t_compute+t_get, "DETAIL=", t_build, t_set, t_compute, t_get)
================================================
FILE: benchmark/benchmark-unitary.py
================================================
# MIT License
#
# Copyright (c) 2022 Quandela
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# As a special exception, the copyright holders of exqalibur library give you
# permission to combine exqalibur with code included in the standard release of
# Perceval under the MIT license (or modified versions of such code). You may
# copy and distribute such a combined system following the terms of the MIT
# license for both exqalibur and Perceval. This exception for the usage of
# exqalibur is limited to the python bindings used by Perceval.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
r"""
This script compares building of unitary when using Circuit or directly by building matrix.
"""
import perceval as pcvl
import perceval.components.unitary_components as comp
import time
import numpy as np
m = 8
def phase_shift(n_mode, theta):
# phase shift in m x m unitary in mode 1 of angle theta
ps_matrix = np.eye(n_mode, dtype=complex)
ps_matrix[0, 0] = np.cos(theta) + 1j * np.sin(theta)
return ps_matrix
u1 = pcvl.Matrix.random_unitary(m)
u2 = pcvl.Matrix.random_unitary(m)
px = pcvl.P("x")
c = comp.Unitary(u2) // (0, comp.PS(px)) // comp.Unitary(u1)
dt_circuit = 0
dt_raw = 0
for _ in range(1000):
top0 = time.time_ns()
px.set_value(1)
c.compute_unitary(use_symbolic=False)
top1 = time.time_ns()
dt_circuit += top1-top0
top0 = time.time_ns()
U = u1 @ phase_shift(m, 1) @ u2
top1 = time.time_ns()
dt_raw += top1-top0
if dt_circuit/dt_raw > 2.5:
print("TOO_SLOW", "circuit", dt_circuit, "raw", dt_raw, "factor", dt_circuit/dt_raw)
else:
print("OK", "circuit", dt_circuit, "raw", dt_raw, "factor", dt_circuit/dt_raw)
================================================
FILE: benchmark/benchmark_QML-DE-solver.py
================================================
# MIT License
#
# Copyright (c) 2022 Quandela
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# As a special exception, the copyright holders of exqalibur library give you
# permission to combine exqalibur with code included in the standard release of
# Perceval under the MIT license (or modified versions of such code). You may
# copy and distribute such a combined system following the terms of the MIT
# license for both exqalibur and Perceval. This exception for the usage of
# exqalibur is limited to the python bindings used by Perceval.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import random
import perceval as pcvl
import perceval.components.unitary_components as comp
import numpy as np
from math import comb
from scipy.optimize import minimize
# Differential equation parameters
lambd = 8
kappa = 0.1
def F(u_prime, u, x): # DE: F(u_prime, u, x) = 0
# Must work with numpy arrays
return (u_prime + lambd * u * (kappa + np.tan(lambd * x)))
# Boundary condition (f(x_0)=f_0)
x_0 = 0
f_0 = 1
# Modeling parameters
n_grid = 50 # number of grid points of the discretized differential equation
range_min = 0 # minimum of the interval on which we wish to approximate our function
range_max = 1 # maximum of the interval on which we wish to approximate our function
X = np.linspace(range_min, range_max, n_grid) # Optimisation grid
# Parameters of the quantum machine learning procedure
eta = 5 # weight granted to the initial condition
a = 200 # Approximate boundaries of the interval that the image of the trial function can cover
N = m = 6
N2 = N ** 2
input_state = pcvl.BasicState([1] * N + [0] * (m - N))
s1 = pcvl.SLOSBackend()
s1.set_circuit(pcvl.Unitary(pcvl.Matrix.random_unitary(m)))
s1.preprocess([input_state])
random.seed(0)
np.random.seed(0)
pcvl.random_seed(0)
fock_dim = comb(N + m - 1, N)
lambda_random = np.random.rand(fock_dim)
lambda_random = a * (lambda_random - np.mean(lambda_random)) / np.std(lambda_random)
dx = (range_max - range_min) / (n_grid - 1)
parameters = np.random.normal(size=4 * N2)
def calc(circuit, input_state, coefs):
s1.set_circuit(circuit)
probs = s1.all_prob(input_state)
return np.sum(np.multiply(probs, coefs))
def computation(params):
"""compute the loss function of a given differential equation in order for it to be optimized"""
coefs = lambda_random # coefficients of the M observable
# initial condition with the two universal interferometers and the phase shift in the middle
U_1 = pcvl.Matrix.parametrized_unitary(N, params[:2 * N2])
U_2 = pcvl.Matrix.parametrized_unitary(N, params[2 * N2:4 * N2])
# Circuit creation
px = pcvl.P("px")
c = (comp.Unitary(U_2)
// (0, comp.PS(px))
// comp.Unitary(U_1))
px.set_value(x_0)
f_theta_0 = calc(c, input_state, coefs)
# boundary condition given a weight eta
loss = eta * (f_theta_0 - f_0) ** 2 * n_grid
# Warning : Y[0] is before the domain we are interested in (used for differentiation), the domain begins at Y[1]
Y = np.zeros(n_grid + 2)
# Small optimisation working if x_0 == range_min
if x_0 == range_min:
Y[1] = f_theta_0
assigned = 1
else:
assigned = 0
px.set_value(range_min - dx)
Y[0] = calc(c, input_state, coefs)
for i in range(assigned, n_grid):
x = X[i]
px.set_value(x)
Y[i + 1] = calc(c, input_state, coefs)
# Y_prime[0] is the beginning of the domain /!\ not the same for Y
px.set_value(range_max + dx)
Y[n_grid + 1] = calc(c, input_state, coefs)
Y_prime = (Y[2:] - Y[:-2]) / (2 * dx)
# This method is apparently the fastest to calculate the L2 norm squared
loss += np.sum((F(Y_prime, Y[1:-1], X)) ** 2)
current_loss = loss / n_grid
return current_loss
def test_QML_DE_solver(benchmark):
benchmark(minimize, computation, parameters,
method='BFGS', options={'gtol': 1E-2})
================================================
FILE: benchmark/benchmark_bosonsampling.py
================================================
# MIT License
#
# Copyright (c) 2022 Quandela
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# As a special exception, the copyright holders of exqalibur library give you
# permission to combine exqalibur with code included in the standard release of
# Perceval under the MIT license (or modified versions of such code). You may
# copy and distribute such a combined system following the terms of the MIT
# license for both exqalibur and Perceval. This exception for the usage of
# exqalibur is limited to the python bindings used by Perceval.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import math
import perceval as pcvl
from perceval.components.unitary_components import BS, PS, Unitary
def get_interferometer(n):
def _gen_mzi(i: int):
return pcvl.catalog["mzi phase last"].build_circuit(theta_a=0.42, theta_b=0.42,
phi_a=math.pi+i*0.1, phi_b=math.pi/2)
return pcvl.GenericInterferometer(n, _gen_mzi)
def simulate_sampling(shots, circuit, input_state):
clifford = pcvl.Clifford2017Backend()
clifford.set_circuit(circuit)
clifford.set_input_state(input_state)
for i in range(shots):
clifford.sample()
def test_bosonsampling_clifford_6(benchmark):
benchmark(simulate_sampling, shots=100,
circuit=get_interferometer(6), input_state=pcvl.BasicState([1] * 6))
def test_bosonsampling_clifford_8(benchmark):
benchmark(simulate_sampling, shots=20,
circuit=get_interferometer(8), input_state=pcvl.BasicState([1] * 8))
================================================
FILE: benchmark/benchmark_pdisplay.py
================================================
# MIT License
#
# Copyright (c) 2022 Quandela
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# As a special exception, the copyright holders of exqalibur library give you
# permission to combine exqalibur with code included in the standard release of
# Perceval under the MIT license (or modified versions of such code). You may
# copy and distribute such a combined system following the terms of the MIT
# license for both exqalibur and Perceval. This exception for the usage of
# exqalibur is limited to the python bindings used by Perceval.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
r"""
This script times the execution of pdisplay for circuits.
"""
import perceval as pcvl
import perceval.components.unitary_components as comp
trials = 2
def generate_circuit(n_mode):
u = pcvl.Matrix.random_unitary(n_mode)
mzi = (pcvl.Circuit(2)
// comp.BS()
// (0, comp.PS(phi=pcvl.P("φ_a")))
// comp.BS()
// (0, comp.PS(phi=pcvl.P("φ_b"))))
return pcvl.Circuit.decomposition(u, mzi, shape=pcvl.InterferometerShape.TRIANGLE)
c6 = generate_circuit(6)
c12 = generate_circuit(12)
def run_pdisplay(c, t, f):
for _ in range(t):
pcvl.pdisplay(c, output_format=f, mplot_noshow=True)
def _run_pdisplay_mplot_6():
run_pdisplay(c6, trials, pcvl.Format.MPLOT)
def _run_pdisplay_mplot_12():
run_pdisplay(c12, trials, pcvl.Format.MPLOT)
def _run_pdisplay_svg_6():
run_pdisplay(c6, trials, pcvl.Format.HTML)
def _run_pdisplay_svg_12():
run_pdisplay(c12, trials, pcvl.Format.HTML)
def test_pdisplay_mplot_6(benchmark):
benchmark(_run_pdisplay_mplot_6)
def test_pdisplay_mplot_12(benchmark):
benchmark(_run_pdisplay_mplot_12)
def test_pdisplay_svg_6(benchmark):
benchmark(_run_pdisplay_svg_6)
def test_pdisplay_svg_12(benchmark):
benchmark(_run_pdisplay_svg_12)
================================================
FILE: benchmark/benchmark_stepper.py
================================================
# MIT License
#
# Copyright (c) 2022 Quandela
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# As a special exception, the copyright holders of exqalibur library give you
# permission to combine exqalibur with code included in the standard release of
# Perceval under the MIT license (or modified versions of such code). You may
# copy and distribute such a combined system following the terms of the MIT
# license for both exqalibur and Perceval. This exception for the usage of
# exqalibur is limited to the python bindings used by Perceval.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import random
import perceval as pcvl
from perceval.backends import SLOSBackend, NaiveBackend
from perceval.simulators import Stepper
from perceval.components import BS, PS
from perceval.utils import BasicState
# definition of the circuit
C = pcvl.Circuit(2)
C.add((0, 1), BS())
C.add(1, PS(1))
C.add((0, 1), BS())
N = 100
def get_sample_from_statevector(sv):
p = random.random()
state = None
for state, pa in sv:
proba = abs(pa)**2
if p > proba:
p -= proba
continue
break
return state
def run_stepper():
samples = []
stepper = Stepper(SLOSBackend())
stepper.set_circuit(C)
for i in range(N):
sv = pcvl.StateVector(pcvl.BasicState([1, 0]))
for r, c in C:
sv = stepper.apply(sv, r, c)
samples.append(get_sample_from_statevector(sv))
return samples
def run_direct():
bs = C._components[0][1]
sim_bs = NaiveBackend()
sim_bs.set_circuit(bs)
ps = C._components[1][1]
sim_ps = NaiveBackend()
sim_ps.set_circuit(ps)
samples = []
bs10 = BasicState([1,0])
bs01 = BasicState([0,1])
for i in range(N):
# apply first bs
sim_bs.set_input_state(bs10)
sv_a0 = sim_bs.prob_amplitude(bs10)
sv_a1 = sim_bs.prob_amplitude(bs01)
# apply ps
sv_b0 = sv_a0
sim_ps.set_input_state(BasicState([1]))
sv_b1 = sv_a1*sim_ps.prob_amplitude(BasicState([1]))
# apply second bs
sv_c0 = sv_b0*sim_bs.prob_amplitude(bs10)
sv_c1 = sv_b0*sim_bs.prob_amplitude(bs01)
sim_bs.set_input_state(bs01)
sv_c0 += sv_b1*sim_bs.prob_amplitude(bs10)
sv_c1 += sv_b1*sim_bs.prob_amplitude(bs01)
# sampling from there
samples.append(bs10 if random.random() > abs(sv_c0)**2 else bs01)
return samples
def test_stepper(benchmark):
benchmark(run_stepper)
def test_stepper_comp_direct(benchmark):
benchmark(run_direct)
================================================
FILE: conftest.py
================================================
import pytest
def pytest_addoption(parser):
parser.addoption("--skip-long-test", action="store_true",
help="do not run long tests")
parser.addoption("--save_figs", action="store_true",
help="use to generate new test figures")
def pytest_runtest_setup(item):
if 'long_test' in item.keywords and item.config.getoption("--skip-long-test"):
pytest.skip("ignored per user request")
================================================
FILE: docs/Makefile
================================================
# Minimal makefile for Sphinx documentation
#
# You can set these variables from the command line, and also
# from the environment for the first two.
SPHINXOPTS ?=
SPHINXBUILD ?= sphinx-build
SOURCEDIR = source
BUILDDIR = build
# Put it first so that "make" without argument is like "make help".
help:
@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
.PHONY: help Makefile
# Catch-all target: route all unknown targets to Sphinx using the new
# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
%: Makefile
@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
multiversion:
python -m sphinx_multiversion -f multiversion_config source build/html
clean:
rm -rf build
.PHONY: clean
================================================
FILE: docs/make.bat
================================================
@ECHO OFF
pushd %~dp0
REM Command file for Sphinx documentation
if "%SPHINXBUILD%" == "" (
set SPHINXBUILD=sphinx-build
)
set SOURCEDIR=source
set BUILDDIR=build
if "%1" == "" goto help
%SPHINXBUILD% >NUL 2>NUL
if errorlevel 9009 (
echo.
echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
echo.installed, then set the SPHINXBUILD environment variable to point
echo.to the full path of the 'sphinx-build' executable. Alternatively you
echo.may add the Sphinx directory to PATH.
echo.
echo.If you don't have Sphinx installed, grab it from
echo.https://www.sphinx-doc.org/
exit /b 1
)
%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
goto end
:help
%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
:end
popd
================================================
FILE: docs/multiversion_config/conf.py
================================================
# MIT License
#
# Copyright (c) 2022 Quandela
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# As a special exception, the copyright holders of exqalibur library give you
# permission to combine exqalibur with code included in the standard release of
# Perceval under the MIT license (or modified versions of such code). You may
# copy and distribute such a combined system following the terms of the MIT
# license for both exqalibur and Perceval. This exception for the usage of
# exqalibur is limited to the python bindings used by Perceval.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
import re
from pathlib import Path
from git import Repo
from perceval.utils.versions.version_utils import keep_latest_versions
sys.path.insert(0, os.path.relpath("../"))
REPO_PATH = Path(__file__).parent.parent.parent.resolve()
repo = Repo(REPO_PATH)
tags = [tag.name for tag in repo.tags]
versions = keep_latest_versions(tags, "v0.6")
versions_string = "|".join([f"({one_version})" for one_version in versions])
versions_regex = re.compile(f"^{versions_string}$")
print(f"Building {versions_regex}")
# Whitelist pattern for tags (set to None to ignore all tags)
smv_tag_whitelist = versions_regex
# Whitelist pattern for branches (set to None to ignore all branches)
smv_branch_whitelist = None
# Whitelist pattern for remotes (set to None to use local branches only)
smv_remote_whitelist = None
# Pattern for released versions
smv_released_pattern = r".*"
smv_regex_name = r"(.*)\..*"
================================================
FILE: docs/requirements.txt
================================================
wheel
sphinx==6.2.1
sphinx_rtd_theme
sphinxcontrib-bibtex
sphinx_autodoc_typehints
enum-tools[sphinx]
nbsphinx
jinja2==3.0.0
ipython
ipykernel
gitpython
git+https://github.com/Quandela/sphinx-multiversion-contrib.git@1.1.1
================================================
FILE: docs/source/_static/css/style.css
================================================
@import url("theme.css");
.wy-nav-content {
max-width: 1200px !important;
}
================================================
FILE: docs/source/_templates/layout.html
================================================
{% extends "!layout.html" %}
{% block extrahead %}
{{ super() }}
{% endblock %}
{% block extrabody %}
{{ super() }}
{% endblock %}
================================================
FILE: docs/source/_templates/page.html
================================================
{% extends "!page.html" %} {% block body %} {% if current_version and
latest_version and current_version != latest_version %}
You're reading the documentation of the {{current_version.name}}. For the latest released version, please have a look at {{latest_version.name}}.
{% endif %} {{ super() }} {% endblock %}% ================================================ FILE: docs/source/_templates/versions.html ================================================ {%- if current_version %}| 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", "A *LO circuit* (just called \"circuit\" here) isn't the same as a\n", "*quantum circuit*. Quantum circuits act on *qubits*, i.e. abstract systems in a 2-dimensional\n", "Hilbert space (or \"computational space\"); while optical circuits act on *photons*\n", "distributed in spatial modes (in the \"Fock space\"). It is possible to simply encode\n", "qubits with photons in an optical circuit; some encodings are\n", "presented in a later tutorial.
|  | \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",
"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",
"\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", "\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", "\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", "\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", "\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", "\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", " |
| 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", "$\\left|G\\right\\rangle = \\prod_{(a,b)\\in E} CZ^{\\{a,b\\}} \\left|+\\right\\rangle^{\\otimes V}$\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", "$CZ = \\begin{bmatrix}\n", "1 & 0 & 0 & 0 \\\\\n", "0 & 1 & 0 & 0 \\\\\n", "0 & 0 & 1 & 0 \\\\\n", "0 & 0 & 0 & -1 \\\\\n", "\\end{bmatrix}$\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", "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", "Modes are using [0-based numbering](https://en.wikipedia.org/wiki/Zero-based_numbering) - so mode 0 is\n", "corresponding to the first one, and mode $(m-1)$ is corresponding to the $m$-th.
![\"Quantum](\"../_static/img/quantum_walk_pretty.png\")
"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
""
],
"text/plain": [
"| 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 |