Fock simulator backend¶
Module name: strawberryfields.backends.fockbackend
The FockBackend
object implements a simulation of quantum optical circuits using
NumPy. The primary component of the FockBackend is a
Circuit
object which is used to simulate a multimode quantum optical system. The
FockBackend
provides the basic APIcompatible interface to the simulator, while the
Circuit
object actually carries out the mathematical simulation.
The Circuit
simulator maintains an internal tensor representation of the quantum state of a multimode quantum optical system
using a (truncated) Fock basis representation. As its various state manipulation methods are called, the quantum state is updated
to reflect these changes. The simulator will try to keep the internal state in a pure (vector) representation
for as long as possible. Unitary gates will not change the type of representation, while state preparations and measurements will.
A number of factors determine the shape and dimensionality of the state tensor:
 the underlying state representation being used (either a ket vector or a density matrix)
 the number of modes \(n\) actively being simulated
 the cutoff dimension \(D\) for the Fock basis
The state tensor corresponds to a multimode quantum system. If the representation is a pure state, the state tensor has shape \((\underbrace{D,...,D}_{n~\text{times}})\). In a mixed state representation, the state tensor has shape \((\underbrace{D,D,...,D,D}_{2n~\text{times}})\). Indices for the same mode appear consecutively. Hence, for a mixed state, the first two indices are for the first mode, the second are for the second mode, etc.
FockBackend methods¶
supports (name) 
Check whether the backend supports the given operating mode. 
begin_circuit (num_subsystems, **kwargs) 
Instantiate a quantum circuit. 
add_mode ([n]) 
Add modes to the circuit. 
del_mode (modes) 
Delete modes from the circuit. 
get_modes () 
Return a list of the active modes for the circuit. 
get_cutoff_dim () 
Returns the Hilbert space cutoff dimension used. 
reset ([pure]) 
Reset the circuit so that all the modes are in the vacuum state. 
state ([modes]) 
Returns the state of the quantum simulation. 
is_vacuum ([tol]) 
Test whether the current circuit state is vacuum (up to given tolerance). 
prepare_vacuum_state (mode) 
Prepare the vacuum state in the specified mode. 
prepare_coherent_state (alpha, mode) 
Prepare a coherent state in the specified mode. 
prepare_squeezed_state (r, phi, mode) 
Prepare a squeezed vacuum state in the specified mode. 
prepare_displaced_squeezed_state (alpha, r, …) 
Prepare a displaced squeezed state in the specified mode. 
prepare_thermal_state (nbar, mode) 
Prepare a thermal state in the specified mode. 
prepare_fock_state (n, mode) 
Prepare a Fock state in the specified mode. 
prepare_ket_state (state, modes) 
Prepare the given ket state in the specified modes. 
prepare_dm_state (state, modes) 
Prepare the given mixed state in the specified modes. 
rotation (phi, mode) 
Apply the phasespace rotation operation to the specified mode. 
displacement (alpha, mode) 
Apply the displacement operation to the specified mode. 
squeeze (z, mode) 
Apply the squeezing operation to the specified mode. 
beamsplitter (t, r, mode1, mode2) 
Apply the beamsplitter operation to the specified modes. 
cubic_phase (gamma, mode) 
Apply the cubic phase operation to the specified mode. 
kerr_interaction (kappa, mode) 
Apply the Kerr interaction \(\exp{(i\kappa \hat{n}^2)}\) to the specified mode. 
cross_kerr_interaction (kappa, mode1, mode2) 
Apply the two mode crossKerr interaction \(\exp{(i\kappa \hat{n}_1\hat{n}_2)}\) to the specified modes. 
loss (T, mode) 
Perform a loss channel operation on the specified mode. 
thermal_loss (T, nbar, mode) 
Perform a thermal loss channel operation on the specified mode. 
measure_homodyne (phi, mode[, shots, select]) 
Perform a homodyne measurement on the specified mode. 
measure_fock (modes[, shots, select]) 
Measure the given modes in the Fock basis. 
Code details¶

class
strawberryfields.backends.fockbackend.
FockBackend
[source]¶ Backend in the Fock basis

circuit
= None¶ representation of the simulated quantum state
Type: Circuit

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 reassigned 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) – Numerical Hilbert space cutoff dimension for the modes. For each mode, the simulator can represent the Fock states \(\ket{0}, \ket{1}, \ldots, \ket{\text{cutoff_dim}1}\).
 pure (bool) – If True (default), use a pure state representation (otherwise will use a mixed state representation).

add_mode
(n=1)[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]

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

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]

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)

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

prepare_coherent_state
(alpha, mode)[source]¶ 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_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_displaced_squeezed_state
(alpha, r, phi, mode)[source]¶ 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_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

rotation
(phi, mode)[source]¶ Apply the phasespace rotation operation to the specified mode.
Parameters:  phi (float) – rotation angle
 mode (int) – which mode to apply the rotation to

displacement
(alpha, mode)[source]¶ Apply the displacement operation to the specified mode.
Parameters:  alpha (complex) – displacement parameter
 mode (int) – which mode to apply the displacement to

squeeze
(z, mode)[source]¶ Apply the squeezing operation to the specified mode.
Parameters:  z (complex) – squeezing parameter
 mode (int) – which mode to apply the squeeze to

beamsplitter
(t, r, mode1, mode2)[source]¶ 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

measure_homodyne
(phi, mode, shots=1, select=None, **kwargs)[source]¶ Perform a homodyne measurement on the specified mode.
See
BaseBackend.measure_homodyne()
.Keyword Arguments:  num_bins (int) – Number of equally spaced bins for the probability distribution function (pdf) simulating the homodyne measurement (default: 100000).
 max (float) – The pdf is discretized onto the 1D grid [max,max] (default: 10).

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

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

get_cutoff_dim
()[source]¶ Returns the Hilbert space cutoff dimension used.
Returns: cutoff dimension Return type: int

state
(modes=None, **kwargs)[source]¶ Returns the state of the quantum simulation.
See
BaseBackend.state()
.Returns: state description Return type: BaseFockState

prepare_fock_state
(n, mode)[source]¶ Prepare a Fock state in the specified mode.
The requested mode is traced out and replaced with the Fock state \(\ket{n}\). As a result the state may have to be described using a density matrix.
Parameters:  n (int) – Fock state to prepare
 mode (int) – which mode to prepare the Fock state in

prepare_ket_state
(state, modes)[source]¶ Prepare the given ket state in the specified modes.
The requested modes are traced out and replaced with the given ket state (in the Fock basis). As a result the state may have to be described using a density matrix.
Parameters:  state (array) – Ket state in the Fock basis. The state can be given in either vector form, with one index, or tensor form, with one index per mode. For backends supporting batched mode, state can be a batch of such vectors or tensors.
 modes (int or Sequence[int]) – Modes to prepare the state in. If modes is not ordered this is taken into account when preparing the state, i.e., when a two mode state is prepared in modes=[3,1], then the first mode of state goes into mode 3 and the second mode goes into mode 1 of the simulator.

prepare_dm_state
(state, modes)[source]¶ Prepare the given mixed state in the specified modes.
The requested modes are traced out and replaced with the given density matrix state (in the Fock basis). As a result the state will be described using a density matrix.
Parameters:  state (array) – Density matrix in the Fock basis. The state can be given in either matrix form, with two indices, or tensor form, with two indices per mode. For backends supporting batched mode, state can be a batch of such matrices or tensors.
 modes (int or Sequence[int]) – which mode to prepare the state in If modes is not ordered this is take into account when preparing the state, i.e., when a two mode state is prepared in modes=[3,1], then the first mode of state goes into mode 3 and the second mode goes into mode 1 of the simulator.

cubic_phase
(gamma, mode)[source]¶ Apply the cubic phase operation to the specified mode.
Applies the operation
\[\exp\left(i \frac{\gamma}{6} (\hat{a} +\hat{a}^\dagger)^3\right)\]to the specified mode.
Note
This method is \(\hbar\) independent. The usual definition of the cubic phase gate is \(\hbar\) dependent:
\[V(\gamma') = \exp\left(i \frac{\gamma'}{3\hbar} \hat{x}^3\right) = \exp\left(i \frac{\gamma' \sqrt{\hbar/2}}{6} (\hat{a} +\hat{a}^\dagger)^3\right).\]Hence the cubic phase gate \(V(\gamma')\) is executed on a backend by scaling the \(\gamma'\) parameter by \(\sqrt{\hbar/2}\) and then passing it to this method, much in the way the \(\hbar\) dependent X and Z gates are implemented through the \(\hbar\) independent
displacement()
method.Warning
The cubic phase gate can suffer heavily from numerical inaccuracies due to finitedimensional cutoffs in the Fock basis. The gate implementation in Strawberry Fields is unitary, but it does not implement an exact cubic phase gate. The Kerr gate provides an alternative nonGaussian gate.
Parameters:  gamma (float) – scaled cubic phase shift, \(\gamma = \gamma' \sqrt{\hbar/2}\)
 mode (int) – which mode to apply it to

kerr_interaction
(kappa, mode)[source]¶ Apply the Kerr interaction \(\exp{(i\kappa \hat{n}^2)}\) to the specified mode.
Parameters:  kappa (float) – strength of the interaction
 mode (int) – which mode to apply it to

cross_kerr_interaction
(kappa, mode1, mode2)[source]¶ Apply the two mode crossKerr interaction \(\exp{(i\kappa \hat{n}_1\hat{n}_2)}\) to the specified modes.
Parameters:  kappa (float) – strength of the interaction
 mode1 (int) – first mode that crossKerr interaction acts on
 mode2 (int) – second mode that crossKerr interaction acts on

measure_fock
(modes, shots=1, select=None, **kwargs)[source]¶ 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 postselection on specific measurement results instead of random sampling.
len(select) == len(modes)
is required.
Returns: measurement results
Return type: tuple[int]
