def test_is_hopping_operator_terms_with_info(self):
grid_length = 4
dimension = 1
wigner_seitz_radius = 10.0
inverse_filling_fraction = 2
# Generate the Hamiltonian.
grid = hypercube_grid_with_given_wigner_seitz_radius_and_filling(
dimension, grid_length, wigner_seitz_radius,
1. / inverse_filling_fraction)
hamiltonian = normal_ordered(
jellium_model(grid, spinless=True, plane_wave=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_low_depth_terms_with_info(
hamiltonian)
terms, indices, is_hopping = result
for i in range(len(terms)):
single_term = list(terms[i].terms)[0]
is_hopping_term = not (single_term[1][1]
or single_term[0][0] == single_term[1][0])
self.assertEqual(is_hopping_term, is_hopping[i])
def test_correct_indices_terms_with_info(self):
grid_length = 4
dimension = 1
wigner_seitz_radius = 10.0
inverse_filling_fraction = 2
n_qubits = grid_length**dimension
# Generate the Hamiltonian.
grid = hypercube_grid_with_given_wigner_seitz_radius_and_filling(
dimension, grid_length, wigner_seitz_radius,
1. / inverse_filling_fraction)
hamiltonian = normal_ordered(
jellium_model(grid, spinless=True, plane_wave=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_low_depth_terms_with_info(
hamiltonian)
terms, indices, is_hopping = result
for i in range(len(terms)):
term = list(terms[i].terms)
term_indices = set()
for single_term in term:
term_indices = term_indices.union(
[single_term[j][0] for j in range(len(single_term))])
self.assertEqual(term_indices, indices[i])
def test_sum_of_ordered_terms_equals_full_hamiltonian(self):
grid_length = 4
dimension = 2
wigner_seitz_radius = 10.0
inverse_filling_fraction = 2
n_qubits = grid_length**dimension
n_particles = n_qubits // inverse_filling_fraction
# Generate the Hamiltonian.
grid = hypercube_grid_with_given_wigner_seitz_radius_and_filling(
dimension, grid_length, wigner_seitz_radius,
1. / inverse_filling_fraction)
hamiltonian = normal_ordered(
jellium_model(grid, spinless=True, plane_wave=False))
hamiltonian.compress()
terms = simulation_ordered_grouped_low_depth_terms_with_info(
hamiltonian)[0]
terms_total = sum(terms, FermionOperator.zero())
length_scale = wigner_seitz_length_scale(wigner_seitz_radius,
n_particles, dimension)
grid = Grid(dimension, grid_length, length_scale)
hamiltonian = jellium_model(grid, spinless=True, plane_wave=False)
hamiltonian = normal_ordered(hamiltonian)
self.assertTrue(terms_total == hamiltonian)
def test_sum_of_ordered_terms_equals_full_hamiltonian(self):
grid_length = 4
dimension = 1
wigner_seitz_radius = 10.0
# Generate the Hamiltonian.
grid = hypercube_grid_with_given_wigner_seitz_radius_and_filling(
dimension, grid_length, wigner_seitz_radius)
hamiltonian = normal_ordered(
jellium_model(grid, spinless=True, plane_wave=False))
hamiltonian.compress()
terms = ordered_low_depth_terms_no_info(hamiltonian)
terms_total = sum(terms, FermionOperator.zero())
self.assertTrue(terms_total == hamiltonian)
def test_all_terms_in_standardized_dual_basis_jellium_hamiltonian(self):
grid_length = 4
dimension = 1
# Generate the Hamiltonian.
grid = hypercube_grid_with_given_wigner_seitz_radius_and_filling(
dimension, grid_length, wigner_seitz_radius=10.)
hamiltonian = normal_ordered(
jellium_model(grid, spinless=True, plane_wave=False))
hamiltonian.compress()
terms = ordered_low_depth_terms_no_info(hamiltonian)
FO = FermionOperator
expected_terms = []
for i in range(grid_length**dimension):
expected_terms.append(FO(((i, 1), (i, 0)), 0.018505508252042547))
expected_terms.append(
FO(((i, 1), ((i + 1) % 4, 0)), -0.012337005501361697))
expected_terms.append(
FO(((i, 1), ((i + 2) % 4, 0)), 0.0061685027506808475))
expected_terms.append(
FO(((i, 1), ((i + 3) % 4, 0)), -0.012337005501361697))
expected_terms.append(
normal_ordered(
FO(((i, 1), ((i + 1) % 4, 1), (i, 0), ((i + 1) % 4, 0)),
3.1830988618379052)))
if i // 2:
expected_terms.append(
normal_ordered(
FO(((i, 1), ((i + 2) % 4, 1), (i, 0),
((i + 2) % 4, 0)), 22.281692032865351)))
for term in terms:
found_in_other = False
for term2 in expected_terms:
if term == term2:
self.assertFalse(found_in_other)
found_in_other = True
self.assertTrue(found_in_other, msg=str(term))
for term in expected_terms:
found_in_other = False
for term2 in terms:
if term == term2:
self.assertFalse(found_in_other)
found_in_other = True
self.assertTrue(found_in_other, msg=str(term))
def test_error_bound_using_info_1d_with_input_ordering(self):
# Generate the Hamiltonian.
grid = hypercube_grid_with_given_wigner_seitz_radius_and_filling(
dimension=1, grid_length=4, wigner_seitz_radius=10.)
hamiltonian = normal_ordered(
jellium_model(grid, spinless=True, plane_wave=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_low_depth_terms_with_info(
hamiltonian, input_ordering=[0, 1, 2, 3])
terms, indices, is_hopping = result
self.assertAlmostEqual(
low_depth_second_order_trotter_error_bound(terms, indices,
is_hopping),
7.4239378440953283)
def test_1d_jellium_wigner_seitz_10_VT_order_gives_larger_error(self):
hamiltonian = normal_ordered(jellium_model(
hypercube_grid_with_given_wigner_seitz_radius_and_filling(
1, 5, wigner_seitz_radius=10.,
spinless=True), spinless=True, plane_wave=False))
TV_error_operator = (
split_operator_trotter_error_operator_diagonal_two_body(
hamiltonian, order='T+V'))
TV_error_bound = numpy.sum(numpy.absolute(
list(TV_error_operator.terms.values())))
VT_error_operator = (
split_operator_trotter_error_operator_diagonal_two_body(
hamiltonian, order='V+T'))
VT_error_bound = numpy.sum(numpy.absolute(
list(VT_error_operator.terms.values())))
self.assertGreater(VT_error_bound, TV_error_bound)
def test_error_bound_using_info_2d_verbose(self):
# Generate the Hamiltonian.
grid = hypercube_grid_with_given_wigner_seitz_radius_and_filling(
dimension=2, grid_length=3, wigner_seitz_radius=10.)
hamiltonian = normal_ordered(
jellium_model(grid, spinless=True, plane_wave=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_low_depth_terms_with_info(
hamiltonian)
terms, indices, is_hopping = result
self.assertAlmostEqual(
low_depth_second_order_trotter_error_bound(terms,
indices,
is_hopping,
jellium_only=True,
verbose=True),
0.052213321121580794)
def test_total_length(self):
grid_length = 8
dimension = 1
wigner_seitz_radius = 10.0
inverse_filling_fraction = 2
n_qubits = grid_length**dimension
# Generate the Hamiltonian.
grid = hypercube_grid_with_given_wigner_seitz_radius_and_filling(
dimension, grid_length, wigner_seitz_radius,
1. / inverse_filling_fraction)
hamiltonian = normal_ordered(
jellium_model(grid, spinless=True, plane_wave=False))
hamiltonian.compress()
# Unpack result into terms, indices they act on, and whether they're
# hopping operators.
result = simulation_ordered_grouped_low_depth_terms_with_info(
hamiltonian)
terms, indices, is_hopping = result
self.assertEqual(len(terms), n_qubits * (n_qubits - 1))
def test_1D_jellium_trotter_error_matches_low_depth_trotter_error(self):
hamiltonian = normal_ordered(jellium_model(
hypercube_grid_with_given_wigner_seitz_radius_and_filling(
1, 5, wigner_seitz_radius=10.,
spinless=True), spinless=True, plane_wave=False))
error_operator = (
fermionic_swap_trotter_error_operator_diagonal_two_body(
hamiltonian))
error_operator.compress()
# Unpack result into terms, indices they act on, and whether
# they're hopping operators.
result = simulation_ordered_grouped_low_depth_terms_with_info(
hamiltonian)
terms, indices, is_hopping = result
old_error_operator = low_depth_second_order_trotter_error_operator(
terms, indices, is_hopping, jellium_only=True)
old_error_operator -= error_operator
self.assertEqual(old_error_operator, FermionOperator.zero())
