def test_ground_state_particle_nonconserving(self):
"""Test getting the ground state of a Hamiltonian that does not
conserve particle number."""
for n_qubits in self.n_qubits_range:
# Initialize a non-particle-number-conserving Hamiltonian
quadratic_hamiltonian = random_quadratic_hamiltonian(
n_qubits, False)
# Compute the true ground state
sparse_operator = get_sparse_operator(quadratic_hamiltonian)
ground_energy, ground_state = get_ground_state(sparse_operator)
# Compute the ground state using the circuit
circuit_energy, circuit_state = (
jw_get_gaussian_state(quadratic_hamiltonian))
# Check that the energies match
self.assertAlmostEqual(ground_energy, circuit_energy)
# Check that the state obtained using the circuit is a ground state
difference = (sparse_operator * circuit_state -
ground_energy * circuit_state)
discrepancy = 0.
if difference.nnz:
discrepancy = max(abs(difference.data))
self.assertTrue(discrepancy < EQ_TOLERANCE)
def test_excited_state_particle_nonconserving(self):
"""Test getting an excited state of a Hamiltonian that conserves
particle number."""
for n_qubits in self.n_qubits_range:
# Initialize a non-particle-number-conserving Hamiltonian
quadratic_hamiltonian = random_quadratic_hamiltonian(
n_qubits, False)
# Pick some orbitals to occupy
num_occupied_orbitals = numpy.random.randint(1, n_qubits + 1)
occupied_orbitals = numpy.random.choice(
range(n_qubits), num_occupied_orbitals, False)
# Compute the Gaussian state
circuit_energy, gaussian_state = jw_get_gaussian_state(
quadratic_hamiltonian, occupied_orbitals)
# Compute the true energy
orbital_energies, constant = (
quadratic_hamiltonian.orbital_energies())
energy = numpy.sum(orbital_energies[occupied_orbitals]) + constant
# Check that the energies match
self.assertAlmostEqual(energy, circuit_energy)
# Check that the state obtained using the circuit is an eigenstate
# with the correct eigenvalue
sparse_operator = get_sparse_operator(quadratic_hamiltonian)
difference = (sparse_operator * gaussian_state -
energy * gaussian_state)
discrepancy = 0.
if difference.nnz:
discrepancy = max(abs(difference.data))
self.assertTrue(discrepancy < EQ_TOLERANCE)
def do_rotate_basis_quadratic_hamiltonian(self, real):
"""Test diagonalizing a quadratic Hamiltonian that conserves particle
number."""
n_qubits = 5
# Initialize a particle-number-conserving quadratic Hamiltonian
# and compute its orbital energies
quad_ham = random_quadratic_hamiltonian(n_qubits, True, real=real)
orbital_energies, constant = quad_ham.orbital_energies()
# Rotate a basis where the Hamiltonian is diagonal
_, diagonalizing_unitary, _ = (
quad_ham.diagonalizing_bogoliubov_transform())
quad_ham.rotate_basis(diagonalizing_unitary.T)
# Check that the rotated Hamiltonian is diagonal with the correct
# orbital energies
D = numpy.zeros((n_qubits, n_qubits), dtype=complex)
D[numpy.diag_indices(n_qubits)] = orbital_energies
self.assertTrue(numpy.allclose(quad_ham.combined_hermitian_part, D))
# Check that the new Hamiltonian still conserves particle number
self.assertTrue(quad_ham.conserves_particle_number)
# Check that the orbital energies and constant are the same
new_orbital_energies, new_constant = quad_ham.orbital_energies()
self.assertTrue(numpy.allclose(orbital_energies, new_orbital_energies))
self.assertAlmostEqual(constant, new_constant)
def test_ground_state_particle_conserving(self):
"""Test getting the ground state of a Hamiltonian that conserves
particle number."""
for n_qubits in self.n_qubits_range:
# Initialize a particle-number-conserving Hamiltonian
quadratic_hamiltonian = random_quadratic_hamiltonian(
n_qubits, True)
# Compute the true ground state
sparse_operator = get_sparse_operator(quadratic_hamiltonian)
ground_energy, ground_state = get_ground_state(sparse_operator)
# Compute the ground state using the circuit
circuit_energy, circuit_state = jw_get_gaussian_state(
quadratic_hamiltonian)
# Check that the energies match
self.assertAlmostEqual(ground_energy, circuit_energy)
# Check that the state obtained using the circuit is a ground state
difference = (sparse_operator * circuit_state -
ground_energy * circuit_state)
discrepancy = numpy.amax(numpy.abs(difference))
self.assertAlmostEqual(discrepancy, 0)
