cirq-core 1.6.0.dev20250520054601__py3-none-any.whl → 1.6.0.dev20250520181654__py3-none-any.whl

cirq/linalg/decompositions.py

@@ -18,18 +18,7 @@ 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
@@ -70,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$,
@@ -108,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
@@ -169,7 +158,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.
@@ -219,7 +208,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:
@@ -265,7 +254,7 @@ 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)
@@ -413,9 +402,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.
 
@@ -428,12 +417,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))
         )
@@ -525,10 +514,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.
@@ -610,8 +599,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)
@@ -637,7 +626,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:
@@ -786,9 +775,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,
@@ -858,7 +847,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/diagonalize.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Callable, List, Tuple
+from typing import Callable
 
 import numpy as np
 
@@ -54,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:
@@ -157,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.
@@ -228,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:

cirq/linalg/diagonalize_test.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import random
-from typing import Optional, Tuple
 
 import numpy as np
 import pytest
@@ -31,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)])
 
 
@@ -50,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)

cirq/linalg/operator_spaces.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -36,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:
@@ -57,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.
 
@@ -74,7 +74,7 @@ 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()))
@@ -90,7 +90,7 @@ def pow_pauli_combination(
     ay: cirq.TParamValComplex,
     az: cirq.TParamValComplex,
     exponent: int,
-) -> Tuple[
+) -> tuple[
     cirq.TParamValComplex, cirq.TParamValComplex, cirq.TParamValComplex, cirq.TParamValComplex
 ]:
     """Computes non-negative integer power of single-qubit Pauli combination.

cirq/linalg/predicates.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 from types import EllipsisType
-from typing import cast, List, Optional, Sequence, Tuple, Union
+from typing import cast, Sequence, Union
 
 import numpy as np
 
@@ -231,9 +231,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, EllipsisType], ...]:
+    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).
@@ -288,10 +288,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(
@@ -302,7 +302,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, EllipsisType]], [slice(None)] * out_size)
+    result = cast(list[Union[slice, int, EllipsisType]], [slice(None)] * out_size)
     if not out_size_specified:
         result.append(Ellipsis)
     if qid_shape is None:

cirq/linalg/transformations.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 import dataclasses
 import functools
 from types import EllipsisType
-from typing import Any, List, Optional, Sequence, Tuple, Union
+from typing import Any, Sequence
 
 import numpy as np
 
@@ -62,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
@@ -104,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.
 
@@ -179,7 +179,7 @@ class _SliceConfig:
 
 @dataclasses.dataclass
 class _BuildFromSlicesArgs:
-    slices: Tuple[_SliceConfig, ...]
+    slices: tuple[_SliceConfig, ...]
     scale: complex
 
 
@@ -237,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
@@ -250,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.
 
@@ -301,8 +301,8 @@ def targeted_conjugate_about(
     return targeted_left_multiply(np.conjugate(tensor), first_multiply, conj_indices, out=out)
 
 
-_TSliceAtom = Union[int, slice, EllipsisType]
-_TSlice = Union[_TSliceAtom, Sequence[_TSliceAtom]]
+_TSliceAtom = int | slice | EllipsisType
+_TSlice = _TSliceAtom | Sequence[_TSliceAtom]
 
 
 def apply_matrix_to_slices(
@@ -310,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.
 
@@ -420,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
@@ -455,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)
 
@@ -476,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,
@@ -536,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)
@@ -634,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
@@ -680,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
@@ -748,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

cirq/ops/arithmetic_operation.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 import abc
 import itertools
-from typing import cast, Iterable, List, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import cast, Iterable, Sequence, TYPE_CHECKING
 
 import numpy as np
 from typing_extensions import Self
@@ -88,7 +88,7 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
     """
 
     @abc.abstractmethod
-    def registers(self) -> Sequence[Union[int, Sequence[int]]]:
+    def registers(self) -> Sequence[int | Sequence[int]]:
         """The data acted upon by the arithmetic gate.
 
         Each register in the list can either be a classical constant (an `int`),
@@ -105,7 +105,7 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
         raise NotImplementedError()
 
     @abc.abstractmethod
-    def with_registers(self, *new_registers: Union[int, Sequence[int]]) -> Self:
+    def with_registers(self, *new_registers: int | Sequence[int]) -> Self:
         """Returns the same fate targeting different registers.
 
         Args:
@@ -119,7 +119,7 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
         raise NotImplementedError()
 
     @abc.abstractmethod
-    def apply(self, *register_values: int) -> Union[int, Iterable[int]]:
+    def apply(self, *register_values: int) -> int | Iterable[int]:
         """Returns the result of the gate operating on classical values.
 
         For example, an addition takes two values (the target and the source),
@@ -164,7 +164,7 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
         """
         raise NotImplementedError()
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         shape = []
         for r in self.registers():
             if isinstance(r, Sequence):
@@ -174,9 +174,9 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
 
     def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs):
         registers = self.registers()
-        input_ranges: List[Sequence[int]] = []
-        shape: List[int] = []
-        overflow_sizes: List[int] = []
+        input_ranges: list[Sequence[int]] = []
+        shape: list[int] = []
+        overflow_sizes: list[int] = []
         for register in registers:
             if isinstance(register, int):
                 input_ranges.append([register])
@@ -198,8 +198,8 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
             output = self.apply(*input_seq)
 
             # Wrap into list.
-            inputs: List[int] = list(input_seq)
-            outputs: List[int] = [output] if isinstance(output, int) else list(output)
+            inputs: list[int] = list(input_seq)
+            outputs: list[int] = [output] if isinstance(output, int) else list(output)
 
             # Omitted tail values default to the corresponding input value.
             if len(outputs) < len(inputs):
@@ -221,8 +221,8 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
                     outputs[i] %= overflow_sizes[i]
 
             # Copy amplitude to new location.
-            cast(List[Union[int, slice]], outputs).append(slice(None))
-            cast(List[Union[int, slice]], inputs).append(slice(None))
+            cast(list[int | slice], outputs).append(slice(None))
+            cast(list[int | slice], inputs).append(slice(None))
             dst[tuple(outputs)] = src[tuple(inputs)]
 
         # In case the reshaped arrays were copies instead of views.
@@ -233,9 +233,7 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
 
 
 def _describe_bad_arithmetic_changed_const(
-    registers: Sequence[Union[int, Sequence[Union[cirq.Qid, int]]]],
-    inputs: List[int],
-    outputs: List[int],
+    registers: Sequence[int | Sequence[cirq.Qid | int]], inputs: list[int], outputs: list[int]
 ) -> str:
     from cirq.circuits import TextDiagramDrawer
 

cirq/ops/boolean_hamiltonian.py

@@ -27,7 +27,7 @@ from __future__ import annotations
 
 import functools
 import itertools
-from typing import Any, Dict, Generator, List, Sequence, Tuple
+from typing import Any, Generator, Sequence
 
 import sympy.parsing.sympy_parser as sympy_parser
 
@@ -80,13 +80,13 @@ class BooleanHamiltonianGate(raw_types.Gate):
         self._boolean_strs: Sequence[str] = boolean_strs
         self._theta: float = theta
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return (2,) * len(self._parameter_names)
 
     def _value_equality_values_(self) -> Any:
         return tuple(self._parameter_names), tuple(self._boolean_strs), self._theta
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'parameter_names': self._parameter_names,
             'boolean_strs': self._boolean_strs,
@@ -121,7 +121,7 @@ class BooleanHamiltonianGate(raw_types.Gate):
         )
 
 
-def _gray_code_comparator(k1: Tuple[int, ...], k2: Tuple[int, ...], flip: bool = False) -> int:
+def _gray_code_comparator(k1: tuple[int, ...], k2: tuple[int, ...], flip: bool = False) -> int:
     """Compares two Gray-encoded binary numbers.
 
     Args:
@@ -144,8 +144,8 @@ def _gray_code_comparator(k1: Tuple[int, ...], k2: Tuple[int, ...], flip: bool =
 
 
 def _simplify_commuting_cnots(
-    cnots: List[Tuple[int, int]], flip_control_and_target: bool
-) -> Tuple[bool, List[Tuple[int, int]]]:
+    cnots: list[tuple[int, int]], flip_control_and_target: bool
+) -> tuple[bool, list[tuple[int, int]]]:
     """Attempts to commute CNOTs and remove cancelling pairs.
 
     Commutation relations are based on 9 (flip_control_and_target=False) or 10
@@ -184,7 +184,7 @@ def _simplify_commuting_cnots(
     target, control = (0, 1) if flip_control_and_target else (1, 0)
 
     to_remove = set()
-    qubit_to_index: List[Tuple[int, Dict[int, int]]] = []
+    qubit_to_index: list[tuple[int, dict[int, int]]] = []
     for j in range(len(cnots)):
         if not qubit_to_index or cnots[j][target] != qubit_to_index[-1][0]:
             # The targets (resp. control) don't match, so we create a new dict.
@@ -205,8 +205,8 @@ def _simplify_commuting_cnots(
 
 
 def _simplify_cnots_triplets(
-    cnots: List[Tuple[int, int]], flip_control_and_target: bool
-) -> Tuple[bool, List[Tuple[int, int]]]:
+    cnots: list[tuple[int, int]], flip_control_and_target: bool
+) -> tuple[bool, list[tuple[int, int]]]:
     """Simplifies CNOT pairs according to equation 11 of [4].
 
     CNOT(i, j) @ CNOT(j, k) == CNOT(j, k) @ CNOT(i, k) @ CNOT(i, j)
@@ -231,7 +231,7 @@ def _simplify_cnots_triplets(
         # First, we look back for as long as the controls (resp. targets) are the same.
         # They all commute, so all are potential candidates for being simplified.
         # prev_match_index is qubit to index in `cnots` array.
-        prev_match_index: Dict[int, int] = {}
+        prev_match_index: dict[int, int] = {}
         for i in range(j - 1, -1, -1):
             # These CNOTs have the same target (resp. control) and though they are not candidates
             # for simplification, since they commute, we can keep looking for candidates.
@@ -245,7 +245,7 @@ def _simplify_cnots_triplets(
         # Next, we look forward for as long as the targets (resp. controls) are the
         # same. They all commute, so all are potential candidates for being simplified.
         # post_match_index is qubit to index in `cnots` array.
-        post_match_index: Dict[int, int] = {}
+        post_match_index: dict[int, int] = {}
         for k in range(j + 1, len(cnots)):
             # These CNOTs have the same control (resp. target) and though they are not candidates
             # for simplification, since they commute, we can keep looking for candidates.
@@ -260,7 +260,7 @@ def _simplify_cnots_triplets(
         keys = prev_match_index.keys() & post_match_index.keys()
         for key in keys:
             # We perform the swap which removes the pivot.
-            new_idx: List[int] = (
+            new_idx: list[int] = (
                 # Anything strictly before the pivot that is not the CNOT to swap.
                 [idx for idx in range(j) if idx != prev_match_index[key]]
                 # The two swapped CNOTs.
@@ -275,7 +275,7 @@ def _simplify_cnots_triplets(
     return False, cnots
 
 
-def _simplify_cnots(cnots: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
+def _simplify_cnots(cnots: list[tuple[int, int]]) -> list[tuple[int, int]]:
     """Takes a series of CNOTs and tries to applies rule to cancel out gates.
 
     Algorithm based on "Efficient quantum circuits for diagonal unitaries without ancillas" by
@@ -302,7 +302,7 @@ def _simplify_cnots(cnots: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
 
 
 def _get_gates_from_hamiltonians(
-    hamiltonian_polynomial_list: List[cirq.PauliSum], qubit_map: Dict[str, cirq.Qid], theta: float
+    hamiltonian_polynomial_list: list[cirq.PauliSum], qubit_map: dict[str, cirq.Qid], theta: float
 ) -> Generator[cirq.Operation, None, None]:
     """Builds a circuit according to [1].
 
@@ -326,8 +326,8 @@ def _get_gates_from_hamiltonians(
         qubit_idx = tuple(sorted(qubit_indices[qubit] for qubit in pauli_string.qubits))
         hamiltonians[qubit_idx] = w
 
-    def _apply_cnots(prevh: Tuple[int, ...], currh: Tuple[int, ...]):
-        cnots: List[Tuple[int, int]] = []
+    def _apply_cnots(prevh: tuple[int, ...], currh: tuple[int, ...]):
+        cnots: list[tuple[int, int]] = []
 
         cnots.extend((prevh[i], prevh[-1]) for i in range(len(prevh) - 1))
         cnots.extend((currh[i], currh[-1]) for i in range(len(currh) - 1))
@@ -341,7 +341,7 @@ def _get_gates_from_hamiltonians(
         hamiltonians.keys(), key=functools.cmp_to_key(_gray_code_comparator)
     )
 
-    previous_h: Tuple[int, ...] = ()
+    previous_h: tuple[int, ...] = ()
     for h in sorted_hamiltonian_keys:
         w = hamiltonians[h]
         yield _apply_cnots(previous_h, h)