def test_hamiltonian_objective_value_not_implemented():
obj = HamiltonianObjective(test_hamiltonian)
trial_result = cirq.TrialResult(params=cirq.ParamResolver({}),
measurements={},
repetitions=1)
with pytest.raises(NotImplementedError):
_ = obj.value(trial_result)
def test_trotter_ansatzes_default_initial_params_iterations_1(
ansatz_factory, trotter_algorithm, order, hamiltonian, atol):
"""Check that a Trotter ansatz with one iteration and default parameters
is consistent with time evolution with one Trotter step."""
ansatz = ansatz_factory(hamiltonian, iterations=1)
objective = HamiltonianObjective(hamiltonian)
qubits = ansatz.qubits
if isinstance(hamiltonian, openfermion.DiagonalCoulombHamiltonian):
one_body = hamiltonian.one_body
elif isinstance(hamiltonian, openfermion.InteractionOperator):
one_body = hamiltonian.one_body_tensor
preparation_circuit = cirq.Circuit.from_ops(
prepare_gaussian_state(qubits,
openfermion.QuadraticHamiltonian(one_body),
occupied_orbitals=range(len(qubits) // 2)))
# Compute value using ansatz circuit and objective
circuit = (preparation_circuit +
ansatz.circuit).with_parameters_resolved_by(
ansatz.param_resolver(ansatz.default_initial_params()))
result = circuit.apply_unitary_effect_to_state(
qubit_order=ansatz.qubit_permutation(qubits))
obj_val = objective.value(result)
# Compute value using study
study = VariationalStudy('study',
ansatz,
objective,
preparation_circuit=preparation_circuit)
study_val = study.value_of(ansatz.default_initial_params())
# Compute value by simulating time evolution
if isinstance(hamiltonian, openfermion.DiagonalCoulombHamiltonian):
half_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body, two_body=0.5 * hamiltonian.two_body)
elif isinstance(hamiltonian, openfermion.InteractionOperator):
half_way_hamiltonian = openfermion.InteractionOperator(
constant=hamiltonian.constant,
one_body_tensor=hamiltonian.one_body_tensor,
two_body_tensor=0.5 * hamiltonian.two_body_tensor)
simulation_circuit = cirq.Circuit.from_ops(
simulate_trotter(qubits,
half_way_hamiltonian,
time=ansatz.adiabatic_evolution_time,
n_steps=1,
order=order,
algorithm=trotter_algorithm))
final_state = (preparation_circuit +
simulation_circuit).apply_unitary_effect_to_state()
correct_val = openfermion.expectation(objective._hamiltonian_linear_op,
final_state).real
numpy.testing.assert_allclose(obj_val, study_val, atol=atol)
numpy.testing.assert_allclose(obj_val, correct_val, atol=atol)
def test_hamiltonian_objective_noise_bounds():
obj = HamiltonianObjective(test_hamiltonian)
numpy.random.seed(38017)
a, b = obj.noise_bounds(1e4)
c, d = obj.noise_bounds(1e2)
numpy.testing.assert_allclose(10 * a, c)
numpy.testing.assert_allclose(10 * b, d)
a, b = obj.noise_bounds(1e4, confidence=0.95)
c, d = obj.noise_bounds(1e2, confidence=0.95)
numpy.testing.assert_allclose(10 * a, c)
numpy.testing.assert_allclose(10 * b, d)
numpy.testing.assert_allclose(obj.noise_bounds(1e2),
obj.noise_bounds(1e2, 0.99))
with pytest.raises(ValueError):
_ = obj.noise_bounds(1.0, 1.0)
with pytest.raises(ValueError):
_ = obj.noise_bounds(1.0, -1.0)
def test_hamiltonian_objective_noise():
obj = HamiltonianObjective(test_hamiltonian)
numpy.random.seed(10821)
assert (abs(obj.noise()) < abs(obj.noise(1e6)) < abs(obj.noise(1e5)) < abs(
obj.noise(1e4)) < abs(obj.noise(1e3)))
def test_hamiltonian_objective_value():
obj = HamiltonianObjective(test_hamiltonian)
obj_linear_op = HamiltonianObjective(test_hamiltonian, use_linear_op=True)
hamiltonian_sparse = openfermion.get_sparse_operator(test_hamiltonian)
simulator = cirq.google.XmonSimulator()
qubits = cirq.LineQubit.range(4)
numpy.random.seed(10581)
result = simulator.simulate(cirq.testing.random_circuit(qubits, 5, 0.8),
qubit_order=qubits)
correct_val = openfermion.expectation(hamiltonian_sparse,
result.final_state)
numpy.testing.assert_allclose(obj.value(result), correct_val, atol=1e-5)
numpy.testing.assert_allclose(obj.value(result.final_state), correct_val,
1e-5)
numpy.testing.assert_allclose(obj_linear_op.value(result), correct_val,
1e-5)
numpy.testing.assert_allclose(obj_linear_op.value(result.final_state),
correct_val, 1e-5)
def test_hamiltonian_objective_init_qubit_operator():
obj = HamiltonianObjective(openfermion.QubitOperator((0, 'X')))
assert obj.hamiltonian == openfermion.QubitOperator((0, 'X'))
def test_trotter_ansatzes_default_initial_params_iterations_2(
ansatz_factory, trotter_algorithm, hamiltonian, atol):
"""Check that a Trotter ansatz with two iterations and default parameters
is consistent with time evolution with two Trotter steps."""
ansatz = ansatz_factory(hamiltonian, iterations=2)
objective = HamiltonianObjective(hamiltonian)
qubits = ansatz.qubits
preparation_circuit = cirq.Circuit.from_ops(
prepare_gaussian_state(
qubits,
openfermion.QuadraticHamiltonian(hamiltonian.one_body),
occupied_orbitals=range(len(qubits) // 2))
)
simulator = cirq.google.XmonSimulator()
# Compute value using ansatz circuit and objective
result = simulator.simulate(
preparation_circuit + ansatz.circuit,
param_resolver=
ansatz.param_resolver(ansatz.default_initial_params()),
qubit_order=ansatz.qubit_permutation(qubits)
)
obj_val = objective.value(result)
# Compute value using study
study = VariationalStudy(
'study',
ansatz,
objective,
preparation_circuit=preparation_circuit)
study_val = study.value_of(ansatz.default_initial_params())
# Compute value by simulating time evolution
quarter_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body,
two_body=0.25 * hamiltonian.two_body)
three_quarters_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body,
two_body=0.75 * hamiltonian.two_body)
simulation_circuit = cirq.Circuit.from_ops(
simulate_trotter(
qubits,
quarter_way_hamiltonian,
time=0.5 * ansatz.adiabatic_evolution_time,
n_steps=1,
order=1,
algorithm=trotter_algorithm),
simulate_trotter(
qubits,
three_quarters_way_hamiltonian,
time=0.5 * ansatz.adiabatic_evolution_time,
n_steps=1,
order=1,
algorithm=trotter_algorithm)
)
result = simulator.simulate(preparation_circuit + simulation_circuit)
final_state = result.final_state
correct_val = openfermion.expectation(
objective._hamiltonian_linear_op, final_state).real
numpy.testing.assert_allclose(obj_val, study_val, atol=atol)
numpy.testing.assert_allclose(obj_val, correct_val, atol=atol)
def test_trotter_ansatzes_default_initial_params_iterations_2(
ansatz, trotter_algorithm, order, hamiltonian, atol):
"""Check that a Trotter ansatz with two iterations and default parameters
is consistent with time evolution with two Trotter steps."""
objective = HamiltonianObjective(hamiltonian)
qubits = ansatz.qubits
if isinstance(hamiltonian, openfermion.DiagonalCoulombHamiltonian):
one_body = hamiltonian.one_body
elif isinstance(hamiltonian, openfermion.InteractionOperator):
one_body = hamiltonian.one_body_tensor
if isinstance(ansatz, SwapNetworkTrotterHubbardAnsatz):
occupied_orbitals = (range(len(qubits) // 4), range(len(qubits) // 4))
else:
occupied_orbitals = range(len(qubits) // 2)
preparation_circuit = cirq.Circuit(
prepare_gaussian_state(qubits,
openfermion.QuadraticHamiltonian(one_body),
occupied_orbitals=occupied_orbitals))
# Compute value using ansatz circuit and objective
circuit = cirq.resolve_parameters(
preparation_circuit + ansatz.circuit,
ansatz.param_resolver(ansatz.default_initial_params()))
result = circuit.final_wavefunction(
qubit_order=ansatz.qubit_permutation(qubits))
obj_val = objective.value(result)
# Compute value using study
study = VariationalStudy('study',
ansatz,
objective,
preparation_circuit=preparation_circuit)
study_val = study.value_of(ansatz.default_initial_params())
# Compute value by simulating time evolution
if isinstance(hamiltonian, openfermion.DiagonalCoulombHamiltonian):
quarter_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body,
two_body=0.25 * hamiltonian.two_body)
three_quarters_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body,
two_body=0.75 * hamiltonian.two_body)
elif isinstance(hamiltonian, openfermion.InteractionOperator):
quarter_way_hamiltonian = openfermion.InteractionOperator(
constant=hamiltonian.constant,
one_body_tensor=hamiltonian.one_body_tensor,
two_body_tensor=0.25 * hamiltonian.two_body_tensor)
three_quarters_way_hamiltonian = openfermion.InteractionOperator(
constant=hamiltonian.constant,
one_body_tensor=hamiltonian.one_body_tensor,
two_body_tensor=0.75 * hamiltonian.two_body_tensor)
simulation_circuit = cirq.Circuit(
simulate_trotter(qubits,
quarter_way_hamiltonian,
time=0.5 * ansatz.adiabatic_evolution_time,
n_steps=1,
order=order,
algorithm=trotter_algorithm),
simulate_trotter(qubits,
three_quarters_way_hamiltonian,
time=0.5 * ansatz.adiabatic_evolution_time,
n_steps=1,
order=order,
algorithm=trotter_algorithm))
final_state = (preparation_circuit +
simulation_circuit).final_wavefunction()
correct_val = openfermion.expectation(objective._hamiltonian_linear_op,
final_state).real
numpy.testing.assert_allclose(obj_val, study_val, atol=atol)
numpy.testing.assert_allclose(obj_val, correct_val, atol=atol)