def result_types_nonzero_shots_bell_pair_testing(device: Device, run_kwargs: Dict[str, Any]):
circuit = (
Circuit()
.h(0)
.cnot(0, 1)
.expectation(observable=Observable.H() @ Observable.X(), target=[0, 1])
.sample(observable=Observable.H() @ Observable.X(), target=[0, 1])
)
result = device.run(circuit, **run_kwargs).result()
assert len(result.result_types) == 2
assert (
0.6
< result.get_value_by_result_type(
ResultType.Expectation(observable=Observable.H() @ Observable.X(), target=[0, 1])
)
< 0.8
)
assert (
len(
result.get_value_by_result_type(
ResultType.Sample(observable=Observable.H() @ Observable.X(), target=[0, 1])
)
)
== run_kwargs["shots"]
)
def get_result_types_three_qubit_circuit(theta, phi, varphi, obs, obs_targets,
shots) -> Circuit:
circuit = (Circuit().rx(0, theta).rx(1, phi).rx(2, varphi).cnot(0, 1).cnot(
1, 2).variance(obs, obs_targets).expectation(obs, obs_targets))
if shots:
circuit.add_result_type(ResultType.Sample(obs, obs_targets))
return circuit
def result_types_all_selected_testing(device: Device,
run_kwargs: Dict[str, Any],
test_program: bool = True):
shots = run_kwargs["shots"]
theta = 0.543
array = np.array([[1, 2j], [-2j, 0]])
circuit = (Circuit().rx(0, theta).rx(1, theta).variance(
Observable.Hermitian(array)).expectation(Observable.Hermitian(array),
0))
if shots:
circuit.add_result_type(
ResultType.Sample(Observable.Hermitian(array), 1))
tasks = (circuit, ) if not test_program else (circuit,
circuit.to_ir(
ir_type=IRType.OPENQASM))
for task in tasks:
result = device.run(task, **run_kwargs).result()
expected_mean = 2 * np.sin(theta) + 0.5 * np.cos(theta) + 0.5
var = 0.25 * (np.sin(theta) - 4 * np.cos(theta))**2
expected_var = [var, var]
expected_eigs = np.linalg.eigvalsh(array)
assert_variance_expectation_sample_result(result, shots, expected_var,
expected_mean, expected_eigs)
def result_types_hermitian_testing(device: Device, run_kwargs: Dict[str, Any]):
shots = run_kwargs["shots"]
theta = 0.543
array = np.array([[1, 2j], [-2j, 0]])
circuit = (Circuit().rx(0, theta).variance(Observable.Hermitian(array),
0).expectation(
Observable.Hermitian(array),
0))
if shots:
circuit.add_result_type(
ResultType.Sample(Observable.Hermitian(array), 0))
result = device.run(circuit, **run_kwargs).result()
expected_mean = 2 * np.sin(theta) + 0.5 * np.cos(theta) + 0.5
expected_var = 0.25 * (np.sin(theta) - 4 * np.cos(theta))**2
expected_eigs = np.linalg.eigvalsh(array)
assert_variance_expectation_sample_result(result, shots, expected_var,
expected_mean, expected_eigs)
def openqasm_result_types_bell_pair_testing(device: Device,
run_kwargs: Dict[str, Any]):
openqasm_string = ("OPENQASM 3;"
"qubit[2] q;"
"h q[0];"
"cnot q[0], q[1];"
"#pragma braket result expectation h(q[0]) @ x(q[1])"
"#pragma braket result sample h(q[0]) @ x(q[1])")
hardcoded_openqasm = OpenQasmProgram(source=openqasm_string)
circuit = (Circuit().h(0).cnot(0, 1).expectation(
Observable.H() @ Observable.X(),
(0, 1)).sample(Observable.H() @ Observable.X(), (0, 1)))
generated_openqasm = circuit.to_ir(ir_type=IRType.OPENQASM)
for program in hardcoded_openqasm, generated_openqasm:
result = device.run(program, **run_kwargs).result()
assert len(result.result_types) == 2
assert (0.6 < result.get_value_by_result_type(
ResultType.Expectation(observable=Observable.H() @ Observable.X(),
target=[0, 1])) < 0.8)
assert (len(
result.get_value_by_result_type(
ResultType.Sample(observable=Observable.H() @ Observable.X(),
target=[0, 1]))) == run_kwargs["shots"])
def test_sample_parent_class():
assert isinstance(ResultType.Sample(observable=Observable.X(), target=0),
ObservableResultType)
"#pragma braket result probability all",
),
(
ResultType.Probability([0, 2]),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.VIRTUAL),
"#pragma braket result probability q[0], q[2]",
),
(
ResultType.Probability(0),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.PHYSICAL),
"#pragma braket result probability $0",
),
(
ResultType.Sample(Observable.I(), target=0),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.VIRTUAL),
"#pragma braket result sample i(q[0])",
),
(
ResultType.Sample(Observable.I()),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.VIRTUAL),
"#pragma braket result sample i all",
),
(
ResultType.Variance(Observable.I(), target=0),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.VIRTUAL),
"#pragma braket result variance i(q[0])",
serialized_criteria = test_criteria.to_dict()
assert serialized_criteria["__class__"] == "ObservableCriteria"
assert "observables" in serialized_criteria
assert "qubits" in serialized_criteria
deserialized_criteria = ObservableCriteria.from_dict(serialized_criteria)
assert test_criteria == deserialized_criteria
@pytest.mark.parametrize(
"observables, qubits, matching_result_type, non_matching_result_type",
[
(
None,
range(3),
[
ResultType.Sample(Observable.X(), 0),
ResultType.Sample(Observable.Z(), 2),
],
[ResultType.Sample(Observable.X(), 4)],
),
(
None,
None,
[
ResultType.Sample(Observable.X(), 0),
ResultType.Sample(Observable.Z(), 10),
],
[ResultType.Probability(0)],
),
(
Observable.X,