def test_hamiltonian_matmul(numpy):
"""Test matrix multiplication between Hamiltonians and state vectors."""
H1 = TFIM(nqubits=3, h=1.0, numpy=numpy)
H2 = Y(nqubits=3, numpy=numpy)
if numpy:
m1 = H1.matrix
m2 = H2.matrix
else:
m1 = H1.matrix.numpy()
m2 = H2.matrix.numpy()
np.testing.assert_allclose((H1 @ H2).matrix, m1 @ m2)
np.testing.assert_allclose((H2 @ H1).matrix, m2 @ m1)
v = utils.random_numpy_complex(8, dtype=m1.dtype)
m = utils.random_numpy_complex((8, 8), dtype=m1.dtype)
np.testing.assert_allclose(H1 @ v, m1.dot(v))
np.testing.assert_allclose(H1 @ m, m1 @ m)
from qibo.core.states import VectorState
state = VectorState.from_tensor(v)
np.testing.assert_allclose(H1 @ state, m1.dot(v))
with pytest.raises(ValueError):
H1 @ np.zeros((8, 8, 8), dtype=m1.dtype)
with pytest.raises(NotImplementedError):
H1 @ 2
def test_hamiltonian_expectation_errors():
h = XXZ(nqubits=3, delta=0.5)
state = utils.random_numpy_complex((4, 4, 4))
with pytest.raises(ValueError):
h.expectation(state)
with pytest.raises(TypeError):
h.expectation("test")
def test_hamiltonian_expectation(numpy, trotter, density_matrix):
h = XXZ(nqubits=3, delta=0.5, numpy=numpy, trotter=trotter)
matrix = np.array(h.matrix)
if density_matrix:
state = utils.random_numpy_complex((8, 8))
state = state + state.T.conj()
norm = np.trace(state)
target_ev = np.trace(matrix.dot(state)).real
else:
state = utils.random_numpy_complex(8)
norm = np.sum(np.abs(state)**2)
target_ev = np.sum(state.conj() * matrix.dot(state)).real
np.testing.assert_allclose(h.expectation(state), target_ev)
np.testing.assert_allclose(h.expectation(state, True), target_ev / norm)
def test_hamiltonian_expectation(numpy, trotter):
h = XXZ(nqubits=3, delta=0.5, numpy=numpy, trotter=trotter)
matrix = np.array(h.matrix)
state = utils.random_numpy_complex(8)
norm = (np.abs(state)**2).sum()
target_ev = (state.conj() * matrix.dot(state)).sum().real
np.testing.assert_allclose(h.expectation(state), target_ev)
np.testing.assert_allclose(h.expectation(state, True), target_ev / norm)
def test_generalized_fsim_error(backend):
"""Check GenerelizedfSim gate raises error for wrong unitary shape."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
phi = np.random.random()
rotation = utils.random_numpy_complex((4, 4))
c = Circuit(2)
with pytest.raises(ValueError):
c.add(gates.GeneralizedfSim(0, 1, rotation, phi))
qibo.set_backend(original_backend)
def test_controlled_by_unitary_action(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
init_state = utils.random_numpy_state(2)
matrix = utils.random_numpy_complex((2, 2))
gate = gates.Unitary(matrix, 1).controlled_by(0)
c = Circuit(2)
c.add(gate)
target_state = c(np.copy(init_state)).numpy()
final_state = gate.unitary.numpy().dot(init_state)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_trotter_hamiltonian_matmul(nqubits, normalize):
"""Test Trotter Hamiltonian expectation value."""
local_ham = TFIM(nqubits, h=1.0, trotter=True)
dense_ham = TFIM(nqubits, h=1.0)
state = utils.random_tensorflow_complex((2**nqubits, ))
trotter_ev = dense_ham.expectation(state, normalize)
target_ev = dense_ham.expectation(state, normalize)
np.testing.assert_allclose(trotter_ev, target_ev)
state = utils.random_numpy_complex((2**nqubits, ))
trotter_ev = dense_ham.expectation(state, normalize)
target_ev = dense_ham.expectation(state, normalize)
np.testing.assert_allclose(trotter_ev, target_ev)
def test_generalized_fsim(backend, accelerators):
"""Check GeneralizedfSim gate is working properly on |++>."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
phi = np.random.random()
rotation = utils.random_numpy_complex((2, 2))
c = Circuit(3, accelerators)
c.add((gates.H(i) for i in range(3)))
c.add(gates.GeneralizedfSim(1, 2, rotation, phi))
final_state = c.execute().numpy()
target_state = np.ones_like(final_state) / np.sqrt(8)
matrix = np.eye(4, dtype=target_state.dtype)
matrix[1:3, 1:3] = rotation
matrix[3, 3] = np.exp(-1j * phi)
target_state[:4] = matrix.dot(target_state[:4])
target_state[4:] = matrix.dot(target_state[4:])
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_unitary_gate(backend, nqubits):
"""Check applying `gates.Unitary` to density matrix."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
shape = 2 * (2**nqubits, )
matrix = utils.random_numpy_complex(shape)
initial_psi = utils.random_numpy_state(nqubits)
initial_rho = np.outer(initial_psi, initial_psi.conj())
circuit = models.Circuit(nqubits, density_matrix=True)
if backend == "custom" and nqubits > 2:
with pytest.raises(NotImplementedError):
circuit.add(gates.Unitary(matrix, *range(nqubits)))
else:
circuit.add(gates.Unitary(matrix, *range(nqubits)))
final_rho = circuit(np.copy(initial_rho)).numpy()
circuit = models.Circuit(nqubits)
circuit.add(gates.Unitary(matrix, *range(nqubits)))
target_psi = circuit(np.copy(initial_psi)).numpy()
target_rho = np.outer(target_psi, target_psi.conj())
np.testing.assert_allclose(final_rho, target_rho)
qibo.set_backend(original_backend)
