cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/linalg/diagonalize_test.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import random
-from typing import Optional, Tuple
 
 import numpy as np
 import pytest
@@ -29,7 +30,7 @@ CNOT = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
 QFT = np.array([[1, 1, 1, 1], [1, 1j, -1, -1j], [1, -1, 1, -1], [1, -1j, -1, 1j]]) * 0.5
 
 
-def random_real_diagonal_matrix(n: int, d: Optional[int] = None) -> np.ndarray:
+def random_real_diagonal_matrix(n: int, d: int | None = None) -> np.ndarray:
     return np.diag([random.random() if d is None or k < d else 0 for k in range(n)])
 
 
@@ -48,8 +49,8 @@ def random_block_diagonal_symmetric_matrix(*ns: int) -> np.ndarray:
 
 
 def random_bi_diagonalizable_pair(
-    n: int, d1: Optional[int] = None, d2: Optional[int] = None
-) -> Tuple[np.ndarray, np.ndarray]:
+    n: int, d1: int | None = None, d2: int | None = None
+) -> tuple[np.ndarray, np.ndarray]:
     u = cirq.testing.random_orthogonal(n)
     s = random_real_diagonal_matrix(n, d1)
     z = random_real_diagonal_matrix(n, d2)
@@ -107,7 +108,7 @@ def assert_bidiagonalized_by(m, p, q, rtol: float = 1e-5, atol: float = 1e-8):
     + [random_symmetric_matrix(4) for _ in range(10)]
     + [random_symmetric_matrix(k) for k in range(1, 10)],
 )
-def test_diagonalize_real_symmetric_matrix(matrix):
+def test_diagonalize_real_symmetric_matrix(matrix) -> None:
     p = cirq.diagonalize_real_symmetric_matrix(matrix)
     assert_diagonalized_by(matrix, p)
 
@@ -122,12 +123,12 @@ def test_diagonalize_real_symmetric_matrix(matrix):
         np.array([[3, 1], [7, 3]]),
     ],
 )
-def test_diagonalize_real_symmetric_matrix_fails(matrix):
+def test_diagonalize_real_symmetric_matrix_fails(matrix) -> None:
     with pytest.raises(ValueError):
         _ = cirq.diagonalize_real_symmetric_matrix(matrix)
 
 
-def test_diagonalize_real_symmetric_matrix_assertion_error():
+def test_diagonalize_real_symmetric_matrix_assertion_error() -> None:
     with pytest.raises(AssertionError):
         matrix = np.array([[0.5, 0], [0, 1]])
         m = np.array([[0, 1], [0, 0]])
@@ -151,7 +152,7 @@ def test_diagonalize_real_symmetric_matrix_assertion_error():
     ]
     + [([6, 6, 5, 5, 5], random_block_diagonal_symmetric_matrix(2, 3)) for _ in range(10)],
 )
-def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars(s, m):
+def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars(s, m) -> None:
     m = np.array(m)
     s = np.diag(s)
     p = cirq.diagonalize_real_symmetric_and_sorted_diagonal_matrices(m, s)
@@ -171,7 +172,7 @@ def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars(s, m):
         ([3, 2, 1], QFT, 'must be real symmetric'),
     ],
 )
-def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars_fail(s, m, match: str):
+def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars_fail(s, m, match: str) -> None:
     m = np.array(m)
     s = np.diag(s)
     with pytest.raises(ValueError, match=match):
@@ -199,7 +200,7 @@ def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars_fail(s, m,
     ]
     + [random_bi_diagonalizable_pair(k) for k in range(1, 10)],
 )
-def test_bidiagonalize_real_matrix_pair_with_symmetric_products(a, b):
+def test_bidiagonalize_real_matrix_pair_with_symmetric_products(a, b) -> None:
     a = np.array(a)
     b = np.array(b)
     p, q = cirq.bidiagonalize_real_matrix_pair_with_symmetric_products(a, b)
@@ -220,14 +221,14 @@ def test_bidiagonalize_real_matrix_pair_with_symmetric_products(a, b):
         [np.array([[1, 1], [1, 0]]), np.array([[1, 0], [1, 1]]), 'mat1 @ mat2.T must be symmetric'],
     ],
 )
-def test_bidiagonalize_real_fails(a, b, match: str):
+def test_bidiagonalize_real_fails(a, b, match: str) -> None:
     a = np.array(a)
     b = np.array(b)
     with pytest.raises(ValueError, match=match):
         cirq.bidiagonalize_real_matrix_pair_with_symmetric_products(a, b)
 
 
-def test_bidiagonalize__assertion_error():
+def test_bidiagonalize__assertion_error() -> None:
     with pytest.raises(AssertionError):
         a = np.diag([0, 1])
         assert_bidiagonalized_by(a, a, a)
@@ -261,7 +262,7 @@ def test_bidiagonalize__assertion_error():
     + [cirq.testing.random_unitary(4) for _ in range(10)]
     + [cirq.testing.random_unitary(k) for k in range(1, 10)],
 )
-def test_bidiagonalize_unitary_with_special_orthogonals(mat):
+def test_bidiagonalize_unitary_with_special_orthogonals(mat) -> None:
     p, d, q = cirq.bidiagonalize_unitary_with_special_orthogonals(mat)
     assert cirq.is_special_orthogonal(p)
     assert cirq.is_special_orthogonal(q)
@@ -273,6 +274,6 @@ def test_bidiagonalize_unitary_with_special_orthogonals(mat):
     'mat',
     [np.diag([0]), np.diag([0.5]), np.diag([1, 0]), np.diag([0.5, 2]), np.array([[0, 1], [0, 0]])],
 )
-def test_bidiagonalize_unitary_fails(mat):
+def test_bidiagonalize_unitary_fails(mat) -> None:
     with pytest.raises(ValueError):
         cirq.bidiagonalize_unitary_with_special_orthogonals(mat)

cirq/linalg/operator_spaces.py

@@ -13,7 +13,10 @@
 # limitations under the License.
 
 """Utilities for manipulating linear operators as elements of vector space."""
-from typing import Dict, Tuple, TYPE_CHECKING
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -33,7 +36,7 @@ PAULI_BASIS = {
 document(PAULI_BASIS, """The four Pauli matrices (including identity) keyed by character.""")
 
 
-def kron_bases(*bases: Dict[str, np.ndarray], repeat: int = 1) -> Dict[str, np.ndarray]:
+def kron_bases(*bases: dict[str, np.ndarray], repeat: int = 1) -> dict[str, np.ndarray]:
     """Creates tensor product of bases."""
     product_basis = {'': np.array([[1]])}
     for basis in bases * repeat:
@@ -54,7 +57,7 @@ def hilbert_schmidt_inner_product(m1: np.ndarray, m2: np.ndarray) -> complex:
 
 
 def expand_matrix_in_orthogonal_basis(
-    m: np.ndarray, basis: Dict[str, np.ndarray]
+    m: np.ndarray, basis: dict[str, np.ndarray]
 ) -> value.LinearDict[str]:
     """Computes coefficients of expansion of m in basis.
 
@@ -71,27 +74,24 @@ def expand_matrix_in_orthogonal_basis(
 
 
 def matrix_from_basis_coefficients(
-    expansion: value.LinearDict[str], basis: Dict[str, np.ndarray]
+    expansion: value.LinearDict[str], basis: dict[str, np.ndarray]
 ) -> np.ndarray:
     """Computes linear combination of basis vectors with given coefficients."""
     some_element = next(iter(basis.values()))
     result = np.zeros_like(some_element, dtype=np.complex128)
     for name, coefficient in expansion.items():
-        result += coefficient * basis[name]
+        result += complex(coefficient) * basis[name]
     return result
 
 
 def pow_pauli_combination(
-    ai: 'cirq.TParamValComplex',
-    ax: 'cirq.TParamValComplex',
-    ay: 'cirq.TParamValComplex',
-    az: 'cirq.TParamValComplex',
+    ai: cirq.TParamValComplex,
+    ax: cirq.TParamValComplex,
+    ay: cirq.TParamValComplex,
+    az: cirq.TParamValComplex,
     exponent: int,
-) -> Tuple[
-    'cirq.TParamValComplex',
-    'cirq.TParamValComplex',
-    'cirq.TParamValComplex',
-    'cirq.TParamValComplex',
+) -> tuple[
+    cirq.TParamValComplex, cirq.TParamValComplex, cirq.TParamValComplex, cirq.TParamValComplex
 ]:
     """Computes non-negative integer power of single-qubit Pauli combination.
 

cirq/linalg/operator_spaces_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 
 import numpy as np
@@ -84,7 +86,7 @@ def _one_hot_matrix(size: int, i: int, j: int) -> np.ndarray:
         ),
     ),
 )
-def test_kron_bases(basis1, basis2, expected_kron_basis):
+def test_kron_bases(basis1, basis2, expected_kron_basis) -> None:
     kron_basis = cirq.kron_bases(basis1, basis2)
     assert len(kron_basis) == 16
     assert set(kron_basis.keys()) == set(expected_kron_basis.keys())
@@ -115,14 +117,14 @@ def test_kron_bases(basis1, basis2, expected_kron_basis):
         ),
     ),
 )
-def test_kron_bases_consistency(basis1, basis2):
+def test_kron_bases_consistency(basis1, basis2) -> None:
     assert set(basis1.keys()) == set(basis2.keys())
     for name in basis1.keys():
         assert np.all(basis1[name] == basis2[name])
 
 
 @pytest.mark.parametrize('basis,repeat', itertools.product((PAULI_BASIS, STANDARD_BASIS), range(5)))
-def test_kron_bases_repeat_sanity_checks(basis, repeat):
+def test_kron_bases_repeat_sanity_checks(basis, repeat) -> None:
     product_basis = cirq.kron_bases(basis, repeat=repeat)
     assert len(product_basis) == 4**repeat
     for name1, matrix1 in product_basis.items():
@@ -138,7 +140,7 @@ def test_kron_bases_repeat_sanity_checks(basis, repeat):
     'm1,m2,expect_real',
     ((X, X, True), (X, Y, True), (X, H, True), (X, SQRT_X, False), (I, SQRT_Z, False)),
 )
-def test_hilbert_schmidt_inner_product_is_conjugate_symmetric(m1, m2, expect_real):
+def test_hilbert_schmidt_inner_product_is_conjugate_symmetric(m1, m2, expect_real) -> None:
     v1 = cirq.hilbert_schmidt_inner_product(m1, m2)
     v2 = cirq.hilbert_schmidt_inner_product(m2, m1)
     assert v1 == v2.conjugate()
@@ -149,7 +151,7 @@ def test_hilbert_schmidt_inner_product_is_conjugate_symmetric(m1, m2, expect_rea
 
 
 @pytest.mark.parametrize('a,m1,b,m2', ((1, X, 1, Z), (2, X, 3, Y), (2j, X, 3, I), (2, X, 3, X)))
-def test_hilbert_schmidt_inner_product_is_linear(a, m1, b, m2):
+def test_hilbert_schmidt_inner_product_is_linear(a, m1, b, m2) -> None:
     v1 = cirq.hilbert_schmidt_inner_product(H, (a * m1 + b * m2))
     v2 = a * cirq.hilbert_schmidt_inner_product(H, m1) + b * cirq.hilbert_schmidt_inner_product(
         H, m2
@@ -158,7 +160,7 @@ def test_hilbert_schmidt_inner_product_is_linear(a, m1, b, m2):
 
 
 @pytest.mark.parametrize('m', (I, X, Y, Z, H, SQRT_X, SQRT_Y, SQRT_Z))
-def test_hilbert_schmidt_inner_product_is_positive_definite(m):
+def test_hilbert_schmidt_inner_product_is_positive_definite(m) -> None:
     v = cirq.hilbert_schmidt_inner_product(m, m)
     # Cannot check using np.is_real due to bug in aarch64.
     # See https://github.com/quantumlib/Cirq/issues/4379
@@ -186,7 +188,7 @@ def test_hilbert_schmidt_inner_product_is_positive_definite(m):
         (SQRT_X, E11, np.sqrt(-0.5j)),
     ),
 )
-def test_hilbert_schmidt_inner_product_values(m1, m2, expected_value):
+def test_hilbert_schmidt_inner_product_values(m1, m2, expected_value) -> None:
     v = cirq.hilbert_schmidt_inner_product(m1, m2)
     assert np.isclose(v, expected_value)
 
@@ -195,7 +197,7 @@ def test_hilbert_schmidt_inner_product_values(m1, m2, expected_value):
     'm,basis',
     itertools.product((I, X, Y, Z, H, SQRT_X, SQRT_Y, SQRT_Z), (PAULI_BASIS, STANDARD_BASIS)),
 )
-def test_expand_matrix_in_orthogonal_basis(m, basis):
+def test_expand_matrix_in_orthogonal_basis(m, basis) -> None:
     expansion = cirq.expand_matrix_in_orthogonal_basis(m, basis)
 
     reconstructed = np.zeros(m.shape, dtype=complex)
@@ -216,7 +218,7 @@ def test_expand_matrix_in_orthogonal_basis(m, basis):
         {'I': 1, 'X': 2, 'Y': 3, 'Z': 4},
     ),
 )
-def test_matrix_from_basis_coefficients(expansion):
+def test_matrix_from_basis_coefficients(expansion) -> None:
     m = cirq.matrix_from_basis_coefficients(expansion, PAULI_BASIS)
 
     for name, coefficient in expansion.items():
@@ -236,7 +238,7 @@ def test_matrix_from_basis_coefficients(expansion):
         )
     ),
 )
-def test_expand_is_inverse_of_reconstruct(m1, basis):
+def test_expand_is_inverse_of_reconstruct(m1, basis) -> None:
     c1 = cirq.expand_matrix_in_orthogonal_basis(m1, basis)
     m2 = cirq.matrix_from_basis_coefficients(c1, basis)
     c2 = cirq.expand_matrix_in_orthogonal_basis(m2, basis)
@@ -299,7 +301,7 @@ def test_expand_is_inverse_of_reconstruct(m1, basis):
         (0, 1, 2, 3, 4, 5, 100, 101),
     ),
 )
-def test_pow_pauli_combination(coefficients, exponent):
+def test_pow_pauli_combination(coefficients, exponent) -> None:
     is_symbolic = any(isinstance(a, sympy.Basic) for a in coefficients)
     if is_symbolic and exponent > 2:
         return  # too slow

cirq/linalg/predicates.py

@@ -11,8 +11,13 @@
 # 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.
+
 """Utility methods for checking properties of matrices."""
-from typing import cast, List, Optional, Sequence, Tuple, Union
+
+from __future__ import annotations
+
+from types import EllipsisType
+from typing import cast, Sequence
 
 import numpy as np
 
@@ -110,8 +115,12 @@ def is_unitary(matrix: np.ndarray, *, rtol: float = 1e-5, atol: float = 1e-8) ->
     Returns:
         Whether the matrix is unitary within the given tolerance.
     """
-    return matrix.shape[0] == matrix.shape[1] and np.allclose(
-        matrix.dot(np.conj(matrix.T)), np.eye(matrix.shape[0]), rtol=rtol, atol=atol
+    return (
+        matrix.ndim == 2
+        and matrix.shape[0] == matrix.shape[1]
+        and np.allclose(
+            matrix.dot(np.conj(matrix.T)), np.eye(matrix.shape[0]), rtol=rtol, atol=atol
+        )
     )
 
 
@@ -226,9 +235,9 @@ def slice_for_qubits_equal_to(
     little_endian_qureg_value: int = 0,
     *,  # Forces keyword args.
     big_endian_qureg_value: int = 0,
-    num_qubits: Optional[int] = None,
-    qid_shape: Optional[Tuple[int, ...]] = None,
-) -> Tuple[Union[slice, int, 'ellipsis'], ...]:
+    num_qubits: int | None = None,
+    qid_shape: tuple[int, ...] | None = None,
+) -> tuple[slice | int | EllipsisType, ...]:
     """Returns an index corresponding to a desired subset of an np.ndarray.
 
     It is assumed that the np.ndarray's shape is of the form (2, 2, 2, ..., 2).
@@ -283,10 +292,10 @@ def slice_for_qubits_equal_to(
     qid_shape_specified = qid_shape is not None
     if qid_shape is not None or num_qubits is not None:
         if num_qubits is None:
-            num_qubits = len(cast(Tuple[int, ...], qid_shape))
+            num_qubits = len(cast(tuple[int, ...], qid_shape))
         elif qid_shape is None:
             qid_shape = (2,) * num_qubits
-        if num_qubits != len(cast(Tuple[int, ...], qid_shape)):
+        if num_qubits != len(cast(tuple[int, ...], qid_shape)):
             raise ValueError('len(qid_shape) != num_qubits')
     if little_endian_qureg_value and big_endian_qureg_value:
         raise ValueError(
@@ -297,7 +306,7 @@ def slice_for_qubits_equal_to(
     out_size = (
         cast(int, num_qubits) if out_size_specified else max(target_qubit_axes, default=-1) + 1
     )
-    result = cast(List[Union[slice, int, 'ellipsis']], [slice(None)] * out_size)
+    result = cast(list[slice | int | EllipsisType], [slice(None)] * out_size)
     if not out_size_specified:
         result.append(Ellipsis)
     if qid_shape is None:

cirq/linalg/predicates_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cmath
 
 import numpy as np
@@ -101,10 +103,13 @@ def test_is_hermitian_tolerance():
 
 
 def test_is_unitary():
+    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)))
     assert not cirq.is_unitary(np.empty((0, 1)))
+    assert not cirq.is_unitary(np.empty((0, 0, 0)))
 
+    assert not cirq.is_unitary(np.array(1))
     assert cirq.is_unitary(np.array([[1]]))
     assert cirq.is_unitary(np.array([[-1]]))
     assert cirq.is_unitary(np.array([[1j]]))

cirq/linalg/tolerance.py

@@ -14,7 +14,10 @@
 
 """Utility for testing approximate equality of matrices and scalars within
 tolerances."""
-from typing import Iterable, TYPE_CHECKING, Union
+
+from __future__ import annotations
+
+from typing import Iterable, TYPE_CHECKING
 
 import numpy as np
 
@@ -22,7 +25,7 @@ if TYPE_CHECKING:
     from numpy.typing import ArrayLike
 
 
-def all_near_zero(a: 'ArrayLike', *, atol: float = 1e-8) -> bool:
+def all_near_zero(a: ArrayLike, *, atol: float = 1e-8) -> bool:
     """Checks if the tensor's elements are all near zero.
 
     Args:
@@ -33,7 +36,7 @@ def all_near_zero(a: 'ArrayLike', *, atol: float = 1e-8) -> bool:
 
 
 def all_near_zero_mod(
-    a: Union[float, Iterable[float], np.ndarray], period: float, *, atol: float = 1e-8
+    a: 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/tolerance_test.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from cirq.linalg.tolerance import all_near_zero, all_near_zero_mod, near_zero, near_zero_mod
 
 
-def test_all_zero():
+def test_all_zero() -> None:
     atol = 5
     assert all_near_zero(0, atol=atol)
     assert all_near_zero(4.5, atol=atol)
@@ -25,7 +27,7 @@ def test_all_zero():
     assert not all_near_zero([-4.5, 0, 1, 4.5, 30], atol=atol)
 
 
-def test_all_zero_mod():
+def test_all_zero_mod() -> None:
     atol = 5
     assert all_near_zero_mod(0, 100, atol=atol)
     assert all_near_zero_mod(4.5, 100, atol=atol)
@@ -45,14 +47,14 @@ def test_all_zero_mod():
     assert not all_near_zero_mod([-4.5, 0, 1, 4.5, 30], 100, atol=atol)
 
 
-def test_near_zero():
+def test_near_zero() -> None:
     atol = 5
     assert near_zero(0, atol=atol)
     assert near_zero(4.5, atol=atol)
     assert not near_zero(5.5, atol=atol)
 
 
-def test_near_zero_mod():
+def test_near_zero_mod() -> None:
     atol = 5
     assert near_zero_mod(0, 100, atol=atol)
     assert near_zero_mod(4.5, 100, atol=atol)

cirq/linalg/transformations.py

@@ -14,9 +14,12 @@
 
 """Utility methods for transforming matrices or vectors."""
 
+from __future__ import annotations
+
 import dataclasses
 import functools
-from typing import Any, List, Optional, Sequence, Tuple, Union
+from types import EllipsisType
+from typing import Any, Sequence
 
 import numpy as np
 
@@ -59,7 +62,7 @@ def reflection_matrix_pow(reflection_matrix: np.ndarray, exponent: float):
     return pos_part_raised + neg_part_raised
 
 
-def match_global_phase(a: np.ndarray, b: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+def match_global_phase(a: np.ndarray, b: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
     """Phases the given matrices so that they agree on the phase of one entry.
 
     To maximize precision, the position with the largest entry from one of the
@@ -101,7 +104,7 @@ def targeted_left_multiply(
     left_matrix: np.ndarray,
     right_target: np.ndarray,
     target_axes: Sequence[int],
-    out: Optional[np.ndarray] = None,
+    out: np.ndarray | None = None,
 ) -> np.ndarray:
     """Left-multiplies the given axes of the target tensor by the given matrix.
 
@@ -176,7 +179,7 @@ class _SliceConfig:
 
 @dataclasses.dataclass
 class _BuildFromSlicesArgs:
-    slices: Tuple[_SliceConfig, ...]
+    slices: tuple[_SliceConfig, ...]
     scale: complex
 
 
@@ -234,8 +237,8 @@ def _build_from_slices(
     d = len(source.shape)
     out[...] = 0
     for arg in args:
-        source_slice: List[Any] = [slice(None)] * d
-        target_slice: List[Any] = [slice(None)] * d
+        source_slice: list[Any] = [slice(None)] * d
+        target_slice: list[Any] = [slice(None)] * d
         for sleis in arg.slices:
             source_slice[sleis.axis] = sleis.source_index
             target_slice[sleis.axis] = sleis.target_index
@@ -247,9 +250,9 @@ def targeted_conjugate_about(
     tensor: np.ndarray,
     target: np.ndarray,
     indices: Sequence[int],
-    conj_indices: Optional[Sequence[int]] = None,
-    buffer: Optional[np.ndarray] = None,
-    out: Optional[np.ndarray] = None,
+    conj_indices: Sequence[int] | None = None,
+    buffer: np.ndarray | None = None,
+    out: np.ndarray | None = None,
 ) -> np.ndarray:
     r"""Conjugates the given tensor about the target tensor.
 
@@ -298,8 +301,8 @@ def targeted_conjugate_about(
     return targeted_left_multiply(np.conjugate(tensor), first_multiply, conj_indices, out=out)
 
 
-_TSliceAtom = Union[int, slice, 'ellipsis']
-_TSlice = Union[_TSliceAtom, Sequence[_TSliceAtom]]
+_TSliceAtom = int | slice | EllipsisType
+_TSlice = _TSliceAtom | Sequence[_TSliceAtom]
 
 
 def apply_matrix_to_slices(
@@ -307,7 +310,7 @@ def apply_matrix_to_slices(
     matrix: np.ndarray,
     slices: Sequence[_TSlice],
     *,
-    out: Optional[np.ndarray] = None,
+    out: np.ndarray | None = None,
 ) -> np.ndarray:
     r"""Left-multiplies an NxN matrix onto N slices of a numpy array.
 
@@ -417,8 +420,8 @@ class EntangledStateError(ValueError):
 
 
 def partial_trace_of_state_vector_as_mixture(
-    state_vector: np.ndarray, keep_indices: List[int], *, atol: float = 1e-8
-) -> Tuple[Tuple[float, np.ndarray], ...]:
+    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.
 
     The input state vector can have any shape, but if it is one-dimensional it
@@ -452,7 +455,7 @@ def partial_trace_of_state_vector_as_mixture(
         if 2**dims != state_vector.size:
             raise ValueError(f'Cannot infer underlying shape of {state_vector.shape}.')
         state_vector = state_vector.reshape((2,) * dims)
-        ret_shape: Tuple[int, ...] = (2 ** len(keep_indices),)
+        ret_shape: tuple[int, ...] = (2 ** len(keep_indices),)
     else:
         ret_shape = tuple(state_vector.shape[i] for i in keep_indices)
 
@@ -473,7 +476,7 @@ def partial_trace_of_state_vector_as_mixture(
 
 def sub_state_vector(
     state_vector: np.ndarray,
-    keep_indices: List[int],
+    keep_indices: list[int],
     *,
     default: np.ndarray = RaiseValueErrorIfNotProvided,
     atol: float = 1e-6,
@@ -533,7 +536,7 @@ def sub_state_vector(
 
     n_qubits = int(np.log2(state_vector.size))
     keep_dims = 1 << len(keep_indices)
-    ret_shape: Union[Tuple[int], Tuple[int, ...]]
+    ret_shape: tuple[int] | tuple[int, ...]
     if state_vector.shape == (state_vector.size,):
         ret_shape = (keep_dims,)
         state_vector = state_vector.reshape((2,) * n_qubits)
@@ -631,7 +634,7 @@ def density_matrix_kronecker_product(t1: np.ndarray, t2: np.ndarray) -> np.ndarr
 
 def factor_state_vector(
     t: np.ndarray, axes: Sequence[int], *, validate=True, atol=1e-07
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray]:
     """Factors a state vector into two independent state vectors.
 
     This function should only be called on state vectors that are known to be
@@ -677,7 +680,7 @@ def factor_state_vector(
 
 def factor_density_matrix(
     t: np.ndarray, axes: Sequence[int], *, validate=True, atol=1e-07
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray]:
     """Factors a density matrix into two independent density matrices.
 
     This function should only be called on density matrices that are known to
@@ -745,7 +748,7 @@ def transpose_density_matrix_to_axis_order(t: np.ndarray, axes: Sequence[int]):
     return transpose_state_vector_to_axis_order(t, axes)
 
 
-def _volumes(shape: Sequence[int]) -> List[int]:
+def _volumes(shape: Sequence[int]) -> list[int]:
     r"""Returns a list of the volume spanned by each dimension.
 
     Given a shape=[d_0, d_1, .., d_n] the volume spanned by each dimension is