def _calculate_result_types(
ir_string: str, measurements: np.ndarray,
measured_qubits: List[int]) -> List[ResultTypeValue]:
ir = json.loads(ir_string)
result_types = []
if not ir.get("results"):
return result_types
for result_type in ir["results"]:
ir_observable = result_type.get("observable")
observable = observable_from_ir(
ir_observable) if ir_observable else None
targets = result_type.get("targets")
rt_type = result_type["type"]
if rt_type == "probability":
value = GateModelQuantumTaskResult._probability_from_measurements(
measurements, measured_qubits, targets)
casted_result_type = Probability(targets=targets)
elif rt_type == "sample":
value = GateModelQuantumTaskResult._calculate_for_targets(
GateModelQuantumTaskResult._samples_from_measurements,
measurements,
measured_qubits,
observable,
targets,
)
casted_result_type = Sample(targets=targets,
observable=ir_observable)
elif rt_type == "variance":
value = GateModelQuantumTaskResult._calculate_for_targets(
GateModelQuantumTaskResult._variance_from_measurements,
measurements,
measured_qubits,
observable,
targets,
)
casted_result_type = Variance(targets=targets,
observable=ir_observable)
elif rt_type == "expectation":
value = GateModelQuantumTaskResult._calculate_for_targets(
GateModelQuantumTaskResult._expectation_from_measurements,
measurements,
measured_qubits,
observable,
targets,
)
casted_result_type = Expectation(targets=targets,
observable=ir_observable)
else:
raise ValueError(f"Unknown result type {rt_type}")
result_types.append(
ResultTypeValue.construct(type=casted_result_type,
value=value))
return result_types
def test_observable_from_ir(testobject, gateobject, expected_ir,
basis_rotation_gates, eigenvalues):
assert testobject == observable_from_ir(expected_ir)
def test_observable_from_ir_tensor_product_value_error():
observable_from_ir(["z", "i", "foo"])
def test_observable_from_ir_tensor_product():
expected_observable = Observable.TensorProduct(
[Observable.Z(), Observable.I(),
Observable.X()])
actual_observable = observable_from_ir(["z", "i", "x"])
assert expected_observable == actual_observable
def test_observable_from_ir_hermitian():
ir_observable = [[[[1, 0], [0, 0]], [[0, 0], [1, 0]]]]
actual_observable = observable_from_ir(ir_observable)
assert actual_observable == Observable.Hermitian(
matrix=np.array([[1.0, 0.0], [0.0, 1.0]]))
def test_observable_from_ir_hermitian_value_error():
ir_observable = [[[[1.0, 0], [0, 1]], [[0.0, 1], [1, 0]]]]
observable_from_ir(ir_observable)
