cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/linalg/decompositions.py

@@ -24,7 +24,6 @@ from typing import (
     Iterable,
     List,
     Optional,
-    Set,
     Tuple,
     TYPE_CHECKING,
     TypeVar,
@@ -32,12 +31,12 @@ from typing import (
 )
 
 import matplotlib.pyplot as plt
+import numpy as np
 
 # this is for older systems with matplotlib <3.2 otherwise 3d projections fail
 from mpl_toolkits import mplot3d
-import numpy as np
 
-from cirq import value, protocols
+from cirq import protocols, value
 from cirq._compat import proper_repr
 from cirq._import import LazyLoader
 from cirq.linalg import combinators, diagonalize, predicates, transformations
@@ -106,29 +105,6 @@ def deconstruct_single_qubit_matrix_into_angles(mat: np.ndarray) -> Tuple[float,
     return right_phase + diagonal_phase, rotation * 2, bottom_phase
 
 
-def _group_similar(items: List[T], comparer: Callable[[T, T], bool]) -> List[List[T]]:
-    """Combines similar items into groups.
-
-    Args:
-      items: The list of items to group.
-      comparer: Determines if two items are similar.
-
-    Returns:
-      A list of groups of items.
-    """
-    groups: List[List[T]] = []
-    used: Set[int] = set()
-    for i in range(len(items)):
-        if i not in used:
-            group = [items[i]]
-            for j in range(i + 1, len(items)):
-                if j not in used and comparer(items[i], items[j]):
-                    used.add(j)
-                    group.append(items[j])
-            groups.append(group)
-    return groups
-
-
 def unitary_eig(
     matrix: np.ndarray, check_preconditions: bool = True, atol: float = 1e-8
 ) -> Tuple[np.ndarray, np.ndarray]:
@@ -175,7 +151,6 @@ def map_eigenvalues(
     Args:
         matrix: The matrix to modify with the function.
         func: The function to apply to the eigenvalues of the matrix.
-        rtol: Relative threshold used when separating eigenspaces.
         atol: Absolute threshold used when separating eigenspaces.
 
     Returns:
@@ -191,15 +166,18 @@ def map_eigenvalues(
     return total
 
 
-def kron_factor_4x4_to_2x2s(matrix: np.ndarray) -> Tuple[complex, np.ndarray, np.ndarray]:
+def kron_factor_4x4_to_2x2s(
+    matrix: np.ndarray, rtol=1e-5, atol=1e-8
+) -> Tuple[complex, np.ndarray, np.ndarray]:
     """Splits a 4x4 matrix U = kron(A, B) into A, B, and a global factor.
 
     Requires the matrix to be the kronecker product of two 2x2 unitaries.
     Requires the matrix to have a non-zero determinant.
-    Giving an incorrect matrix will cause garbage output.
 
     Args:
         matrix: The 4x4 unitary matrix to factor.
+        rtol: Per-matrix-entry relative tolerance on equality.
+        atol: Per-matrix-entry absolute tolerance on equality.
 
     Returns:
         A scalar factor and a pair of 2x2 unit-determinant matrices. The
@@ -232,6 +210,9 @@ def kron_factor_4x4_to_2x2s(matrix: np.ndarray) -> Tuple[complex, np.ndarray, np
         f1 *= -1
         g = -g
 
+    if not np.allclose(matrix, g * np.kron(f1, f2), rtol=rtol, atol=atol):
+        raise ValueError("Invalid 4x4 kronecker product.")
+
     return g, f1, f2
 
 
@@ -266,7 +247,7 @@ def so4_to_magic_su2s(
             raise ValueError('mat must be 4x4 special orthogonal.')
 
     ab = combinators.dot(MAGIC, mat, MAGIC_CONJ_T)
-    _, a, b = kron_factor_4x4_to_2x2s(ab)
+    _, a, b = kron_factor_4x4_to_2x2s(ab, rtol, atol)
 
     return a, b
 
@@ -283,13 +264,7 @@ class AxisAngleDecomposition:
     rotation axis, and g is the global phase.
     """
 
-    def __init__(
-        self,
-        *,
-        angle: float,
-        axis: Tuple[float, float, float],
-        global_phase: Union[int, float, complex],
-    ):
+    def __init__(self, *, angle: float, axis: Tuple[float, float, float], global_phase: complex):
         if not np.isclose(np.linalg.norm(axis, 2), 1, atol=1e-8):
             raise ValueError('Axis vector must be normalized.')
         self.global_phase = complex(global_phase)
@@ -629,12 +604,12 @@ def scatter_plot_normalized_kak_interaction_coefficients(
         >>> plt.show()
     """
     show_plot = not ax
-    if not ax:
+    if ax is None:
         fig = plt.figure()
         ax = cast(mplot3d.axes3d.Axes3D, fig.add_subplot(1, 1, 1, projection='3d'))
 
     def coord_transform(
-        pts: Union[List[Tuple[int, int, int]], np.ndarray]
+        pts: Union[List[Tuple[int, int, int]], np.ndarray],
     ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
         if len(pts) == 0:
             return np.array([]), np.array([]), np.array([])
@@ -993,7 +968,7 @@ def _canonicalize_kak_vector(k_vec: np.ndarray, atol: float) -> np.ndarray:
     unitaries required to bring the KAK vector into canonical form.
 
     Args:
-        k_vec: THe KAK vector to be canonicalized. This input may be vectorized,
+        k_vec: The KAK vector to be canonicalized. This input may be vectorized,
             with shape (...,3), where the final axis denotes the k_vector and
             all other axes are broadcast.
         atol: How close x2 must be to π/4 to guarantee z2 >= 0.

cirq/linalg/decompositions_test.py

@@ -18,8 +18,8 @@ import numpy as np
 import pytest
 
 import cirq
-from cirq import value
-from cirq import unitary_eig
+from cirq import unitary_eig, value
+from cirq.linalg.decompositions import MAGIC, MAGIC_CONJ_T
 
 X = np.array([[0, 1], [1, 0]])
 Y = np.array([[0, -1j], [1j, 0]])
@@ -39,15 +39,8 @@ def assert_kronecker_factorization_within_tolerance(matrix, g, f1, f2):
     assert np.allclose(restored, matrix), "Can't factor kronecker product."
 
 
-def assert_kronecker_factorization_not_within_tolerance(matrix, g, f1, f2):
-    restored = g * cirq.linalg.combinators.kron(f1, f2)
-    assert np.any(np.isnan(restored) or not np.allclose(restored, matrix))
-
-
 def assert_magic_su2_within_tolerance(mat, a, b):
-    M = cirq.linalg.decompositions.MAGIC
-    MT = cirq.linalg.decompositions.MAGIC_CONJ_T
-    recon = cirq.linalg.combinators.dot(MT, cirq.linalg.combinators.kron(a, b), M)
+    recon = cirq.linalg.combinators.dot(MAGIC_CONJ_T, cirq.linalg.combinators.kron(a, b), MAGIC)
     assert np.allclose(recon, mat), "Failed to decompose within tolerance."
 
 
@@ -149,14 +142,15 @@ def test_kron_factor_special_unitaries(f1, f2):
     assert_kronecker_factorization_within_tolerance(p, g, g1, g2)
 
 
-def test_kron_factor_fail():
-    mat = cirq.kron_with_controls(cirq.CONTROL_TAG, X)
-    g, f1, f2 = cirq.kron_factor_4x4_to_2x2s(mat)
-    with pytest.raises(ValueError):
-        assert_kronecker_factorization_not_within_tolerance(mat, g, f1, f2)
-    mat = cirq.kron_factor_4x4_to_2x2s(np.diag([1, 1, 1, 1j]))
-    with pytest.raises(ValueError):
-        assert_kronecker_factorization_not_within_tolerance(mat, g, f1, f2)
+def test_kron_factor_invalid_input():
+    mats = [
+        cirq.kron_with_controls(cirq.CONTROL_TAG, X),
+        np.array([[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 2, 3, 4]]),
+        np.diag([1, 1, 1, 1j]),
+    ]
+    for mat in mats:
+        with pytest.raises(ValueError, match="Invalid 4x4 kronecker product"):
+            cirq.kron_factor_4x4_to_2x2s(mat)
 
 
 def recompose_so4(a: np.ndarray, b: np.ndarray) -> np.ndarray:
@@ -165,8 +159,7 @@ def recompose_so4(a: np.ndarray, b: np.ndarray) -> np.ndarray:
     assert cirq.is_special_unitary(a)
     assert cirq.is_special_unitary(b)
 
-    magic = np.array([[1, 0, 0, 1j], [0, 1j, 1, 0], [0, 1j, -1, 0], [1, 0, 0, -1j]]) * np.sqrt(0.5)
-    result = np.real(cirq.dot(np.conj(magic.T), cirq.kron(a, b), magic))
+    result = np.real(cirq.dot(MAGIC_CONJ_T, cirq.kron(a, b), MAGIC))
     assert cirq.is_orthogonal(result)
     return result
 
@@ -656,7 +649,7 @@ def test_kak_vector_matches_vectorized():
     np.testing.assert_almost_equal(actual, expected)
 
 
-def test_KAK_vector_local_invariants_random_input():
+def test_kak_vector_local_invariants_random_input():
     actual = _local_invariants_from_kak(cirq.kak_vector(_random_unitaries))
     expected = _local_invariants_from_kak(_kak_vecs)
 
@@ -697,7 +690,7 @@ def test_kak_vector_on_weyl_chamber_face():
         (np.kron(X, X), (0, 0, 0)),
     ),
 )
-def test_KAK_vector_weyl_chamber_vertices(unitary, expected):
+def test_kak_vector_weyl_chamber_vertices(unitary, expected):
     actual = cirq.kak_vector(unitary)
     np.testing.assert_almost_equal(actual, expected)
 
@@ -741,6 +734,7 @@ def test_kak_decompose(unitary: np.ndarray):
     assert len(list(circuit.all_operations())) == 8
 
 
+@cirq.testing.retry_once_with_later_random_values
 def test_num_two_qubit_gates_required():
     for i in range(4):
         assert (

cirq/linalg/diagonalize.py

@@ -14,7 +14,7 @@
 
 """Utility methods for diagonalizing matrices."""
 
-from typing import Tuple, Callable, List
+from typing import Callable, List, Tuple
 
 import numpy as np
 

cirq/linalg/diagonalize_test.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import random
-from typing import Tuple, Optional
+from typing import Optional, Tuple
 
 import numpy as np
 import pytest

cirq/linalg/operator_spaces.py

@@ -13,13 +13,17 @@
 # limitations under the License.
 
 """Utilities for manipulating linear operators as elements of vector space."""
-from typing import Dict, Tuple
+from typing import Dict, Tuple, TYPE_CHECKING
 
 import numpy as np
+import sympy
 
 from cirq import value
 from cirq._doc import document
 
+if TYPE_CHECKING:
+    import cirq
+
 PAULI_BASIS = {
     'I': np.eye(2),
     'X': np.array([[0.0, 1.0], [1.0, 0.0]]),
@@ -78,8 +82,17 @@ def matrix_from_basis_coefficients(
 
 
 def pow_pauli_combination(
-    ai: value.Scalar, ax: value.Scalar, ay: value.Scalar, az: value.Scalar, exponent: int
-) -> Tuple[value.Scalar, value.Scalar, value.Scalar, value.Scalar]:
+    ai: 'cirq.TParamValComplex',
+    ax: 'cirq.TParamValComplex',
+    ay: 'cirq.TParamValComplex',
+    az: 'cirq.TParamValComplex',
+    exponent: int,
+) -> Tuple[
+    'cirq.TParamValComplex',
+    'cirq.TParamValComplex',
+    'cirq.TParamValComplex',
+    'cirq.TParamValComplex',
+]:
     """Computes non-negative integer power of single-qubit Pauli combination.
 
     Returns scalar coefficients bi, bx, by, bz such that
@@ -96,7 +109,10 @@ def pow_pauli_combination(
     if exponent == 0:
         return 1, 0, 0, 0
 
-    v = np.sqrt(ax * ax + ay * ay + az * az).item()
+    if any(isinstance(a, sympy.Basic) for a in [ax, ay, az]):
+        v = sympy.sqrt(ax * ax + ay * ay + az * az)
+    else:
+        v = np.sqrt(ax * ax + ay * ay + az * az).item()
     s = (ai + v) ** exponent
     t = (ai - v) ** exponent
 

cirq/linalg/operator_spaces_test.py

@@ -17,6 +17,7 @@ import itertools
 import numpy as np
 import pytest
 import scipy.linalg
+import sympy
 
 import cirq
 
@@ -287,11 +288,21 @@ def test_expand_is_inverse_of_reconstruct(m1, basis):
             (-1, -2, 3, 4),
             (1j, 2j, 3j, 4j),
             (1j, 2j, 3, 4),
+            (sympy.Symbol('i'), sympy.Symbol('x'), sympy.Symbol('y'), sympy.Symbol('z')),
+            (
+                sympy.Symbol('i') * 1j,
+                -sympy.Symbol('x'),
+                -sympy.Symbol('y') * 1j,
+                sympy.Symbol('z'),
+            ),
         ),
         (0, 1, 2, 3, 4, 5, 100, 101),
     ),
 )
 def test_pow_pauli_combination(coefficients, exponent):
+    is_symbolic = any(isinstance(a, sympy.Basic) for a in coefficients)
+    if is_symbolic and exponent > 2:
+        return  # too slow
     i = cirq.PAULI_BASIS['I']
     x = cirq.PAULI_BASIS['X']
     y = cirq.PAULI_BASIS['Y']
@@ -303,5 +314,7 @@ def test_pow_pauli_combination(coefficients, exponent):
 
     bi, bx, by, bz = cirq.pow_pauli_combination(ai, ax, ay, az, exponent)
     result = bi * i + bx * x + by * y + bz * z
-
-    assert np.allclose(result, expected_result)
+    if is_symbolic:
+        assert cirq.approx_eq(result, expected_result)
+    else:
+        assert np.allclose(result, expected_result)

cirq/linalg/predicates.py

@@ -12,12 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Utility methods for checking properties of matrices."""
-from typing import cast, List, Optional, Sequence, Union, Tuple
+from typing import cast, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 
-from cirq.linalg import tolerance, transformations
 from cirq import value
+from cirq.linalg import tolerance, transformations
 
 
 def is_diagonal(matrix: np.ndarray, *, atol: float = 1e-8) -> bool:
@@ -308,7 +308,7 @@ def slice_for_qubits_equal_to(
     else:
         if little_endian_qureg_value < 0 and not qid_shape_specified:
             # Allow negative binary numbers
-            little_endian_qureg_value &= (1 << len(target_shape)) - 1
+            little_endian_qureg_value &= (1 << len(target_shape)) - 1  # pragma: no cover
         digits = value.big_endian_int_to_digits(little_endian_qureg_value, base=target_shape[::-1])[
             ::-1
         ]

cirq/linalg/predicates_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import cmath
+
 import numpy as np
 import pytest
 

cirq/linalg/tolerance.py

@@ -14,7 +14,7 @@
 
 """Utility for testing approximate equality of matrices and scalars within
 tolerances."""
-from typing import Union, Iterable, TYPE_CHECKING
+from typing import Iterable, TYPE_CHECKING, Union
 
 import numpy as np
 
@@ -33,7 +33,7 @@ def all_near_zero(a: 'ArrayLike', *, atol: float = 1e-8) -> bool:
 
 
 def all_near_zero_mod(
-    a: Union[float, complex, Iterable[float], np.ndarray], period: float, *, atol: float = 1e-8
+    a: Union[float, Iterable[float], np.ndarray], period: float, *, atol: float = 1e-8
 ) -> bool:
     """Checks if the tensor's elements are all near multiples of the period.
 

cirq/linalg/transformations.py

@@ -15,6 +15,7 @@
 """Utility methods for transforming matrices or vectors."""
 
 import dataclasses
+import functools
 from typing import Any, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
@@ -29,8 +30,6 @@ from cirq.linalg import predicates
 # user provides a different np.array([]) value.
 RaiseValueErrorIfNotProvided: np.ndarray = np.array([])
 
-_NPY_MAXDIMS = 32  # Should be changed once numpy/numpy#5744 is resolved.
-
 
 def reflection_matrix_pow(reflection_matrix: np.ndarray, exponent: float):
     """Raises a matrix with two opposing eigenvalues to a power.
@@ -154,7 +153,6 @@ def targeted_left_multiply(
 
     all_indices = set(input_indices + data_indices + tuple(output_indices))
 
-    # TODO(#5757): remove type ignore when numpy has proper override signature.
     return np.einsum(
         left_matrix,
         input_indices,
@@ -165,10 +163,8 @@ def targeted_left_multiply(
         # but this is a workaround for a bug in numpy:
         #     https://github.com/numpy/numpy/issues/10926
         optimize=len(all_indices) >= 26,
-        # And this is workaround for *another* bug!
-        # Supposed to be able to just say 'old=old'.
-        **({'out': out} if out is not None else {}),
-    )  # type: ignore
+        out=out,
+    )
 
 
 @dataclasses.dataclass
@@ -407,13 +403,12 @@ def partial_trace(tensor: np.ndarray, keep_indices: Sequence[int]) -> np.ndarray
     if not all(i < ndim for i in keep_indices):
         raise ValueError(
             f'keep_indices were {keep_indices} but must be in first half, '
-            f'i.e. have index less that {ndim}.'
+            f'i.e. have index less than {ndim}.'
         )
     keep_set = set(keep_indices)
     keep_map = dict(zip(keep_indices, sorted(keep_indices)))
     left_indices = [keep_map[i] if i in keep_set else i for i in range(ndim)]
     right_indices = [ndim + i if i in keep_set else i for i in left_indices]
-    # TODO(#5757): remove type ignore when numpy has proper override signature.
     return np.einsum(tensor, left_indices + right_indices)
 
 
@@ -422,7 +417,7 @@ class EntangledStateError(ValueError):
 
 
 def partial_trace_of_state_vector_as_mixture(
-    state_vector: np.ndarray, keep_indices: List[int], *, atol: Union[int, float] = 1e-8
+    state_vector: np.ndarray, keep_indices: List[int], *, atol: float = 1e-8
 ) -> Tuple[Tuple[float, np.ndarray], ...]:
     """Returns a mixture representing a state vector with only some qubits kept.
 
@@ -481,7 +476,7 @@ def sub_state_vector(
     keep_indices: List[int],
     *,
     default: np.ndarray = RaiseValueErrorIfNotProvided,
-    atol: Union[int, float] = 1e-6,
+    atol: float = 1e-6,
 ) -> np.ndarray:
     r"""Attempts to factor a state vector into two parts and return one of them.
 
@@ -807,6 +802,29 @@ def transpose_flattened_array(t: np.ndarray, shape: Sequence[int], axes: Sequenc
     return ret
 
 
+@functools.cache
+def _can_numpy_support_dims(num_dims: int) -> bool:
+    try:
+        _ = np.empty((1,) * num_dims)
+        return True
+    except ValueError:  # pragma: no cover
+        return False
+
+
 def can_numpy_support_shape(shape: Sequence[int]) -> bool:
     """Returns whether numpy supports the given shape or not numpy/numpy#5744."""
-    return len(shape) <= _NPY_MAXDIMS
+    return min(shape, default=0) >= 0 and _can_numpy_support_dims(len(shape))
+
+
+def phase_delta(u1: np.ndarray, u2: np.ndarray) -> complex:
+    """Calculates the phase delta of two unitaries.
+
+    The delta is from u1 to u2. i.e. u1 * phase_delta(u1, u2) == u2.
+
+    Assumes but does not verify that inputs are valid unitaries and differ only
+    by phase.
+    """
+    # All cells will have the same phase difference. Just choose the cell with the largest
+    # absolute value, to minimize rounding error.
+    max_index = np.unravel_index(np.abs(u1).argmax(), u1.shape)
+    return u2[max_index] / u1[max_index]

cirq/linalg/transformations_test.py

@@ -648,3 +648,16 @@ def test_transpose_flattened_array(num_dimensions):
         assert np.array_equal(want, got)
         got = linalg.transpose_flattened_array(A.reshape(shape), shape, axes).reshape(want.shape)
         assert np.array_equal(want, got)
+
+
+@pytest.mark.parametrize('shape, result', [((), True), (30 * (1,), True), ((-3, 1, -1), False)])
+def test_can_numpy_support_shape(shape: tuple[int, ...], result: bool) -> None:
+    assert linalg.can_numpy_support_shape(shape) is result
+
+
+@pytest.mark.parametrize('coeff', [1, 1j, -1, -1j, 1j**0.5, 1j**0.3])
+def test_phase_delta(coeff):
+    u1 = cirq.testing.random_unitary(4)
+    u2 = u1 * coeff
+    np.testing.assert_almost_equal(linalg.phase_delta(u1, u2), coeff)
+    np.testing.assert_almost_equal(u1 * linalg.phase_delta(u1, u2), u2)

cirq/neutral_atoms/__init__.py

@@ -15,6 +15,6 @@
 """Neutral atom devices and gates."""
 
 from cirq.neutral_atoms.convert_to_neutral_atom_gates import (
-    is_native_neutral_atom_gate,
-    is_native_neutral_atom_op,
+    is_native_neutral_atom_gate as is_native_neutral_atom_gate,
+    is_native_neutral_atom_op as is_native_neutral_atom_op,
 )

cirq/neutral_atoms/convert_to_neutral_atom_gates_test.py

@@ -16,7 +16,6 @@ import pytest
 
 import cirq
 
-
 Q, Q2, Q3 = cirq.LineQubit.range(3)