# sf.backends.BaseGaussianState¶

class BaseGaussianState(state_data, num_modes, mode_names=None)[source]

Bases: strawberryfields.backends.states.BaseState

Class for the representation of quantum states using the Gaussian formalism.

Note that this class uses the Gaussian representation convention

$\bar{\mathbf{r}} = (\bar{x}_1,\bar{x}_2,\dots,\bar{x}_N,\bar{p}_1,\dots,\bar{p}_N)$
Parameters
• state_data (tuple(mu, cov)) – A tuple containing the vector of means array mu and the covariance matrix array cov, in terms of the complex displacement.

• 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

• mode_names (Sequence) – (optional) this argument contains a list providing mode names for each mode in the state

 EQ_TOLERANCE 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
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

 The covariance matrix describing the Gaussian state. displacement([modes]) Returns the displacement parameter $$\alpha$$ of the modes specified. 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. is_coherent(mode[, tol]) Returns True if the Gaussian state of a particular mode is a coherent state. is_squeezed(mode[, tol]) Returns True if the Gaussian state of a particular mode is a squeezed state. mean_photon(mode, **kwargs) Returns the mean photon number of a particular mode. The vector of means describing the Gaussian state. 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. reduced_gaussian(modes) Returns the vector of means and the covariance matrix of the specified modes. squeezing([modes]) Returns the squeezing parameters $$(r,\phi)$$ of the modes specified. wigner(mode, xvec, pvec) Calculates the discretized Wigner function of the specified mode.
cov()[source]

The covariance matrix describing the Gaussian state.

The diagonal elements of the covariance matrix correspond to the variance in the position and momentum quadratures:

$\begin{split}\mathbf{V}_{ii} = \begin{cases} (\Delta x_i)^2, & 0\leq i\leq N-1\\ (\Delta p_{i-N})^2, & N\leq i\leq 2(N-1) \end{cases}\end{split}$

where $$\Delta x_i$$ and $$\Delta p_i$$ refer to the position and momentum quadrature variance of mode $$i$$ respectively.

Note that if the covariance matrix is purely diagonal, then this corresponds to squeezing $$z=re^{i\phi}$$ where $$\phi=0$$, and $$\Delta x_i = e^{-2r}$$, $$\Delta p_i = e^{2r}$$.

Returns

the $$2N\times 2N$$ covariance matrix.

Return type

array

displacement(modes=None)[source]

Returns the displacement parameter $$\alpha$$ of the modes specified.

Parameters

modes (int or Sequence[int]) – modes specified

Returns

sequence of complex displacements $$\alpha$$ corresponding to the list of specified modes

Return type

Sequence[complex]

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

abstract 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

abstract 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

abstract 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

• **kwargs

• cutoff (int): (default 10) specifies the fock basis truncation when calculating of the fock basis probabilities. 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

is_coherent(mode, tol=1e-10)[source]

Returns True if the Gaussian state of a particular mode is a coherent state.

Parameters
• mode (int) – the specified mode

• tol (float) – the numerical precision in determining if squeezing is not present

Returns

True if and only if the state is a coherent state.

Return type

bool

is_squeezed(mode, tol=1e-06)[source]

Returns True if the Gaussian state of a particular mode is a squeezed state.

Parameters
• mode (int) – the specified mode

• tol (float) – the numerical precision in determining if squeezing is present

Returns

True if and only if the state is a squeezed state.

Return type

bool

abstract 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

means()[source]

The vector of means describing the Gaussian state.

For a $$N$$ mode state, this has the form

$\bar{\mathbf{r}} = \left(\bar{x}_0,\dots,\bar{x}_{N-1},\bar{p}_0,\dots,\bar{p}_{N-1}\right)$

where $$\bar{x}_i$$ and $$\bar{p}_i$$ refer to the mean position and momentum quadrature of mode $$i$$ respectively.

Returns

a length $$2N$$ array containing the vector of means.

Return type

array

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)

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

• **kwargs

• cutoff (int): (default 10) specifies where to truncate the returned density matrix. 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

reduced_gaussian(modes)[source]

Returns the vector of means and the covariance matrix of the specified modes.

Parameters

modes (int of Sequence[int]) – indices of the requested modes

Returns

where means is an array containing the vector of means, and cov is a square array containing the covariance matrix.

Return type

tuple (means, cov)

squeezing(modes=None)[source]

Returns the squeezing parameters $$(r,\phi)$$ of the modes specified.

Parameters

modes (int or Sequence[int]) – modes specified

Returns

sequence of tuples containing the squeezing parameters $$(r,\phi)$$ of the specified modes.

Return type

List[(float, float)]

wigner(mode, xvec, pvec)[source]

Calculates the discretized Wigner function of the specified mode.

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