def is_valid_cov(cov, hbar=2, rtol=1e-05, atol=1e-08):
r""" Checks if the covariance matrix is a valid quantum covariance matrix.
Args:
cov (array): a covariance matrix
hbar (float): value of hbar in the uncertainty relation
Returns:
(bool): whether the given covariance matrix is a valid covariance matrix
"""
(n, m) = cov.shape
if n != m:
# raise ValueError("The input matrix must be square")
return False
if not np.allclose(cov, np.transpose(cov), rtol=rtol, atol=atol):
# raise ValueError("The input matrix is not symmetric")
return False
if n % 2 != 0:
# raise ValueError("The input matrix is of even dimension")
return False
nmodes = n // 2
vals = np.linalg.eigvalsh(cov + 0.5j * hbar * sympmat(nmodes))
vals[np.abs(vals) < atol] = 0.0
if np.all(vals >= 0):
# raise ValueError("The input matrix violates the uncertainty relation")
return True
return False
def test_sympmat(n):
"""test X_n = [[0, I], [-I, 0]]"""
I = np.identity(n)
O = np.zeros_like(I)
X = np.block([[O, I], [-I, O]])
res = symplectic.sympmat(n)
assert np.all(X == res)
def test_gaussian_gate_matrix_with_fock_tensor(self, setup_backend,
num_mode, cutoff, tol):
"""Test if the gaussian gate matrix has the right effect in the Fock basis"""
S = sympmat(num_mode)
d = np.random.random(2 * num_mode)
Ggate_matrix = gaussian_gate_matrix(S, d, cutoff)
ref_state = np.transpose(
fock_tensor(S, (d[:num_mode] + 1j * d[num_mode:]) / 2, cutoff),
(0, 2, 1, 3) if num_mode == 2 else (0, 3, 1, 4, 2, 5),
)
assert np.allclose(Ggate_matrix, ref_state, atol=tol, rtol=0.0)
# batched=True case for gaussian_gate_matrix
batch = 3
S = np.stack([S, S, S])
d = np.random.random((batch, 2 * num_mode))
Ggate_matrix = gaussian_gate_matrix(S, d, cutoff, batched=True)
ref_state = np.transpose(
fock_tensor(S[0], (d[0, :num_mode] + 1j * d[0, num_mode:]) / 2,
cutoff),
(0, 2, 1, 3) if num_mode == 2 else (0, 3, 1, 4, 2, 5),
)
assert np.allclose(Ggate_matrix[0], ref_state, atol=tol, rtol=0.0)
ref_state = np.transpose(
fock_tensor(S[2], (d[2, :num_mode] + 1j * d[2, num_mode:]) / 2,
cutoff),
(0, 2, 1, 3) if num_mode == 2 else (0, 3, 1, 4, 2, 5),
)
assert np.allclose(Ggate_matrix[2], ref_state, atol=tol, rtol=0.0)
def hamil_to_covmat(H, tol=1e-10): # pragma: no cover
r"""Converts a Hamiltonian matrix to a covariance matrix.
Given a Hamiltonian matrix of a Gaussian state H, finds the equivalent covariance matrix
V in the xp ordering.
For more details, see https://arxiv.org/abs/1507.01941
Args:
H (array): positive definite Hamiltonian matrix
tol (int): the number of decimal places to use when determining if the Hamiltonian is symmetric
Returns:
array: Gaussian covariance matrix
"""
(n, m) = H.shape
if n != m:
raise ValueError("Input matrix must be square")
if np.linalg.norm(H - np.transpose(H)) >= tol:
raise ValueError("The input matrix is not symmetric")
vals = np.linalg.eigvalsh(H)
for val in vals:
if val <= 0:
raise ValueError("Input matrix is not positive definite")
n = n // 2
omega = sympmat(n)
Wi = 1j * omega @ H
l, v = np.linalg.eig(Wi)
V = (1j *
(v @ np.diag(1.0 / np.tanh(l.real)) @ np.linalg.inv(v)) @ omega).real
return V
def williamson(V, rtol=1e-05, atol=1e-08):
r"""Williamson decomposition of positive-definite (real) symmetric matrix.
See `this thread <https://math.stackexchange.com/questions/1171842/finding-the-symplectic-matrix-in-williamsons-theorem/2682630#2682630>`_
and the `Williamson decomposition documentation <https://strawberryfields.ai/photonics/conventions/decompositions.html#williamson-decomposition>`_
Args:
V (array[float]): positive definite symmetric (real) matrix
rtol (float): the relative tolerance parameter used in ``np.allclose``
atol (float): the absolute tolerance parameter used in ``np.allclose``
Returns:
tuple[array,array]: ``(Db, S)`` where ``Db`` is a diagonal matrix
and ``S`` is a symplectic matrix such that :math:`V = S^T Db S`
"""
(n, m) = V.shape
if n != m:
raise ValueError("The input matrix is not square")
if not np.allclose(V, V.T, rtol=rtol, atol=atol):
raise ValueError("The input matrix is not symmetric")
if n % 2 != 0:
raise ValueError("The input matrix must have an even number of rows/columns")
n = n // 2
omega = sympmat(n)
vals = np.linalg.eigvalsh(V)
for val in vals:
if val <= 0:
raise ValueError("Input matrix is not positive definite")
Mm12 = sqrtm(np.linalg.inv(V)).real
r1 = Mm12 @ omega @ Mm12
s1, K = schur(r1)
X = np.array([[0, 1], [1, 0]])
I = np.identity(2)
seq = []
# In what follows I construct a permutation matrix p so that the Schur matrix has
# only positive elements above the diagonal
# Also the Schur matrix uses the x_1,p_1, ..., x_n,p_n ordering thus I permute using perm
# to go to the ordering x_1, ..., x_n, p_1, ... , p_n
for i in range(n):
if s1[2 * i, 2 * i + 1] > 0:
seq.append(I)
else:
seq.append(X)
perm = np.array([2 * i for i in range(n)] + [2 * i + 1 for i in range(n)])
p = block_diag(*seq)
Kt = K @ p
Ktt = Kt[:, perm]
s1t = p @ s1 @ p
dd = [1 / s1t[2 * i, 2 * i + 1] for i in range(n)]
Db = np.diag(dd + dd)
S = Mm12 @ Ktt @ sqrtm(Db)
return Db, np.linalg.inv(S).T
def test_symplectic_multimode(self, tol):
"""Test multimode version gives symplectic matrix"""
r = [0.543] * 4
phi = [0.123] * 4
S = symplectic.squeezing(r, phi)
# the symplectic matrix
O = symplectic.sympmat(4)
assert np.allclose(S @ O @ S.T, O, atol=tol, rtol=0)
def test_dtype(self, tol):
"""Test multimode version gives symplectic matrix"""
r = [0.543] * 4
phi = [0.123] * 4
S = symplectic.squeezing(r, phi)
S32_bit = symplectic.squeezing(r, phi, dtype=np.float32)
# the symplectic matrix
O = symplectic.sympmat(4)
assert np.allclose(S32_bit @ O @ S32_bit.T, O, atol=tol, rtol=0)
assert np.allclose(S, S32_bit, atol=tol, rtol=0)
def test_gaussian_gate_output(self, setup_backend, cutoff, tol):
"""Test if the output state of the gaussian gate has the right effect on states in the Fock basis"""
S = sympmat(2)
d = np.random.random(4)
X = np.zeros((cutoff, cutoff), dtype=np.complex128)
X[0, 0] = 1
Ggate_output = gaussian_gate(S,
d, [0, 1],
in_modes=X,
cutoff=cutoff,
pure=True)
ref_state = np.einsum("acbd,bd->ac",
fock_tensor(S, (d[:2] + 1j * d[2:]) / 2, cutoff),
X)
assert np.allclose(Ggate_output, ref_state, atol=tol, rtol=0.0)
def covmat_to_hamil(V, tol=1e-10): # pragma: no cover
r"""Converts a covariance matrix to a Hamiltonian.
Given a covariance matrix V of a Gaussian state :math:`\rho` in the xp ordering,
finds a positive matrix :math:`H` such that
.. math:: \rho = \exp(-Q^T H Q/2)/Z
where :math:`Q = (x_1,\dots,x_n,p_1,\dots,p_n)` are the canonical
operators, and Z is the partition function.
For more details, see https://arxiv.org/abs/1507.01941
Args:
V (array): Gaussian covariance matrix
tol (int): the number of decimal places to use when determining if the matrix is symmetric
Returns:
array: positive definite Hamiltonian matrix
"""
(n, m) = V.shape
if n != m:
raise ValueError("Input matrix must be square")
if np.linalg.norm(V - np.transpose(V)) >= tol:
raise ValueError("The input matrix is not symmetric")
n = n // 2
omega = sympmat(n)
vals = np.linalg.eigvalsh(V)
for val in vals:
if val <= 0:
raise ValueError("Input matrix is not positive definite")
W = 1j * V @ omega
l, v = np.linalg.eig(W)
H = (1j * omega
@ (v @ np.diag(np.arctanh(1.0 / l.real)) @ np.linalg.inv(v))).real
return H
def bloch_messiah(S, tol=1e-10, rounding=9):
r"""Bloch-Messiah decomposition of a symplectic matrix.
See :ref:`bloch_messiah`.
Decomposes a symplectic matrix into two symplectic unitaries and squeezing transformation.
It automatically sorts the squeezers so that they respect the canonical symplectic form.
Note that it is assumed that the symplectic form is
.. math:: \Omega = \begin{bmatrix}0&I\\-I&0\end{bmatrix}
where :math:`I` is the identity matrix and :math:`0` is the zero matrix.
As in the Takagi decomposition, the singular values of N are considered
equal if they are equal after np.round(values, rounding).
If S is a passive transformation, then return the S as the first passive
transformation, and set the the squeezing and second unitary matrices to
identity. This choice is not unique.
For more info see:
https://math.stackexchange.com/questions/1886038/finding-euler-decomposition-of-a-symplectic-matrix
Args:
S (array[float]): symplectic matrix
tol (float): the tolerance used when checking if the matrix is symplectic:
:math:`|S^T\Omega S-\Omega| \leq tol`
rounding (int): the number of decimal places to use when rounding the singular values
Returns:
tuple[array]: Returns the tuple ``(ut1, st1, vt1)``. ``ut1`` and ``vt1`` are symplectic orthogonal,
and ``st1`` is diagonal and of the form :math:`= \text{diag}(s1,\dots,s_n, 1/s_1,\dots,1/s_n)`
such that :math:`S = ut1 st1 v1`
"""
(n, m) = S.shape
if n != m:
raise ValueError("The input matrix is not square")
if n % 2 != 0:
raise ValueError(
"The input matrix must have an even number of rows/columns")
n = n // 2
omega = sympmat(n)
if np.linalg.norm(np.transpose(S) @ omega @ S - omega) >= tol:
raise ValueError("The input matrix is not symplectic")
if np.linalg.norm(np.transpose(S) @ S - np.eye(2 * n)) >= tol:
u, sigma = polar(S, side="left")
ss, uss = takagi(sigma, tol=tol, rounding=rounding)
# Apply a permutation matrix so that the squeezers appear in the order
# s_1,...,s_n, 1/s_1,...1/s_n
perm = np.array(list(range(0, n)) + list(reversed(range(n, 2 * n))))
pmat = np.identity(2 * n)[perm, :]
ut = uss @ pmat
# Apply a second permutation matrix to permute s
# (and their corresonding inverses) to get the canonical symplectic form
qomega = np.transpose(ut) @ (omega) @ ut
st = pmat @ np.diag(ss) @ pmat
# Identifying degenerate subspaces
result = []
for _k, g in groupby(np.round(np.diag(st), rounding)[:n]):
result.append(list(g))
stop_is = list(np.cumsum([len(res) for res in result]))
start_is = [0] + stop_is[:-1]
# Rotation matrices (not permutations) based on svd.
# See Appendix B2 of Serafini's book for more details.
u_list, v_list = [], []
for start_i, stop_i in zip(start_is, stop_is):
x = qomega[start_i:stop_i, n + start_i:n + stop_i].real
u_svd, _s_svd, v_svd = np.linalg.svd(x)
u_list = u_list + [u_svd]
v_list = v_list + [v_svd.T]
pmat1 = block_diag(*(u_list + v_list))
st1 = pmat1.T @ pmat @ np.diag(ss) @ pmat @ pmat1
ut1 = uss @ pmat @ pmat1
v1 = np.transpose(ut1) @ u
else:
ut1 = S
st1 = np.eye(2 * n)
v1 = np.eye(2 * n)
return ut1.real, st1.real, v1.real
def williamson(V, tol=1e-11):
r"""Williamson decomposition of positive-definite (real) symmetric matrix.
See :ref:`williamson`.
Note that it is assumed that the symplectic form is
.. math:: \Omega = \begin{bmatrix}0&I\\-I&0\end{bmatrix}
where :math:`I` is the identity matrix and :math:`0` is the zero matrix.
See https://math.stackexchange.com/questions/1171842/finding-the-symplectic-matrix-in-williamsons-theorem/2682630#2682630
Args:
V (array[float]): positive definite symmetric (real) matrix
tol (float): the tolerance used when checking if the matrix is symmetric: :math:`|V-V^T| \leq` tol
Returns:
tuple[array,array]: ``(Db, S)`` where ``Db`` is a diagonal matrix
and ``S`` is a symplectic matrix such that :math:`V = S^T Db S`
"""
(n, m) = V.shape
if n != m:
raise ValueError("The input matrix is not square")
diffn = np.linalg.norm(V - np.transpose(V))
if diffn >= tol:
raise ValueError("The input matrix is not symmetric")
if n % 2 != 0:
raise ValueError(
"The input matrix must have an even number of rows/columns")
n = n // 2
omega = sympmat(n)
vals = np.linalg.eigvalsh(V)
for val in vals:
if val <= 0:
raise ValueError("Input matrix is not positive definite")
Mm12 = sqrtm(np.linalg.inv(V)).real
r1 = Mm12 @ omega @ Mm12
s1, K = schur(r1)
X = np.array([[0, 1], [1, 0]])
I = np.identity(2)
seq = []
# In what follows I construct a permutation matrix p so that the Schur matrix has
# only positive elements above the diagonal
# Also the Schur matrix uses the x_1,p_1, ..., x_n,p_n ordering thus I use rotmat to
# go to the ordering x_1, ..., x_n, p_1, ... , p_n
for i in range(n):
if s1[2 * i, 2 * i + 1] > 0:
seq.append(I)
else:
seq.append(X)
p = block_diag(*seq)
Kt = K @ p
s1t = p @ s1 @ p
dd = xpxp_to_xxpp(s1t)
perm_indices = xpxp_to_xxpp(np.arange(2 * n))
Ktt = Kt[:, perm_indices]
Db = np.diag([1 / dd[i, i + n]
for i in range(n)] + [1 / dd[i, i + n] for i in range(n)])
S = Mm12 @ Ktt @ sqrtm(Db)
return Db, np.linalg.inv(S).T