cirq-core 1.7.0.dev20250819195403__py3-none-any.whl → 1.7.0.dev20250821232720__py3-none-any.whl

cirq/linalg/decompositions_test.py

@@ -35,19 +35,19 @@ CNOT = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
 CZ = np.diag([1, 1, 1, -1])
 
 
-def assert_kronecker_factorization_within_tolerance(matrix, g, f1, f2):
+def assert_kronecker_factorization_within_tolerance(matrix, g, f1, f2) -> None:
     restored = g * cirq.linalg.combinators.kron(f1, f2)
     assert not np.any(np.isnan(restored)), "NaN in kronecker product."
     assert np.allclose(restored, matrix), "Can't factor kronecker product."
 
 
-def assert_magic_su2_within_tolerance(mat, a, b):
+def assert_magic_su2_within_tolerance(mat, a, b) -> None:
     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."
 
 
 @pytest.mark.parametrize('matrix', [X, cirq.kron(X, X), cirq.kron(X, Y), cirq.kron(X, np.eye(2))])
-def test_map_eigenvalues_identity(matrix):
+def test_map_eigenvalues_identity(matrix) -> None:
     identity_mapped = cirq.map_eigenvalues(matrix, lambda e: e)
     assert np.allclose(matrix, identity_mapped)
 
@@ -63,7 +63,7 @@ def test_map_eigenvalues_identity(matrix):
         [X, 0.5, np.array([[1j, 1], [1, 1j]]) * (1 - 1j) / 2],
     ],
 )
-def test_map_eigenvalues_raise(matrix, exponent, desired):
+def test_map_eigenvalues_raise(matrix, exponent, desired) -> None:
     exp_mapped = cirq.map_eigenvalues(matrix, lambda e: complex(e) ** exponent)
     assert np.allclose(desired, exp_mapped)
 
@@ -88,7 +88,7 @@ def _random_unitary_with_close_eigenvalues():
         _random_unitary_with_close_eigenvalues(),
     ],
 )
-def test_unitary_eig(matrix):
+def test_unitary_eig(matrix) -> None:
     # np.linalg.eig(matrix) won't work for the perturbed matrix
     d, vecs = unitary_eig(matrix)
 
@@ -96,7 +96,7 @@ def test_unitary_eig(matrix):
     np.testing.assert_allclose(matrix, vecs @ np.diag(d) @ vecs.conj().T, atol=1e-14)
 
 
-def test_non_unitary_eig():
+def test_non_unitary_eig() -> None:
     with pytest.raises(Exception):
         unitary_eig(np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 0, 1, 2], [3, 4, 5, 6]]))
 
@@ -118,7 +118,7 @@ def test_non_unitary_eig():
     ]
     + [(cirq.testing.random_unitary(2), cirq.testing.random_unitary(2)) for _ in range(10)],
 )
-def test_kron_factor(f1, f2):
+def test_kron_factor(f1, f2) -> None:
     p = cirq.kron(f1, f2)
     g, g1, g2 = cirq.kron_factor_4x4_to_2x2s(p)
     assert abs(np.linalg.det(g1) - 1) < 0.00001
@@ -134,7 +134,7 @@ def test_kron_factor(f1, f2):
         for _ in range(10)
     ],
 )
-def test_kron_factor_special_unitaries(f1, f2):
+def test_kron_factor_special_unitaries(f1, f2) -> None:
     p = cirq.kron(f1, f2)
     g, g1, g2 = cirq.kron_factor_4x4_to_2x2s(p)
     assert np.allclose(cirq.kron(g1, g2), p)
@@ -144,7 +144,7 @@ def test_kron_factor_special_unitaries(f1, f2):
     assert_kronecker_factorization_within_tolerance(p, g, g1, g2)
 
 
-def test_kron_factor_invalid_input():
+def test_kron_factor_invalid_input() -> None:
     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]]),
@@ -167,7 +167,7 @@ def recompose_so4(a: np.ndarray, b: np.ndarray) -> np.ndarray:
 
 
 @pytest.mark.parametrize('m', [cirq.testing.random_special_orthogonal(4) for _ in range(10)])
-def test_so4_to_magic_su2s(m):
+def test_so4_to_magic_su2s(m) -> None:
     a, b = cirq.so4_to_magic_su2s(m)
     m2 = recompose_so4(a, b)
     assert_magic_su2_within_tolerance(m2, a, b)
@@ -181,7 +181,7 @@ def test_so4_to_magic_su2s(m):
         for _ in range(10)
     ],
 )
-def test_so4_to_magic_su2s_known_factors(a, b):
+def test_so4_to_magic_su2s_known_factors(a, b) -> None:
     m = recompose_so4(a, b)
     a2, b2 = cirq.so4_to_magic_su2s(m)
     m2 = recompose_so4(a2, b2)
@@ -206,7 +206,7 @@ def test_so4_to_magic_su2s_known_factors(a, b):
         np.diag([1, 1, 1, -1]),
     ],
 )
-def test_so4_to_magic_su2s_fail(mat):
+def test_so4_to_magic_su2s_fail(mat) -> None:
     with pytest.raises(ValueError):
         _ = cirq.so4_to_magic_su2s(mat)
 
@@ -214,7 +214,7 @@ def test_so4_to_magic_su2s_fail(mat):
 @pytest.mark.parametrize(
     'x,y,z', [[(random.random() * 2 - 1) * np.pi * 2 for _ in range(3)] for _ in range(10)]
 )
-def test_kak_canonicalize_vector(x, y, z):
+def test_kak_canonicalize_vector(x, y, z) -> None:
     i = np.eye(2)
     m = cirq.unitary(
         cirq.KakDecomposition(
@@ -243,12 +243,12 @@ def test_kak_canonicalize_vector(x, y, z):
     assert np.allclose(m, m2)
 
 
-def test_kak_vector_empty():
+def test_kak_vector_empty() -> None:
     assert len(cirq.kak_vector([])) == 0
 
 
 @pytest.mark.usefixtures('closefigures')
-def test_kak_plot_empty():
+def test_kak_plot_empty() -> None:
     cirq.scatter_plot_normalized_kak_interaction_coefficients([])
 
 
@@ -257,21 +257,21 @@ def test_kak_plot_empty():
     [np.eye(4), SWAP, SWAP * 1j, CZ, CNOT, SWAP @ CZ]
     + [cirq.testing.random_unitary(4) for _ in range(10)],
 )
-def test_kak_decomposition(target):
+def test_kak_decomposition(target) -> None:
     kak = cirq.kak_decomposition(target)
     np.testing.assert_allclose(cirq.unitary(kak), target, atol=1e-8)
 
 
-def test_kak_decomposition_unitary_object():
+def test_kak_decomposition_unitary_object() -> None:
     op = cirq.ISWAP(*cirq.LineQubit.range(2)) ** 0.5
     kak = cirq.kak_decomposition(op)
     np.testing.assert_allclose(cirq.unitary(kak), cirq.unitary(op), atol=1e-8)
     assert cirq.kak_decomposition(kak) is kak
 
 
-def test_kak_decomposition_invalid_object():
+def test_kak_decomposition_invalid_object() -> None:
     with pytest.raises(TypeError, match='unitary effect'):
-        _ = cirq.kak_decomposition('test')
+        _ = cirq.kak_decomposition('test')  # type: ignore[arg-type]
 
     with pytest.raises(ValueError, match='4x4 unitary matrix'):
         _ = cirq.kak_decomposition(np.eye(3))
@@ -289,7 +289,7 @@ def test_kak_decomposition_invalid_object():
     np.testing.assert_allclose(cirq.unitary(nil), np.eye(4), atol=1e-8)
 
 
-def test_kak_decomposition_eq():
+def test_kak_decomposition_eq() -> None:
     eq = cirq.testing.EqualsTester()
 
     eq.make_equality_group(
@@ -339,7 +339,7 @@ def test_kak_decomposition_eq():
     )
 
 
-def test_kak_repr():
+def test_kak_repr() -> None:
     cirq.testing.assert_equivalent_repr(
         cirq.KakDecomposition(
             global_phase=1j,
@@ -374,7 +374,7 @@ cirq.KakDecomposition(
     )
 
 
-def test_kak_str():
+def test_kak_str() -> None:
     v = cirq.KakDecomposition(
         interaction_coefficients=(0.3 * np.pi / 4, 0.2 * np.pi / 4, 0.1 * np.pi / 4),
         single_qubit_operations_before=(cirq.unitary(cirq.I), cirq.unitary(cirq.X)),
@@ -391,7 +391,7 @@ def test_kak_str():
     )
 
 
-def test_axis_angle_decomposition_eq():
+def test_axis_angle_decomposition_eq() -> None:
     eq = cirq.testing.EqualsTester()
 
     eq.make_equality_group(
@@ -402,13 +402,13 @@ def test_axis_angle_decomposition_eq():
     eq.add_equality_group(cirq.AxisAngleDecomposition(angle=1, axis=(0.8, 0.6, 0), global_phase=1))
 
 
-def test_axis_angle_decomposition_repr():
+def test_axis_angle_decomposition_repr() -> None:
     cirq.testing.assert_equivalent_repr(
         cirq.AxisAngleDecomposition(angle=1, axis=(0, 0.6, 0.8), global_phase=-1)
     )
 
 
-def test_axis_angle_decomposition_str():
+def test_axis_angle_decomposition_str() -> None:
     assert str(cirq.axis_angle(cirq.unitary(cirq.X))) == '1*π around X'
     assert str(cirq.axis_angle(cirq.unitary(cirq.Y))) == '1*π around Y'
     assert str(cirq.axis_angle(cirq.unitary(cirq.Z))) == '1*π around Z'
@@ -424,14 +424,14 @@ def test_axis_angle_decomposition_str():
     )
 
 
-def test_axis_angle_decomposition_unitary():
+def test_axis_angle_decomposition_unitary() -> None:
     u = cirq.testing.random_unitary(2)
     u = cirq.unitary(cirq.T)
     a = cirq.axis_angle(u)
     np.testing.assert_allclose(u, cirq.unitary(a), atol=1e-8)
 
 
-def test_axis_angle():
+def test_axis_angle() -> None:
     assert cirq.approx_eq(
         cirq.axis_angle(cirq.unitary(cirq.ry(1e-10))),
         cirq.AxisAngleDecomposition(angle=0, axis=(1, 0, 0), global_phase=1),
@@ -492,7 +492,7 @@ def test_axis_angle():
     )
 
 
-def test_axis_angle_canonicalize():
+def test_axis_angle_canonicalize() -> None:
     a = cirq.AxisAngleDecomposition(
         angle=np.pi * 2.3, axis=(1, 0, 0), global_phase=1j
     ).canonicalize()
@@ -522,7 +522,7 @@ def test_axis_angle_canonicalize():
     assert np.isclose(a.angle, -np.pi + 0.01)
 
 
-def test_axis_angle_canonicalize_approx_equal():
+def test_axis_angle_canonicalize_approx_equal() -> None:
     a1 = cirq.AxisAngleDecomposition(angle=np.pi, axis=(1, 0, 0), global_phase=1)
     a2 = cirq.AxisAngleDecomposition(angle=-np.pi, axis=(1, 0, 0), global_phase=-1)
     b1 = cirq.AxisAngleDecomposition(angle=np.pi, axis=(1, 0, 0), global_phase=-1)
@@ -530,7 +530,7 @@ def test_axis_angle_canonicalize_approx_equal():
     assert not cirq.approx_eq(a1, b1, atol=1e-8)
 
 
-def test_axis_angle_init():
+def test_axis_angle_init() -> None:
     a = cirq.AxisAngleDecomposition(angle=1, axis=(0, 1, 0), global_phase=1j)
     assert a.angle == 1
     assert a.axis == (0, 1, 0)
@@ -541,14 +541,14 @@ def test_axis_angle_init():
 
 
 @pytest.mark.usefixtures('closefigures')
-def test_scatter_plot_normalized_kak_interaction_coefficients():
+def test_scatter_plot_normalized_kak_interaction_coefficients() -> None:
     a, b = cirq.LineQubit.range(2)
-    data = [
+    data = (
         cirq.kak_decomposition(cirq.unitary(cirq.CZ)),
         cirq.unitary(cirq.CZ),
         cirq.CZ,
         cirq.Circuit(cirq.H(a), cirq.CNOT(a, b)),
-    ]
+    )
     ax = cirq.scatter_plot_normalized_kak_interaction_coefficients(data)
     assert ax is not None
     ax2 = cirq.scatter_plot_normalized_kak_interaction_coefficients(
@@ -645,33 +645,35 @@ def _local_invariants_from_kak(vector: np.ndarray) -> np.ndarray:
 _random_unitaries, _kak_vecs = _random_two_qubit_unitaries(100, random_state=11)
 
 
-def test_kak_vector_matches_vectorized():
+def test_kak_vector_matches_vectorized() -> None:
     actual = cirq.kak_vector(_random_unitaries)
     expected = np.array([cirq.kak_vector(u) for u in _random_unitaries])
     np.testing.assert_almost_equal(actual, expected)
 
 
-def test_kak_vector_local_invariants_random_input():
+def test_kak_vector_local_invariants_random_input() -> None:
     actual = _local_invariants_from_kak(cirq.kak_vector(_random_unitaries))
     expected = _local_invariants_from_kak(_kak_vecs)
 
     np.testing.assert_almost_equal(actual, expected)
 
 
-def test_kak_vector_on_weyl_chamber_face():
+def test_kak_vector_on_weyl_chamber_face() -> None:
     # unitaries with KAK vectors from I to ISWAP
     theta_swap = np.linspace(0, np.pi / 4, 10)
     k_vecs = np.zeros((10, 3))
     k_vecs[:, (0, 1)] = theta_swap[:, np.newaxis]
 
-    kwargs = dict(
-        global_phase=1j,
-        single_qubit_operations_before=(X, Y),
-        single_qubit_operations_after=(Z, 1j * X),
-    )
     unitaries = np.array(
         [
-            cirq.unitary(cirq.KakDecomposition(interaction_coefficients=(t, t, 0), **kwargs))
+            cirq.unitary(
+                cirq.KakDecomposition(
+                    interaction_coefficients=(t, t, 0),
+                    global_phase=1j,
+                    single_qubit_operations_before=(X, Y),
+                    single_qubit_operations_after=(Z, 1j * X),
+                )
+            )
             for t in theta_swap
         ]
     )
@@ -692,7 +694,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) -> None:
     actual = cirq.kak_vector(unitary)
     np.testing.assert_almost_equal(actual, expected)
 
@@ -701,17 +703,17 @@ cases = [np.eye(3), SWAP.reshape((2, 8)), SWAP.ravel()]
 
 
 @pytest.mark.parametrize('bad_input', cases)
-def test_kak_vector_wrong_matrix_shape(bad_input):
+def test_kak_vector_wrong_matrix_shape(bad_input) -> None:
     with pytest.raises(ValueError, match='to have shape'):
         cirq.kak_vector(bad_input)
 
 
-def test_kak_vector_negative_atol():
+def test_kak_vector_negative_atol() -> None:
     with pytest.raises(ValueError, match='must be positive'):
         cirq.kak_vector(np.eye(4), atol=-1.0)
 
 
-def test_kak_vector_input_not_unitary():
+def test_kak_vector_input_not_unitary() -> None:
     with pytest.raises(ValueError, match='must correspond to'):
         cirq.kak_vector(np.zeros((4, 4)))
 
@@ -728,7 +730,7 @@ def test_kak_vector_input_not_unitary():
         cirq.unitary(cirq.CZ),
     ],
 )
-def test_kak_decompose(unitary: np.ndarray):
+def test_kak_decompose(unitary: np.ndarray) -> None:
     kak = cirq.kak_decomposition(unitary)
     circuit = cirq.Circuit(kak._decompose_(cirq.LineQubit.range(2)))
     np.testing.assert_allclose(cirq.unitary(circuit), unitary, atol=1e-6)
@@ -737,7 +739,7 @@ def test_kak_decompose(unitary: np.ndarray):
 
 
 @cirq.testing.retry_once_with_later_random_values
-def test_num_two_qubit_gates_required():
+def test_num_two_qubit_gates_required() -> None:
     for i in range(4):
         assert (
             cirq.num_cnots_required(
@@ -749,7 +751,7 @@ def test_num_two_qubit_gates_required():
     assert cirq.num_cnots_required(np.eye(4)) == 0
 
 
-def test_num_two_qubit_gates_required_invalid():
+def test_num_two_qubit_gates_required_invalid() -> None:
     with pytest.raises(ValueError, match="(4,4)"):
         cirq.num_cnots_required(np.array([[1]]))
 
@@ -772,7 +774,7 @@ def test_num_two_qubit_gates_required_invalid():
         ),
     ],
 )
-def test_extract_right_diag(u):
+def test_extract_right_diag(u) -> None:
     assert cirq.num_cnots_required(u) == 3
     diag = cirq.linalg.extract_right_diag(u)
     assert cirq.is_diagonal(diag)

cirq/linalg/diagonalize_test.py

@@ -67,7 +67,7 @@ def _get_assert_diagonalized_by_str(m, p, d):
     )
 
 
-def assert_diagonalized_by(m, p, atol: float = 1e-8):
+def assert_diagonalized_by(m, p, atol: float = 1e-8) -> None:
     d = p.T.dot(m).dot(p)
 
     assert cirq.is_orthogonal(p) and cirq.is_diagonal(
@@ -82,7 +82,7 @@ def _get_assert_bidiagonalized_by_str(m, p, q, d):
     )
 
 
-def assert_bidiagonalized_by(m, p, q, rtol: float = 1e-5, atol: float = 1e-8):
+def assert_bidiagonalized_by(m, p, q, rtol: float = 1e-5, atol: float = 1e-8) -> None:
     d = p.dot(m).dot(q)
 
     assert (

cirq/linalg/predicates.py

@@ -160,7 +160,7 @@ def is_normal(matrix: np.ndarray, *, rtol: float = 1e-5, atol: float = 1e-8) ->
     return matrix_commutes(matrix, matrix.T.conj(), rtol=rtol, atol=atol)
 
 
-def is_cptp(*, kraus_ops: Sequence[np.ndarray], rtol: float = 1e-5, atol: float = 1e-8):
+def is_cptp(*, kraus_ops: Sequence[np.ndarray], rtol: float = 1e-5, atol: float = 1e-8) -> bool:
     """Determines if a channel is completely positive trace preserving (CPTP).
 
     A channel composed of Kraus operators K[0:n] is a CPTP map if the sum of

cirq/linalg/predicates_test.py

@@ -23,7 +23,7 @@ import cirq
 from cirq.linalg import matrix_commutes
 
 
-def test_is_diagonal():
+def test_is_diagonal() -> None:
     assert cirq.is_diagonal(np.empty((0, 0)))
     assert cirq.is_diagonal(np.empty((1, 0)))
     assert cirq.is_diagonal(np.empty((0, 1)))
@@ -48,7 +48,7 @@ def test_is_diagonal():
     assert cirq.is_diagonal(np.array([[1, 1e-11], [1e-10, 1]]))
 
 
-def test_is_diagonal_tolerance():
+def test_is_diagonal_tolerance() -> None:
     atol = 0.5
 
     # Pays attention to specified tolerance.
@@ -60,7 +60,7 @@ def test_is_diagonal_tolerance():
     assert not cirq.is_diagonal(np.array([[1, 0.5], [-0.6, 1]]), atol=atol)
 
 
-def test_is_hermitian():
+def test_is_hermitian() -> None:
     assert cirq.is_hermitian(np.empty((0, 0)))
     assert not cirq.is_hermitian(np.empty((1, 0)))
     assert not cirq.is_hermitian(np.empty((0, 1)))
@@ -87,7 +87,7 @@ def test_is_hermitian():
     assert cirq.is_hermitian(np.array([[1, 1j + 1e-11], [-1j, 1 + 1j * 1e-9]]))
 
 
-def test_is_hermitian_tolerance():
+def test_is_hermitian_tolerance() -> None:
     atol = 0.5
 
     # Pays attention to specified tolerance.
@@ -102,7 +102,7 @@ def test_is_hermitian_tolerance():
     assert not cirq.is_hermitian(np.array([[1, 0, 0.6], [0, 1, 0], [0, 0, 1]]), atol=atol)
 
 
-def test_is_unitary():
+def test_is_unitary() -> None:
     assert not cirq.is_unitary(np.empty((0,)))
     assert cirq.is_unitary(np.empty((0, 0)))
     assert not cirq.is_unitary(np.empty((1, 0)))
@@ -133,7 +133,7 @@ def test_is_unitary():
     assert cirq.is_unitary(np.array([[1, 1j + 1e-11], [1j, 1 + 1j * 1e-9]]) * np.sqrt(0.5))
 
 
-def test_is_unitary_tolerance():
+def test_is_unitary_tolerance() -> None:
     atol = 0.5
 
     # Pays attention to specified tolerance.
@@ -145,7 +145,7 @@ def test_is_unitary_tolerance():
     assert not cirq.is_unitary(np.array([[1.2, 0, 0], [0, 1.3, 0], [0, 0, 1.2]]), atol=atol)
 
 
-def test_is_orthogonal():
+def test_is_orthogonal() -> None:
     assert cirq.is_orthogonal(np.empty((0, 0)))
     assert not cirq.is_orthogonal(np.empty((1, 0)))
     assert not cirq.is_orthogonal(np.empty((0, 1)))
@@ -173,7 +173,7 @@ def test_is_orthogonal():
     assert cirq.is_orthogonal(np.array([[1, 1e-11], [0, 1 + 1e-11]]))
 
 
-def test_is_orthogonal_tolerance():
+def test_is_orthogonal_tolerance() -> None:
     atol = 0.5
 
     # Pays attention to specified tolerance.
@@ -185,7 +185,7 @@ def test_is_orthogonal_tolerance():
     assert not cirq.is_orthogonal(np.array([[1.2, 0, 0], [0, 1.3, 0], [0, 0, 1.2]]), atol=atol)
 
 
-def test_is_special_orthogonal():
+def test_is_special_orthogonal() -> None:
     assert cirq.is_special_orthogonal(np.empty((0, 0)))
     assert not cirq.is_special_orthogonal(np.empty((1, 0)))
     assert not cirq.is_special_orthogonal(np.empty((0, 1)))
@@ -215,7 +215,7 @@ def test_is_special_orthogonal():
     assert cirq.is_special_orthogonal(np.array([[1, 1e-11], [0, 1 + 1e-11]]))
 
 
-def test_is_special_orthogonal_tolerance():
+def test_is_special_orthogonal_tolerance() -> None:
     atol = 0.5
 
     # Pays attention to specified tolerance.
@@ -234,7 +234,7 @@ def test_is_special_orthogonal_tolerance():
     )
 
 
-def test_is_special_unitary():
+def test_is_special_unitary() -> None:
     assert cirq.is_special_unitary(np.empty((0, 0)))
     assert not cirq.is_special_unitary(np.empty((1, 0)))
     assert not cirq.is_special_unitary(np.empty((0, 1)))
@@ -260,7 +260,7 @@ def test_is_special_unitary():
     assert cirq.is_special_unitary(np.array([[1, 1j + 1e-11], [1j, 1 + 1j * 1e-9]]) * np.sqrt(0.5))
 
 
-def test_is_special_unitary_tolerance():
+def test_is_special_unitary_tolerance() -> None:
     atol = 0.5
 
     # Pays attention to specified tolerance.
@@ -277,7 +277,7 @@ def test_is_special_unitary_tolerance():
     )
 
 
-def test_is_normal():
+def test_is_normal() -> None:
     assert cirq.is_normal(np.array([[1]]))
     assert cirq.is_normal(np.array([[3j]]))
     assert cirq.is_normal(cirq.testing.random_density_matrix(4))
@@ -286,7 +286,7 @@ def test_is_normal():
     assert not cirq.is_normal(np.zeros((1, 0)))
 
 
-def test_is_normal_tolerance():
+def test_is_normal_tolerance() -> None:
     atol = 0.25
 
     # Pays attention to specified tolerance.
@@ -298,7 +298,7 @@ def test_is_normal_tolerance():
     assert not cirq.is_normal(np.array([[0, 0.5, 0], [0, 0, 0.6], [0, 0, 0]]), atol=atol)
 
 
-def test_is_cptp():
+def test_is_cptp() -> None:
     rt2 = np.sqrt(0.5)
     # Amplitude damping with gamma=0.5.
     assert cirq.is_cptp(kraus_ops=[np.array([[1, 0], [0, rt2]]), np.array([[0, rt2], [0, 0]])])
@@ -325,15 +325,15 @@ def test_is_cptp():
     # Makes 4 2x2 kraus ops.
     one_qubit_u = cirq.testing.random_unitary(8)
     one_qubit_kraus = np.reshape(one_qubit_u[:, :2], (-1, 2, 2))
-    assert cirq.is_cptp(kraus_ops=one_qubit_kraus)
+    assert cirq.is_cptp(kraus_ops=one_qubit_kraus)  # type: ignore[arg-type]
 
     # Makes 16 4x4 kraus ops.
     two_qubit_u = cirq.testing.random_unitary(64)
     two_qubit_kraus = np.reshape(two_qubit_u[:, :4], (-1, 4, 4))
-    assert cirq.is_cptp(kraus_ops=two_qubit_kraus)
+    assert cirq.is_cptp(kraus_ops=two_qubit_kraus)  # type: ignore[arg-type]
 
 
-def test_is_cptp_tolerance():
+def test_is_cptp_tolerance() -> None:
     rt2_ish = np.sqrt(0.5) - 0.01
     atol = 0.25
     # Moderately-incorrect amplitude damping with gamma=0.5.
@@ -345,7 +345,7 @@ def test_is_cptp_tolerance():
     )
 
 
-def test_commutes():
+def test_commutes() -> None:
     assert matrix_commutes(np.empty((0, 0)), np.empty((0, 0)))
     assert not matrix_commutes(np.empty((1, 0)), np.empty((0, 1)))
     assert not matrix_commutes(np.empty((0, 1)), np.empty((1, 0)))
@@ -372,7 +372,7 @@ def test_commutes():
     assert matrix_commutes(xx, np.diag([1, -1, -1, 1 + 1e-9]))
 
 
-def test_commutes_tolerance():
+def test_commutes_tolerance() -> None:
     atol = 0.5
 
     x = np.array([[0, 1], [1, 0]])
@@ -383,7 +383,7 @@ def test_commutes_tolerance():
     assert not matrix_commutes(x, x + z * 0.5, atol=atol)
 
 
-def test_allclose_up_to_global_phase():
+def test_allclose_up_to_global_phase() -> None:
     assert cirq.allclose_up_to_global_phase(np.array([1]), np.array([1j]))
 
     assert not cirq.allclose_up_to_global_phase(np.array([[[1]]]), np.array([1]))
@@ -402,7 +402,7 @@ def test_allclose_up_to_global_phase():
     assert not cirq.allclose_up_to_global_phase(np.array([[1]]), np.array([[2]]))
 
 
-def test_binary_sub_tensor_slice():
+def test_binary_sub_tensor_slice() -> None:
     a = slice(None)
     e = Ellipsis
 
@@ -437,7 +437,7 @@ def test_binary_sub_tensor_slice():
     assert cirq.slice_for_qubits_equal_to([2], 0b0, num_qubits=3) == (a, a, 0)
 
 
-def test_binary_sub_tensor_slice_big_endian():
+def test_binary_sub_tensor_slice_big_endian() -> None:
     a = slice(None)
     e = Ellipsis
     sfqet = cirq.slice_for_qubits_equal_to
@@ -473,7 +473,7 @@ def test_binary_sub_tensor_slice_big_endian():
     assert sfqet([2], big_endian_qureg_value=0b0, num_qubits=3) == (a, a, 0)
 
 
-def test_qudit_sub_tensor_slice():
+def test_qudit_sub_tensor_slice() -> None:
     a = slice(None)
     sfqet = cirq.slice_for_qubits_equal_to
 

cirq/linalg/transformations.py

@@ -34,7 +34,7 @@ from cirq.linalg import predicates
 RaiseValueErrorIfNotProvided: np.ndarray = np.array([])
 
 
-def reflection_matrix_pow(reflection_matrix: np.ndarray, exponent: float):
+def reflection_matrix_pow(reflection_matrix: np.ndarray, exponent: float) -> np.ndarray:
     """Raises a matrix with two opposing eigenvalues to a power.
 
     Args:
@@ -720,7 +720,7 @@ def factor_density_matrix(
     return extracted, remainder
 
 
-def transpose_state_vector_to_axis_order(t: np.ndarray, axes: Sequence[int]):
+def transpose_state_vector_to_axis_order(t: np.ndarray, axes: Sequence[int]) -> np.ndarray:
     """Transposes the axes of a state vector to a specified order.
 
     Args:
@@ -733,7 +733,7 @@ def transpose_state_vector_to_axis_order(t: np.ndarray, axes: Sequence[int]):
     return np.moveaxis(t, axes, range(len(axes)))
 
 
-def transpose_density_matrix_to_axis_order(t: np.ndarray, axes: Sequence[int]):
+def transpose_density_matrix_to_axis_order(t: np.ndarray, axes: Sequence[int]) -> np.ndarray:
     """Transposes the axes of a density matrix to a specified order.
 
     Args:
@@ -780,7 +780,9 @@ def _index_from_coordinates(s: Sequence[int], volume: Sequence[int]) -> int:
     return np.dot(s, volume)
 
 
-def transpose_flattened_array(t: np.ndarray, shape: Sequence[int], axes: Sequence[int]):
+def transpose_flattened_array(
+    t: np.ndarray, shape: Sequence[int], axes: Sequence[int]
+) -> np.ndarray:
     """Transposes a flattened array.
 
     Equivalent to np.transpose(t.reshape(shape), axes).reshape((-1,)).

cirq/neutral_atoms/neutral_atom_devices.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 from cirq import ops
 
 
-def neutral_atom_gateset(max_parallel_z=None, max_parallel_xy=None):
+def neutral_atom_gateset(max_parallel_z=None, max_parallel_xy=None) -> ops.Gateset:
     return ops.Gateset(
         ops.AnyIntegerPowerGateFamily(ops.CNotPowGate),
         ops.AnyIntegerPowerGateFamily(ops.CCNotPowGate),

cirq/ops/arithmetic_operation.py

@@ -17,10 +17,9 @@ from __future__ import annotations
 
 import abc
 import itertools
-from typing import cast, Iterable, Sequence, TYPE_CHECKING
+from typing import cast, Iterable, Self, Sequence, TYPE_CHECKING
 
 import numpy as np
-from typing_extensions import Self
 
 from cirq.ops.raw_types import Gate
 

cirq/ops/classically_controlled_operation.py

@@ -117,10 +117,10 @@ class ClassicallyControlledOperation(raw_types.Operation):
         return self._sub_operation.without_classical_controls()
 
     @property
-    def qubits(self):
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return self._sub_operation.qubits
 
-    def with_qubits(self, *new_qubits):
+    def with_qubits(self, *new_qubits) -> cirq.Operation:
         return self._sub_operation.with_qubits(*new_qubits).with_classical_controls(
             *self._conditions
         )

cirq/ops/clifford_gate.py

@@ -374,7 +374,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         object.__setattr__(self, '_clifford_tableau', _clifford_tableau.copy())
 
     @property
-    def clifford_tableau(self):
+    def clifford_tableau(self) -> qis.CliffordTableau:
         return self._clifford_tableau
 
     def _json_dict_(self) -> dict[str, Any]: