def test_random_operators_are_reproducible(self):
op1 = random_diagonal_coulomb_hamiltonian(5, seed=5947)
op2 = random_diagonal_coulomb_hamiltonian(5, seed=5947)
numpy.testing.assert_allclose(op1.one_body, op2.one_body)
numpy.testing.assert_allclose(op1.two_body, op2.two_body)
op1 = random_interaction_operator(5, seed=8911)
op2 = random_interaction_operator(5, seed=8911)
numpy.testing.assert_allclose(op1.one_body_tensor, op2.one_body_tensor)
numpy.testing.assert_allclose(op1.two_body_tensor, op2.two_body_tensor)
op1 = random_quadratic_hamiltonian(5, seed=17711)
op2 = random_quadratic_hamiltonian(5, seed=17711)
numpy.testing.assert_allclose(op1.combined_hermitian_part,
op2.combined_hermitian_part)
numpy.testing.assert_allclose(op1.antisymmetric_part,
op2.antisymmetric_part)
op1 = random_antisymmetric_matrix(5, seed=24074)
op2 = random_antisymmetric_matrix(5, seed=24074)
numpy.testing.assert_allclose(op1, op2)
op1 = random_hermitian_matrix(5, seed=56753)
op2 = random_hermitian_matrix(5, seed=56753)
numpy.testing.assert_allclose(op1, op2)
op1 = random_unitary_matrix(5, seed=56486)
op2 = random_unitary_matrix(5, seed=56486)
numpy.testing.assert_allclose(op1, op2)
def setUp(self):
self.n_qubits = 5
self.constant = 1.7
self.chemical_potential = 2.
# Obtain random Hermitian and antisymmetric matrices
self.hermitian_mat = random_hermitian_matrix(self.n_qubits)
self.antisymmetric_mat = random_antisymmetric_matrix(self.n_qubits)
self.combined_hermitian = (
self.hermitian_mat -
self.chemical_potential * numpy.eye(self.n_qubits))
# Initialize a particle-number-conserving Hamiltonian
self.quad_ham_pc = QuadraticHamiltonian(self.hermitian_mat,
constant=self.constant)
# Initialize a non-particle-number-conserving Hamiltonian
self.quad_ham_npc = QuadraticHamiltonian(self.hermitian_mat,
self.antisymmetric_mat,
self.constant,
self.chemical_potential)
# Initialize the sparse operators and get their ground energies
self.quad_ham_pc_sparse = get_sparse_operator(self.quad_ham_pc)
self.quad_ham_npc_sparse = get_sparse_operator(self.quad_ham_npc)
self.pc_ground_energy, self.pc_ground_state = get_ground_state(
self.quad_ham_pc_sparse)
self.npc_ground_energy, self.npc_ground_state = get_ground_state(
self.quad_ham_npc_sparse)
def test_equality(self):
"""Test that the decomposition is valid."""
n = 7
antisymmetric_matrix = random_antisymmetric_matrix(2 * n,
real=True,
seed=9799)
canonical, orthogonal = antisymmetric_canonical_form(
antisymmetric_matrix)
result_matrix = orthogonal.dot(antisymmetric_matrix.dot(orthogonal.T))
for i in numpy.ndindex(result_matrix.shape):
self.assertAlmostEqual(result_matrix[i], canonical[i])
def test_canonical(self):
"""Test that the returned canonical matrix has the right form."""
n = 7
# Obtain a random antisymmetric matrix
antisymmetric_matrix = random_antisymmetric_matrix(2 * n,
real=True,
seed=29206)
canonical, _ = antisymmetric_canonical_form(antisymmetric_matrix)
for i in range(2 * n):
for j in range(2 * n):
if i < n and j == n + i:
self.assertTrue(canonical[i, j] >= 0.0)
elif i >= n and j == i - n:
self.assertTrue(canonical[i, j] < 0.0)
else:
self.assertAlmostEqual(canonical[i, j], 0.)
diagonal = canonical[range(n), range(n, 2 * n)]
for i in range(n - 1):
self.assertTrue(diagonal[i] <= diagonal[i + 1])
