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 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 _qft_operations(qubit_count):
qft_ops = []
for target_qubit in range(qubit_count):
angle = np.pi / 2
qft_ops.append(jaqcd.H(target=target_qubit))
for control_qubit in range(target_qubit + 1, qubit_count):
qft_ops.append(
jaqcd.CPhaseShift(control=control_qubit,
target=target_qubit,
angle=angle))
angle /= 2
amplitudes = [
"".join([str(random.randint(0, 1)) for _ in range(qubit_count)])
for _ in range(2**(qubit_count // 2))
]
return jaqcd.Program(
instructions=qft_ops,
results=[
jaqcd.StateVector(),
jaqcd.Amplitude(states=amplitudes),
jaqcd.Expectation(observable=["x"]),
],
)
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,
)
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
# 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),
def test_from_braket_result_type_unknown_observable():
from_braket_result_type(
jaqcd.Expectation(targets=[0], observable=[[[[0, 0], [1, 0], [3, 2]], [[1, 0], [0, 0]]]])
)
def test_from_braket_result_type_tensor_product_extra():
from_braket_result_type(jaqcd.Expectation(targets=[0, 1, 2], observable=["h", "i"]))
from braket.default_simulator.observables import Hadamard, PauliX, TensorProduct
from braket.default_simulator.result_types import (
Amplitude,
Expectation,
Probability,
StateVector,
Variance,
from_braket_result_type,
)
from braket.ir import jaqcd
from braket.ir.jaqcd import shared_models
NUM_SAMPLES = 1000
observable_type_testdata = [
(jaqcd.Expectation(targets=[1], observable=["x"]), Expectation),
(jaqcd.Variance(targets=[1], observable=["y"]), Variance),
(jaqcd.Variance(targets=[1], observable=["z"]), Variance),
(jaqcd.Expectation(observable=["h"]), Expectation),
(jaqcd.Variance(targets=[0], observable=[[[[0, 0], [1, 0]], [[1, 0], [0, 0]]]]), Variance),
(jaqcd.Expectation(targets=[0, 1], observable=["h", "i"]), Expectation),
(
jaqcd.Variance(targets=[0, 1], observable=["h", [[[0, 0], [1, 0]], [[1, 0], [0, 0]]]]),
Variance,
),
]
@pytest.fixture
def state_vector():
multiplier = np.concatenate([np.ones(8), np.ones(8) * 1j])
(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]),
),
(
jaqcd.Sample(observable=["z"]),
[
np.array([1, -1, -1, 1, -1, 1, 1, 1, 1, 1]),
np.array([1, -1, 1, 1, -1, -1, 1, -1, 1, 1]),
np.array([-1, -1, 1, -1, -1, -1, 1, -1, 1, 1]),
np.array([1, -1, -1, 1, -1, -1, -1, -1, 1, -1]),
],
),
(jaqcd.Expectation(targets=[1], observable=["z"]), 0.2),
(jaqcd.Expectation(targets=[1],
observable=[[[[-1, 0], [0, 0]], [[0, 0], [1,
0]]]]), -0.2),
(jaqcd.Expectation(targets=[1, 2], observable=["z", "y"]), 0.6),
(jaqcd.Expectation(observable=["z"]), [0.4, 0.2, -0.2, -0.4]),
(jaqcd.Variance(targets=[1], observable=["z"]), 0.96),
(jaqcd.Variance(targets=[1],
observable=[[[[-1, 0], [0, 0]], [[0, 0], [1, 0]]]]), 0.96),
(jaqcd.Variance(targets=[1, 2], observable=["z", "y"]), 0.64),
(jaqcd.Variance(observable=["z"]), [0.84, 0.96, 0.96, 0.84]),
]
def test_measurement_counts_from_measurements():
measurements: np.ndarray = np.array([[1, 0, 1, 0], [0, 0, 0, 0],
(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]),
),
(
jaqcd.Sample(observable=["z"]),
[
np.array([1, -1, -1, 1, -1, 1, 1, 1, 1, 1]),
np.array([1, -1, 1, 1, -1, -1, 1, -1, 1, 1]),
np.array([-1, -1, 1, -1, -1, -1, 1, -1, 1, 1]),
np.array([1, -1, -1, 1, -1, -1, -1, -1, 1, -1]),
],
),
(jaqcd.Expectation(targets=[1], observable=["z"]), 0.2),
(jaqcd.Expectation(targets=[1, 2], observable=["z", "y"]), 0.6),
(jaqcd.Expectation(observable=["z"]), [0.4, 0.2, -0.2, -0.4]),
(jaqcd.Variance(targets=[1], observable=["z"]), 0.96),
(jaqcd.Variance(targets=[1, 2], observable=["z", "y"]), 0.64),
(jaqcd.Variance(observable=["z"]), [0.84, 0.96, 0.96, 0.84]),
]
def test_measurement_counts_from_measurements():
measurements: np.ndarray = np.array([[1, 0, 1, 0], [0, 0, 0, 0],
[1, 0, 1, 0], [1, 0, 0, 0],
[1, 0, 0, 0], [1, 0, 1, 0]])
measurement_counts = GateModelQuantumTaskResult.measurement_counts_from_measurements(
measurements)
expected_counts: Counter = {"1010": 3, "0000": 1, "1000": 2}
