def test_execute_with_ddd_with_num_trials(executor):
"""Tests the option num_trials of execute_with_ddd."""
executor = Executor(executor)
mitigated_1 = execute_with_ddd(
circuit_cirq_a,
executor,
rule=xx,
num_trials=1,
)
assert executor.calls_to_executor == 1
assert len(executor.executed_circuits) == 1
mitigated_2 = execute_with_ddd(
circuit_cirq_a,
executor,
rule=xx,
num_trials=2,
)
# Note executor contains the history of both experiments
if executor.can_batch:
assert executor.calls_to_executor == 2
else:
assert executor.calls_to_executor == 3
assert len(executor.executed_circuits) == 3
# For deterministic DDD sequences num_trials is irrelevant
assert np.isclose(mitigated_1, mitigated_2)
def test_mitigate_executor_ddd():
ddd_value = execute_with_ddd(
circuit_cirq_a,
serial_executor,
rule=xx,
)
mitigated_executor = mitigate_executor(serial_executor, rule=xx)
assert np.isclose(mitigated_executor(circuit_cirq_a), ddd_value)
def test_execute_with_ddd_without_noise(circuit_type, circuit, rule):
"""Tests that execute_with_ddd preserves expected results
in the absence of noise.
"""
circuit = convert_from_mitiq(circuit, circuit_type)
true_noiseless_value = 1.0
unmitigated = noiseless_serial_executor(circuit)
mitigated = execute_with_ddd(
circuit,
executor=noiseless_serial_executor,
rule=rule,
)
error_unmitigated = abs(unmitigated - true_noiseless_value)
error_mitigated = abs(mitigated - true_noiseless_value)
assert np.isclose(error_unmitigated, error_mitigated)
def test_execute_with_ddd_and_damping_noise(circuit_type, rule):
"""Tests that with execute_with_ddd the error of a noisy
expectation value is unchanged with depolarizing noise.
"""
circuit = convert_from_mitiq(circuit_cirq_a, circuit_type)
true_noiseless_value = 1.0
unmitigated = amp_damp_executor(circuit)
mitigated = execute_with_ddd(
circuit,
amp_damp_executor,
rule=rule,
)
error_unmitigated = abs(unmitigated - true_noiseless_value)
error_mitigated = abs(mitigated - true_noiseless_value)
assert error_mitigated < error_unmitigated
def test_execute_with_ddd_with_full_output():
"""Tests the option full_output of execute_with_ddd."""
executor = Executor(noiseless_serial_executor)
ddd_value, ddd_data = execute_with_ddd(
circuit_cirq_a,
executor,
rule=xx,
num_trials=2,
full_output=True,
)
assert len(executor.executed_circuits) == 2
assert len(ddd_data["circuits_with_ddd"]) == 2
assert len(ddd_data["ddd_trials"]) == 2
assert ddd_data["ddd_value"] == ddd_value
# For a deterministic rule
assert ddd_data["ddd_trials"][0] == ddd_data["ddd_trials"][1]
def test_execute_with_ddd_and_depolarizing_noise(circuit_type, circuit,
executor, rule):
"""Tests that with execute_with_ddd the error of a noisy
expectation value is unchanged with depolarizing noise.
"""
circuit = convert_from_mitiq(circuit, circuit_type)
true_noiseless_value = 1.0
unmitigated = serial_executor(circuit)
mitigated = execute_with_ddd(
circuit,
executor,
rule=rule,
)
error_unmitigated = abs(unmitigated - true_noiseless_value)
error_mitigated = abs(mitigated - true_noiseless_value)
# For moment-based depolarizing noise DDD should
# have no effect (since noise commutes with DDD gates).
assert np.isclose(error_mitigated, error_unmitigated)
def test_ddd_decorator():
ddd_value = execute_with_ddd(
circuit_cirq_a,
serial_executor,
rule=xx,
)
@ddd_decorator(rule=xx)
def my_serial_executor(circuit):
return serial_executor(circuit)
assert np.isclose(my_serial_executor(circuit_cirq_a), ddd_value)
# Test batched executors too
@ddd_decorator(rule=xx)
def my_batched_executor(circuits) -> List[float]:
return batched_executor(circuits)
assert np.isclose(*my_batched_executor([circuit_cirq_a]), ddd_value)