def result_obj_5(task_metadata_shots):
return GateModelTaskResult(
taskMetadata=task_metadata_shots,
additionalMetadata=AdditionalMetadata(action=jaqcd.Program(
instructions=[
jaqcd.CNot(control=0, target=1),
jaqcd.CNot(control=2, target=3)
],
results=[
jaqcd.Probability(targets=[1]),
jaqcd.Expectation(observable=["z"])
],
)),
measurements=[
[0, 0, 1, 0],
[1, 1, 1, 1],
[1, 0, 0, 1],
[0, 0, 1, 0],
[1, 1, 1, 1],
[0, 1, 1, 1],
[0, 0, 0, 1],
[0, 1, 1, 1],
[0, 0, 0, 0],
[0, 0, 0, 1],
],
measuredQubits=[0, 1, 2, 3],
)
def openqasm_result_obj_shots(task_metadata_shots, additional_metadata_openqasm):
return GateModelTaskResult.construct(
measurements=[[0, 0], [0, 1], [0, 1], [0, 1]],
measuredQubits=[0, 1],
taskMetadata=task_metadata_shots,
additionalMetadata=additional_metadata_openqasm,
resultTypes=[jaqcd.Probability()],
)
def test_ir_non_empty_instructions_result_types():
circ = Circuit().h(0).cnot(0, 1).probability([0, 1])
expected = jaqcd.Program(
instructions=[jaqcd.H(target=0),
jaqcd.CNot(control=0, target=1)],
results=[jaqcd.Probability(targets=[0, 1])],
basis_rotation_instructions=[],
)
assert circ.to_ir() == expected
def test_from_object_result_types(result_obj_5):
result_obj = result_obj_5
task_result = GateModelQuantumTaskResult.from_object(result_obj)
expected_measurements = np.asarray(result_obj.measurements, dtype=int)
assert np.array2string(task_result.measurements) == np.array2string(expected_measurements)
assert np.allclose(task_result.values[0], np.array([0.6, 0.4]))
assert task_result.values[1] == [0.4, 0.2, -0.2, -0.4]
assert task_result.result_types[0].type == jaqcd.Probability(targets=[1])
assert task_result.result_types[1].type == jaqcd.Expectation(observable=["z"])
def result_str_4(task_metadata_zero_shots, additional_metadata):
result = GateModelTaskResult(
resultTypes=[
ResultTypeValue(type=jaqcd.Probability(targets=[0]), value=[0.5, 0.5]),
ResultTypeValue(
type=jaqcd.StateVector(), value=[(0.70710678, 0), (0, 0), (0, 0), (0.70710678, 0)]
),
ResultTypeValue(type=jaqcd.Expectation(observable=["y"], targets=[0]), value=0.0),
ResultTypeValue(type=jaqcd.Variance(observable=["y"], targets=[0]), value=0.1),
ResultTypeValue(type=jaqcd.Amplitude(states=["00"]), value={"00": (0.70710678, 0)}),
],
measuredQubits=list(range(2)),
taskMetadata=task_metadata_zero_shots,
additionalMetadata=additional_metadata,
)
return result.json()
def result_obj_4(task_metadata_zero_shots, additional_metadata):
return GateModelTaskResult(
resultTypes=[
ResultTypeValue.construct(type=jaqcd.Probability(targets=[0]),
value=np.array([0.5, 0.5])),
ResultTypeValue.construct(
type=jaqcd.StateVector(),
value=np.array(
[complex(0.70710678, 0), 0, 0,
complex(0.70710678, 0)]),
),
ResultTypeValue.construct(type=jaqcd.Expectation(observable=["y"],
targets=[0]),
value=0.0),
ResultTypeValue.construct(type=jaqcd.Variance(observable=["y"],
targets=[0]),
value=0.1),
ResultTypeValue.construct(type=jaqcd.Amplitude(states=["00"]),
value={"00": complex(0.70710678, 0)}),
],
measuredQubits=list(range(2)),
taskMetadata=task_metadata_zero_shots,
additionalMetadata=additional_metadata,
)
# ANY KIND, either express or implied. See the License for the specific
# language governing permissions and limitations under the License.
import itertools
import json
import random
import numpy as np
import pytest
import braket.ir.jaqcd as jaqcd
from braket.default_simulator.simulator import DefaultSimulator
results_data = [
([jaqcd.Expectation(observable=["x"])]),
([jaqcd.Probability(targets=[0, 1])]),
([jaqcd.Probability(),
jaqcd.Variance(observable=["x"])]),
([jaqcd.Variance(observable=["z"], targets=[0])]),
]
@pytest.fixture
def generate_continuous_gates_circuit():
def _generate_circuit(num_qubits, num_layers, results):
instructions = []
for layer in range(num_layers):
for qubit in range(num_qubits):
instructions.extend([
jaqcd.Rx(target=qubit, angle=0.15),
jaqcd.Ry(target=qubit, angle=0.16),
def test_from_braket_result_type_probability():
translated = from_braket_result_type(jaqcd.Probability(targets=[0, 1]))
assert isinstance(translated, Probability)
assert translated._targets == [0, 1]
@pytest.fixture
def malformatted_results_2(task_metadata_shots, additional_metadata):
return GateModelTaskResult(
measurementProbabilities={
"011000": 0.9999999999999982
},
measuredQubits=[0],
taskMetadata=task_metadata_shots,
additionalMetadata=additional_metadata,
).json()
test_ir_results = [
(jaqcd.Probability(targets=[1]), np.array([0.6, 0.4])),
(jaqcd.Probability(targets=[1, 2]), np.array([0.4, 0.2, 0.0, 0.4])),
(
jaqcd.Probability(),
np.array([
0.1, 0.2, 0.2, 0.0, 0.0, 0.0, 0.0, 0.2, 0.0, 0.1, 0.0, 0.0, 0.0,
0.0, 0.0, 0.2
]),
),
(jaqcd.Sample(targets=[1], observable=["z"]),
np.array([1, -1, 1, 1, -1, -1, 1, -1, 1, 1])),
(
jaqcd.Sample(targets=[1, 2], observable=["x", "y"]),
np.array([-1, 1, 1, -1, 1, 1, 1, 1, 1, 1]),
),
(
def test_openqasm_shots_calculate_result_types(openqasm_result_obj_shots):
result = GateModelQuantumTaskResult._from_object_internal_computational_basis_sampling(
openqasm_result_obj_shots
)
assert result.result_types[0].type == jaqcd.Probability()
assert np.array_equal(result.result_types[0].value, [0.25, 0.75, 0, 0])
