def dual_basis_jellium_hamiltonian(grid_length, dimension=3,
wigner_seitz_radius=10., n_particles=None,
spinless=True):
"""Return the jellium Hamiltonian with the given parameters.
Args:
grid_length (int): The number of spatial orbitals per dimension.
dimension (int): The dimension of the system.
wigner_seitz_radius (float): The radius per particle in Bohr.
n_particles (int): The number of particles in the system.
Defaults to half filling if not specified.
"""
n_qubits = grid_length ** dimension
if not spinless:
n_qubits *= 2
if n_particles is None:
# Default to half filling fraction.
n_particles = n_qubits // 2
if not (0 <= n_particles <= n_qubits):
raise ValueError('n_particles must be between 0 and the number of'
' spin-orbitals.')
# Compute appropriate length scale.
length_scale = wigner_seitz_length_scale(
wigner_seitz_radius, n_particles, dimension)
grid = Grid(dimension, grid_length, length_scale)
hamiltonian = jellium_model(grid, spinless=spinless, plane_wave=False)
hamiltonian = normal_ordered(hamiltonian)
hamiltonian.compress()
return hamiltonian
def test_3d2_with_spin(self):
dimension = 3
grid_length = 2
n_spatial_orbitals = grid_length**dimension
wigner_seitz_radius = 9.3
spinless = False
n_qubits = n_spatial_orbitals
if not spinless:
n_qubits *= 2
n_particles_big = 9
length_scale = wigner_seitz_length_scale(wigner_seitz_radius,
n_particles_big, dimension)
self.grid3 = Grid(dimension, grid_length, length_scale)
# Get the occupied orbitals of the plane-wave basis Hartree-Fock state.
hamiltonian = jellium_model(self.grid3, spinless, plane_wave=True)
hamiltonian = normal_ordered(hamiltonian)
hamiltonian.compress()
occupied_states = numpy.array(
lowest_single_particle_energy_states(hamiltonian, n_particles_big))
self.hf_state_index3 = numpy.sum(2**occupied_states)
self.hf_state3 = csc_matrix(([1.0], ([self.hf_state_index3], [0])),
shape=(2**n_qubits, 1))
self.orbital_occupations3 = [
digit == '1' for digit in bin(self.hf_state_index3)[2:]
][::-1]
self.occupied_orbitals3 = [
index for index, occupied in enumerate(self.orbital_occupations3)
if occupied
]
self.reversed_occupied_orbitals3 = list(self.occupied_orbitals3)
for i in range(len(self.reversed_occupied_orbitals3)):
self.reversed_occupied_orbitals3[i] = -1 + int(
numpy.log2(self.hf_state3.shape[0])
) - self.reversed_occupied_orbitals3[i]
self.reversed_hf_state_index3 = sum(
2**index for index in self.reversed_occupied_orbitals3)
operator = (FermionOperator('4^ 2^ 3^ 5 5 4', 2) +
FermionOperator('7^ 6^ 7 4', -3.7j) +
FermionOperator('3^ 7', 2.1))
operator = normal_ordered(operator)
transformed_operator = normal_ordered(
fourier_transform(operator, self.grid3, spinless))
expected = -0.2625 - 0.578125j
# Calculated from expected = expectation(get_sparse_operator(
# transformed_operator), self.hf_state3)
actual = expectation_db_operator_with_pw_basis_state(
operator, self.reversed_occupied_orbitals3, n_spatial_orbitals,
self.grid3, spinless)
self.assertAlmostEqual(expected, actual)
def test_hf_state_plane_wave_basis_lowest_single_determinant_state(self):
grid_length = 7
dimension = 1
spinless = True
n_particles = 4
length_scale = 2.0
grid = Grid(dimension, grid_length, length_scale)
hamiltonian = jellium_model(grid, spinless)
hamiltonian_sparse = get_sparse_operator(hamiltonian)
hf_state = hartree_fock_state_jellium(grid,
n_particles,
spinless,
plane_wave=True)
HF_energy = expectation(hamiltonian_sparse, hf_state)
for occupied_orbitals in permutations([1] * n_particles + [0] *
(grid_length - n_particles)):
state_index = numpy.sum(2**numpy.array(occupied_orbitals))
HF_competitor = csr_matrix(([1.0], ([state_index], [0])),
shape=(2**grid_length, 1))
self.assertLessEqual(
HF_energy, expectation(hamiltonian_sparse, HF_competitor))
def test_hf_state_energy_close_to_ground_energy_at_high_density(self):
grid_length = 8
dimension = 1
spinless = True
n_particles = grid_length**dimension // 2
# High density -> small length_scale.
length_scale = 0.25
grid = Grid(dimension, grid_length, length_scale)
hamiltonian = jellium_model(grid, spinless)
hamiltonian_sparse = get_sparse_operator(hamiltonian)
hf_state = hartree_fock_state_jellium(grid,
n_particles,
spinless,
plane_wave=True)
restricted_hamiltonian = jw_number_restrict_operator(
hamiltonian_sparse, n_particles)
E_g = get_ground_state(restricted_hamiltonian)[0]
E_HF_plane_wave = expectation(hamiltonian_sparse, hf_state)
self.assertAlmostEqual(E_g, E_HF_plane_wave, places=5)
def test_hf_state_energy_same_in_plane_wave_and_dual_basis(self):
grid_length = 4
dimension = 1
wigner_seitz_radius = 10.0
spinless = False
n_orbitals = grid_length**dimension
if not spinless:
n_orbitals *= 2
n_particles = n_orbitals // 2
length_scale = wigner_seitz_length_scale(wigner_seitz_radius,
n_particles, dimension)
grid = Grid(dimension, grid_length, length_scale)
hamiltonian = jellium_model(grid, spinless)
hamiltonian_dual_basis = jellium_model(grid,
spinless,
plane_wave=False)
# Get the Hamiltonians as sparse operators.
hamiltonian_sparse = get_sparse_operator(hamiltonian)
hamiltonian_dual_sparse = get_sparse_operator(hamiltonian_dual_basis)
hf_state = hartree_fock_state_jellium(grid,
n_particles,
spinless,
plane_wave=True)
hf_state_dual = hartree_fock_state_jellium(grid,
n_particles,
spinless,
plane_wave=False)
E_HF_plane_wave = expectation(hamiltonian_sparse, hf_state)
E_HF_dual = expectation(hamiltonian_dual_sparse, hf_state_dual)
self.assertAlmostEqual(E_HF_dual, E_HF_plane_wave)
def test_ffft_2d_4x4_equal_expectation_values(self):
system_size = 4
n_qubits = 16
grid = Grid(dimensions=2, length=system_size, scale=1.0)
dual_basis = jellium_model(grid, spinless=True, plane_wave=False)
ffft_result = operator_2d_fft_with_reordering(dual_basis, system_size)
jw_dual_basis = jordan_wigner(dual_basis)
jw_plane_wave = jordan_wigner(ffft_result)
# Do plane wave and dual basis calculations together.
pw_engine = MainEngine()
pw_wavefunction = pw_engine.allocate_qureg(system_size**2)
db_engine = MainEngine()
db_wavefunction = db_engine.allocate_qureg(system_size**2)
pw_engine.flush()
db_engine.flush()
# Choose random state.
state = numpy.zeros(2**n_qubits, dtype=complex)
for i in range(len(state)):
state[i] = (random.random() *
numpy.exp(1j * 2 * numpy.pi * random.random()))
state /= numpy.linalg.norm(state)
# Put randomly chosen state in the registers.
pw_engine.backend.set_wavefunction(state, pw_wavefunction)
db_engine.backend.set_wavefunction(state, db_wavefunction)
# Apply the FFFT to the dual basis wave function.
ffft_2d(db_engine, db_wavefunction, system_size)
# Flush the engine and compute expectation values and eigenvalues.
pw_engine.flush()
db_engine.flush()
plane_wave_expectation_value = (
pw_engine.backend.get_expectation_value(jw_dual_basis,
pw_wavefunction))
dual_basis_expectation_value = (
db_engine.backend.get_expectation_value(jw_plane_wave,
db_wavefunction))
All(Measure) | pw_wavefunction
All(Measure) | db_wavefunction
self.assertAlmostEqual(plane_wave_expectation_value,
dual_basis_expectation_value)
def test_jw_restrict_jellium_ground_state_integration(self):
n_qubits = 4
grid = Grid(dimensions=1, length=n_qubits, scale=1.0)
jellium_hamiltonian = jordan_wigner_sparse(
jellium_model(grid, spinless=False))
# 2 * n_qubits because of spin
number_sparse = jordan_wigner_sparse(number_operator(2 * n_qubits))
restricted_number = jw_number_restrict_operator(number_sparse, 2)
restricted_jellium_hamiltonian = jw_number_restrict_operator(
jellium_hamiltonian, 2)
energy, ground_state = get_ground_state(restricted_jellium_hamiltonian)
number_expectation = expectation(restricted_number, ground_state)
self.assertAlmostEqual(number_expectation, 2)
def setUp(self):
grid_length = 4
dimension = 1
wigner_seitz_radius = 10.
self.spinless = True
self.n_spatial_orbitals = grid_length**dimension
n_qubits = self.n_spatial_orbitals
self.n_particles = 3
# Compute appropriate length scale and the corresponding grid.
length_scale = wigner_seitz_length_scale(wigner_seitz_radius,
self.n_particles, dimension)
self.grid1 = Grid(dimension, grid_length, length_scale)
# Get the occupied orbitals of the plane-wave basis Hartree-Fock state.
hamiltonian = jellium_model(self.grid1, self.spinless, plane_wave=True)
hamiltonian = normal_ordered(hamiltonian)
hamiltonian.compress()
occupied_states = numpy.array(
lowest_single_particle_energy_states(hamiltonian,
self.n_particles))
self.hf_state_index1 = numpy.sum(2**occupied_states)
self.hf_state1 = csc_matrix(([1.0], ([self.hf_state_index1], [0])),
shape=(2**n_qubits, 1))
self.orbital_occupations1 = [
digit == '1' for digit in bin(self.hf_state_index1)[2:]
][::-1]
self.occupied_orbitals1 = [
index for index, occupied in enumerate(self.orbital_occupations1)
if occupied
]
self.reversed_occupied_orbitals1 = list(self.occupied_orbitals1)
for i in range(len(self.reversed_occupied_orbitals1)):
self.reversed_occupied_orbitals1[i] = -1 + int(
numpy.log2(self.hf_state1.shape[0])
) - self.reversed_occupied_orbitals1[i]
self.reversed_hf_state_index1 = sum(
2**index for index in self.reversed_occupied_orbitals1)
def test_jordan_wigner_dual_basis_hamiltonian_default_to_jellium(self):
grid = Grid(dimensions=1, scale=1.0, length=4)
self.assertTrue(
jordan_wigner_dual_basis_hamiltonian(grid).isclose(
jordan_wigner(jellium_model(grid, plane_wave=False))))
def test_plane_wave_hamiltonian_default_to_jellium_with_no_geometry(self):
grid = Grid(dimensions=1, scale=1.0, length=4)
self.assertTrue(
plane_wave_hamiltonian(grid).isclose(jellium_model(grid)))
def test_8mode_ffft_with_external_swaps_equal_expectation_values(self):
n_qubits = 8
grid = Grid(dimensions=1, length=n_qubits, scale=1.0)
dual_basis = jellium_model(grid, spinless=True, plane_wave=False)
ffft_result = normal_ordered(dual_basis)
# Swap 01234567 to 45670123 for fourier_transform. Additionally,
# the FFFT's ordering is 04261537, so swap 04261537 to 01234567,
# and then 01234567 to 45670123.
swap_mode_list = ([1, 3, 5, 2, 4, 1, 3, 5] +
[3, 2, 4, 1, 3, 5, 0, 2, 4, 6, 1, 3, 5, 2, 4, 3])
for mode in swap_mode_list:
ffft_result = swap_adjacent_fermionic_modes(ffft_result, mode)
ffft_result = normal_ordered(ffft_result)
ffft_result = fourier_transform(ffft_result, grid, spinless=True)
ffft_result = normal_ordered(ffft_result)
# After the FFFT, swap 45670123 -> 01234567.
swap_mode_list = [3, 2, 4, 1, 3, 5, 0, 2, 4, 6, 1, 3, 5, 2, 4, 3]
for mode in swap_mode_list:
ffft_result = swap_adjacent_fermionic_modes(ffft_result, mode)
ffft_result = normal_ordered(ffft_result)
jw_dual_basis = jordan_wigner(dual_basis)
jw_plane_wave = jordan_wigner(ffft_result)
# Do plane wave and dual basis calculations simultaneously.
pw_engine = MainEngine()
pw_wavefunction = pw_engine.allocate_qureg(n_qubits)
db_engine = MainEngine()
db_wavefunction = db_engine.allocate_qureg(n_qubits)
pw_engine.flush()
db_engine.flush()
# Choose random state.
state = numpy.zeros(2**n_qubits, dtype=complex)
for i in range(len(state)):
state[i] = (random.random() *
numpy.exp(1j * 2 * numpy.pi * random.random()))
state /= numpy.linalg.norm(state)
# Put randomly chosen state in the registers.
pw_engine.backend.set_wavefunction(state, pw_wavefunction)
db_engine.backend.set_wavefunction(state, db_wavefunction)
prepare_logical_state(pw_wavefunction, i)
prepare_logical_state(db_wavefunction, i)
All(H) | [pw_wavefunction[1], pw_wavefunction[3]]
All(H) | [db_wavefunction[1], db_wavefunction[3]]
ffft(db_engine, db_wavefunction, n_qubits)
Ph(3 * numpy.pi / 4) | db_wavefunction[0]
# Flush the engine and compute expectation values and eigenvalues.
pw_engine.flush()
db_engine.flush()
plane_wave_expectation_value = (
pw_engine.backend.get_expectation_value(jw_dual_basis,
pw_wavefunction))
dual_basis_expectation_value = (
db_engine.backend.get_expectation_value(jw_plane_wave,
db_wavefunction))
All(Measure) | pw_wavefunction
All(Measure) | db_wavefunction
self.assertAlmostEqual(plane_wave_expectation_value,
dual_basis_expectation_value)
