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()