def test_model_integration_with_constant(self):
# Compute Hamiltonian in both momentum and position space.
length_scale = 0.7
grid = Grid(dimensions=2, length=3, scale=length_scale)
spinless = True
# Include the Madelung constant in the momentum but not the position
# Hamiltonian.
momentum_hamiltonian = jellium_model(grid,
spinless,
True,
include_constant=True)
position_hamiltonian = jellium_model(grid, spinless, False)
# Diagonalize and confirm the same energy.
jw_momentum = jordan_wigner(momentum_hamiltonian)
jw_position = jordan_wigner(position_hamiltonian)
momentum_spectrum = eigenspectrum(jw_momentum)
position_spectrum = eigenspectrum(jw_position)
# Confirm momentum spectrum is shifted 2.8372 / length_scale higher.
max_difference = numpy.amax(momentum_spectrum - position_spectrum)
min_difference = numpy.amax(momentum_spectrum - position_spectrum)
self.assertAlmostEqual(max_difference, 2.8372 / length_scale)
self.assertAlmostEqual(min_difference, 2.8372 / length_scale)
def test_bk_jw_majoranas(self):
# Check if the Majorana operators have the same spectrum
# irrespectively of the transform.
n_qubits = 7
a = FermionOperator(((1, 0), ))
a_dag = FermionOperator(((1, 1), ))
c = a + a_dag
d = 1j * (a_dag - a)
c_spins = [jordan_wigner(c), bravyi_kitaev(c)]
d_spins = [jordan_wigner(d), bravyi_kitaev(d)]
c_sparse = [
get_sparse_operator(c_spins[0]),
get_sparse_operator(c_spins[1])
]
d_sparse = [
get_sparse_operator(d_spins[0]),
get_sparse_operator(d_spins[1])
]
c_spectrum = [eigenspectrum(c_spins[0]), eigenspectrum(c_spins[1])]
d_spectrum = [eigenspectrum(d_spins[0]), eigenspectrum(d_spins[1])]
self.assertAlmostEqual(
0., numpy.amax(numpy.absolute(d_spectrum[0] - d_spectrum[1])))
def test_plane_wave_hamiltonian_integration(self):
length_set = [3, 4]
spinless_set = [True, False]
geometry = [('H', (0, )), ('H', (0.8, ))]
length_scale = 1.1
for l in length_set:
for spinless in spinless_set:
grid = Grid(dimensions=1, scale=length_scale, length=l)
h_plane_wave = plane_wave_hamiltonian(grid,
geometry,
spinless,
True,
include_constant=True)
h_dual_basis = plane_wave_hamiltonian(grid, geometry, spinless,
False)
jw_h_plane_wave = jordan_wigner(h_plane_wave)
jw_h_dual_basis = jordan_wigner(h_dual_basis)
h_plane_wave_spectrum = eigenspectrum(jw_h_plane_wave)
h_dual_basis_spectrum = eigenspectrum(jw_h_dual_basis)
max_diff = numpy.amax(h_plane_wave_spectrum -
h_dual_basis_spectrum)
min_diff = numpy.amin(h_plane_wave_spectrum -
h_dual_basis_spectrum)
self.assertAlmostEqual(max_diff, 2.8372 / length_scale)
self.assertAlmostEqual(min_diff, 2.8372 / length_scale)
def test_eigenspectrum(self):
fermion_eigenspectrum = eigenspectrum(self.fermion_operator)
qubit_eigenspectrum = eigenspectrum(self.qubit_operator)
interaction_eigenspectrum = eigenspectrum(self.interaction_operator)
for i in range(2 ** self.n_qubits):
self.assertAlmostEqual(fermion_eigenspectrum[i],
qubit_eigenspectrum[i])
self.assertAlmostEqual(fermion_eigenspectrum[i],
interaction_eigenspectrum[i])
def test_bk_jw_number_operator(self):
# Check if number operator has the same spectrum in both
# BK and JW representations
n = number_operator(1, 0)
jw_n = jordan_wigner(n)
bk_n = bravyi_kitaev(n)
# Diagonalize and make sure the spectra are the same.
jw_spectrum = eigenspectrum(jw_n)
bk_spectrum = eigenspectrum(bk_n)
self.assertAlmostEqual(
0., numpy.amax(numpy.absolute(jw_spectrum - bk_spectrum)))
def test_bk_jw_hopping_operator(self):
# Check if the spectrum fits for a single hoppping operator
n_qubits = 5
ho = FermionOperator(((1, 1), (4, 0))) + FermionOperator(
((4, 1), (1, 0)))
jw_ho = jordan_wigner(ho)
bk_ho = bravyi_kitaev(ho)
# Diagonalize and make sure the spectra are the same.
jw_spectrum = eigenspectrum(jw_ho)
bk_spectrum = eigenspectrum(bk_ho)
self.assertAlmostEqual(
0., numpy.amax(numpy.absolute(jw_spectrum - bk_spectrum)))
def test_bk_jw_number_operator_scaled(self):
# Check if number operator has the same spectrum in both
# JW and BK representations
n_qubits = 1
n = number_operator(n_qubits, 0, coefficient=2) # eigenspectrum (0,2)
jw_n = jordan_wigner(n)
bk_n = bravyi_kitaev(n)
# Diagonalize and make sure the spectra are the same.
jw_spectrum = eigenspectrum(jw_n)
bk_spectrum = eigenspectrum(bk_n)
self.assertAlmostEqual(
0., numpy.amax(numpy.absolute(jw_spectrum - bk_spectrum)))
def test_bk_jw_integration(self):
# This is a legacy test, which was a minimal failing example when
# optimization for hermitian operators was used.
n_qubits = 4
# Minimal failing example:
fo = FermionOperator(((3, 1), ))
jw = jordan_wigner(fo)
bk = bravyi_kitaev(fo)
jw_spectrum = eigenspectrum(jw)
bk_spectrum = eigenspectrum(bk)
self.assertAlmostEqual(
0., numpy.amax(numpy.absolute(jw_spectrum - bk_spectrum)))
def test_bk_jw_number_operators(self):
# Check if a number operator has the same spectrum in both
# JW and BK representations
n_qubits = 2
n1 = number_operator(n_qubits, 0)
n2 = number_operator(n_qubits, 1)
n = n1 + n2
jw_n = jordan_wigner(n)
bk_n = bravyi_kitaev(n)
# Diagonalize and make sure the spectra are the same.
jw_spectrum = eigenspectrum(jw_n)
bk_spectrum = eigenspectrum(bk_n)
self.assertAlmostEqual(
0., numpy.amax(numpy.absolute(jw_spectrum - bk_spectrum)))
def test_model_integration(self):
# Compute Hamiltonian in both momentum and position space.
grid = Grid(dimensions=2, length=3, scale=1.0)
spinless = True
momentum_hamiltonian = jellium_model(grid, spinless, True)
position_hamiltonian = jellium_model(grid, spinless, False)
# Diagonalize and confirm the same energy.
jw_momentum = jordan_wigner(momentum_hamiltonian)
jw_position = jordan_wigner(position_hamiltonian)
momentum_spectrum = eigenspectrum(jw_momentum)
position_spectrum = eigenspectrum(jw_position)
# Confirm spectra are the same.
difference = numpy.amax(
numpy.absolute(momentum_spectrum - position_spectrum))
self.assertAlmostEqual(difference, 0.)
def test_potential_integration(self):
# Compute potential energy operator in momentum and position space.
grid = Grid(dimensions=2, length=3, scale=2.)
spinless = 1
momentum_potential = plane_wave_potential(grid, spinless)
position_potential = dual_basis_potential(grid, spinless)
# Diagonalize and confirm the same energy.
jw_momentum = jordan_wigner(momentum_potential)
jw_position = jordan_wigner(position_potential)
momentum_spectrum = eigenspectrum(jw_momentum)
position_spectrum = eigenspectrum(jw_position)
# Confirm spectra are the same.
difference = numpy.amax(
numpy.absolute(momentum_spectrum - position_spectrum))
self.assertAlmostEqual(difference, 0.)
def test_kinetic_integration(self):
# Compute kinetic energy operator in both momentum and position space.
grid = Grid(dimensions=2, length=2, scale=3.)
spinless = False
momentum_kinetic = plane_wave_kinetic(grid, spinless)
position_kinetic = dual_basis_kinetic(grid, spinless)
# Diagonalize and confirm the same energy.
jw_momentum = jordan_wigner(momentum_kinetic)
jw_position = jordan_wigner(position_kinetic)
momentum_spectrum = eigenspectrum(jw_momentum)
position_spectrum = eigenspectrum(jw_position)
# Confirm spectra are the same.
difference = numpy.amax(
numpy.absolute(momentum_spectrum - position_spectrum))
self.assertAlmostEqual(difference, 0.)
def test_bk_jw_integration_original(self):
# This is a legacy test, which was an example proposed by Ryan,
# failing when optimization for hermitian operators was used.
n_qubits = 5
fermion_operator = FermionOperator(((3, 1), (2, 1), (1, 0), (0, 0)),
-4.3)
fermion_operator += FermionOperator(((3, 1), (1, 0)), 8.17)
fermion_operator += 3.2 * FermionOperator()
# Map to qubits and compare matrix versions.
jw_qubit_operator = jordan_wigner(fermion_operator)
bk_qubit_operator = bravyi_kitaev(fermion_operator)
# Diagonalize and make sure the spectra are the same.
jw_spectrum = eigenspectrum(jw_qubit_operator)
bk_spectrum = eigenspectrum(bk_qubit_operator)
self.assertAlmostEqual(0., numpy.amax(numpy.absolute(jw_spectrum -
bk_spectrum)))
def test_model_integration(self):
# Compute Hamiltonian in both momentum and position space.
n_dimensions = 2
grid_length = 3
length_scale = 1.
spinless = 1
momentum_hamiltonian = jellium_model(
n_dimensions, grid_length, length_scale, spinless, 1)
position_hamiltonian = jellium_model(
n_dimensions, grid_length, length_scale, spinless, 0)
# Diagonalize and confirm the same energy.
jw_momentum = jordan_wigner(momentum_hamiltonian)
jw_position = jordan_wigner(position_hamiltonian)
momentum_spectrum = eigenspectrum(jw_momentum)
position_spectrum = eigenspectrum(jw_position)
# Confirm spectra are the same.
difference = numpy.amax(
numpy.absolute(momentum_spectrum - position_spectrum))
self.assertAlmostEqual(difference, 0.)
def test_kinetic_integration(self):
# Compute kinetic energy operator in both momentum and position space.
n_dimensions = 2
grid_length = 2
length_scale = 3.
spinless = 0
momentum_kinetic = momentum_kinetic_operator(
n_dimensions, grid_length, length_scale, spinless)
position_kinetic = position_kinetic_operator(
n_dimensions, grid_length, length_scale, spinless)
# Diagonalize and confirm the same energy.
jw_momentum = jordan_wigner(momentum_kinetic)
jw_position = jordan_wigner(position_kinetic)
momentum_spectrum = eigenspectrum(jw_momentum)
position_spectrum = eigenspectrum(jw_position)
# Confirm spectra are the same.
difference = numpy.amax(
numpy.absolute(momentum_spectrum - position_spectrum))
self.assertAlmostEqual(difference, 0.)
def test_u_operator_integration(self):
n_dimensions = 1
length_scale = 1
grid_length = 3
spinless_set = [True, False]
nuclear_charges = numpy.empty((3))
nuclear_charges[0] = 1
nuclear_charges[1] = -3
nuclear_charges[2] = 2
for spinless in spinless_set:
u_plane_wave = plane_wave_u_operator(
n_dimensions, grid_length, length_scale, nuclear_charges,
spinless)
u_dual_basis = dual_basis_u_operator(
n_dimensions, grid_length, length_scale, nuclear_charges,
spinless)
jw_u_plane_wave = jordan_wigner(u_plane_wave)
jw_u_dual_basis = jordan_wigner(u_dual_basis)
u_plane_wave_spectrum = eigenspectrum(jw_u_plane_wave)
u_dual_basis_spectrum = eigenspectrum(jw_u_dual_basis)
diff = numpy.amax(numpy.absolute(
u_plane_wave_spectrum - u_dual_basis_spectrum))
self.assertAlmostEqual(diff, 0)
