def test_add_result_type_same_observable_wrong_target_order_hermitian(): array = np.eye(4) circ = (Circuit().add_result_type( ResultType.Expectation( observable=Observable.Hermitian(matrix=array), target=[0, 1])).add_result_type( ResultType.Variance( observable=Observable.Hermitian(matrix=array), target=[1, 0]))) assert not circ.observables_simultaneously_measurable assert not circ.basis_rotation_instructions
def test_obs_rt_equality(): a1 = ObservableResultType(ascii_symbols=["Obs"], observable=Observable.X(), target=0) a2 = ObservableResultType(ascii_symbols=["Obs"], observable=Observable.X(), target=0) a3 = ObservableResultType(ascii_symbols=["Obs"], observable=Observable.X(), target=1) a4 = "hi" assert a1 == a2 assert a1 != a3 assert a1 != a4 assert ResultType.Variance(observable=Observable.Y(), target=0) != ResultType.Expectation( observable=Observable.Y(), target=0 )
def test_get_value_by_result_type(result_obj_4): result = GateModelQuantumTaskResult.from_object(result_obj_4) assert np.allclose( result.get_value_by_result_type(ResultType.Probability(target=0)), result.values[0] ) assert np.allclose(result.get_value_by_result_type(ResultType.StateVector()), result.values[1]) assert ( result.get_value_by_result_type(ResultType.Expectation(observable=Observable.Y(), target=0)) == result.values[2] ) assert ( result.get_value_by_result_type(ResultType.Variance(observable=Observable.Y(), target=0)) == result.values[3] ) assert result.get_value_by_result_type(ResultType.Amplitude(state=["00"])) == result.values[4]
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 get_value_by_result_type(self, result_type: ResultType) -> Any: """ Get value by result type. The result type must have already been requested in the circuit sent to the device for this task result. Args: result_type (ResultType): result type requested Returns: Any: value of the result corresponding to the result type Raises: ValueError: If result type is not found in result. Result types must be added to the circuit before the circuit is run on a device. """ rt_ir = result_type.to_ir() try: rt_hash = GateModelQuantumTaskResult._result_type_hash(rt_ir) result_type_index = self._result_types_indices[rt_hash] return self.values[result_type_index] except KeyError: raise ValueError( "Result type not found in result. " + "Result types must be added to circuit before circuit is run on device." )
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 test_add_circuit_with_target(bell_pair): circ = Circuit().add_circuit(bell_pair, target=[10, 11]) expected = (Circuit().add_instruction(Instruction( Gate.H(), 10)).add_instruction(Instruction(Gate.CNot(), [10, 11])).add_result_type( ResultType.Probability([10, 11]))) assert circ == expected
def test_result_type_skips_computation_already_populated(calculate_result_types_mocked): result_str = json.dumps( { "braketSchemaHeader": { "name": "braket.task_result.gate_model_task_result", "version": "1", }, "measurements": [[0]], "resultTypes": [ {"type": {"observable": ["z"], "targets": [0], "type": "variance"}, "value": 12.0} ], "measuredQubits": [0], "taskMetadata": { "braketSchemaHeader": {"name": "braket.task_result.task_metadata", "version": "1"}, "id": "arn:aws:braket:us-east-1:1234567890:quantum-task/22a238b2-ae96", "shots": 1, "deviceId": "arn:aws:braket:::device/quantum-simulator/amazon/dm1", "deviceParameters": { "braketSchemaHeader": { "name": "braket.device_schema.simulators." "gate_model_simulator_device_parameters", "version": "1", }, "paradigmParameters": { "braketSchemaHeader": { "name": "braket.device_schema.gate_model_parameters", "version": "1", }, "qubitCount": 1, "disableQubitRewiring": False, }, }, "createdAt": "2022-01-12T06:05:22.633Z", "endedAt": "2022-01-12T06:05:24.136Z", "status": "COMPLETED", }, "additionalMetadata": { "action": { "braketSchemaHeader": {"name": "braket.ir.openqasm.program", "version": "1"}, "source": "\nqubit[1] q;\nh q[0];\n#pragma braket result variance z(q[0])\n", }, "simulatorMetadata": { "braketSchemaHeader": { "name": "braket.task_result.simulator_metadata", "version": "1", }, "executionDuration": 16, }, }, } ) res = GateModelQuantumTaskResult.from_string(result_str) assert ( res.get_value_by_result_type(ResultType.Variance(observable=Observable.Z(), target=[0])) == 12 ) calculate_result_types_mocked.assert_not_called()
def result_types_bell_pair_full_probability_testing(device: Device, run_kwargs: Dict[str, Any]): shots = run_kwargs["shots"] tol = get_tol(shots) circuit = Circuit().h(0).cnot(0, 1).probability() result = device.run(circuit, **run_kwargs).result() assert len(result.result_types) == 1 assert np.allclose( result.get_value_by_result_type(ResultType.Probability()), np.array([0.5, 0, 0, 0.5]), **tol )
def noisy_circuit_1qubit_noise_full_probability(device: Device, run_kwargs: Dict[str, Any]): shots = run_kwargs["shots"] tol = get_tol(shots) circuit = Circuit().x(0).x(1).bit_flip(0, 0.1).probability() result = device.run(circuit, **run_kwargs).result() assert len(result.result_types) == 1 assert np.allclose( result.get_value_by_result_type(ResultType.Probability()), np.array([0.0, 0.1, 0, 0.9]), **tol)
def result_types_bell_pair_marginal_probability_testing( device: Device, run_kwargs: Dict[str, Any]): shots = run_kwargs["shots"] tol = get_tol(shots) circuit = Circuit().h(0).cnot(0, 1).probability(0) tasks = (circuit, circuit.to_ir(ir_type=IRType.OPENQASM)) for task in tasks: result = device.run(task, **run_kwargs).result() assert len(result.result_types) == 1 assert np.allclose( result.get_value_by_result_type(ResultType.Probability(target=0)), np.array([0.5, 0.5]), **tol)
def noisy_circuit_2qubit_noise_full_probability(device: Device, run_kwargs: Dict[str, Any]): shots = run_kwargs["shots"] tol = get_tol(shots) K0 = np.eye(4) * np.sqrt(0.9) K1 = np.kron(np.array([[0.0, 1.0], [1.0, 0.0]]), np.array([[0.0, 1.0], [1.0, 0.0]])) * np.sqrt(0.1) circuit = Circuit().x(0).x(1).kraus((0, 1), [K0, K1]).probability() result = device.run(circuit, **run_kwargs).result() assert len(result.result_types) == 1 assert np.allclose( result.get_value_by_result_type(ResultType.Probability()), np.array([0.1, 0.0, 0, 0.9]), **tol)
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 result_types_zero_shots_bell_pair_testing( device: Device, include_state_vector: bool, run_kwargs: Dict[str, Any], include_amplitude: bool = True, ): circuit = ( Circuit() .h(0) .cnot(0, 1) .expectation(observable=Observable.H() @ Observable.X(), target=[0, 1]) ) if include_amplitude: circuit.amplitude(["01", "10", "00", "11"]) if include_state_vector: circuit.state_vector() result = device.run(circuit, **run_kwargs).result() assert len(result.result_types) == 3 if include_state_vector else 2 assert np.allclose( result.get_value_by_result_type( ResultType.Expectation(observable=Observable.H() @ Observable.X(), target=[0, 1]) ), 1 / np.sqrt(2), ) if include_state_vector: assert np.allclose( result.get_value_by_result_type(ResultType.StateVector()), np.array([1, 0, 0, 1]) / np.sqrt(2), ) if include_amplitude: assert result.get_value_by_result_type(ResultType.Amplitude(["01", "10", "00", "11"])) == { "01": 0j, "10": 0j, "00": (1 / np.sqrt(2)), "11": (1 / np.sqrt(2)), }
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_noisy_circuit_1qubit_noise_full_probability( device: Device, run_kwargs: Dict[str, Any]): shots = run_kwargs["shots"] tol = get_tol(shots) openqasm_string = ("OPENQASM 3;" "qubit[2] q;" "x q[0];" "x q[1];" "#pragma braket noise bit_flip(0.1) q[0]" "#pragma braket result probability q[0], q[1]") hardcoded_openqasm = OpenQasmProgram(source=openqasm_string) circuit = Circuit().x(0).x(1).bit_flip(0, 0.1).probability([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) == 1 assert np.allclose( result.get_value_by_result_type( ResultType.Probability(target=[0, 1])), np.array([0.0, 0.1, 0, 0.9]), **tol)
def get_value_by_result_type(self, result_type: ResultType) -> Any: """ Get value by result type. The result type must have already been requested in the circuit sent to the device for this task result. Args: result_type (ResultType): result type requested Returns: Any: value of the result corresponding to the result type Raises: ValueError: If result type is not found in result. Result types must be added to the circuit before the circuit is run on a device. """ rt_ir = result_type.to_ir() for rt in self.result_types: if rt_ir == rt.type: return rt.value raise ValueError( "Result type not found in result. " + "Result types must be added to circuit before circuit is run on device." )
def test_add_result_type_already_exists(): expected = [ResultType.StateVector()] circ = Circuit(expected).add_result_type(expected[0]) assert list(circ.result_types) == expected
def test_add_result_type_with_target(prob): expected = [ResultType.Probability([10, 11])] circ = Circuit().add_result_type(prob, target=[10, 11]) assert list(circ.result_types) == expected
def test_add_result_type_with_mapping(prob): expected = [ResultType.Probability([10, 11])] circ = Circuit().add_result_type(prob, target_mapping={0: 10, 1: 11}) assert list(circ.result_types) == expected
def test_copy_with_mapping_target(sv): target_mapping = {0: 10, 1: 11} expected = ResultType.StateVector() assert sv.copy(target_mapping=target_mapping) == expected
def test_ascii_symbol(): ascii_symbols = ["foo"] result_type = ResultType(ascii_symbols=ascii_symbols) assert result_type.ascii_symbols == ascii_symbols
def result_type(): return ResultType(ascii_symbols=["foo"])
def test_copy_with_target(sv): target = [10, 11] expected = ResultType.StateVector() assert sv.copy(target=target) == expected
def test_add_result_type_observable_conflict_all(): circ = Circuit().add_result_type(ResultType.Probability()) circ.add_result_type(ResultType.Expectation(observable=Observable.Y()))
def test_add_result_type_observable_conflict_selected_target_then_all_target(): circ = Circuit().add_result_type( ResultType.Expectation(observable=Observable.Y(), target=[0, 1])) circ.add_result_type(ResultType.Probability())
def sv(): return ResultType.StateVector()
def prob(): return ResultType.Probability([0, 1])
def test_none_ascii(): ResultType(ascii_symbols=None)