def test_probability_equality():
a1 = ResultType.Probability([0, 1])
a2 = ResultType.Probability([0, 1])
a3 = ResultType.Probability([0, 1, 2])
a4 = "hi"
assert a1 == a2
assert a1 != a3
assert a1 != a4
def test_add_result_type_observable_no_conflict_target_all():
expected = [
ResultType.Expectation(observable=Observable.Z(), target=[0]),
ResultType.Probability(),
]
circ = Circuit(expected)
assert circ.result_types == expected
def test_equality_statevector():
result1 = ResultType.StateVector()
result2 = ResultType.StateVector()
result3 = ResultType.Probability([1])
result4 = "hi"
assert result1 == result2
assert result1 != result3
assert result1 != result4
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 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 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 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 test_add_result_type_with_target(prob):
expected = [ResultType.Probability([10, 11])]
circ = Circuit().add_result_type(prob, target=[10, 11])
assert circ.observables_simultaneously_measurable
assert list(circ.result_types) == expected
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 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_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_add_result_type_observable_conflict_selected_target_then_all_target():
circ = Circuit().add_result_type(
ResultType.Expectation(observable=Observable.Y(), target=[1]))
circ.add_result_type(ResultType.Probability())
assert not circ.observables_simultaneously_measurable
assert not circ.basis_rotation_instructions
None,
range(3),
[
ResultType.Sample(Observable.X(), 0),
ResultType.Sample(Observable.Z(), 2),
],
[ResultType.Sample(Observable.X(), 4)],
),
(
None,
None,
[
ResultType.Sample(Observable.X(), 0),
ResultType.Sample(Observable.Z(), 10),
],
[ResultType.Probability(0)],
),
(
Observable.X,
range(3),
[
ResultType.Sample(Observable.X(), 0),
ResultType.Sample(Observable.X(), 1),
ResultType.Sample(Observable.X()),
],
[
ResultType.Sample(Observable.X(), 3),
ResultType.Sample(Observable.Y(), 1),
],
),
(
def test_copy_with_mapping_target_hasattr(prob):
target_mapping = {0: 10, 1: 11}
expected = ResultType.Probability([10, 11])
assert prob.copy(target_mapping=target_mapping) == expected
"#pragma braket result density_matrix q[0], q[2]",
),
(
ResultType.DensityMatrix(0),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.PHYSICAL),
"#pragma braket result density_matrix $0",
),
(
ResultType.Amplitude(["01", "10"]),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.PHYSICAL),
'#pragma braket result amplitude "01", "10"',
),
(
ResultType.Probability(),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.VIRTUAL),
"#pragma braket result probability all",
),
(
ResultType.Probability([0, 2]),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.VIRTUAL),
"#pragma braket result probability q[0], q[2]",
),
(
ResultType.Probability(0),
OpenQASMSerializationProperties(
qubit_reference_type=QubitReferenceType.PHYSICAL),
"#pragma braket result probability $0",
assert str(
recwarn[0].message).startswith("Noise is not applied to any gate")
assert np.allclose(
circuit.as_unitary(),
np.kron(gates.Si().to_matrix(),
np.kron(gates.CPhaseShift(0.15).to_matrix(), np.eye(2))),
)
@pytest.mark.parametrize(
"circuit,expected_unitary",
[
(Circuit().h(0), gates.H().to_matrix()),
(Circuit().h(0).add_result_type(
ResultType.Probability(target=[0])), gates.H().to_matrix()),
(Circuit().x(0), gates.X().to_matrix()),
(Circuit().y(0), gates.Y().to_matrix()),
(Circuit().z(0), gates.Z().to_matrix()),
(Circuit().s(0), gates.S().to_matrix()),
(Circuit().si(0), gates.Si().to_matrix()),
(Circuit().t(0), gates.T().to_matrix()),
(Circuit().ti(0), gates.Ti().to_matrix()),
(Circuit().v(0), gates.V().to_matrix()),
(Circuit().vi(0), gates.Vi().to_matrix()),
(Circuit().rx(0, 0.15), gates.Rx(0.15).to_matrix()),
(Circuit().ry(0, 0.15), gates.Ry(0.15).to_matrix()),
(Circuit().rz(0, 0.15), gates.Rz(0.15).to_matrix()),
(Circuit().phaseshift(0, 0.15), gates.PhaseShift(0.15).to_matrix()),
(Circuit().cnot(1, 0), gates.CNot().to_matrix()),
(Circuit().cnot(1, 0).add_result_type(
def test_copy_with_target_hasattr(prob):
target = [10, 11]
expected = ResultType.Probability(target)
assert prob.copy(target=target) == expected
def prob():
return ResultType.Probability([0, 1])
def test_get_value_by_result_type_value_error(result_obj_4):
result = GateModelQuantumTaskResult.from_object(result_obj_4)
result.get_value_by_result_type(ResultType.Probability(target=[0, 1]))