NoisySamplingSimulator

The NoisySamplingSimulator is a special simulator dedicated to sample states from a noisy input state.

It is completely separated from the other simulators, and, as such, it is not available through the SimulatorFactory. As its name suggests, it requires a sampling able backend such as CliffordClifford2017.

The NoisySamplingSimulator exposes two simulation methods:

  • samples that returns a python dictionary with a BSSamples in the “results” field

  • sample_count that returns a python dictionary with a BSCount in the “results” field

Note that these two methods require a SVDistribution without superposed states (but can be annotated), since we can’t retrieve the probability amplitudes from the backend.

Also, this simulator can only simulate non-polarized unitary circuits.

Using a NoisySamplingSimulator

import perceval as pcvl

sim = pcvl.NoisySamplingSimulator(pcvl.Clifford2017Backend())
sim.set_circuit(pcvl.BS())  # Now, sim holds a 2 modes circuit

# Physical and logical selection
sim.set_selection(min_detected_photons_filter = 2)  # Other fields: heralds (accounting only the output), postselect
sim.set_detectors([pcvl.Detector.threshold(), pcvl.Detector.pnr()])

svd = pcvl.SVDistribution({pcvl.BasicState("|{_:0}, {_:1}>"): 1})
# Sample stream
print(sim.samples(svd, 5)["results"])  # Random sampling; results may change at each run
# [ |1,1>, |0,2>, |0,2>, |1,1>, |1,1> ]

# Sample count
print(sim.sample_count(svd, max_samples = 10, max_shots = 10)["results"])
# {
#   |1,1>: 7
#   |0,2>: 2
# }
class perceval.simulators.NoisySamplingSimulator(sampling_backend)

Simulates a sampling, using a perfect sampling algorithm. It is used to take advantage of a parallel sampling algorithm, by computing multiple output states at once, while taking noise and post-processing (heralds, post-selection, detector characteristics) into account

Parameters:

sampling_backend (ASamplingBackend) – Instance of a sampling-capable back-end

compute_physical_logical_perf(value)

Tells the simulator to compute or not the physical and logical performances when possible

Parameters:

value (bool) – True to compute the physical and logical performances, False otherwise.

format_results(results, physical_perf, logical_perf)

Format the simulation results by computing the global performance, and returning the physical and logical performances only if needed.

Parameters:

  • results – the simulation results

  • physical_perf – the physical performance

  • logical_perf – the logical performance

keep_heralds(value)

Tells the simulator to keep or discard ancillary modes in output states

Parameters:

value (bool) – True to keep ancillaries/heralded modes, False to discard them (default is keep).

log_resources(method, extra_parameters)

Log resources of the noisy sampling simulator

Parameters:

  • method (str) – name of the method used

  • extra_parameters (dict) –

    extra parameters to log

    Extra parameter can be:

    • max_samples

    • max_shots

property min_detected_photons_filter
Returns:

The minimum number of detected photons filter. Counts both user-defined minimum number of photons and heralds

sample_count(svd, max_samples, max_shots=None, progress_callback=None)

Run a noisy sampling simulation and retrieve the results

Parameters:

  • svd (SVDistribution | tuple[Source, BasicState]) – The noisy input, expressed as a mixed state, or a tuple containing the source and the perfect input state

  • max_samples (int) – Max expected samples of interest in the results

  • max_shots (Optional[int]) – Shots limit before the sampling ends (you might get fewer samples than expected)

  • progress_callback (Optional[Callable[[float, str], Optional[dict]]]) – A progress callback

Return type:

dict

Returns:

A dictionary of the form { “results”: BSCount, “physical_perf”: float, “logical_perf”: float }

  • results is the post-selected output state sample count

  • physical_perf is the performance computed from the detected photon filter

  • logical_perf is the performance computed from the post-selection

samples(svd, max_samples, max_shots=None, progress_callback=None)

Run a noisy sampling simulation and retrieve the results

Parameters:

  • svd (SVDistribution | tuple[Source, FockState]) – The noisy input, expressed as a mixed state, or a tuple containing the source and the perfect input state

  • max_samples (int) – Max expected samples of interest in the results

  • max_shots (Optional[int]) – Shots limit before the sampling ends (you might get fewer samples than expected)

  • progress_callback (Optional[callable]) – A progress callback

Return type:

dict

Returns:

A dictionary of the form { “results”: BSSamples, “physical_perf”: float, “logical_perf”: float }

  • results is the post-selected output state sample stream

  • physical_perf is the performance computed from the detected photon filter

  • logical_perf is the performance computed from the post-selection

set_circuit(circuit)

Set the circuit to simulate the sampling on

Parameters:

circuit (ACircuit) – A unitary circuit

set_detectors(detector_list)
Parameters:

detector_list (list[IDetector]) – A list of detectors to simulate

set_min_detected_photons_filter(value)

Set the physical detection filter. Any output state with less than this threshold gets discarded.

Parameters:

value (int) – Minimal photon count in output states of interest.

set_selection(min_detected_photons_filter=None, postselect=None, heralds=None)

Set multiple selection filters at once to remove unwanted states from computed output distribution

Parameters:

  • min_detected_photons_filter (Optional[int]) – minimum number of detected photons in the output distribution

  • postselect (Optional[PostSelect]) – a post-selection function

  • heralds (Optional[dict]) – expected detections (heralds). Only corresponding states will be selected, others are filtered out. Mapping of heralds. For instance {5: 0, 6: 1} means 0 photon is expected on mode 5 and 1 on mode 6.

ExqaliburNoisySamplingSimulator

The ExqaliburNoisySamplingSimulator does the same things as the NoisySamplingSimulator, but its methods are implemented in exqalibur so it runs faster.

Also, this simulator requires the backend to be a wrapper around a pure exqalibur sampling backend. The CliffordClifford2017 backend is an example of such a backend.

class perceval.simulators.ExqaliburNoisySamplingSimulator(sampling_backend)

Simulates a sampling, using a perfect sampling algorithm. It is used to take advantage of a parallel sampling algorithm, by computing multiple output states at once, while taking noise and post-processing (heralds, post-selection, detector characteristics) into account.

This particular sampling simulator runs exclusively using exqalibur methods for an even faster.

Parameters:

sampling_backend (ExqaliburBackendWrapper) – Instance of a sampling-capable exqalibur-wrapped back-end

compute_physical_logical_perf(value)

Tells the simulator to compute or not the physical and logical performances when possible

Parameters:

value (bool) – True to compute the physical and logical performances, False otherwise.

format_results(results, physical_perf, logical_perf)

Format the simulation results by computing the global performance, and returning the physical and logical performances only if needed.

Parameters:

  • results – the simulation results

  • physical_perf – the physical performance

  • logical_perf – the logical performance

keep_heralds(value)

Tells the simulator to keep or discard ancillary modes in output states

Parameters:

value (bool) – True to keep ancillaries/heralded modes, False to discard them (default is keep).

log_resources(method, extra_parameters)

Log resources of the noisy sampling simulator

Parameters:

  • method (str) – name of the method used

  • extra_parameters (dict) –

    extra parameters to log

    Extra parameter can be:

    • max_samples

    • max_shots

property min_detected_photons_filter
Returns:

The minimum number of detected photons filter. Counts both user-defined minimum number of photons and heralds

sample_count(svd, max_samples, max_shots=None, progress_callback=None)

Run a noisy sampling simulation and retrieve the results

Parameters:

  • svd (SVDistribution | tuple[Source, BasicState]) – The noisy input, expressed as a mixed state, or a tuple containing the source and the perfect input state

  • max_samples (int) – Max expected samples of interest in the results

  • max_shots (Optional[int]) – Shots limit before the sampling ends (you might get fewer samples than expected)

  • progress_callback (Optional[Callable[[float, str], Optional[dict]]]) – A progress callback

Return type:

dict

Returns:

A dictionary of the form { “results”: BSCount, “physical_perf”: float, “logical_perf”: float }

  • results is the post-selected output state sample count

  • physical_perf is the performance computed from the detected photon filter

  • logical_perf is the performance computed from the post-selection

samples(svd, max_samples, max_shots=None, progress_callback=None)

Run a noisy sampling simulation and retrieve the results

Parameters:

  • svd (SVDistribution | tuple[Source, FockState]) – The noisy input, expressed as a mixed state, or a tuple containing the source and the perfect input state

  • max_samples (int) – Max expected samples of interest in the results

  • max_shots (Optional[int]) – Shots limit before the sampling ends (you might get fewer samples than expected)

  • progress_callback (Optional[Callable[[float, str], Optional[dict]]]) – A progress callback

Return type:

dict

Returns:

A dictionary of the form { “results”: BSSamples, “physical_perf”: float, “logical_perf”: float }

  • results is the post-selected output state sample stream

  • physical_perf is the performance computed from the detected photon filter

  • logical_perf is the performance computed from the post-selection

set_circuit(circuit)

Set the circuit to simulate the sampling on

Parameters:

circuit (ACircuit) – A unitary circuit

set_detectors(detector_list)
Parameters:

detector_list (Optional[list[Optional[IDetector]]]) – A list of detectors to simulate

set_min_detected_photons_filter(value)

Set the physical detection filter. Any output state with less than this threshold gets discarded.

Parameters:

value (int) – Minimal photon count in output states of interest.

set_selection(min_detected_photons_filter=None, postselect=None, heralds=None)

Set multiple selection filters at once to remove unwanted states from computed output distribution

Parameters:

  • min_detected_photons_filter (Optional[int]) – minimum number of detected photons in the output distribution

  • postselect (Optional[PostSelect]) – a post-selection function

  • heralds (Optional[dict]) – expected detections (heralds). Only corresponding states will be selected, others are filtered out. Mapping of heralds. For instance {5: 0, 6: 1} means 0 photon is expected on mode 5 and 1 on mode 6.