def test_jax(self):
"""Test that a jax array is automatically converted into
a diagonal tensor"""
t = jnp.array([0.1, 0.2, 0.3])
res = fn.diag(t)
assert fn.allclose(res, onp.diag([0.1, 0.2, 0.3]))
res = fn.diag(t, k=1)
assert fn.allclose(res, onp.diag([0.1, 0.2, 0.3], k=1))
def test_torch(self):
"""Test that a torch tensor is automatically converted into
a diagonal tensor"""
t = torch.tensor([0.1, 0.2, 0.3])
res = fn.diag(t)
assert isinstance(res, torch.Tensor)
assert fn.allclose(res, onp.diag([0.1, 0.2, 0.3]))
res = fn.diag(t, k=1)
assert fn.allclose(res, onp.diag([0.1, 0.2, 0.3], k=1))
def test_tensorflow(self):
"""Test that a tensorflow tensor is automatically converted into
a diagonal tensor"""
t = tf.Variable([0.1, 0.2, 0.3])
res = fn.diag(t)
assert isinstance(res, tf.Tensor)
assert fn.allclose(res, onp.diag([0.1, 0.2, 0.3]))
res = fn.diag(t, k=1)
assert fn.allclose(res, onp.diag([0.1, 0.2, 0.3], k=1))
def test_array(self):
"""Test that a NumPy array is automatically converted into
a diagonal tensor"""
t = np.array([0.1, 0.2, 0.3])
res = fn.diag(t)
assert isinstance(res, np.ndarray)
assert fn.allclose(res, onp.diag([0.1, 0.2, 0.3]))
res = fn.diag(t, k=1)
assert fn.allclose(res, onp.diag([0.1, 0.2, 0.3], k=1))
def test_sequence(self, a, interface):
"""Test that a sequence is automatically converted into
a diagonal tensor"""
t = [0.1, 0.2, a]
res = fn.diag(t)
assert fn.get_interface(res) == interface
assert fn.allclose(res, onp.diag([0.1, 0.2, 0.5]))
def _decomposition_1_cnot(U, wires):
r"""If there is just one CNOT, we can write the circuit in the form
-╭U- = -C--╭C--A-
-╰U- = -D--╰X--B-
To do this decomposition, first we find G, H in SO(4) such that
G (Edag V E) H = (Edag U E)
where V depends on the central CNOT gate, and both U, V are in SU(4). This
is done following the methods in https://arxiv.org/pdf/quant-ph/0308045.pdf.
Once we find G and H, we can use the fact that E SO(4) Edag gives us
something in SU(2) x SU(2) to give A, B, C, D.
"""
# We will actually find a decomposition for the following circuit instead
# of the original U
# -╭U-╭SWAP- = -C--╭C-╭SWAP--B-
# -╰U-╰SWAP- = -D--╰X-╰SWAP--A-
# This ensures that the internal part of the decomposition has determinant 1.
swap_U = np.exp(1j * np.pi / 4) * math.dot(math.cast_like(SWAP, U), U)
# First let's compute gamma(u). For the one-CNOT case, uuT is always real.
u = math.dot(math.cast_like(Edag, U), math.dot(swap_U,
math.cast_like(E, U)))
uuT = math.dot(u, math.T(u))
# Since uuT is real, we can use eigh of its real part. eigh also orders the
# eigenvalues in ascending order.
_, p = math.linalg.eigh(qml.math.real(uuT))
# Fix the determinant if necessary so that p is in SO(4)
p = math.dot(p, math.diag([1, 1, 1, math.sign(math.linalg.det(p))]))
# Now, we must find q such that p uu^T p^T = q vv^T q^T.
# For this case, our V = SWAP CNOT01 is constant. Thus, we can compute v,
# vvT, and its eigenvalues and eigenvectors directly. These matrices are stored
# above as the constants v_one_cnot and q_one_cnot.
# Once we have p and q properly in SO(4), we compute G and H in SO(4) such
# that U = G V H
G = math.dot(p, q_one_cnot.T)
H = math.dot(math.conj(math.T(v_one_cnot)), math.dot(math.T(G), u))
# We now use the magic basis to convert G, H to SU(2) x SU(2)
AB = math.dot(E, math.dot(G, Edag))
CD = math.dot(E, math.dot(H, Edag))
# Extract the tensor prodcts to SU(2) x SU(2)
A, B = _su2su2_to_tensor_products(AB)
C, D = _su2su2_to_tensor_products(CD)
# Recover the operators in the decomposition; note that because of the
# initial SWAP, we exchange the order of A and B
A_ops = zyz_decomposition(A, wires[1])
B_ops = zyz_decomposition(B, wires[0])
C_ops = zyz_decomposition(C, wires[0])
D_ops = zyz_decomposition(D, wires[1])
return C_ops + D_ops + [qml.CNOT(wires=wires)] + A_ops + B_ops
def _extract_su2su2_prefactors(U, V):
r"""This function is used for the case of 2 CNOTs and 3 CNOTs. It does something
similar as the 1-CNOT case, but there is no special form for one of the
SO(4) operations.
Suppose U, V are SU(4) matrices for which there exists A, B, C, D such that
(A \otimes B) V (C \otimes D) = U. The problem is to find A, B, C, D in SU(2)
in an analytic and fully differentiable manner.
This decomposition is possible when U and V are in the same double coset of
SU(4), meaning there exists G, H in SO(4) s.t. G (Edag V E) H = (Edag U
E). This is guaranteed here by how V was constructed in both the
_decomposition_2_cnots and _decomposition_3_cnots methods.
Then, we can use the fact that E SO(4) Edag gives us something in SU(2) x
SU(2) to give A, B, C, D.
"""
# A lot of the work here happens in the magic basis. Essentially, we
# don't look explicitly at some U = G V H, but rather at
# E^\dagger U E = G E^\dagger V E H
# so that we can recover
# U = (E G E^\dagger) V (E H E^\dagger) = (A \otimes B) V (C \otimes D).
# There is some math in the paper explaining how when we define U in this way,
# we can simultaneously diagonalize functions of U and V to ensure they are
# in the same coset and recover the decomposition.
u = math.dot(math.cast_like(Edag, V), math.dot(U, math.cast_like(E, V)))
v = math.dot(math.cast_like(Edag, V), math.dot(V, math.cast_like(E, V)))
uuT = math.dot(u, math.T(u))
vvT = math.dot(v, math.T(v))
# Get the p and q in SO(4) that diagonalize uuT and vvT respectively (and
# their eigenvalues). We are looking for a simultaneous diagonalization,
# which we know exists because of how U and V were constructed. Furthermore,
# The way we will do this is by noting that, since uuT/vvT are complex and
# symmetric, so both their real and imaginary parts share a set of
# real-valued eigenvectors, which are also eigenvectors of uuT/vvT
# themselves. So we can use eigh, which orders the eigenvectors, and so we
# are guaranteed that the p and q returned will be "in the same order".
_, p = math.linalg.eigh(math.real(uuT) + math.imag(uuT))
_, q = math.linalg.eigh(math.real(vvT) + math.imag(vvT))
# If determinant of p/q is not 1, it is in O(4) but not SO(4), and has determinant
# We can transform it to SO(4) by simply negating one of the columns.
p = math.dot(p, math.diag([1, 1, 1, math.sign(math.linalg.det(p))]))
q = math.dot(q, math.diag([1, 1, 1, math.sign(math.linalg.det(q))]))
# Now, we should have p, q in SO(4) such that p^T u u^T p = q^T v v^T q.
# Then (v^\dag q p^T u)(v^\dag q p^T u)^T = I.
# So we can set G = p q^T, H = v^\dag q p^T u to obtain G v H = u.
G = math.dot(math.cast_like(p, 1j), math.T(q))
H = math.dot(math.conj(math.T(v)), math.dot(math.T(G), u))
# These are still in SO(4) though - we want to convert things into SU(2) x SU(2)
# so use the entangler. Since u = E^\dagger U E and v = E^\dagger V E where U, V
# are the target matrices, we can reshuffle as in the docstring above,
# U = (E G E^\dagger) V (E H E^\dagger) = (A \otimes B) V (C \otimes D)
# where A, B, C, D are in SU(2) x SU(2).
AB = math.dot(math.cast_like(E, G), math.dot(G, math.cast_like(Edag, G)))
CD = math.dot(math.cast_like(E, H), math.dot(H, math.cast_like(Edag, H)))
# Now, we just need to extract the constituent tensor products.
A, B = _su2su2_to_tensor_products(AB)
C, D = _su2su2_to_tensor_products(CD)
return A, B, C, D