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 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_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)