def result_types_zero_shots_bell_pair_testing(device: Device, include_state_vector: bool, run_kwargs: Dict[str, Any]): circuit = (Circuit().h(0).cnot( 0, 1).expectation(observable=Observable.H() @ Observable.X(), target=[0, 1]).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), ) 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_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 test_add_result_type_same_observable_wrong_target_order_tensor_product(): Circuit().add_result_type( ResultType.Expectation( observable=Observable.Y() @ Observable.X(), target=[0, 1])).add_result_type( ResultType.Variance(observable=Observable.Y() @ Observable.X(), target=[1, 0]))
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() 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) == 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: amplitude = result.get_value_by_result_type( ResultType.Amplitude(["01", "10", "00", "11"])) assert np.isclose(amplitude["01"], 0) assert np.isclose(amplitude["10"], 0) assert np.isclose(amplitude["00"], 1 / np.sqrt(2)) assert np.isclose(amplitude["11"], 1 / np.sqrt(2))
def test_flattened_tensor_product(): observable_one = Observable.Z() @ Observable.Y() observable_two = Observable.X() @ Observable.H() actual = Observable.TensorProduct([observable_one, observable_two]) expected = Observable.TensorProduct( [Observable.Z(), Observable.Y(), Observable.X(), Observable.H()] ) assert expected == actual
def test_basis_rotation_instructions_multiple_result_types_same_targets(): circ = (Circuit().h(0).cnot(0, 1).expectation( observable=Observable.H() @ Observable.X(), target=[0, 1]).sample(observable=Observable.H() @ Observable.X(), target=[0, 1]).variance( observable=Observable.H() @ Observable.X(), target=[0, 1])) expected = [Instruction(Gate.Ry(-np.pi / 4), 0), Instruction(Gate.H(), 1)] assert circ.basis_rotation_instructions == expected
def test_add_result_type_same_observable_wrong_target_order_tensor_product(): circ = (Circuit().add_result_type( ResultType.Expectation( observable=Observable.Y() @ Observable.X(), target=[0, 1])).add_result_type( ResultType.Variance(observable=Observable.Y() @ Observable.X(), 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 result_types_noncommuting_flipped_targets_testing(device: Device, run_kwargs: Dict[str, Any]): circuit = ( Circuit() .h(0) .cnot(0, 1) .expectation(observable=Observable.H() @ Observable.X(), target=[0, 1]) .expectation(observable=Observable.H() @ Observable.X(), target=[1, 0]) ) result = device.run(circuit, shots=0, **run_kwargs).result() assert np.allclose(result.values[0], np.sqrt(2) / 2) assert np.allclose(result.values[1], np.sqrt(2) / 2)
def test_tensor_product_to_ir(): t = Observable.TensorProduct( [Observable.Z(), Observable.I(), Observable.X()]) assert t.to_ir() == ["z", "i", "x"] assert t.qubit_count == 3 assert t.ascii_symbols == tuple(["Z@I@X"] * 3)
def test_tensor_product_rmatmul_observable(): t1 = Observable.TensorProduct([Observable.Z(), Observable.I(), Observable.X()]) o1 = Observable.I() t = o1 @ t1 assert t.to_ir() == ["i", "z", "i", "x"] assert t.qubit_count == 4 assert t.ascii_symbols == tuple(["I@Z@I@X"] * 4)
def test_basis_rotation_instructions_tensor_product_shared_factors(): circ = (Circuit().h(0).cnot(0, 1).expectation( observable=Observable.X() @ Observable.Y() @ Observable.Y(), target=[0, 1, 2]).expectation(observable=Observable.X() @ Observable.Y(), target=[0, 1])) expected = [ Instruction(Gate.H(), 0), Instruction(Gate.Z(), 1), Instruction(Gate.S(), 1), Instruction(Gate.H(), 1), Instruction(Gate.Z(), 2), Instruction(Gate.S(), 2), Instruction(Gate.H(), 2), ] assert circ.basis_rotation_instructions == expected
def test_obs_rt_repr(): a1 = ObservableResultType(ascii_symbols=["Obs"], observable=Observable.X(), target=0) assert ( str(a1) == "ObservableResultType(observable=X('qubit_count': 1), target=QubitSet([Qubit(0)]))" )
def test_tensor_product_matmul_tensor(): t1 = Observable.TensorProduct([Observable.Z(), Observable.I(), Observable.X()]) t2 = Observable.TensorProduct( [Observable.Hermitian(matrix=Observable.I().to_matrix()), Observable.Y()] ) t3 = t1 @ t2 assert t3.to_ir() == ["z", "i", "x", [[[1.0, 0], [0, 0]], [[0, 0], [1.0, 0]]], "y"] assert t3.qubit_count == 5 assert t3.ascii_symbols == tuple(["Z@I@X@Hermitian@Y"] * 5)
def test_ir_non_empty_instructions_result_types_basis_rotation_instructions(): circ = Circuit().h(0).cnot(0, 1).sample(observable=Observable.X(), target=[0]) expected = jaqcd.Program( instructions=[jaqcd.H(target=0), jaqcd.CNot(control=0, target=1)], results=[jaqcd.Sample(observable=["x"], targets=[0])], basis_rotation_instructions=[jaqcd.H(target=0)], ) assert circ.to_ir() == expected
def result_types_noncommuting_all(device: Device, run_kwargs: Dict[str, Any]): array = np.array([[1, 2j], [-2j, 0]]) circuit = (Circuit().h(0).cnot( 0, 1).expectation(observable=Observable.Hermitian(array)).expectation( observable=Observable.X())) tasks = (circuit, circuit.to_ir(ir_type=IRType.OPENQASM)) for task in tasks: result = device.run(task, shots=0, **run_kwargs).result() assert np.allclose(result.values[0], [0.5, 0.5]) assert np.allclose(result.values[1], [0, 0])
def result_types_observable_not_in_instructions(device: Device, run_kwargs: Dict[str, Any]): shots = run_kwargs["shots"] tol = get_tol(shots) bell = (Circuit().h(0).cnot(0, 1).expectation(observable=Observable.X(), target=[2]).variance( observable=Observable.Y(), target=[3])) result = device.run(bell, **run_kwargs).result() assert np.allclose(result.values[0], 0, **tol) assert np.allclose(result.values[1], 1, **tol)
def test_basis_rotation_instructions_identity(): circ = (Circuit().h(0).cnot(0, 1).cnot(1, 2).cnot(2, 3).cnot( 3, 4).expectation(observable=Observable.X(), target=[ 0 ]).expectation(observable=Observable.I(), target=[2]).expectation( observable=Observable.I() @ Observable.Y(), target=[1, 3]).expectation(observable=Observable.I(), target=[ 0 ]).expectation(observable=Observable.X() @ Observable.I(), target=[1, 3]).expectation(observable=Observable.Y(), target=[2])) expected = [ Instruction(Gate.H(), 0), Instruction(Gate.H(), 1), Instruction(Gate.Z(), 2), Instruction(Gate.S(), 2), Instruction(Gate.H(), 2), Instruction(Gate.Z(), 3), Instruction(Gate.S(), 3), Instruction(Gate.H(), 3), ] assert circ.basis_rotation_instructions == expected
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_batch_execute_parallel(mock_run_batch): """Test batch_execute(parallel=True) correctly calls batch execution methods in Braket SDK""" mock_run_batch.return_value = TASK_BATCH dev = _aws_device(wires=4, foo="bar", parallel=True) assert dev.parallel is True with QuantumTape() as circuit: qml.Hadamard(wires=0) qml.CNOT(wires=[0, 1]) qml.probs(wires=[0]) qml.expval(qml.PauliX(1)) qml.var(qml.PauliY(2)) qml.sample(qml.PauliZ(3)) circuits = [circuit, circuit] batch_results = dev.batch_execute(circuits) for results in batch_results: assert np.allclose( results[0], RESULT.get_value_by_result_type( result_types.Probability(target=[0]))) assert np.allclose( results[1], RESULT.get_value_by_result_type( result_types.Expectation(observable=Observable.X(), target=1)), ) assert np.allclose( results[2], RESULT.get_value_by_result_type( result_types.Variance(observable=Observable.Y(), target=2)), ) assert np.allclose( results[3], RESULT.get_value_by_result_type( result_types.Sample(observable=Observable.Z(), target=3)), ) mock_run_batch.assert_called_with( [CIRCUIT, CIRCUIT], s3_destination_folder=("foo", "bar"), shots=SHOTS, max_parallel=None, max_connections=AwsQuantumTaskBatch.MAX_CONNECTIONS_DEFAULT, poll_timeout_seconds=AwsQuantumTask.DEFAULT_RESULTS_POLL_TIMEOUT, poll_interval_seconds=AwsQuantumTask.DEFAULT_RESULTS_POLL_INTERVAL, foo="bar", )
def test_pl_to_braket_circuit_hamiltonian(): """Tests that a PennyLane circuit is correctly converted into a Braket circuit""" dev = _aws_device(wires=2, foo="bar") with QuantumTape() as tape: qml.RX(0.2, wires=0) qml.RX(0.3, wires=1) qml.CNOT(wires=[0, 1]) qml.expval( qml.Hamiltonian((2, 3), (qml.PauliX(wires=0), qml.PauliY(wires=1)))) braket_circuit_true = (Circuit().rx(0, 0.2).rx(1, 0.3).cnot( 0, 1).expectation(Observable.X(), [0]).expectation(Observable.Y(), [1])) braket_circuit = dev._pl_to_braket_circuit(tape) assert braket_circuit_true == braket_circuit
def test_execute(mock_run): mock_run.return_value = TASK dev = _aws_device(wires=4, foo="bar") with QuantumTape() as circuit: qml.Hadamard(wires=0) qml.CNOT(wires=[0, 1]) qml.probs(wires=[0]) qml.expval(qml.PauliX(1)) qml.var(qml.PauliY(2)) qml.sample(qml.PauliZ(3)) results = dev.execute(circuit) assert np.allclose( results[0], RESULT.get_value_by_result_type(result_types.Probability(target=[0]))) assert np.allclose( results[1], RESULT.get_value_by_result_type( result_types.Expectation(observable=Observable.X(), target=1)), ) assert np.allclose( results[2], RESULT.get_value_by_result_type( result_types.Variance(observable=Observable.Y(), target=2)), ) assert np.allclose( results[3], RESULT.get_value_by_result_type( result_types.Sample(observable=Observable.Z(), target=3)), ) assert dev.task == TASK mock_run.assert_called_with( CIRCUIT, s3_destination_folder=("foo", "bar"), shots=SHOTS, poll_timeout_seconds=AwsQuantumTask.DEFAULT_RESULTS_POLL_TIMEOUT, poll_interval_seconds=AwsQuantumTask.DEFAULT_RESULTS_POLL_INTERVAL, foo="bar", )
def result_types_noncommuting_testing(device: Device, run_kwargs: Dict[str, Any]): shots = 0 theta = 0.432 phi = 0.123 varphi = -0.543 array = np.array( [ [-6, 2 + 1j, -3, -5 + 2j], [2 - 1j, 0, 2 - 1j, -5 + 4j], [-3, 2 + 1j, 0, -4 + 3j], [-5 - 2j, -5 - 4j, -4 - 3j, -6], ] ) obs1 = Observable.X() @ Observable.Y() obs1_targets = [0, 2] obs2 = Observable.Z() @ Observable.Z() obs2_targets = [0, 2] obs3 = Observable.Y() @ Observable.Hermitian(array) obs3_targets = [0, 1, 2] circuit = ( get_result_types_three_qubit_circuit(theta, phi, varphi, obs1, obs1_targets, shots) .expectation(obs2, obs2_targets) .expectation(obs3, obs3_targets) ) result = device.run(circuit, **run_kwargs).result() expected_mean1 = np.sin(theta) * np.sin(phi) * np.sin(varphi) expected_var1 = ( 8 * np.sin(theta) ** 2 * np.cos(2 * varphi) * np.sin(phi) ** 2 - np.cos(2 * (theta - phi)) - np.cos(2 * (theta + phi)) + 2 * np.cos(2 * theta) + 2 * np.cos(2 * phi) + 14 ) / 16 expected_mean2 = 0.849694136476246 expected_mean3 = 1.4499810303182408 assert np.allclose(result.values[0], expected_var1) assert np.allclose(result.values[1], expected_mean1) assert np.allclose(result.values[2], expected_mean2) assert np.allclose(result.values[3], expected_mean3)
def result_types_tensor_x_y_testing(device: Device, run_kwargs: Dict[str, Any]): shots = run_kwargs["shots"] theta = 0.432 phi = 0.123 varphi = -0.543 obs = Observable.X() @ Observable.Y() obs_targets = [0, 2] circuit = get_result_types_three_qubit_circuit(theta, phi, varphi, obs, obs_targets, shots) result = device.run(circuit, **run_kwargs).result() expected_mean = np.sin(theta) * np.sin(phi) * np.sin(varphi) expected_var = (8 * np.sin(theta)**2 * np.cos(2 * varphi) * np.sin(phi)**2 - np.cos(2 * (theta - phi)) - np.cos(2 * (theta + phi)) + 2 * np.cos(2 * theta) + 2 * np.cos(2 * phi) + 14) / 16 expected_eigs = get_pauli_eigenvalues(1) assert_variance_expectation_sample_result(result, shots, expected_var, expected_mean, expected_eigs)
def test_variance_parent_class(): assert isinstance(ResultType.Variance(observable=Observable.X(), target=0), ObservableResultType)
def test_basis_rotation_instructions_target(): circ = Circuit().h(0).cnot(0, 1).expectation(observable=Observable.X(), target=0) expected = [Instruction(Gate.H(), 0)] assert circ.basis_rotation_instructions == expected
}, })) TASK = Mock() TASK.result.return_value = RESULT type(TASK).id = PropertyMock(return_value="task_arn") TASK.state.return_value = "COMPLETED" TASK_BATCH = Mock() TASK_BATCH.results.return_value = [RESULT, RESULT] type(TASK_BATCH).tasks = PropertyMock(return_value=[TASK, TASK]) SIM_TASK = Mock() SIM_TASK.result.return_value.additional_metadata.simulatorMetadata.executionDuration = 1234 type(SIM_TASK).id = PropertyMock(return_value="task_arn") SIM_TASK.state.return_value = "COMPLETED" CIRCUIT = (Circuit().h(0).cnot( 0, 1).i(2).i(3).probability(target=[0]).expectation( observable=Observable.X(), target=1).variance(observable=Observable.Y(), target=2).sample(observable=Observable.Z(), target=3)) DEVICE_ARN = "baz" def test_reset(): """Tests that the members of the device are cleared on reset.""" dev = _aws_device(wires=2) dev._circuit = CIRCUIT dev._task = TASK dev.reset() assert dev.circuit is None
def test_qubit_count_getter(h): assert h.qubit_count is h._moments.qubit_count @pytest.mark.xfail(raises=AttributeError) def test_qubit_count_setter(h): h.qubit_count = 1 @pytest.mark.parametrize( "circuit,expected_qubit_count", [ (Circuit().h(0).h(1).h(2), 3), ( Circuit().h(0).expectation( observable=Observable.H() @ Observable.X(), target=[0, 1]).sample( observable=Observable.H() @ Observable.X(), target=[0, 1]), 2, ), ( Circuit().h(0).probability([1, 2]).state_vector(), 1, ), ( Circuit().h(0).variance(observable=Observable.H(), target=1).state_vector().amplitude(["01"]), 2, ), ], )
def test_expectation_init_value_error_ascii_symbols(): ObservableResultType(ascii_symbols=["Obs"], observable=Observable.X() @ Observable.Y(), target=[1, 2])
def test_obs_rt_init_value_error_qubit_count(): ObservableResultType(ascii_symbols=["Obs"], observable=Observable.X(), target=[0, 1])