sf.backends.GaussianBackend¶

class GaussianBackend[source]¶

Bases: strawberryfields.backends.base.BaseGaussian

The GaussianBackend implements a simulation of quantum optical circuits in NumPy using the Gaussian formalism, returning a GaussianState state object.

The primary component of the GaussianBackend is a GaussianModes object which is used to simulate a multi-mode quantum optical system. GaussianBackend provides the basic API-compatible interface to the simulator, while the GaussianModes object actually carries out the mathematical simulation.

The GaussianModes simulators maintain an internal covariance matrix & vector of means representation of a multi-mode quantum optical system.

Note that unlike commonly used covariance matrix representations we encode our state in two complex matrices \(N\) and \(M\) that are defined as follows \(N_{i,j} = \langle a^\dagger _i a_j \rangle\) \(M_{i,j} = \langle a _i a_j \rangle\) and a vector of means \(\alpha_i =\langle a_i \rangle\).

Attributes

`circuit_spec`
`compiler`
`short_name`

circuit_spec = 'gaussian'¶

compiler = 'gaussian'¶

short_name = 'gaussian'¶

Methods

`add_mode`([n])	Add modes to the circuit.
`beamsplitter`(theta, phi, mode1, mode2)	Apply the beamsplitter operation to the specified modes.
`begin_circuit`(num_subsystems, **kwargs)	Instantiate a quantum circuit.
`cross_kerr_interaction`(kappa, mode1, mode2)
`cubic_phase`(gamma, mode)
`del_mode`(modes)	Delete modes from the circuit.
`displacement`(r, phi, mode)	Apply the displacement operation to the specified mode.
`get_cutoff_dim`()
`get_modes`()	Return a list of the active modes for the circuit.
`is_vacuum`([tol])	Test whether the current circuit state is vacuum (up to given tolerance).
`kerr_interaction`(kappa, mode)
`loss`(T, mode)	Perform a loss channel operation on the specified mode.
`measure_fock`(modes[, shots, select])	Measure the given modes in the Fock basis.
`measure_heterodyne`(mode[, shots, select])	Perform a heterodyne measurement on the given mode.
`measure_homodyne`(phi, mode[, shots, select])	Measure a phase space quadrature of the given mode.
`measure_threshold`(modes[, shots, select])	Measure the given modes in the thresholded Fock basis, i.e., zero or nonzero photons).
`mzgate`(phi_in, phi_ex, mode1, mode2)	Apply the Mach-Zehnder interferometer operation to the specified modes.
`passive`(T, modes)	Perform an arbitrary multimode passive operation
`prepare_coherent_state`(r, phi, mode)	Prepare a coherent state in the specified mode.
`prepare_displaced_squeezed_state`(r_d, phi_d, …)	Prepare a displaced squeezed state in the specified mode.
`prepare_dm_state`(state, mode)
`prepare_fock_state`(n, mode)
`prepare_gaussian_state`(r, V, modes)	Prepare a Gaussian state.
`prepare_ket_state`(state, mode)
`prepare_squeezed_state`(r, phi, mode)	Prepare a squeezed vacuum state in the specified mode.
`prepare_thermal_state`(nbar, mode)	Prepare a thermal state in the specified mode.
`prepare_vacuum_state`(mode)	Prepare the vacuum state in the specified mode.
`reset`([pure])	Reset the circuit so that all the modes are in the vacuum state.
`rotation`(phi, mode)	Apply the phase-space rotation operation to the specified mode.
`squeeze`(r, phi, mode)	Apply the squeezing operation to the specified mode.
`state`([modes])	Returns the state of the quantum simulation.
`supports`(name)	Check whether the backend supports the given operating mode.
`thermal_loss`(T, nbar, mode)	Perform a thermal loss channel operation on the specified mode.

add_mode(n=1, **kwargs)[source]¶

Add modes to the circuit.

The new modes are initialized to the vacuum state. They are assigned mode indices sequentially, starting from the first unassigned index.

Parameters: n (int) – number of modes to add
Returns: indices of the newly added modes
Return type: list[int]
Keyword Arguments: peaks (list) – number of Gaussian peaks for each new mode (for bosonic backend only)

beamsplitter(theta, phi, mode1, mode2)[source]¶

Apply the beamsplitter operation to the specified modes.

Parameters

theta (float) – transmissivity is cos(theta)
phi (float) – phase angle
mode1 (int) – first mode that beamsplitter acts on
mode2 (int) – second mode that beamsplitter acts on

begin_circuit(num_subsystems, **kwargs)[source]¶

Instantiate a quantum circuit.

Instantiates a representation of a quantum optical state with num_subsystems modes. The state is initialized to vacuum.

The modes in the circuit are indexed sequentially using integers, starting from zero. Once an index is assigned to a mode, it can never be re-assigned to another mode. If the mode is deleted its index becomes invalid. An operation acting on an invalid or unassigned mode index raises an IndexError exception.

Parameters

num_subsystems (int) – number of modes in the circuit

Keyword Arguments

cutoff_dim (int) – Hilbert space truncation dimension (for Fock basis backends only)
batch_size (int) – (optional) batch-axis dimension, enables batched operation if > 1 (for the TF backend only)

cross_kerr_interaction(kappa, mode1, mode2)¶

cubic_phase(gamma, mode)¶

del_mode(modes)[source]¶

Delete modes from the circuit.

The deleted modes are traced out. As a result the state may have to be described using a density matrix.

The indices of the deleted modes become invalid for the lifetime of the circuit object. They will never be reassigned to other modes. Deleting a mode that has already been deleted raises an IndexError exception.

Parameters: modes (Sequence[int]) – mode numbers to delete

displacement(r, phi, mode)[source]¶

Apply the displacement operation to the specified mode.

Parameters

r (float) – displacement amplitude
phi (float) – displacement angle
mode (int) – which mode to apply the displacement to

get_cutoff_dim()¶

get_modes()[source]¶

Return a list of the active modes for the circuit.

A mode is active if it has been created and has not been deleted.

Returns: sorted list of active (assigned, not invalid) mode indices
Return type: list[int]

is_vacuum(tol=0.0, **kwargs)[source]¶

Test whether the current circuit state is vacuum (up to given tolerance).

Returns True iff \(|\bra{0} \rho \ket{0} -1| \le\) tol, i.e., the fidelity of the current circuit state with the vacuum state is within the given tolerance from 1.

Parameters: tol (float) – numerical tolerance
Returns: True iff current state is vacuum up to tolerance tol
Return type: bool

kerr_interaction(kappa, mode)¶

loss(T, mode)[source]¶

Perform a loss channel operation on the specified mode.

Parameters

T (float) – loss parameter, \(0\leq T\leq 1\).
mode (int) – index of mode where operation is carried out

measure_fock(modes, shots=1, select=None, **kwargs)[source]¶

Measure the given modes in the Fock basis.

Note

When shots == 1, updates the current system state to the conditional state of that measurement result. When shots > 1, the system state is not updated.

Parameters

modes (Sequence[int]) – which modes to measure
shots (int) – number of measurement samples to obtain
select (None or Sequence[int]) – If not None: desired values of the measurement results. Enables post-selection on specific measurement results instead of random sampling. len(select) == len(modes) is required.

Returns

measurement results

Return type

tuple[int]

measure_heterodyne(mode, shots=1, select=None, **kwargs)[source]¶

Perform a heterodyne measurement on the given mode.

Updates the current state of the circuit such that the measured mode is reset to the vacuum state.

Parameters

mode (int) – which mode to measure
shots (int) – number of measurement samples to obtain
select (None or complex) – If not None: desired value of the measurement result. Enables post-selection on specific measurement results instead of random sampling.

Returns

measured value

Return type

complex

measure_homodyne(phi, mode, shots=1, select=None, **kwargs)[source]¶

Measure a phase space quadrature of the given mode.

See BaseBackend.measure_homodyne().

Keyword Arguments: eps (float) – Homodyne amounts to projection onto a quadrature eigenstate. This eigenstate is approximated by a squeezed state whose variance has been squeezed to the amount eps, \(V_\text{meas} = \texttt{eps}^2\). Perfect homodyning is obtained when eps \(\to 0\).
Returns: measured value
Return type: float

measure_threshold(modes, shots=1, select=None, **kwargs)[source]¶

Measure the given modes in the thresholded Fock basis, i.e., zero or nonzero photons).

Note

When :code:shots == 1, updates the current system state to the conditional state of that measurement result. When :code:shots > 1, the system state is not updated.

Parameters

modes (Sequence[int]) – which modes to measure
shots (int) – number of measurement samples to obtain
select (None or Sequence[int]) – If not None: desired values of the measurement results. Enables post-selection on specific measurement results instead of random sampling. len(select) == len(modes) is required.

Returns

measurement results

Return type

tuple[int]

mzgate(phi_in, phi_ex, mode1, mode2)[source]¶

Apply the Mach-Zehnder interferometer operation to the specified modes.

Parameters

phi_in (float) – internal phase
phi_ex (float) – external phase
mode1 (int) – first mode that MZ interferometer acts on
mode2 (int) – second mode that MZ interferometer acts on

passive(T, modes)[source]¶

Perform an arbitrary multimode passive operation

Parameters

T (array) – an NxN matrix acting on a N mode state
modes (int or Sequence[int]) – Which modes to prepare the state in.

Details and Conventions

Acts the following transformation on the state:

\[a^{\dagger}_i \to \sum_j T_{ij} a^{\dagger}_j\]

prepare_coherent_state(r, phi, mode)[source]¶

Prepare a coherent state in the specified mode.

The requested mode is traced out and replaced with the coherent state \(\ket{r e^{i\phi}}\). As a result the state may have to be described using a density matrix.

Parameters

r (float) – coherent state displacement amplitude
phi (float) – coherent state displacement phase
mode (int) – which mode to prepare the coherent state in

prepare_displaced_squeezed_state(r_d, phi_d, r_s, phi_s, mode)[source]¶

Prepare a displaced squeezed state in the specified mode.

The requested mode is traced out and replaced with the displaced squeezed state \(\ket{\alpha, z}\), where \(\alpha=r_d e^{i\phi_d}\) and \(z=r_s e^{i\phi_s}\). As a result the state may have to be described using a density matrix.

Parameters

r_d (float) – displacement amplitude
phi_d (float) – displacement angle
r_s (float) – squeezing amplitude
phi_s (float) – squeezing angle
mode (int) – which mode to prepare the squeezed state in

prepare_dm_state(state, mode)¶

prepare_fock_state(n, mode)¶

prepare_gaussian_state(r, V, modes)[source]¶

Prepare a Gaussian state.

The specified modes are traced out and replaced with a Gaussian state provided via a vector of means and a covariance matrix.

Note

This method is \(\hbar\) independent. The input arrays are the means and covariance of the \(a+a^\dagger\) and \(-i(a-a^\dagger)\) operators. They are obtained by dividing the xp means by \(\sqrt{\hbar/2}\) and the xp covariance by \(\hbar/2\).

Parameters

r (array) – vector of means in xp ordering
V (array) – covariance matrix in xp ordering
modes (int or Sequence[int]) – Which modes to prepare the state in. If the modes are not sorted, this is taken into account when preparing the state. I.e., when a two mode state is prepared with modes=[3,1], the first mode of the given state goes into mode 3 and the second mode goes into mode 1.

prepare_ket_state(state, mode)¶

prepare_squeezed_state(r, phi, mode)[source]¶

Prepare a squeezed vacuum state in the specified mode.

The requested mode is traced out and replaced with the squeezed state \(\ket{z}\), where \(z=re^{i\phi}\). As a result the state may have to be described using a density matrix.

Parameters

r (float) – squeezing amplitude
phi (float) – squeezing angle
mode (int) – which mode to prepare the squeezed state in

prepare_thermal_state(nbar, mode)[source]¶

Prepare a thermal state in the specified mode.

The requested mode is traced out and replaced with the thermal state \(\rho(nbar)\). As a result the state may have to be described using a density matrix.

Parameters

nbar (float) – thermal population (mean photon number) of the mode
mode (int) – which mode to prepare the thermal state in

prepare_vacuum_state(mode)[source]¶

Prepare the vacuum state in the specified mode.

The requested mode is traced out and replaced with the vacuum state. As a result the state may have to be described using a density matrix.

Parameters: mode (int) – which mode to prepare the vacuum state in

reset(pure=True, **kwargs)[source]¶

Reset the circuit so that all the modes are in the vacuum state.

After the reset the circuit is in the same state as it was after the last begin_circuit() call. It will have the original number of modes, all initialized in the vacuum state. Some circuit parameters may be changed during the reset, see the keyword args below.

Parameters: pure (bool) – if True, initialize the circuit in a pure state representation (will use a mixed state representation if pure is False)
Keyword Arguments: cutoff_dim (int) – new Hilbert space truncation dimension (for Fock basis backends only)

rotation(phi, mode)[source]¶

Apply the phase-space rotation operation to the specified mode.

Parameters

phi (float) – rotation angle
mode (int) – which mode to apply the rotation to

squeeze(r, phi, mode)[source]¶

Apply the squeezing operation to the specified mode.

Parameters

r (float) – squeezing amplitude
phi (float) – squeezing angle
mode (int) – which mode to apply the squeeze to

state(modes=None, **kwargs)[source]¶

Returns the state of the quantum simulation.

See BaseBackend.state().

Returns: state description
Return type: GaussianState

supports(name)¶

Check whether the backend supports the given operating mode.

Currently supported operating modes are:

“gaussian”: for manipulations in the Gaussian representation using the displacements and covariance matrices
“fock_basis”: for manipulations in the Fock representation
“bosonic”: for manipulations of states represented as linear combinations of Gaussian functions in phase space
“mixed_states”: for representations where the quantum state is mixed
“batched”: allows for a multiple circuits to be simulated in parallel

Parameters: name (str) – name of the operating mode which we are checking support for
Returns: True if this backend supports that operating mode.
Return type: bool

thermal_loss(T, nbar, mode)[source]¶

Perform a thermal loss channel operation on the specified mode.

Parameters

T (float) – loss parameter, \(0\leq T\leq 1\).
nbar (float) – mean photon number of the environment thermal state
mode (int) – index of mode where operation is carried out

code/api/strawberryfields.backends.GaussianBackend

Download Python script

Download Notebook

View on GitHub

sf.backends.GaussianBackend¶

Attributes

Methods

Details and Conventions

Contents