def no_result_types_testing(circuit: Circuit, device: Device,
run_kwargs: Dict[str, Any], expected: Dict[str,
float]):
shots = run_kwargs["shots"]
tol = get_tol(shots)
result = device.run(circuit, **run_kwargs).result()
probabilities = result.measurement_probabilities
for bitstring in probabilities:
assert np.allclose(probabilities[bitstring], expected[bitstring],
**tol)
assert len(result.measurements) == shots
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 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)
result = device.run(circuit, **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 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())
)
result = device.run(circuit, 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 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()
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()),
np.array([0.5, 0, 0, 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 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 result_types_tensor_z_z_testing(device: Device, run_kwargs: Dict[str, Any]):
shots = run_kwargs["shots"]
theta = 0.432
phi = 0.123
varphi = -0.543
obs = Observable.Z() @ Observable.Z()
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 = 0.849694136476246
expected_var = 0.27801987443788634
expected_eigs = get_pauli_eigenvalues(1)
assert_variance_expectation_sample_result(
result, shots, expected_var, expected_mean, expected_eigs
)
def result_types_tensor_z_hermitian_testing(device: Device,
run_kwargs: Dict[str, Any]):
shots = run_kwargs["shots"]
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],
])
obs = Observable.Z() @ Observable.Hermitian(array)
obs_targets = [0, 1, 2]
circuit = get_result_types_three_qubit_circuit(theta, phi, varphi, obs,
obs_targets, shots)
tasks = (circuit, circuit.to_ir(ir_type=IRType.OPENQASM))
for task in tasks:
result = device.run(task, **run_kwargs).result()
expected_mean = 0.5 * (
-6 * np.cos(theta) * (np.cos(varphi) + 1) - 2 * np.sin(varphi) *
(np.cos(theta) + np.sin(phi) - 2 * np.cos(phi)) +
3 * np.cos(varphi) * np.sin(phi) + np.sin(phi))
expected_var = (
1057 - np.cos(2 * phi) + 12 *
(27 + np.cos(2 * phi)) * np.cos(varphi) -
2 * np.cos(2 * varphi) * np.sin(phi) *
(16 * np.cos(phi) + 21 * np.sin(phi)) + 16 * np.sin(2 * phi) - 8 *
(-17 + np.cos(2 * phi) + 2 * np.sin(2 * phi)) * np.sin(varphi) -
8 * np.cos(2 * theta) *
(3 + 3 * np.cos(varphi) + np.sin(varphi))**2 - 24 * np.cos(phi) *
(np.cos(phi) + 2 * np.sin(phi)) * np.sin(2 * varphi) -
8 * np.cos(theta) *
(4 * np.cos(phi) *
(4 + 8 * np.cos(varphi) + np.cos(2 * varphi) -
(1 + 6 * np.cos(varphi)) * np.sin(varphi)) + np.sin(phi) *
(15 + 8 * np.cos(varphi) - 11 * np.cos(2 * varphi) +
42 * np.sin(varphi) + 3 * np.sin(2 * varphi)))) / 16
z_array = np.diag([1, -1])
expected_eigs = np.linalg.eigvalsh(np.kron(z_array, array))
assert_variance_expectation_sample_result(result, shots, expected_var,
expected_mean, expected_eigs)
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 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 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 result_types_tensor_z_h_y_testing(device: Device, run_kwargs: Dict[str,
Any]):
shots = run_kwargs["shots"]
theta = 0.432
phi = 0.123
varphi = -0.543
obs = Observable.Z() @ Observable.H() @ Observable.Y()
obs_targets = [0, 1, 2]
circuit = get_result_types_three_qubit_circuit(theta, phi, varphi, obs,
obs_targets, shots)
tasks = (circuit, circuit.to_ir(ir_type=IRType.OPENQASM))
for task in tasks:
result = device.run(task, **run_kwargs).result()
expected_mean = -(np.cos(varphi) * np.sin(phi) +
np.sin(varphi) * np.cos(theta)) / np.sqrt(2)
expected_var = (3 + np.cos(2 * phi) * np.cos(varphi)**2 -
np.cos(2 * theta) * np.sin(varphi)**2 - 2 *
np.cos(theta) * np.sin(phi) * np.sin(2 * varphi)) / 4
expected_eigs = get_pauli_eigenvalues(1)
assert_variance_expectation_sample_result(result, shots, expected_var,
expected_mean, expected_eigs)
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 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"])