Fock States¶

Warning

The ordering of the Fock basis is increasing with particle numbers, and in each particle number conserving subspace, lexicographic ordering is used.

Example for 3 modes:

General Fock State¶

class FockState(*, d: int, connector: BaseConnector, config: Config | None = None)¶

Object to represent a general bosonic state in the Fock basis.

Note

If you only work with pure states, it is advised to use PureFockState instead.

Parameters:

d (int) – The number of modes.
connector (BaseConnector) – Instance containing calculation functions.
config (Config) – Instance containing constants for the simulation.

reset() → None¶: Resets the Fock state to a vacuum state.

classmethod from_fock_state(state: BaseFockState) → FockState¶

Instantiation using another BaseFockState instance.

Parameters:: state (BaseFockState) – The instance from which a FockState instance is created.

property nonzero_elements: Generator[Tuple[complex, Tuple], Any, None]¶: The nonzero contributions to the state representation in Fock basis.

property density_matrix: ndarray¶: The density matrix of the state in the truncated Fock space.

get_particle_detection_probability(occupation_number: ndarray) → float¶

Returns the particle number detection probability using the occupation number specified as a parameter.

Parameters:: occupation_number (tuple) – Tuple of natural numbers representing the number of particles in each mode.
Returns:: The probability of detection.
Return type:: float

property fock_probabilities: ndarray¶

Returns the particle detection probabilities.

Note

The ordering of the Fock basis is increasing with particle numbers, and in each particle number conserving subspace, lexicographic ordering is used.

Returns:: The particle detection probabilities.
Return type:: numpy.ndarray

property fock_probabilities_map: Dict[Tuple[int, ...], float]¶: The particle number detection probabilities in a map.

reduced(modes: Tuple[int, ...]) → FockState¶: Reduces the state to a subsystem corresponding to the specified modes.

normalize() → None¶

Normalizes the density matrix to have a trace of 1.

Raises:: RuntimeError – Raised if the current norm of the state is too close to 0.

validate() → None¶

Validates the represented state.

Raises:: InvalidState – Raised, if the density matrix is not positive semidefinite, not self-adjoint or the trace of the density matrix is not 1.

quadratures_mean_variance(modes: Tuple[int, ...], phi: float = 0) → Tuple[float, float]¶

This method calculates the mean and the variance of the qudrature operators for a single qumode state. The quadrature operators \(x\) and \(p\) for a mode \(i\) can be calculated using the creation and annihilation operators as follows:

\[\begin{split}x_i &= \sqrt{\frac{\hbar}{2}} (a_i + a_i^\dagger) \\ p_i &= -i \sqrt{\frac{\hbar}{2}} (a_i - a_i^\dagger).\end{split}\]

Let \(\phi \in [ 0, 2 \pi )\), we can rotate the quadratures using the following transformation:

\[Q_{i, \phi} = \cos\phi~x_i + \sin\phi~p_i.\]

The expectation value \(\langle Q_{i, \phi}\rangle\) can be calculated as:

\[\operatorname{Tr}(\rho_i Q_{i, \phi}),\]

where \(\rho_i\) is the reduced density matrix of the mode \(i\) and \(Q_{i, \phi}\) is the rotated quadrature operator for a single mode and the variance is calculated as:

\[\operatorname{\textit{Var}(Q_{i,\phi})} = \langle Q_{i, \phi}^{2}\rangle - \langle Q_{i, \phi}\rangle^{2}.\]

Parameters:

phi (float) – The rotation angle. By default it is 0 which means that the mean of the position operator is being calculated. For \(\phi= \frac{\pi}{2}\) the mean of the momentum operator is being calculated.
modes (tuple[int]) – The correspoding mode at which the mean of the quadratures are being calculated.

Returns:

A tuple that contains the expectation value and the: varianceof of the quadrature operator respectively.

Return type:

(float, float)

get_purity()¶: The purity of the Fock state.

copy() → State¶

Returns an exact copy of this state.

Returns:: An exact copy of this state.
Return type:: State

property d: int¶: The number of modes.

fidelity(state: BaseFockState) → float¶

Calculates the state fidelity between two quantum states.

The state fidelity \(F\) between two density matrices \(\rho_1, \rho_2\) is given by:

\[\operatorname{F}(\rho_1, \rho_2) = \operatorname{Tr}(\sqrt{\sqrt{\rho_1} \rho_2\sqrt{\rho_1}})^2 = \operatorname{Tr}(\sqrt{\rho_1 \rho_2})^2\]

Parameters:: state – Either a PureFockState or a FockState that can be used to calculate the fidelity aganist it.
Returns:: The calculated fidelity.
Return type:: float

property fock_amplitudes_map: DefaultDict[tuple, complex]¶: Probability amplitudes of Fock basis states representing the state.

get_marginal_fock_probabilities(modes: Tuple[int, ...]) → ndarray¶

Return the particle number probabilities on a given subsystem.

Parameters:: modes (tuple[int, ...]) – The indices of the modes to keep.
Returns:: The marginal particle number detection probabilities.
Return type:: numpy.ndarray

plot_wigner(positions: List[float], momentums: List[float], mode: int | None = None) → None¶

Plots the Wigner function in phase space for a single mode using the given positions and momentums.

Parameters:

positions (List[float]) – List of position values (x-axis)
momentums (List[float]) – List of momentum values (p-axis)
mode (int, optional) – Mode where Wigner function should be calculcated.

Note

Only a single mode is supported.

Returns:: This method generates a plot and does not return a value.
Return type:: None

wigner_function(positions: List[float], momentums: List[float], modes: Tuple[int, ...] | None = None) → ndarray¶

This method calculates the Wigner function values at the specified position and momentum vectors, according to the following equation:

\[W(r) = \frac{1}{\pi^d \sqrt{\mathrm{det} \sigma}} \exp \big ( - (r - \mu)^T \sigma^{-1} (r - \mu) \big ).\]

Note

The implementation is copied from QuTiP.

Note

Only single modes are supported.

Parameters:

positions (list[float]) – List of position vectors.
momentums (list[float]) – List of momentum vectors.
modes (tuple[int], optional) – Modes where Wigner function should be calculcated.

Returns:

The Wigner function values in the shape of a grid specified by the input.

Return type:

numpy.ndarray

Pure Fock State¶

class PureFockState(*, d: int, connector: BaseConnector, config: Config | None = None)¶

A simulated pure Fock state.

If no mixed states are needed for a Fock simulation, then this state is the most appropriate currently, since it does not store an entire density matrix, only a state vector with size

\[{d + c - 1 \choose c - 1},\]

where \(c \in \mathbb{N}\) is the Fock space cutoff.

Variables:

state_vector – The state vector of the quantum state.

Parameters:

d (int) – The number of modes.
connector (BaseConnector) – Instance containing calculation functions.
config (Config) – Instance containing constants for the simulation.

reset() → None¶: Resets the Fock state to a vacuum state.

property nonzero_elements¶: The nonzero contributions to the state representation in Fock basis.

property density_matrix: ndarray¶: The density matrix of the state in the truncated Fock space.

reduced(modes: Tuple[int, ...]) → FockState¶: Reduces the state to a subsystem corresponding to the specified modes.

get_particle_detection_probability(occupation_number: ndarray) → float¶

Returns the particle number detection probability using the occupation number specified as a parameter.

Parameters:: occupation_number (tuple) – Tuple of natural numbers representing the number of particles in each mode.
Returns:: The probability of detection.
Return type:: float

property fock_probabilities: ndarray¶

Returns the particle detection probabilities.

Note

The ordering of the Fock basis is increasing with particle numbers, and in each particle number conserving subspace, lexicographic ordering is used.

Returns:: The particle detection probabilities.
Return type:: numpy.ndarray

property fock_probabilities_map: Dict[Tuple[int, ...], float]¶: The particle number detection probabilities in a map.

normalize() → None¶: Normalizes the state to have norm 1.

validate() → None¶

Validates the represented state.

Raises:: InvalidState – Raised, if the norm of the state vector is not close to 1.0.

quadratures_mean_variance(modes: Tuple[int, ...], phi: float = 0) → Tuple[float, float]¶

\[\begin{split}x_i &= \sqrt{\frac{\hbar}{2}} (a_i + a_i^\dagger) \\ p_i &= -i \sqrt{\frac{\hbar}{2}} (a_i - a_i^\dagger).\end{split}\]

Let \(\phi \in [ 0, 2 \pi )\), we can rotate the quadratures using the following transformation:

\[Q_{i, \phi} = \cos\phi~x_i + \sin\phi~p_i.\]

The expectation value \(\langle Q_{i, \phi}\rangle\) can be calculated as:

\[\operatorname{Tr}(\rho_i Q_{i, \phi}),\]

where \(\rho_i\) is the reduced density matrix of the mode \(i\) and \(Q_{i, \phi}\) is the rotated quadrature operator for a single mode and the variance is calculated as:

\[\operatorname{\textit{Var}(Q_{i,\phi})} = \langle Q_{i, \phi}^{2}\rangle - \langle Q_{i, \phi}\rangle^{2}.\]

Parameters:

phi (float) – The rotation angle. By default it is 0 which means that the mean of the position operator is being calculated. For \(\phi= \frac{\pi}{2}\) the mean of the momentum operator is being calculated.
modes (tuple[int]) – The correspoding mode at which the mean of the quadratures are being calculated.

Returns:

A tuple that contains the expectation value and the: varianceof of the quadrature operator respectively.

Return type:

(float, float)

mean_photon_number()¶

Returns the mean photon number

\[\mathbb{E}_{\ket{\psi}}(\hat{n}) := \bra{\psi} \hat{n} \ket{\psi},\]

where \(\hat{n}\) is the total photon number operator.

variance_photon_number()¶

Returns the photon number variance

\[\operatorname{Var}_{\ket{\psi}}(\hat{n}) := \bra{\psi} (\hat{n} - \bar{n})^2 \ket{\psi},\]

where \(\hat{n}\) is the total photon number operator and \(\bar{n}\) is its expectation value given by mean_photon_number().

copy() → PureFockState¶

Returns an exact copy of this state.

Returns:: An exact copy of this state.
Return type:: State

get_purity()¶: The purity of the Fock state.

property d: int¶: The number of modes.

fidelity(state: BaseFockState) → float¶

Calculates the state fidelity between two quantum states.

The state fidelity \(F\) between two density matrices \(\rho_1, \rho_2\) is given by:

\[\operatorname{F}(\rho_1, \rho_2) = \operatorname{Tr}(\sqrt{\sqrt{\rho_1} \rho_2\sqrt{\rho_1}})^2 = \operatorname{Tr}(\sqrt{\rho_1 \rho_2})^2\]

Parameters:: state – Either a PureFockState or a FockState that can be used to calculate the fidelity aganist it.
Returns:: The calculated fidelity.
Return type:: float

property fock_amplitudes_map: DefaultDict[tuple, complex]¶: Probability amplitudes of Fock basis states representing the state.

get_marginal_fock_probabilities(modes: Tuple[int, ...]) → ndarray¶

Return the particle number probabilities on a given subsystem.

Parameters:: modes (tuple[int, ...]) – The indices of the modes to keep.
Returns:: The marginal particle number detection probabilities.
Return type:: numpy.ndarray

plot_wigner(positions: List[float], momentums: List[float], mode: int | None = None) → None¶

Plots the Wigner function in phase space for a single mode using the given positions and momentums.

Parameters:

positions (List[float]) – List of position values (x-axis)
momentums (List[float]) – List of momentum values (p-axis)
mode (int, optional) – Mode where Wigner function should be calculcated.

Note

Only a single mode is supported.

Returns:: This method generates a plot and does not return a value.
Return type:: None

wigner_function(positions: List[float], momentums: List[float], modes: Tuple[int, ...] | None = None) → ndarray¶

This method calculates the Wigner function values at the specified position and momentum vectors, according to the following equation:

\[W(r) = \frac{1}{\pi^d \sqrt{\mathrm{det} \sigma}} \exp \big ( - (r - \mu)^T \sigma^{-1} (r - \mu) \big ).\]

Note

The implementation is copied from QuTiP.

Note

Only single modes are supported.

Parameters:

positions (list[float]) – List of position vectors.
momentums (list[float]) – List of momentum vectors.
modes (tuple[int], optional) – Modes where Wigner function should be calculcated.

Returns:

The Wigner function values in the shape of a grid specified by the input.

Return type:

numpy.ndarray