sf.backends.BaseFockState¶

class BaseFockState(state_data, num_modes, pure, cutoff_dim, mode_names=None)[source]¶

Bases: strawberryfields.backends.states.BaseState

Class for the representation of quantum states in the Fock basis.

Parameters

state_data (array) – the state representation in the Fock basis
num_modes (int) – the number of modes in the state
pure (bool) – True if the state is a pure state, false if the state is mixed
cutoff_dim (int) – the Fock basis truncation size
mode_names (Sequence) – (optional) this argument contains a list providing mode names for each mode in the state

Attributes

`EQ_TOLERANCE`
`cutoff_dim`	The numerical truncation of the Fock space used by the underlying state.
`data`	Returns the underlying numerical (or symbolic) representation of the state.
`hbar`	Returns the value of $\hbar$ used in the generation of the state.
`is_pure`	Checks whether the state is a pure state.
`mode_indices`	Returns a dictionary mapping the mode names to mode indices.
`mode_names`	Returns a dictionary mapping the mode index to mode names.
`num_modes`	Gets the number of modes that the state represents.

EQ_TOLERANCE = 1e-10¶

cutoff_dim¶

The numerical truncation of the Fock space used by the underlying state. Note that a cutoff of D corresponds to the Fock states $\{|0\rangle,\dots,|D-1\rangle\}$

Returns: the cutoff dimension
Return type: int

data¶: Returns the underlying numerical (or symbolic) representation of the state. The form of this data differs for different backends.

hbar¶

Returns the value of $\hbar$ used in the generation of the state.

The value of $\hbar$ is a convention chosen in the definition of $\x$ and $\p$. See Operators for more details.

Returns: $\hbar$ value.
Return type: float

is_pure¶

Checks whether the state is a pure state.

Returns: True if and only if the state is pure.
Return type: bool

mode_indices¶

Returns a dictionary mapping the mode names to mode indices.

The mode names are determined from the initialization argument mode_names. If these were not supplied, the names are generated automatically based on the mode indices.

Returns: dictionary of the form {"mode name":i,...}
Return type: dict

mode_names¶

Returns a dictionary mapping the mode index to mode names.

The mode names are determined from the initialization argument mode_names. If these were not supplied, the names are generated automatically based on the mode indices.

Returns: dictionary of the form {i:"mode name",...}
Return type: dict

num_modes¶

Gets the number of modes that the state represents.

Returns: the number of modes in the state
Return type: int

Methods

`all_fock_probs`(**kwargs)	Probabilities of all possible Fock basis states for the current circuit state.
`diagonal_expectation`(modes, values)	Calculates the expectation value of an operator that is diagonal in the number basis
`dm`(**kwargs)	The numerical density matrix for the quantum state in the Fock basis.
`fidelity`(other_state, mode, **kwargs)	Fidelity of the reduced state in the specified mode with a user supplied state.
`fidelity_coherent`(alpha_list, **kwargs)	The fidelity of the state with a product of coherent states.
`fidelity_vacuum`(**kwargs)	The fidelity of the state with the vacuum state.
`fock_prob`(n, **kwargs)	Probability of a particular Fock basis state.
`ket`(**kwargs)	The numerical state vector for the quantum state in the Fock basis.
`mean_photon`(mode, **kwargs)	Returns the mean photon number of a particular mode.
`number_expectation`(modes)	Calculates the expectation value of a product of number operators acting on given modes
`p_quad_values`(mode, xvec, pvec)	Calculates the discretized p-quadrature probability distribution of the specified mode.
`parity_expectation`(modes)	Calculates the expectation value of a product of parity operators acting on given modes
`poly_quad_expectation`(A[, d, k, phi])	The multi-mode expectation values and variance of arbitrary 2nd order polynomials of quadrature operators.
`quad_expectation`(mode[, phi])	The $\x_{\phi}$ operator expectation values and variance for the specified mode.
`reduced_dm`(modes, **kwargs)	Returns a reduced density matrix in the Fock basis.
`trace`(**kwargs)	Trace of the density operator corresponding to the state.
`wigner`(mode, xvec, pvec)	Calculates the discretized Wigner function of the specified mode.
`x_quad_values`(mode, xvec, pvec)	Calculates the discretized x-quadrature probability distribution of the specified mode.

all_fock_probs(**kwargs)[source]¶

Probabilities of all possible Fock basis states for the current circuit state.

For example, in the case of 3 modes, this method allows the Fock state probability $|\braketD{0,2,3}{\psi}|^2$ to be returned via

probs = state.all_fock_probs()
probs[0,2,3]

Returns

array of dimension $\underbrace{D\times D\times D\cdots\times D}_{\text{num modes}}$: containing the Fock state probabilities, where $D$ is the Fock basis cutoff truncation

Return type

array

diagonal_expectation(modes, values)[source]¶: Calculates the expectation value of an operator that is diagonal in the number basis

dm(**kwargs)[source]¶

The numerical density matrix for the quantum state in the Fock basis.

Keyword Arguments: cutoff (int) – Specifies where to truncate the returned density matrix (default value is 10). Note that the cutoff argument only applies for Gaussian representation; states represented in the Fock basis will use their own internal cutoff dimension.
Returns: the numerical density matrix in the Fock basis
Return type: array

fidelity(other_state, mode, **kwargs)[source]¶

Fidelity of the reduced state in the specified mode with a user supplied state. Note that this method only supports single-mode states.

Parameters: other_state – a pure state vector array represented in the Fock basis (for Fock backends) or a Sequence (mu, cov) containing the means and covariance matrix (for Gaussian backends)
Returns: The fidelity of the circuit state with other_state.

fidelity_coherent(alpha_list, **kwargs)[source]¶

The fidelity of the state with a product of coherent states.

The fidelity is defined by

\[\bra{\vec{\alpha}}\rho\ket{\vec{\alpha}}\]

Parameters: alpha_list (Sequence[complex]) – list of coherent state parameters, one for each mode
Returns: the fidelity value
Return type: float

fidelity_vacuum(**kwargs)[source]¶

The fidelity of the state with the vacuum state.

Returns: the fidelity of the state with the vacuum
Return type: float

fock_prob(n, **kwargs)[source]¶

Probability of a particular Fock basis state.

Computes the probability $|\braket{\vec{n}|\psi}|^2$ of measuring the given multi-mode Fock state based on the state $\ket{\psi}$.

Warning

Computing the Fock probabilities of states has exponential scaling in the Gaussian representation (for example states output by a Gaussian backend as a BaseGaussianState). This shouldn’t affect small-scale problems, where only a few Fock basis state probabilities need to be calculated, but will become evident in larger scale problems.

Parameters: n (Sequence[int]) – the Fock state $\ket{\vec{n}}$ that we want to measure the probability of
Keyword Arguments: cutoff (int) – Specifies where to truncate the computation (default value is 10). Note that the cutoff argument only applies for Gaussian representation; states represented in the Fock basis will use their own internal cutoff dimension.
Returns: measurement probability
Return type: float

ket(**kwargs)[source]¶

The numerical state vector for the quantum state in the Fock basis. Note that if the state is mixed, this method returns None.

Keyword Arguments: cutoff (int) – Specifies where to truncate the returned density matrix (default value is 10). Note that the cutoff argument only applies for Gaussian representation; states represented in the Fock basis will use their own internal cutoff dimension.
Returns: the numerical state vector. Returns None if the state is mixed.
Return type: array/None

mean_photon(mode, **kwargs)[source]¶

Returns the mean photon number of a particular mode.

Parameters

mode (int) – specifies the mode
**kwargs –
- cutoff (int): (default 10) Fock basis trunction for calculation of mean photon number. Note that the cutoff argument only applies for Gaussian representation; states represented in the Fock basis will use their own internal cutoff dimension.

Returns

the mean photon number and variance

Return type

tuple

number_expectation(modes)[source]¶: Calculates the expectation value of a product of number operators acting on given modes

p_quad_values(mode, xvec, pvec)¶

Calculates the discretized p-quadrature probability distribution of the specified mode.

Parameters

mode (int) – the mode to calculate the p-quadrature probability values of
xvec (array) – array of discretized $x$ quadrature values
pvec (array) – array of discretized $p$ quadrature values

Returns

1D array of size len(pvec), containing reduced p-quadrature probability values for a specified range of x and p.

Return type

array

parity_expectation(modes)[source]¶: Calculates the expectation value of a product of parity operators acting on given modes

poly_quad_expectation(A, d=None, k=0, phi=0, **kwargs)[source]¶

The multi-mode expectation values and variance of arbitrary 2nd order polynomials of quadrature operators.

An arbitrary 2nd order polynomial of quadrature operators over $N$ modes can always be written in the following form:

\[P(\mathbf{r}) = \mathbf{r}^T A\mathbf{r} + \mathbf{r}^T \mathbf{d} + k I\]

where:

$A\in\mathbb{R}^{2N\times 2N}$ is a symmetric matrix representing the quadratic coefficients,
$\mathbf{d}\in\mathbb{R}^{2N}$ is a real vector representing the linear coefficients,
$k\in\mathbb{R}$ represents the constant term, and
$\mathbf{r} = (\x_1,\dots,\x_N,\p_1,\dots,\p_N)$ is the vector of quadrature operators in $xp$-ordering.

This method returns the expectation value of this second-order polynomial,

\[\langle P(\mathbf{r})\rangle,\]

as well as the variance

\[\Delta P(\mathbf{r})^2 = \braket{P(\mathbf{r})^2} - \braket{P(\mathbf{r})}^2\]

Parameters

A (array) – a real symmetric 2Nx2N NumPy array, representing the quadratic coefficients of the second order quadrature polynomial.
d (array) – a real length-2N NumPy array, representing the linear coefficients of the second order quadrature polynomial. Defaults to the zero vector.
k (float) – the constant term. Default 0.
phi (float) – quadrature angle, clockwise from the positive $x$ axis. If provided, the vectori of quadrature operators $\mathbf{r}$ is first rotated by angle $\phi$ in the phase space.

Returns

expectation value and variance

Return type

tuple (float, float)

quad_expectation(mode, phi=0, **kwargs)[source]¶

The $\x_{\phi}$ operator expectation values and variance for the specified mode.

The $\x_{\phi}$ operator is defined as follows,

\[\x_{\phi} = \cos\phi~\x + \sin\phi~\p\]

with corresponding expectation value

\[\bar{x_{\phi}}=\langle x_{\phi}\rangle = \text{Tr}(\x_{\phi}\rho_{mode})\]

and variance

\[\Delta x_{\phi}^2 = \langle x_{\phi}^2\rangle - \braket{x_{\phi}}^2\]

Parameters

mode (int) – the requested mode
phi (float) –
quadrature angle, clockwise from the positive $x$ axis.
- $\phi=0$ corresponds to the $x$ expectation and variance (default)
- $\phi=\pi/2$ corresponds to the $p$ expectation and variance

Returns

expectation value and variance

Return type

tuple (float, float)

reduced_dm(modes, **kwargs)[source]¶

Returns a reduced density matrix in the Fock basis.

Parameters: modes (int or Sequence[int]) – specifies the mode(s) to return the reduced density matrix for.
Keyword Arguments: cutoff (int) – Specifies where to truncate the returned density matrix (default value is 10). Note that the cutoff argument only applies for Gaussian representation; states represented in the Fock basis will use their own internal cutoff dimension.
Returns: the reduced density matrix for the specified modes
Return type: array

trace(**kwargs)[source]¶

Trace of the density operator corresponding to the state.

For pure states the trace corresponds to the squared norm of the ket vector.

For physical states this should always be 1, any deviations from this value are due to numerical errors and Hilbert space truncation artefacts.

Returns: trace of the state
Return type: float

wigner(mode, xvec, pvec)[source]¶

Calculates the discretized Wigner function of the specified mode.

Note

This code is a modified version of the ‘iterative’ method of the wigner function provided in QuTiP, which is released under the BSD license, with the following copyright notice:

Parameters

mode (int) – the mode to calculate the Wigner function for
xvec (array) – array of discretized $x$ quadrature values
pvec (array) – array of discretized $p$ quadrature values

Returns

2D array of size [len(xvec), len(pvec)], containing reduced Wigner function values for specified x and p values.

Return type

array

x_quad_values(mode, xvec, pvec)¶

Calculates the discretized x-quadrature probability distribution of the specified mode.

Parameters

mode (int) – the mode to calculate the x-quadrature probability values of
xvec (array) – array of discretized $x$ quadrature values
pvec (array) – array of discretized $p$ quadrature values

Returns

1D array of size len(xvec), containing reduced x-quadrature probability values for a specified range of x and p.

Return type

array

code/api/strawberryfields.backends.BaseFockState

Download Python script

Download Notebook

View on GitHub

sf.backends.BaseFockState¶

Attributes

Methods

Contents