def _compute_eigenvalues(factors: List[Observable],
qubits: Tuple[int, ...]) -> np.ndarray:
# Check if there are any non-standard observables, namely Hermitian and Identity
if any({not observable.is_standard for observable in factors}):
# Tensor product of observables contains a mixture
# of standard and nonstandard observables
factors_sorted = sorted(factors, key=lambda x: x.measured_qubits)
eigenvalues = np.ones(1)
for is_standard, group in itertools.groupby(
factors_sorted, lambda x: x.is_standard):
# Group observables by whether or not they are standard
group_eigenvalues = (
# `group` contains only standard observables, so eigenvalues
# are simply Pauli eigenvalues
pauli_eigenvalues(len(list(group))) if is_standard
# `group` contains only nonstandard observables, so eigenvalues
# must be calculated
else functools.reduce(
np.kron,
tuple(nonstandard.eigenvalues
for nonstandard in group)))
eigenvalues = np.kron(eigenvalues, group_eigenvalues)
else:
eigenvalues = pauli_eigenvalues(len(qubits))
return eigenvalues
def test_cache_usage(depth):
"""Test that the right number of cachings have been executed after clearing the cache"""
operation_helpers.pauli_eigenvalues.cache_clear()
operation_helpers.pauli_eigenvalues(depth)
assert (functools._CacheInfo(
depth - 1, depth, 128,
depth) == operation_helpers.pauli_eigenvalues.cache_info())
def test_tensor_product_standard():
tensor = observables.TensorProduct(
[
observables.Hadamard([1]),
observables.PauliX([3]),
observables.PauliZ([7]),
observables.PauliY([4]),
]
)
assert tensor.targets == (1, 3, 4)
assert tensor.measured_qubits == (1, 3, 7, 4)
assert (tensor.eigenvalues == pauli_eigenvalues(4)).all()
assert not tensor.is_standard
# Z ignored
assert (tensor.diagonalizing_matrix == np.kron(np.kron(h_diag, x_diag), y_diag)).all()
#
# http://aws.amazon.com/apache2.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 numpy as np
import pytest
from braket.default_simulator import gate_operations, observables
from braket.default_simulator.operation_helpers import check_unitary, pauli_eigenvalues
testdata = [
(observables.Hadamard([13]), (13,), (13,), pauli_eigenvalues(1), True),
(observables.PauliX([11]), (11,), (11,), pauli_eigenvalues(1), True),
(observables.PauliY([10]), (10,), (10,), pauli_eigenvalues(1), True),
(observables.PauliZ([9]), (), (9,), pauli_eigenvalues(1), True),
(observables.Identity([7]), (), (7,), np.array([1, 1]), False),
(
observables.Hermitian(np.array([[1, 1 - 1j], [1 + 1j, -1]]), [4]),
(4,),
(4,),
[-np.sqrt(3), np.sqrt(3)],
False,
),
(
observables.Hermitian(np.array([[1, 1 - 1j], [1 + 1j, -1]])),
None,
None,
def eigenvalues(self) -> np.ndarray:
return pauli_eigenvalues(1)
def test_correct_eigenvalues_pauli_kronecker_products_two_qubits():
"""Test the pauli_eigenvalues function for two qubits"""
assert np.array_equal(operation_helpers.pauli_eigenvalues(2),
np.diag(np.kron(z_matrix, z_matrix)))
def test_correct_eigenvalues_paulis():
"""Test the pauli_eigenvalues function for one qubit"""
assert np.array_equal(operation_helpers.pauli_eigenvalues(1),
np.diag(z_matrix))