sf.backends.BaseGaussian

class BaseGaussian[source]

Bases: strawberryfields.backends.base.BaseBackend

Abstract base class for backends that are only capable of Gaussian state manipulation.

circuit_spec

short_name

circuit_spec = None
short_name = 'base'

add_mode([n])

Add modes to the circuit.

beamsplitter(t, r, 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(alpha, 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).

prepare_coherent_state(alpha, mode)

Prepare a coherent state in the specified mode.

prepare_displaced_squeezed_state(alpha, r, …)

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(z, 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)

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]

beamsplitter(t, r, mode1, mode2)

Apply the beamsplitter operation to the specified modes.

It is assumed that \(|r|^2+|t|^2 = t^2+|r|^2=1\), i.e that t is real.

Parameters
  • t (float) – transmitted amplitude

  • r (complex) – reflected amplitude (with phase)

  • mode1 (int) – first mode that beamsplitter acts on

  • mode2 (int) – second mode that beamsplitter acts on

begin_circuit(num_subsystems, **kwargs)

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)[source]
cubic_phase(gamma, mode)[source]
del_mode(modes)

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(alpha, mode)

Apply the displacement operation to the specified mode.

Parameters
  • alpha (complex) – displacement parameter

  • mode (int) – which mode to apply the displacement to

get_cutoff_dim()[source]
get_modes()

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)

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)[source]
loss(T, mode)

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)

Measure the given modes in the Fock basis.

..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]

measure_heterodyne(mode, shots=1, select=None)[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)

Measure a phase space quadrature of the given mode.

For the measured mode, samples the probability distribution \(f(q) = \bra{q_\phi} \rho \ket{q_\phi}\) and returns the sampled value. Here \(\ket{q_\phi}\) is the eigenstate of the operator

\[\hat{q}_\phi = \sqrt{2/\hbar}(\cos(\phi)\hat{x} +\sin(\phi)\hat{p}) = e^{-i\phi} \hat{a} +e^{i\phi} \hat{a}^\dagger.\]

Note

This method is \(\hbar\) independent. The returned values can be converted to conventional position/momentum eigenvalues by multiplying them with \(\sqrt{\hbar/2}\).

Updates the current state such that the measured mode is reset to the vacuum state. This is because we cannot represent exact position or momentum eigenstates in any of the backends, and experimentally the photons are destroyed in a homodyne measurement.

Parameters
  • phi (float) – phase angle of the quadrature to measure (x: \(\phi=0\), p: \(\phi=\pi/2\))

  • mode (int) – which mode to measure

  • shots (int) – number of measurement samples to obtain

  • select (None or float) – If not None: desired value of the measurement result. Enables post-selection on specific measurement results instead of random sampling.

Keyword arguments can be used to pass additional parameters to the backend. Options for such arguments will be documented in the respective subclasses.

Returns

measured value

Return type

float

measure_threshold(modes, shots=1, select=None, **kwargs)

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]

prepare_coherent_state(alpha, mode)

Prepare a coherent state in the specified mode.

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

Parameters
  • alpha (complex) – coherent state displacement parameter

  • mode (int) – which mode to prepare the coherent state in

prepare_displaced_squeezed_state(alpha, r, phi, mode)

Prepare a displaced squeezed state in the specified mode.

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

Parameters
  • alpha (complex) – displacement parameter

  • r (float) – squeezing amplitude

  • phi (float) – squeezing angle

  • mode (int) – which mode to prepare the squeezed state in

prepare_dm_state(state, mode)[source]
prepare_fock_state(n, mode)[source]
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)[source]
prepare_squeezed_state(r, phi, mode)

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)

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)

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)

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)

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(z, mode)

Apply the squeezing operation to the specified mode.

Parameters
  • z (complex) – squeezing parameter

  • 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

BaseGaussianState

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

  • “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)

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