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)
