def test_invalid_qubit_state_vector(self, rep):
"""Test that an exception is raised if the state
vector is the wrong size"""
dev = DefaultTensorTF(wires=2, representation=rep)
state = np.array([0, 123.432])
with pytest.raises(
ValueError,
match=r"can apply QubitStateVector only to all of the 2 wires"
):
dev.execute([qml.QubitStateVector(state, wires=[0])], [], {})
def test_single_wire_expectation(self, gate, obs, expected, theta, phi, rep, tol):
"""Test that identity expectation value (i.e. the trace) is 1"""
dev = DefaultTensorTF(wires=2, representation=rep)
queue = [gate(theta, wires=0), gate(phi, wires=1), qml.CNOT(wires=[0, 1])]
observables = [obs(wires=[i]) for i in range(2)]
for i in range(len(observables)):
observables[i].return_type = qml.operation.Expectation
res = dev.execute(queue, observables, {})
assert np.allclose(res, expected(theta, phi), atol=tol, rtol=0)
def test_basis_state(self, tol, rep):
"""Test basis state initialization"""
dev = DefaultTensorTF(wires=4, representation=rep)
state = np.array([0, 0, 1, 0])
dev.execute([qml.BasisState(state, wires=[0, 1, 2, 3])], [], {})
res = dev._state().numpy().flatten()
expected = np.zeros([2**4])
expected[np.ravel_multi_index(state, [2] * 4)] = 1
assert np.allclose(res, expected, atol=tol, rtol=0)
def test_two_qubit_parameters(self, init_state, op, func, theta, rep, tol):
"""Test two qubit parametrized operations"""
dev = DefaultTensorTF(wires=2, representation=rep)
state = init_state(2)
queue = [qml.QubitStateVector(state, wires=[0, 1])]
queue += [op(theta, wires=[0, 1])]
dev.execute(queue, [], {})
res = dev._state().numpy().flatten()
expected = func(theta) @ state
assert np.allclose(res, expected, atol=tol, rtol=0)
def test_single_qubit_no_parameters(self, init_state, op, mat, rep, tol):
"""Test non-parametrized single qubit operations"""
dev = DefaultTensorTF(wires=1, representation=rep)
state = init_state(1)
queue = [qml.QubitStateVector(state, wires=[0])]
queue += [op(wires=0)]
dev.execute(queue, [], {})
res = dev._state().numpy().flatten()
expected = mat @ state
assert np.allclose(res, expected, atol=tol, rtol=0)
def test_qubit_unitary(self, init_state, mat, rep, tol):
"""Test application of arbitrary qubit unitaries"""
N = int(np.log2(len(mat)))
dev = DefaultTensorTF(wires=N, representation=rep)
state = init_state(N)
queue = [qml.QubitStateVector(state, wires=range(N))]
queue += [qml.QubitUnitary(mat, wires=range(N))]
dev.execute(queue, [], {})
res = dev._state().numpy().flatten()
expected = mat @ state
assert np.allclose(res, expected, atol=tol, rtol=0)
def test_var(self, theta, phi, rep, tol):
"""Tests for variance calculation"""
dev = DefaultTensorTF(wires=1, representation=rep)
# test correct variance for <Z> of a rotated state
queue = [qml.RX(phi, wires=0), qml.RY(theta, wires=0)]
observables = [qml.PauliZ(wires=[0])]
for i in range(len(observables)):
observables[i].return_type = qml.operation.Variance
res = dev.execute(queue, observables, {})
expected = 0.25 * (3 - np.cos(2 * theta) - 2 * np.cos(theta) ** 2 * np.cos(2 * phi))
assert np.allclose(res, expected, atol=tol, rtol=0)
def test_rotation(self, init_state, rep, tol):
"""Test three axis rotation gate"""
dev = DefaultTensorTF(wires=1, representation=rep)
state = init_state(1)
a = 0.542
b = 1.3432
c = -0.654
queue = [qml.QubitStateVector(state, wires=[0])]
queue += [qml.Rot(a, b, c, wires=0)]
dev.execute(queue, [], {})
res = dev._state().numpy().flatten()
expected = rot(a, b, c) @ state
assert np.allclose(res, expected, atol=tol, rtol=0)
def test_three_qubit_no_parameters(self, init_state, op, mat, rep, tol):
"""Test non-parametrized three qubit operations"""
if rep == "mps":
pytest.skip("Three-qubit gates not supported for `mps` representation.")
dev = DefaultTensorTF(wires=3, representation=rep)
state = init_state(3)
queue = [qml.QubitStateVector(state, wires=[0, 1, 2])]
queue += [op(wires=[0, 1, 2])]
dev.execute(queue, [], {})
res = dev._state().numpy().flatten()
expected = mat @ state
assert np.allclose(res, expected, atol=tol, rtol=0)
def test_var_hermitian(self, theta, phi, rep, tol):
"""Tests for variance calculation using an arbitrary Hermitian observable"""
dev = DefaultTensorTF(wires=2, representation=rep)
# test correct variance for <H> of a rotated state
H = np.array([[4, -1 + 6j], [-1 - 6j, 2]])
queue = [qml.RX(phi, wires=0), qml.RY(theta, wires=0)]
observables = [qml.Hermitian(H, wires=[0])]
for i in range(len(observables)):
observables[i].return_type = qml.operation.Variance
res = dev.execute(queue, observables, {})
expected = 0.5 * (2 * np.sin(2 * theta) * np.cos(phi)**2 +
24 * np.sin(phi) * np.cos(phi) *
(np.sin(theta) - np.cos(theta)) +
35 * np.cos(2 * phi) + 39)
assert np.allclose(res, expected, atol=tol, rtol=0)
def test_hermitian_expectation(self, theta, phi, rep, tol):
"""Test that arbitrary Hermitian expectation values are correct"""
dev = DefaultTensorTF(wires=2, representation=rep)
queue = [qml.RY(theta, wires=0), qml.RY(phi, wires=1), qml.CNOT(wires=[0, 1])]
observables = [qml.Hermitian(A, wires=[i]) for i in range(2)]
for i in range(len(observables)):
observables[i].return_type = qml.operation.Expectation
res = dev.execute(queue, observables, {})
a = A[0, 0]
re_b = A[0, 1].real
d = A[1, 1]
ev1 = ((a - d) * np.cos(theta) + 2 * re_b * np.sin(theta) * np.sin(phi) + a + d) / 2
ev2 = ((a - d) * np.cos(theta) * np.cos(phi) + 2 * re_b * np.sin(phi) + a + d) / 2
expected = np.array([ev1, ev2])
assert np.allclose(res, expected, atol=tol, rtol=0)