def from_string(result: str) -> GateModelQuantumTaskResult:
"""
Create GateModelQuantumTaskResult from string.
Args:
result (str): JSON object string, with GateModelQuantumTaskResult attributes as keys.
Returns:
GateModelQuantumTaskResult: A GateModelQuantumTaskResult based on the given string
Raises:
ValueError: If neither "Measurements" nor "MeasurementProbabilities" is a key
in the result dict
"""
obj = GateModelTaskResult.parse_raw(result)
if obj.resultTypes:
for result_type in obj.resultTypes:
type = result_type.type.type
if type == "probability":
result_type.value = np.array(result_type.value)
elif type == "statevector":
result_type.value = np.array(
[complex(*value) for value in result_type.value])
elif type == "amplitude":
for state in result_type.value:
result_type.value[state] = complex(
*result_type.value[state])
return GateModelQuantumTaskResult._from_object_internal(obj)
def result_obj_1(task_metadata_shots, additional_metadata):
return GateModelTaskResult(
measurements=[[0, 0], [0, 1], [0, 1], [0, 1]],
measuredQubits=[0, 1],
taskMetadata=task_metadata_shots,
additionalMetadata=additional_metadata,
)
def result_str_3(task_metadata_shots, additional_metadata):
return GateModelTaskResult(
measurementProbabilities={"011000": 0.9999999999999982},
measuredQubits=list(range(6)),
taskMetadata=task_metadata_shots,
additionalMetadata=additional_metadata,
).json()
def test_from_object_equal_to_from_string(result_obj_1, result_str_1,
result_str_3):
assert GateModelQuantumTaskResult.from_object(
result_obj_1) == GateModelQuantumTaskResult.from_string(result_str_1)
assert GateModelQuantumTaskResult.from_object(
GateModelTaskResult.parse_raw(result_str_3)
) == GateModelQuantumTaskResult.from_string(result_str_3)
def result_obj_5(task_metadata_shots):
return GateModelTaskResult(
taskMetadata=task_metadata_shots,
additionalMetadata=AdditionalMetadata(action=jaqcd.Program(
instructions=[
jaqcd.CNot(control=0, target=1),
jaqcd.CNot(control=2, target=3)
],
results=[
jaqcd.Probability(targets=[1]),
jaqcd.Expectation(observable=["z"])
],
)),
measurements=[
[0, 0, 1, 0],
[1, 1, 1, 1],
[1, 0, 0, 1],
[0, 0, 1, 0],
[1, 1, 1, 1],
[0, 1, 1, 1],
[0, 0, 0, 1],
[0, 1, 1, 1],
[0, 0, 0, 0],
[0, 0, 0, 1],
],
measuredQubits=[0, 1, 2, 3],
)
def malformatted_results_2(task_metadata_shots, additional_metadata):
return GateModelTaskResult(
measurementProbabilities={"011000": 0.9999999999999982},
measuredQubits=[0],
taskMetadata=task_metadata_shots,
additionalMetadata=additional_metadata,
).json()
def result_str_4(task_metadata_zero_shots, additional_metadata):
result = GateModelTaskResult(
resultTypes=[
ResultTypeValue(type=jaqcd.Probability(targets=[0]), value=[0.5, 0.5]),
ResultTypeValue(
type=jaqcd.StateVector(), value=[(0.70710678, 0), (0, 0), (0, 0), (0.70710678, 0)]
),
ResultTypeValue(type=jaqcd.Expectation(observable=["y"], targets=[0]), value=0.0),
ResultTypeValue(type=jaqcd.Variance(observable=["y"], targets=[0]), value=0.1),
ResultTypeValue(type=jaqcd.Amplitude(states=["00"]), value={"00": (0.70710678, 0)}),
],
measuredQubits=list(range(2)),
taskMetadata=task_metadata_zero_shots,
additionalMetadata=additional_metadata,
)
return result.json()
def openqasm_result_obj_shots(task_metadata_shots, additional_metadata_openqasm):
return GateModelTaskResult.construct(
measurements=[[0, 0], [0, 1], [0, 1], [0, 1]],
measuredQubits=[0, 1],
taskMetadata=task_metadata_shots,
additionalMetadata=additional_metadata_openqasm,
resultTypes=[jaqcd.Probability()],
)
def test_from_string_measurement_probabilities(result_str_3):
result_obj = GateModelTaskResult.parse_raw(result_str_3)
task_result = GateModelQuantumTaskResult.from_string(result_str_3)
assert task_result.measurement_probabilities == result_obj.measurementProbabilities
shots = 100
measurement_list = [list("011000") for _ in range(shots)]
expected_measurements = np.asarray(measurement_list, dtype=int)
assert np.allclose(task_result.measurements, expected_measurements)
assert task_result.measurement_counts == Counter(["011000" for x in range(shots)])
assert not task_result.measurement_counts_copied_from_device
assert task_result.measurement_probabilities_copied_from_device
assert not task_result.measurements_copied_from_device
def test_from_string_measurements(result_str_1):
result_obj = GateModelTaskResult.parse_raw(result_str_1)
task_result = GateModelQuantumTaskResult.from_string(result_str_1)
expected_measurements = np.asarray(result_obj.measurements, dtype=int)
assert task_result.task_metadata == result_obj.taskMetadata
assert task_result.additional_metadata == result_obj.additionalMetadata
assert np.array2string(task_result.measurements) == np.array2string(expected_measurements)
assert not task_result.measurement_counts_copied_from_device
assert not task_result.measurement_probabilities_copied_from_device
assert task_result.measurements_copied_from_device
assert task_result.measured_qubits == result_obj.measuredQubits
assert task_result.values == []
assert task_result.result_types == []
def from_string(result: str) -> GateModelQuantumTaskResult:
"""
Create GateModelQuantumTaskResult from string.
Args:
result (str): JSON object string, with GateModelQuantumTaskResult attributes as keys.
Returns:
GateModelQuantumTaskResult: A GateModelQuantumTaskResult based on the given string
Raises:
ValueError: If neither "Measurements" nor "MeasurementProbabilities" is a key
in the result dict
"""
obj = GateModelTaskResult.parse_raw(result)
GateModelQuantumTaskResult.cast_result_types(obj)
return GateModelQuantumTaskResult._from_object_internal(obj)
def _create_results_obj(
results: List[Dict[str, Any]],
circuit_ir: Program,
simulation: StateVectorSimulation,
) -> GateModelTaskResult:
result_dict = {
"taskMetadata":
TaskMetadata(id=str(uuid.uuid4()),
shots=simulation.shots,
deviceId=DefaultSimulator.DEVICE_ID),
"additionalMetadata":
AdditionalMetadata(action=circuit_ir),
}
if results:
result_dict["resultTypes"] = results
if simulation.shots:
result_dict[
"measurements"] = DefaultSimulator._formatted_measurements(
simulation)
result_dict[
"measuredQubits"] = DefaultSimulator._get_measured_qubits(
simulation.qubit_count)
return GateModelTaskResult.construct(**result_dict)
def result_obj_4(task_metadata_zero_shots, additional_metadata):
return GateModelTaskResult(
resultTypes=[
ResultTypeValue.construct(type=jaqcd.Probability(targets=[0]),
value=np.array([0.5, 0.5])),
ResultTypeValue.construct(
type=jaqcd.StateVector(),
value=np.array(
[complex(0.70710678, 0), 0, 0,
complex(0.70710678, 0)]),
),
ResultTypeValue.construct(type=jaqcd.Expectation(observable=["y"],
targets=[0]),
value=0.0),
ResultTypeValue.construct(type=jaqcd.Variance(observable=["y"],
targets=[0]),
value=0.1),
ResultTypeValue.construct(type=jaqcd.Amplitude(states=["00"]),
value={"00": complex(0.70710678, 0)}),
],
measuredQubits=list(range(2)),
taskMetadata=task_metadata_zero_shots,
additionalMetadata=additional_metadata,
)
}))
GATE_MODEL_RESULT = GateModelTaskResult(
**{
"measurements": [[0, 0], [0, 0], [0, 0], [1, 1]],
"measuredQubits": [0, 1],
"taskMetadata": {
"braketSchemaHeader": {
"name": "braket.task_result.task_metadata",
"version": "1"
},
"id": "task_arn",
"shots": 100,
"deviceId": "default",
},
"additionalMetadata": {
"action": {
"braketSchemaHeader": {
"name": "braket.ir.jaqcd.program",
"version": "1"
},
"instructions": [{
"control": 0,
"target": 1,
"type": "cnot"
}],
},
},
})
RESULT = GateModelQuantumTaskResult.from_string(
def malformatted_results_1(task_metadata_shots, additional_metadata):
return GateModelTaskResult(
measuredQubits=list(range(6)),
taskMetadata=task_metadata_shots,
additionalMetadata=additional_metadata,
).json()
