def test_mitigated_execute_with_cdr(circuit_type, fit_function, kwargs,
random_state):
circuit = random_x_z_cnot_circuit(
LineQubit.range(2),
n_moments=5,
random_state=random_state,
)
circuit = convert_from_mitiq(circuit, circuit_type)
obs = Observable(PauliString("XZ"), PauliString("YY"))
true_value = obs.expectation(circuit, simulate)
noisy_value = obs.expectation(circuit, execute)
cdr_executor = mitigate_executor(
executor=execute,
observable=obs,
simulator=simulate,
num_training_circuits=20,
fraction_non_clifford=0.5,
fit_function=fit_function,
random_state=random_state,
**kwargs,
)
cdr_mitigated = cdr_executor(circuit)
assert abs(cdr_mitigated - true_value) <= abs(noisy_value - true_value)
def test_mitigate_executor_with_cdr_using_clifford_circuit():
a, b = cirq.LineQubit.range(2)
clifCirc = cirq.Circuit(
cirq.H.on(a),
cirq.H.on(b),
)
obs = Observable(PauliString("XZ"), PauliString("YY"))
mitigated_executor = mitigate_executor(observable=obs,
executor=execute,
simulator=simulate)
mitigated = mitigated_executor(clifCirc)
assert obs.expectation(clifCirc, simulate) == mitigated
def test_execute_with_variable_noise_cdr(circuit_type):
circuit = random_x_z_cnot_circuit(LineQubit.range(2),
n_moments=5,
random_state=1)
circuit = convert_from_mitiq(circuit, circuit_type)
obs = Observable(PauliString("IZ"), PauliString("ZZ"))
true_value = obs.expectation(circuit, simulate)
noisy_value = obs.expectation(circuit, execute)
vncdr_value = execute_with_cdr(
circuit,
execute,
obs,
simulator=simulate,
num_training_circuits=10,
fraction_non_clifford=0.5,
scale_factors=[1, 3],
random_state=1,
)
assert abs(vncdr_value - true_value) <= abs(noisy_value - true_value)
def test_no_num_fit_parameters_with_custom_fit_raises_error():
with pytest.raises(ValueError, match="Must provide `num_fit_parameters`"):
execute_with_cdr(
random_x_z_cnot_circuit(LineQubit.range(2),
n_moments=2,
random_state=1),
execute,
observables=Observable(PauliString()),
simulator=simulate,
fit_function=lambda _: 1,
)
def test_execute_with_pec_with_observable():
circuit = twoq_circ
obs = Observable(PauliString("ZZ"))
executor = partial(
mitiq_cirq.compute_density_matrix,
noise_model=cirq.depolarize,
noise_level=(BASE_NOISE, ),
)
true_value = 1.0
noisy_value = obs.expectation(circuit, mitiq_cirq.compute_density_matrix)
pec_value = execute_with_pec(
circuit,
executor,
observable=obs,
representations=pauli_representations,
num_samples=100,
force_run_all=False,
random_state=101,
)
assert abs(pec_value - true_value) < abs(noisy_value - true_value)
assert np.isclose(pec_value, true_value, atol=0.1)
def test_raw():
circuit = cirq.Circuit(cirq.H.on(cirq.LineQubit(0)))
observable = Observable(PauliString("X"))
executor = Executor(mitiq_cirq.compute_density_matrix)
raw_value = raw.execute(circuit, executor, observable)
assert isinstance(raw_value, complex)
assert executor.executed_circuits == [circuit]
compute_density_matrix_noiseless = functools.partial(
mitiq_cirq.compute_density_matrix, noise_level=(0.0, ))
executor_noiseless = Executor(compute_density_matrix_noiseless)
true_value = raw.execute(circuit, executor_noiseless, observable)
assert np.isclose(true_value, 1.0)
assert executor_noiseless.executed_circuits == [circuit]
def test_execute_with_pec_partial_representations():
# Only use the CNOT representation.
reps = [pauli_representations[-1]]
pec_value = execute_with_pec(
twoq_circ,
executor=partial(
mitiq_cirq.compute_density_matrix,
noise_model=cirq.depolarize,
noise_level=(BASE_NOISE, ),
),
observable=Observable(PauliString("ZZ")),
representations=reps,
num_samples=100,
force_run_all=False,
random_state=101,
)
assert isinstance(pec_value, complex)
def test_decorator_execute_with_cdr(circuit_type, fit_function, kwargs,
random_state):
obs = Observable(PauliString("XZ"), PauliString("YY"))
@cdr_decorator(
observable=obs,
simulator=simulate,
num_training_circuits=20,
fraction_non_clifford=0.5,
fit_function=fit_function,
random_state=random_state,
**kwargs,
)
def decorated_execute(circuit: QPROGRAM) -> np.ndarray:
return execute(circuit)
def decorated_execute_with_cdr(circuit_type):
circuit = random_x_z_cnot_circuit(
LineQubit.range(2),
n_moments=5,
random_state=random_state,
)
circuit = convert_from_mitiq(circuit, circuit_type)
true_value = obs.expectation(circuit, simulate)
noisy_value = obs.expectation(circuit, execute)
cdr_value = decorated_execute(circuit, )
assert abs(cdr_value - true_value) <= abs(noisy_value - true_value)
def decorated_execute_using_clifford_circuit():
a, b = cirq.LineQubit.range(2)
clifCirc = cirq.Circuit(
cirq.H.on(a),
cirq.H.on(b),
)
cdr_mitigaged = decorated_execute(clifCirc)
assert obs.expectation(clifCirc, simulate) == cdr_mitigaged
decorated_execute_with_cdr(circuit_type)
decorated_execute_using_clifford_circuit()
circuit, mitiq_cirq.compute_density_matrix, observable,
)
return np.real(abs(true_value - raw_value) / abs(true_value - zne_value))
track_zne.param_names = [
"circuit",
"nqubits",
"depth",
"observable",
]
track_zne.params = (
benchmark_circuit_types,
[1],
[1, 2, 3],
[Observable(PauliString("Z"))],
)
track_zne.unit = "Error mitigation factor"
track_zne.timeout = 300
def track_pec(
circuit_type: str,
nqubits: int,
depth: int,
observable: Observable,
num_samples: int,
) -> float:
"""Returns the PEC error mitigation factor, i.e., the ratio
(error without PEC) / (error with PEC).
