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

cirq/interop/quirk/url_to_circuit.py

@@ -11,21 +11,12 @@
 # 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.
+
+from __future__ import annotations
+
 import json
 import urllib.parse
-from typing import (
-    Any,
-    cast,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, cast, Iterable, Mapping, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -47,12 +38,10 @@ if TYPE_CHECKING:
 def quirk_url_to_circuit(
     quirk_url: str,
     *,
-    qubits: Optional[Sequence['cirq.Qid']] = None,
-    extra_cell_makers: Union[
-        Dict[str, 'cirq.Gate'], Iterable['cirq.interop.quirk.cells.CellMaker']
-    ] = (),
+    qubits: Sequence[cirq.Qid] | None = None,
+    extra_cell_makers: dict[str, cirq.Gate] | Iterable[cirq.interop.quirk.cells.CellMaker] = (),
     max_operation_count: int = 10**6,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Parses a Cirq circuit out of a Quirk URL.
 
     Args:
@@ -150,13 +139,11 @@ def quirk_url_to_circuit(
 def quirk_json_to_circuit(
     data: dict,
     *,
-    qubits: Optional[Sequence['cirq.Qid']] = None,
-    extra_cell_makers: Union[
-        Dict[str, 'cirq.Gate'], Iterable['cirq.interop.quirk.cells.CellMaker']
-    ] = (),
-    quirk_url: Optional[str] = None,
+    qubits: Sequence[cirq.Qid] | None = None,
+    extra_cell_makers: dict[str, cirq.Gate] | Iterable[cirq.interop.quirk.cells.CellMaker] = (),
+    quirk_url: str | None = None,
     max_operation_count: int = 10**6,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Constructs a Cirq circuit from Quirk's JSON format.
 
     Args:
@@ -239,7 +226,7 @@ def quirk_json_to_circuit(
     if qubits is not None:
         qs = qubits
 
-        def map_qubit(qubit: 'cirq.Qid') -> 'cirq.Qid':
+        def map_qubit(qubit: cirq.Qid) -> cirq.Qid:
             q = cast(devices.LineQubit, qubit)
             if q.x >= len(qs):
                 raise IndexError(
@@ -255,9 +242,9 @@ def quirk_json_to_circuit(
 
 
 def _parse_cols_into_composite_cell(
-    data: Dict[str, Any], registry: Dict[str, CellMaker]
+    data: dict[str, Any], registry: dict[str, CellMaker]
 ) -> CompositeCell:
-    if not isinstance(data, Dict):
+    if not isinstance(data, dict):
         raise ValueError('Circuit JSON must be a dictionary.')
     if 'cols' not in data:
         raise ValueError(f'Circuit JSON dict must have a "cols" entry.\nJSON={data}')
@@ -266,7 +253,7 @@ def _parse_cols_into_composite_cell(
         raise ValueError(f'Circuit JSON cols must be a list.\nJSON={data}')
 
     # Parse column json into cells.
-    parsed_cols: List[List[Optional[Cell]]] = []
+    parsed_cols: list[list[Cell | None]] = []
     height = 0
     for i, col in enumerate(cols):
         parsed_col, h = _parse_col_cells_with_height(registry, i, col)
@@ -300,8 +287,8 @@ def _parse_cols_into_composite_cell(
     return CompositeCell(height, parsed_cols, gate_count=gate_count)
 
 
-def _register_custom_gate(gate_json: Any, registry: Dict[str, CellMaker]):
-    if not isinstance(gate_json, Dict):
+def _register_custom_gate(gate_json: Any, registry: dict[str, CellMaker]):
+    if not isinstance(gate_json, dict):
         raise ValueError(f'Custom gate json must be a dictionary.\nCustom gate json={gate_json!r}.')
 
     if 'id' not in gate_json:
@@ -343,11 +330,11 @@ def _register_custom_gate(gate_json: Any, registry: Dict[str, CellMaker]):
         )
 
 
-def _init_ops(data: Dict[str, Any]) -> 'cirq.OP_TREE':
+def _init_ops(data: dict[str, Any]) -> cirq.OP_TREE:
     if 'init' not in data:
         return []
     init = data['init']
-    if not isinstance(init, List):
+    if not isinstance(init, list):
         raise ValueError(f'Circuit JSON init must be a list but was {init!r}.')
     init_ops = []
     for i in range(len(init)):
@@ -371,8 +358,8 @@ def _init_ops(data: Dict[str, Any]) -> 'cirq.OP_TREE':
 
 
 def _parse_col_cells_with_height(
-    registry: Dict[str, CellMaker], col: int, col_data: Any
-) -> Tuple[List[Optional[Cell]], int]:
+    registry: dict[str, CellMaker], col: int, col_data: Any
+) -> tuple[list[Cell | None], int]:
     if not isinstance(col_data, list):
         raise ValueError(f'col must be a list.\ncol: {col_data!r}')
     result = []
@@ -385,8 +372,8 @@ def _parse_col_cells_with_height(
 
 
 def _parse_cell_with_height(
-    registry: Dict[str, CellMaker], row: int, col: int, entry: Any
-) -> Tuple[Optional[Cell], int]:
+    registry: dict[str, CellMaker], row: int, col: int, entry: Any
+) -> tuple[Cell | None, int]:
     if entry == 1:
         return None, 0
 

cirq/interop/quirk/url_to_circuit_test.py

@@ -11,6 +11,9 @@
 # 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.
+
+from __future__ import annotations
+
 import json
 import urllib
 
@@ -353,7 +356,7 @@ def test_example_qft_circuit():
 6: ───┼───×─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────@^0.016───@^0.031───@^(1/16)───@^(1/8)───@^0.25───@^0.5───H───┼─────────┼─────────┼─────────┼──────────┼─────────┼────────@───────────
       │                                                                                                                                                                                                                                               │         │         │         │          │         │        │
 7: ───×───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────@^0.008───@^0.016───@^0.031───@^(1/16)───@^(1/8)───@^0.25───@^0.5───H───
-    """
+    """  # noqa: E501
 
     qft_example_json = (
         '{"cols":['

cirq/json_resolver_cache.py

@@ -12,16 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Methods for resolving JSON types during serialization."""
+
+from __future__ import annotations
+
 import datetime
 import functools
-from typing import Dict, List, NamedTuple, Optional, Tuple, TYPE_CHECKING
-
-from cirq.protocols.json_serialization import ObjectFactory
+from typing import NamedTuple, TYPE_CHECKING
 
 if TYPE_CHECKING:
     import cirq
     import cirq.devices.unconstrained_device
     import cirq.ops.pauli_gates
+    from cirq.protocols.json_serialization import ObjectFactory
 
 
 # Needed for backwards compatible named tuples of CrossEntropyResult
@@ -30,23 +32,23 @@ SpecklePurityPair = NamedTuple('SpecklePurityPair', [('num_cycle', int), ('purit
 CrossEntropyResult = NamedTuple(
     'CrossEntropyResult',
     [
-        ('data', List[CrossEntropyPair]),
+        ('data', list[CrossEntropyPair]),
         ('repetitions', int),
-        ('purity_data', Optional[List[SpecklePurityPair]]),
+        ('purity_data', list[SpecklePurityPair] | None),
     ],
 )
 CrossEntropyResultDict = NamedTuple(
-    'CrossEntropyResultDict', [('results', Dict[Tuple['cirq.Qid', ...], CrossEntropyResult])]
+    'CrossEntropyResultDict', [('results', dict[tuple['cirq.Qid', ...], CrossEntropyResult])]
 )
 
 
 @functools.lru_cache()
-def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
+def _class_resolver_dictionary() -> dict[str, ObjectFactory]:
     import numpy as np
     import pandas as pd
 
     import cirq
-    from cirq.devices import InsertionNoiseModel
+    from cirq.devices import InsertionNoiseModel, NoiseModelFromNoiseProperties, ThermalNoiseModel
     from cirq.devices.noise_model import _NoNoiseModel
     from cirq.experiments import GridInteractionLayer
     from cirq.ops import raw_types
@@ -80,7 +82,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         )
 
     def _cross_entropy_result_dict(
-        results: List[Tuple[List['cirq.Qid'], CrossEntropyResult]], **kwargs
+        results: list[tuple[list[cirq.Qid], CrossEntropyResult]], **kwargs
     ) -> CrossEntropyResultDict:
         return CrossEntropyResultDict(results={tuple(qubits): result for qubits, result in results})
 
@@ -173,6 +175,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'NamedQubit': cirq.NamedQubit,
         'NamedQid': cirq.NamedQid,
         'NoIdentifierQubit': cirq.testing.NoIdentifierQubit,
+        'NoiseModelFromNoiseProperties': NoiseModelFromNoiseProperties,
         'ObservableMeasuredResult': cirq.work.ObservableMeasuredResult,
         'OpIdentifier': cirq.OpIdentifier,
         'ParamResolver': cirq.ParamResolver,
@@ -224,6 +227,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'SympyCondition': cirq.SympyCondition,
         'TaggedOperation': cirq.TaggedOperation,
         'TensoredConfusionMatrices': cirq.TensoredConfusionMatrices,
+        'ThermalNoiseModel': ThermalNoiseModel,
         'TiltedSquareLattice': cirq.TiltedSquareLattice,
         'ThreeQubitDiagonalGate': cirq.ThreeQubitDiagonalGate,
         'TrialResult': cirq.ResultDict,  # keep support for Cirq < 0.11.
@@ -235,9 +239,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'VirtualTag': cirq.VirtualTag,
         'WaitGate': cirq.WaitGate,
         # The formatter keeps putting this back
-        # pylint: disable=line-too-long
-        'XEBPhasedFSimCharacterizationOptions': cirq.experiments.XEBPhasedFSimCharacterizationOptions,
-        # pylint: enable=line-too-long
+        'XEBPhasedFSimCharacterizationOptions': cirq.experiments.XEBPhasedFSimCharacterizationOptions,  # noqa: E501
         '_XEigenState': cirq.value.product_state._XEigenState,
         'XPowGate': cirq.XPowGate,
         'XXPowGate': cirq.XXPowGate,

cirq/linalg/__init__.py

@@ -26,7 +26,6 @@ from cirq.linalg.combinators import (
 )
 
 from cirq.linalg.decompositions import (
-    # pylint: disable=line-too-long
     axis_angle as axis_angle,
     AxisAngleDecomposition as AxisAngleDecomposition,
     deconstruct_single_qubit_matrix_into_angles as deconstruct_single_qubit_matrix_into_angles,
@@ -39,15 +38,14 @@ from cirq.linalg.decompositions import (
     map_eigenvalues as map_eigenvalues,
     num_cnots_required as num_cnots_required,
     unitary_eig as unitary_eig,
-    scatter_plot_normalized_kak_interaction_coefficients as scatter_plot_normalized_kak_interaction_coefficients,
+    scatter_plot_normalized_kak_interaction_coefficients as scatter_plot_normalized_kak_interaction_coefficients,  # noqa: E501
     so4_to_magic_su2s as so4_to_magic_su2s,
 )
 
 from cirq.linalg.diagonalize import (
-    # pylint: disable=line-too-long
-    bidiagonalize_real_matrix_pair_with_symmetric_products as bidiagonalize_real_matrix_pair_with_symmetric_products,
-    bidiagonalize_unitary_with_special_orthogonals as bidiagonalize_unitary_with_special_orthogonals,
-    diagonalize_real_symmetric_and_sorted_diagonal_matrices as diagonalize_real_symmetric_and_sorted_diagonal_matrices,
+    bidiagonalize_real_matrix_pair_with_symmetric_products as bidiagonalize_real_matrix_pair_with_symmetric_products,  # noqa: E501
+    bidiagonalize_unitary_with_special_orthogonals as bidiagonalize_unitary_with_special_orthogonals,  # noqa: E501
+    diagonalize_real_symmetric_and_sorted_diagonal_matrices as diagonalize_real_symmetric_and_sorted_diagonal_matrices,  # noqa: E501
     diagonalize_real_symmetric_matrix as diagonalize_real_symmetric_matrix,
 )
 

cirq/linalg/combinators.py

@@ -14,8 +14,10 @@
 
 """Utility methods for combining matrices."""
 
+from __future__ import annotations
+
 import functools
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -25,7 +27,7 @@ if TYPE_CHECKING:
     from numpy.typing import ArrayLike, DTypeLike
 
 
-def kron(*factors: Union[np.ndarray, complex], shape_len: int = 2) -> np.ndarray:
+def kron(*factors: np.ndarray | complex, shape_len: int = 2) -> np.ndarray:
     """Computes the kronecker product of a sequence of values.
 
     A *args version of lambda args: functools.reduce(np.kron, args).
@@ -56,7 +58,7 @@ document(
 )
 
 
-def kron_with_controls(*factors: Union[np.ndarray, complex]) -> np.ndarray:
+def kron_with_controls(*factors: np.ndarray | complex) -> np.ndarray:
     """Computes the kronecker product of a sequence of values and control tags.
 
     Use `cirq.CONTROL_TAG` to represent controls. Any entry of the output
@@ -107,7 +109,7 @@ def kron_with_controls(*factors: Union[np.ndarray, complex]) -> np.ndarray:
     return product
 
 
-def dot(*values: 'ArrayLike') -> np.ndarray:
+def dot(*values: ArrayLike) -> np.ndarray:
     """Computes the dot/matrix product of a sequence of values.
 
     Performs the computation in serial order without regard to the matrix
@@ -136,7 +138,7 @@ def dot(*values: 'ArrayLike') -> np.ndarray:
     return result
 
 
-def _merge_dtypes(dtype1: 'DTypeLike', dtype2: 'DTypeLike') -> np.dtype:
+def _merge_dtypes(dtype1: DTypeLike, dtype2: DTypeLike) -> np.dtype:
     return (np.zeros(0, dtype1) + np.zeros(0, dtype2)).dtype
 
 

cirq/linalg/combinators_test.py

@@ -11,13 +11,16 @@
 # 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.
+
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
 import cirq
 
 
-def test_dot():
+def test_dot() -> None:
     assert cirq.dot(2) == 2
     assert cirq.dot(2.5, 2.5) == 6.25
 
@@ -33,7 +36,7 @@ def test_dot():
         cirq.dot()
 
 
-def test_kron_multiplies_sizes():
+def test_kron_multiplies_sizes() -> None:
     assert cirq.kron(np.array([1, 2])).shape == (1, 2)
     assert cirq.kron(np.array([1, 2]), shape_len=1).shape == (2,)
     assert cirq.kron(np.array([1, 2]), np.array([3, 4, 5]), shape_len=1).shape == (6,)
@@ -51,7 +54,7 @@ def test_kron_multiplies_sizes():
     assert np.allclose(cirq.kron(np.eye(2), np.eye(3), np.eye(4)), np.eye(24))
 
 
-def test_kron_spreads_values():
+def test_kron_spreads_values() -> None:
     u = np.array([[2, 3], [5, 7]])
 
     assert np.allclose(
@@ -68,7 +71,7 @@ def test_kron_spreads_values():
     )
 
 
-def test_acts_like_kron_multiplies_sizes():
+def test_acts_like_kron_multiplies_sizes() -> None:
     assert np.allclose(cirq.kron_with_controls(), np.eye(1))
     assert np.allclose(cirq.kron_with_controls(np.eye(2), np.eye(3), np.eye(4)), np.eye(24))
 
@@ -79,7 +82,7 @@ def test_acts_like_kron_multiplies_sizes():
     )
 
 
-def test_supports_controls():
+def test_supports_controls() -> None:
     u = np.array([[2, 3], [5, 7]])
     assert np.allclose(cirq.kron_with_controls(cirq.CONTROL_TAG), np.array([[1, 0], [0, 1]]))
     assert np.allclose(
@@ -92,7 +95,7 @@ def test_supports_controls():
     )
 
 
-def test_block_diag():
+def test_block_diag() -> None:
     assert np.allclose(cirq.block_diag(), np.zeros((0, 0)))
 
     assert np.allclose(cirq.block_diag(np.array([[1, 2], [3, 4]])), np.array([[1, 2], [3, 4]]))
@@ -108,7 +111,7 @@ def test_block_diag():
         _ = cirq.block_diag(np.array([[1, 2, 3], [3, 4, 5]]))
 
 
-def test_block_diag_dtype():
+def test_block_diag_dtype() -> None:
     assert cirq.block_diag().dtype == np.complex128
 
     assert cirq.block_diag(np.array([[1]], dtype=np.int8)).dtype == np.int8

cirq/linalg/decompositions.py

@@ -12,23 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 """Utility methods for breaking matrices into useful pieces."""
 
+from __future__ import annotations
+
 import cmath
 import math
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Iterable,
-    List,
-    Optional,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import Any, Callable, cast, Iterable, TYPE_CHECKING, TypeVar
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -69,7 +59,7 @@ def _rotation_matrix(angle: float) -> np.ndarray:
     return np.array([[c, -s], [s, c]])
 
 
-def deconstruct_single_qubit_matrix_into_angles(mat: np.ndarray) -> Tuple[float, float, float]:
+def deconstruct_single_qubit_matrix_into_angles(mat: np.ndarray) -> tuple[float, float, float]:
     r"""Breaks down a 2x2 unitary into ZYZ angle parameters.
 
     Given a unitary U, this function returns three angles: $\phi_0, \phi_1, \phi_2$,
@@ -107,7 +97,7 @@ def deconstruct_single_qubit_matrix_into_angles(mat: np.ndarray) -> Tuple[float,
 
 def unitary_eig(
     matrix: np.ndarray, check_preconditions: bool = True, atol: float = 1e-8
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray]:
     r"""Gives the guaranteed unitary eigendecomposition of a normal matrix.
 
     All hermitian and unitary matrices are normal matrices. This method was
@@ -126,7 +116,7 @@ def unitary_eig(
             was unitary.
 
     Returns:
-        A Tuple of
+        A tuple of
             eigvals: The eigenvalues of `matrix`.
             V: The unitary matrix with the eigenvectors as columns.
 
@@ -140,7 +130,6 @@ def unitary_eig(
     return R.diagonal(), V
 
 
-# pylint: enable=missing-raises-doc
 def map_eigenvalues(
     matrix: np.ndarray, func: Callable[[complex], complex], *, atol: float = 1e-8
 ) -> np.ndarray:
@@ -168,7 +157,7 @@ def map_eigenvalues(
 
 def kron_factor_4x4_to_2x2s(
     matrix: np.ndarray, rtol=1e-5, atol=1e-8
-) -> Tuple[complex, np.ndarray, np.ndarray]:
+) -> 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.
@@ -218,7 +207,7 @@ def kron_factor_4x4_to_2x2s(
 
 def so4_to_magic_su2s(
     mat: np.ndarray, *, rtol: float = 1e-5, atol: float = 1e-8, check_preconditions: bool = True
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray]:
     """Finds 2x2 special-unitaries A, B where mat = Mag.H @ kron(A, B) @ Mag.
 
     Mag is the magic basis matrix:
@@ -264,14 +253,14 @@ class AxisAngleDecomposition:
     rotation axis, and g is the global phase.
     """
 
-    def __init__(self, *, angle: float, axis: Tuple[float, float, float], global_phase: 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)
         self.axis = tuple(axis)
         self.angle = float(angle)
 
-    def canonicalize(self, atol: float = 1e-8) -> 'AxisAngleDecomposition':
+    def canonicalize(self, atol: float = 1e-8) -> AxisAngleDecomposition:
         """Returns a standardized AxisAngleDecomposition with the same unitary.
 
         Ensures the axis (x, y, z) satisfies x+y+z >= 0.
@@ -412,9 +401,9 @@ class KakDecomposition:
         self,
         *,
         global_phase: complex = complex(1),
-        single_qubit_operations_before: Optional[Tuple[np.ndarray, np.ndarray]] = None,
-        interaction_coefficients: Tuple[float, float, float],
-        single_qubit_operations_after: Optional[Tuple[np.ndarray, np.ndarray]] = None,
+        single_qubit_operations_before: tuple[np.ndarray, np.ndarray] | None = None,
+        interaction_coefficients: tuple[float, float, float],
+        single_qubit_operations_after: tuple[np.ndarray, np.ndarray] | None = None,
     ):
         """Initializes a decomposition for a two-qubit operation U.
 
@@ -427,12 +416,12 @@ class KakDecomposition:
             single_qubit_operations_after: a0, a1 from the above equation.
         """
         self.global_phase: complex = global_phase
-        self.single_qubit_operations_before: Tuple[np.ndarray, np.ndarray] = (
+        self.single_qubit_operations_before: tuple[np.ndarray, np.ndarray] = (
             single_qubit_operations_before
             or (np.eye(2, dtype=np.complex64), np.eye(2, dtype=np.complex64))
         )
         self.interaction_coefficients = interaction_coefficients
-        self.single_qubit_operations_after: Tuple[np.ndarray, np.ndarray] = (
+        self.single_qubit_operations_after: tuple[np.ndarray, np.ndarray] = (
             single_qubit_operations_after
             or (np.eye(2, dtype=np.complex64), np.eye(2, dtype=np.complex64))
         )
@@ -524,10 +513,10 @@ class KakDecomposition:
 
 
 def scatter_plot_normalized_kak_interaction_coefficients(
-    interactions: Iterable[Union[np.ndarray, 'cirq.SupportsUnitary', 'KakDecomposition']],
+    interactions: Iterable[np.ndarray | cirq.SupportsUnitary | KakDecomposition],
     *,
     include_frame: bool = True,
-    ax: Optional[mplot3d.axes3d.Axes3D] = None,
+    ax: mplot3d.axes3d.Axes3D | None = None,
     **kwargs,
 ):
     r"""Plots the interaction coefficients of many two-qubit operations.
@@ -609,8 +598,8 @@ def scatter_plot_normalized_kak_interaction_coefficients(
         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],
-    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        pts: 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([])
         xs, ys, zs = np.transpose(pts)
@@ -636,7 +625,7 @@ def scatter_plot_normalized_kak_interaction_coefficients(
 
     # parse input and extract KAK vector
     if not isinstance(interactions, np.ndarray):
-        interactions_extracted: List[np.ndarray] = [
+        interactions_extracted: list[np.ndarray] = [
             a if isinstance(a, np.ndarray) else protocols.unitary(a) for a in interactions
         ]
     else:
@@ -785,9 +774,9 @@ KAK_GAMMA = np.array([[1, 1, 1, 1],
 
 
 def kak_decomposition(
-    unitary_object: Union[
-        np.ndarray, 'cirq.SupportsUnitary', 'cirq.Gate', 'cirq.Operation', KakDecomposition
-    ],
+    unitary_object: (
+        np.ndarray | cirq.SupportsUnitary | cirq.Gate | cirq.Operation | KakDecomposition
+    ),
     *,
     rtol: float = 1e-5,
     atol: float = 1e-8,
@@ -857,7 +846,7 @@ def kak_decomposition(
 
 
 def kak_vector(
-    unitary: Union[Iterable[np.ndarray], np.ndarray],
+    unitary: Iterable[np.ndarray] | np.ndarray,
     *,
     rtol: float = 1e-5,
     atol: float = 1e-8,

cirq/linalg/decompositions_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 random
 
 import numpy as np
@@ -582,7 +584,7 @@ def _local_two_qubit_unitaries(samples, random_state):
 _kak_gens = np.array([np.kron(X, X), np.kron(Y, Y), np.kron(Z, Z)])
 
 
-def _random_two_qubit_unitaries(num_samples: int, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE'):
+def _random_two_qubit_unitaries(num_samples: int, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE):
     # Randomly generated two-qubit unitaries and the KAK vectors (not canonical)
     kl = _local_two_qubit_unitaries(num_samples, random_state)
 

cirq/linalg/diagonalize.py

@@ -14,7 +14,9 @@
 
 """Utility methods for diagonalizing matrices."""
 
-from typing import Callable, List, Tuple
+from __future__ import annotations
+
+from typing import Callable
 
 import numpy as np
 
@@ -52,7 +54,7 @@ def diagonalize_real_symmetric_matrix(
 
 def _contiguous_groups(
     length: int, comparator: Callable[[int, int], bool]
-) -> List[Tuple[int, int]]:
+) -> list[tuple[int, int]]:
     """Splits range(length) into approximate equivalence classes.
 
     Args:
@@ -155,7 +157,7 @@ def bidiagonalize_real_matrix_pair_with_symmetric_products(
     rtol: float = 1e-5,
     atol: float = 1e-8,
     check_preconditions: bool = True,
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray]:
     """Finds orthogonal matrices that diagonalize both mat1 and mat2.
 
     Requires mat1 and mat2 to be real.
@@ -226,7 +228,7 @@ def bidiagonalize_real_matrix_pair_with_symmetric_products(
 
 def bidiagonalize_unitary_with_special_orthogonals(
     mat: np.ndarray, *, rtol: float = 1e-5, atol: float = 1e-8, check_preconditions: bool = True
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Finds orthogonal matrices L, R such that L @ matrix @ R is diagonal.
 
     Args: