def test_hamiltonian_term_initialization(backend):
"""Test initialization and matrix assignment of ``HamiltonianTerm``."""
matrix = np.random.random((2, 2))
term = terms.HamiltonianTerm(matrix, 0)
assert term.target_qubits == (0, )
K.assert_allclose(term.matrix, matrix)
matrix = np.random.random((4, 4))
term = terms.HamiltonianTerm(matrix, 2, 3)
assert term.target_qubits == (2, 3)
K.assert_allclose(term.matrix, matrix)
def test_hamiltonian_term_merge(backend):
"""Test ``HamiltonianTerm.merge``."""
matrix1 = np.random.random((2, 2))
matrix2 = np.random.random((4, 4))
term1 = terms.HamiltonianTerm(matrix1, 1)
term2 = terms.HamiltonianTerm(matrix2, 0, 1)
mterm = term2.merge(term1)
target_matrix = np.kron(np.eye(2), matrix1) + matrix2
assert mterm.target_qubits == (0, 1)
K.assert_allclose(mterm.matrix, target_matrix)
with pytest.raises(ValueError):
term1.merge(term2)
def test_term_group_append():
"""Test ``GroupTerm.can_append`` method."""
term1 = terms.HamiltonianTerm(np.random.random((8, 8)), 0, 1, 3)
term2 = terms.HamiltonianTerm(np.random.random((2, 2)), 0)
term3 = terms.HamiltonianTerm(np.random.random((2, 2)), 1)
term4 = terms.HamiltonianTerm(np.random.random((2, 2)), 2)
group = terms.TermGroup(term1)
assert group.can_append(term2)
assert group.can_append(term3)
assert not group.can_append(term4)
group.append(term2)
group.append(term3)
assert group.target_qubits == {0, 1, 3}
def test_hamiltonian_term_initialization_errors():
"""Test initializing ``HamiltonianTerm`` with wrong parameters."""
# Wrong HamiltonianTerm matrix
with pytest.raises(TypeError):
t = terms.HamiltonianTerm("test", 0, 1)
# Passing negative target qubits in HamiltonianTerm
with pytest.raises(ValueError):
t = terms.HamiltonianTerm("test", 0, -1)
# Passing matrix shape incompatible with number of qubits
with pytest.raises(ValueError):
t = terms.HamiltonianTerm(np.random.random((4, 4)), 0, 1, 2)
# Merging terms with invalid qubits
t1 = terms.HamiltonianTerm(np.random.random((4, 4)), 0, 1)
t2 = terms.HamiltonianTerm(np.random.random((4, 4)), 1, 2)
with pytest.raises(ValueError):
t = t1.merge(t2)
def test_symbolic_term_merge(backend):
"""Test merging ``SymbolicTerm`` to ``HamiltonianTerm``."""
from qibo.symbols import X, Z
matrix = np.random.random((4, 4))
term1 = terms.HamiltonianTerm(matrix, 0, 1)
term2 = terms.SymbolicTerm(1, X(0) * Z(1))
term = term1.merge(term2)
target_matrix = matrix + np.kron(matrices.X, matrices.Z)
K.assert_allclose(term.matrix, target_matrix)
def test_hamiltonian_term_mul(backend):
"""Test scalar multiplication of ``HamiltonianTerm``."""
matrix = np.random.random((4, 4))
term = terms.HamiltonianTerm(matrix, 0, 2)
mterm = 2 * term
assert mterm.target_qubits == term.target_qubits
K.assert_allclose(mterm.matrix, 2 * matrix)
mterm = term * 5
assert mterm.target_qubits == term.target_qubits
K.assert_allclose(mterm.matrix, 5 * matrix)
def test_hamiltonian_term_exponentiation(backend):
"""Test exp gate application of ``HamiltonianTerm``."""
from scipy.linalg import expm
matrix = np.random.random((2, 2))
term = terms.HamiltonianTerm(matrix, 1)
exp_matrix = expm(-0.5j * matrix)
K.assert_allclose(term.exp(0.5), exp_matrix)
initial_state = random_state(2)
final_state = term.expgate(0.5)(np.copy(initial_state))
exp_gate = gates.Unitary(exp_matrix, 1)
target_state = exp_gate(np.copy(initial_state))
K.assert_allclose(final_state, target_state)
def test_hamiltonian_term_gates(backend):
"""Test gate application of ``HamiltonianTerm``."""
matrix = np.random.random((4, 4))
term = terms.HamiltonianTerm(matrix, 1, 2)
gate = term.gate
assert gate.target_qubits == (1, 2)
K.assert_allclose(gate.matrix, matrix)
initial_state = random_state(4)
final_state = term(np.copy(initial_state))
c = models.Circuit(4)
c.add(gates.Unitary(matrix, 1, 2))
target_state = c(np.copy(initial_state))
K.assert_allclose(final_state, target_state)
def test_term_group_to_term(backend):
"""Test ``GroupTerm.term`` property."""
from qibo.symbols import X, Z
matrix = np.random.random((8, 8))
term1 = terms.HamiltonianTerm(matrix, 0, 1, 3)
term2 = terms.SymbolicTerm(1, X(0) * Z(3))
term3 = terms.SymbolicTerm(2, X(1))
group = terms.TermGroup(term1)
group.append(term2)
group.append(term3)
matrix2 = np.kron(np.kron(matrices.X, np.eye(2)), matrices.Z)
matrix3 = np.kron(np.kron(np.eye(2), matrices.X), np.eye(2))
target_matrix = matrix + matrix2 + 2 * matrix3
K.assert_allclose(group.term.matrix, target_matrix)
