def test_tensor_product_rmatmul_observable():
t1 = Observable.TensorProduct([Observable.Z(), Observable.I(), Observable.X()])
o1 = Observable.I()
t = o1 @ t1
assert t.to_ir() == ["i", "z", "i", "x"]
assert t.qubit_count == 4
assert t.ascii_symbols == tuple(["I@Z@I@X"] * 4)
def test_observable_equality():
o1 = Observable.I()
o2 = Observable.I()
o3 = Observable.Z()
o4 = "a"
assert o1 == o2
assert o1 != o3
assert o1 != o4
def test_tensor_product_matmul_tensor():
t1 = Observable.TensorProduct([Observable.Z(), Observable.I(), Observable.X()])
t2 = Observable.TensorProduct(
[Observable.Hermitian(matrix=Observable.I().to_matrix()), Observable.Y()]
)
t3 = t1 @ t2
assert t3.to_ir() == ["z", "i", "x", [[[1.0, 0], [0, 0]], [[0, 0], [1.0, 0]]], "y"]
assert t3.qubit_count == 5
assert t3.ascii_symbols == tuple(["Z@I@X@Hermitian@Y"] * 5)
def test_basis_rotation_instructions_multiple_result_types_tensor_product_hermitian_qubit_count_2(
):
circ = (Circuit().h(0).cnot(0, 1).cnot(1, 2).expectation(
observable=Observable.I(), target=[1]).sample(
observable=Observable.Hermitian(matrix=np.eye(4)) @ Observable.H(),
target=[0, 1, 2]).variance(observable=Observable.H(),
target=[2]).expectation(
observable=Observable.I(),
target=[0]))
expected = [
Instruction(Gate.Unitary(matrix=np.eye(4)), target=[0, 1]),
Instruction(Gate.Ry(-np.pi / 4), 2),
]
assert circ.basis_rotation_instructions == expected
def test_tensor_product_to_ir():
t = Observable.TensorProduct(
[Observable.Z(), Observable.I(),
Observable.X()])
assert t.to_ir() == ["z", "i", "x"]
assert t.qubit_count == 3
assert t.ascii_symbols == tuple(["Z@I@X"] * 3)
def test_matmul_observable():
o1 = Observable.I()
o2 = Observable.Z()
o3 = o1 @ o2
assert isinstance(o3, Observable.TensorProduct)
assert o3.qubit_count == 2
assert o3.to_ir() == ["i", "z"]
assert o3.ascii_symbols == ("I@Z", "I@Z")
def test_hermitian_equality():
matrix = Observable.H().to_matrix()
a1 = Observable.Hermitian(matrix=matrix)
a2 = Observable.Hermitian(matrix=matrix)
a3 = Observable.Hermitian(matrix=Observable.I().to_matrix())
a4 = "hi"
assert a1 == a2
assert a1 != a3
assert a1 != a4
def test_basis_rotation_instructions_identity():
circ = (Circuit().h(0).cnot(0, 1).cnot(1, 2).cnot(2, 3).cnot(
3, 4).expectation(observable=Observable.X(), target=[
0
]).expectation(observable=Observable.I(), target=[2]).expectation(
observable=Observable.I() @ Observable.Y(),
target=[1, 3]).expectation(observable=Observable.I(), target=[
0
]).expectation(observable=Observable.X() @ Observable.I(),
target=[1,
3]).expectation(observable=Observable.Y(),
target=[2]))
expected = [
Instruction(Gate.H(), 0),
Instruction(Gate.H(), 1),
Instruction(Gate.Z(), 2),
Instruction(Gate.S(), 2),
Instruction(Gate.H(), 2),
Instruction(Gate.Z(), 3),
Instruction(Gate.S(), 3),
Instruction(Gate.H(), 3),
]
assert circ.basis_rotation_instructions == expected
def test_matmul_non_observable():
Observable.I() @ "a"
ir.Expectation,
{
"observable": Observable.Z(),
"target": [0]
},
{
"observable": ["z"],
"targets": [0]
},
),
(
ResultType.Expectation,
"expectation",
ir.Expectation,
{
"observable": Observable.Z() @ Observable.I() @ Observable.X(),
"target": [0, 1, 2]
},
{
"observable": ["z", "i", "x"],
"targets": [0, 1, 2]
},
),
(
ResultType.Expectation,
"expectation",
ir.Expectation,
{
"observable":
Observable.Hermitian(matrix=Observable.I().to_matrix()),
"target": [0]
def test_observable_from_ir_tensor_product():
expected_observable = Observable.TensorProduct(
[Observable.Z(), Observable.I(),
Observable.X()])
actual_observable = observable_from_ir(["z", "i", "x"])
assert expected_observable == actual_observable
def test_tensor_product_rmatmul_value_error():
"a" @ Observable.TensorProduct(
[Observable.Z(), Observable.I(),
Observable.X()])
def test_tensor_product_value_error():
Observable.TensorProduct([Observable.Z(),
Observable.I(),
Observable.X()]) @ "a"
ir.Probability,
{"target": None},
{},
),
(
ResultType.Expectation,
"expectation",
ir.Expectation,
{"observable": Observable.Z(), "target": [0]},
{"observable": ["z"], "targets": [0]},
),
(
ResultType.Expectation,
"expectation",
ir.Expectation,
{"observable": Observable.Z() @ Observable.I() @ Observable.X(), "target": [0, 1, 2]},
{"observable": ["z", "i", "x"], "targets": [0, 1, 2]},
),
(
ResultType.Expectation,
"expectation",
ir.Expectation,
{"observable": Observable.Hermitian(matrix=Observable.I().to_matrix()), "target": [0]},
{"observable": [[[[1.0, 0], [0, 0]], [[0, 0], [1.0, 0]]]], "targets": [0]},
),
(
ResultType.Expectation,
"expectation",
ir.Expectation,
{"observable": Observable.Hermitian(matrix=Observable.I().to_matrix()), "target": None},
{"observable": [[[[1.0, 0], [0, 0]], [[0, 0], [1.0, 0]]]]},
def test_hermitian_to_ir():
matrix = Observable.I().to_matrix()
obs = Observable.Hermitian(matrix=matrix)
assert obs.to_ir() == [[[[1, 0], [0, 0]], [[0, 0], [1, 0]]]]
# or in the "license" file accompanying this file. This file is
# 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 math
import numpy as np
import pytest
from braket.circuits import Gate, Observable
from braket.circuits.observables import observable_from_ir
from braket.circuits.quantum_operator_helpers import get_pauli_eigenvalues
testdata = [
(Observable.I(), Gate.I(), ["i"], (), np.array([1, 1])),
(Observable.X(), Gate.X(), ["x"], tuple([Gate.H()]),
get_pauli_eigenvalues(1)),
(
Observable.Y(),
Gate.Y(),
["y"],
tuple([Gate.Z(), Gate.S(), Gate.H()]),
get_pauli_eigenvalues(1),
),
(Observable.Z(), Gate.Z(), ["z"], (), get_pauli_eigenvalues(1)),
(Observable.H(), Gate.H(), ["h"], tuple([Gate.Ry(-math.pi / 4)]),
get_pauli_eigenvalues(1)),
]
invalid_hermitian_matrices = [
ir.Expectation,
{
"observable": Observable.Z(),
"target": [0]
},
{
"observable": ["z"],
"targets": [0]
},
),
(
ResultType.Expectation,
"expectation",
ir.Expectation,
{
"observable": Observable.Z() @ Observable.I() @ Observable.X(),
"target": [0, 1, 2]
},
{
"observable": ["z", "i", "x"],
"targets": [0, 1, 2]
},
),
(
ResultType.Expectation,
"expectation",
ir.Expectation,
{
"observable":
Observable.Hermitian(matrix=Observable.I().to_matrix()),
"target": [0]
def test_tensor_product_eigenvalue_index_out_of_bounds():
obs = Observable.TensorProduct(
[Observable.Z(), Observable.I(),
Observable.X()])
obs.eigenvalue(8)
import math
import numpy as np
import pytest
from braket.circuits import Gate, Observable
from braket.circuits.observables import observable_from_ir
from braket.circuits.quantum_operator_helpers import get_pauli_eigenvalues
from braket.circuits.serialization import (
IRType,
OpenQASMSerializationProperties,
QubitReferenceType,
)
testdata = [
(Observable.I(), Gate.I(), ["i"], (), np.array([1, 1])),
(Observable.X(), Gate.X(), ["x"], tuple([Gate.H()]), get_pauli_eigenvalues(1)),
(
Observable.Y(),
Gate.Y(),
["y"],
tuple([Gate.Z(), Gate.S(), Gate.H()]),
get_pauli_eigenvalues(1),
),
(Observable.Z(), Gate.Z(), ["z"], (), get_pauli_eigenvalues(1)),
(Observable.H(), Gate.H(), ["h"], tuple([Gate.Ry(-math.pi / 4)]), get_pauli_eigenvalues(1)),
]
invalid_hermitian_matrices = [
(np.array([[1]])),
(np.array([1])),
