sf.backends.gaussianbackend.states.GaussianState

class GaussianState(state_data, num_modes, qmat, Amat, mode_names=None)[source]

Bases: strawberryfields.backends.states.BaseGaussianState

Class for the representation of quantum states using Gaussian representation.

Parameters
  • state_data (tuple(mu, cov)) – A tuple containing the vector of means mu and the covariance matrix cov.

  • num_modes (int) – the number of modes in the state

  • qmat (array) – The covariance matrix for the Q function

  • Amat (array) – The A matrix from Hamilton’s paper

  • 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

cov()

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.

means()

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 the reduced density matrix in the Fock basis for a particular mode.

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

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)

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]

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

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

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)

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

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

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)

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)

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 the reduced density matrix in the Fock basis for a particular mode.

Parameters
  • modes (int) – specifies the mode. For the Gaussian backend, only a single mode reduced density matrix can be returned.

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

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)

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)

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