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

cirq/ops/identity.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 import numbers
 from types import NotImplementedType
-from typing import Any, Dict, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -41,7 +41,7 @@ class IdentityGate(raw_types.Gate):
     """
 
     def __init__(
-        self, num_qubits: Optional[int] = None, qid_shape: Optional[Tuple[int, ...]] = None
+        self, num_qubits: int | None = None, qid_shape: tuple[int, ...] | None = None
     ) -> None:
         """Inits IdentityGate.
 
@@ -68,7 +68,7 @@ class IdentityGate(raw_types.Gate):
     def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]):
         return True
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self._qid_shape
 
     def num_qubits(self) -> int:
@@ -79,7 +79,7 @@ class IdentityGate(raw_types.Gate):
             return self
         return NotImplemented
 
-    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> Union[bool, NotImplementedType]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType:
         """The identity gate commutes with all other gates."""
         if not isinstance(other, raw_types.Gate):
             return NotImplemented
@@ -91,7 +91,7 @@ class IdentityGate(raw_types.Gate):
     def _unitary_(self) -> np.ndarray:
         return np.identity(np.prod(self._qid_shape, dtype=np.int64).item())
 
-    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray | None:
         return args.target_tensor
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
@@ -120,13 +120,13 @@ class IdentityGate(raw_types.Gate):
     def _trace_distance_bound_(self) -> float:
         return 0.0
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         other = {}
         if not all(d == 2 for d in self._qid_shape):
             other['qid_shape'] = self._qid_shape
         return {'num_qubits': len(self._qid_shape), **other}
 
-    def _mul_with_qubits(self, qubits: Tuple[cirq.Qid, ...], other):
+    def _mul_with_qubits(self, qubits: tuple[cirq.Qid, ...], other):
         if isinstance(other, raw_types.Operation):
             return other
         if isinstance(other, numbers.Complex):
@@ -137,12 +137,12 @@ class IdentityGate(raw_types.Gate):
 
     _rmul_with_qubits = _mul_with_qubits
 
-    def _circuit_diagram_info_(self, args) -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args) -> tuple[str, ...]:
         if self.num_qubits() <= 0:
             return NotImplemented
         return ('I',) * self.num_qubits()
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         args.validate_version('2.0', '3.0')
         return ''.join([args.format('id {0};\n', qubit) for qubit in qubits])
 

cirq/ops/kraus_channel.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, FrozenSet, Iterable, Mapping, Tuple, TYPE_CHECKING, Union
+from typing import Any, Iterable, Mapping, TYPE_CHECKING
 
 import numpy as np
 
@@ -32,7 +32,7 @@ class KrausChannel(raw_types.Gate):
     def __init__(
         self,
         kraus_ops: Iterable[np.ndarray],
-        key: Union[str, cirq.MeasurementKey, None] = None,
+        key: str | cirq.MeasurementKey | None = None,
         validate: bool = False,
     ):
         kraus_ops = list(kraus_ops)
@@ -59,7 +59,7 @@ class KrausChannel(raw_types.Gate):
         self._key = key
 
     @staticmethod
-    def from_channel(channel: cirq.Gate, key: Union[str, cirq.MeasurementKey, None] = None):
+    def from_channel(channel: cirq.Gate, key: str | cirq.MeasurementKey | None = None):
         """Creates a copy of a channel with the given measurement key."""
         return KrausChannel(kraus_ops=list(protocols.kraus(channel)), key=key)
 
@@ -95,16 +95,16 @@ class KrausChannel(raw_types.Gate):
             return self
         return KrausChannel(kraus_ops=self._kraus_ops, key=key_map[str(self._key)])
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         return KrausChannel(kraus_ops=self._kraus_ops, key=protocols.with_key_path(self._key, path))
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         return KrausChannel(
             kraus_ops=self._kraus_ops, key=protocols.with_key_path_prefix(self._key, prefix)
         )
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ):
         return KrausChannel(
             kraus_ops=self._kraus_ops,
@@ -122,7 +122,7 @@ class KrausChannel(raw_types.Gate):
             args.append(f'key=\'{self._key}\'')
         return f'cirq.KrausChannel({", ".join(args)})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['_kraus_ops', '_key'])
 
     @classmethod

cirq/ops/linear_combinations.py

@@ -16,20 +16,7 @@ from __future__ import annotations
 
 import numbers
 from collections import defaultdict
-from typing import (
-    AbstractSet,
-    Any,
-    DefaultDict,
-    Dict,
-    FrozenSet,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import AbstractSet, Any, Iterable, Mapping, TYPE_CHECKING, Union
 
 import numpy as np
 import sympy
@@ -48,7 +35,7 @@ if TYPE_CHECKING:
 
     import cirq
 
-UnitPauliStringT = FrozenSet[Tuple[raw_types.Qid, pauli_gates.Pauli]]
+UnitPauliStringT = frozenset[tuple[raw_types.Qid, pauli_gates.Pauli]]
 PauliSumLike = Union[
     complex, PauliString, 'PauliSum', pauli_string.SingleQubitPauliStringGateOperation
 ]
@@ -92,7 +79,7 @@ class LinearCombinationOfGates(value.LinearDict[raw_types.Gate]):
         """
         super().__init__(terms, validator=self._is_compatible)
 
-    def num_qubits(self) -> Optional[int]:
+    def num_qubits(self) -> int | None:
         """Returns number of qubits in the domain if known, None if unknown."""
         if not self:
             return None
@@ -102,29 +89,25 @@ class LinearCombinationOfGates(value.LinearDict[raw_types.Gate]):
     def _is_compatible(self, gate: cirq.Gate) -> bool:
         return self.num_qubits() is None or self.num_qubits() == gate.num_qubits()
 
-    def __add__(
-        self, other: Union[raw_types.Gate, LinearCombinationOfGates]
-    ) -> LinearCombinationOfGates:
+    def __add__(self, other: raw_types.Gate | LinearCombinationOfGates) -> LinearCombinationOfGates:
         if not isinstance(other, LinearCombinationOfGates):
             other = other.wrap_in_linear_combination()
         return super().__add__(other)
 
     def __iadd__(
-        self, other: Union[raw_types.Gate, LinearCombinationOfGates]
+        self, other: raw_types.Gate | LinearCombinationOfGates
     ) -> LinearCombinationOfGates:
         if not isinstance(other, LinearCombinationOfGates):
             other = other.wrap_in_linear_combination()
         return super().__iadd__(other)
 
-    def __sub__(
-        self, other: Union[raw_types.Gate, LinearCombinationOfGates]
-    ) -> LinearCombinationOfGates:
+    def __sub__(self, other: raw_types.Gate | LinearCombinationOfGates) -> LinearCombinationOfGates:
         if not isinstance(other, LinearCombinationOfGates):
             other = other.wrap_in_linear_combination()
         return super().__sub__(other)
 
     def __isub__(
-        self, other: Union[raw_types.Gate, LinearCombinationOfGates]
+        self, other: raw_types.Gate | LinearCombinationOfGates
     ) -> LinearCombinationOfGates:
         if not isinstance(other, LinearCombinationOfGates):
             other = other.wrap_in_linear_combination()
@@ -239,7 +222,7 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
         return isinstance(operation, raw_types.Operation)
 
     @property
-    def qubits(self) -> Tuple[raw_types.Qid, ...]:
+    def qubits(self) -> tuple[raw_types.Qid, ...]:
         """Returns qubits acted on self."""
         if not self:
             return ()
@@ -319,7 +302,7 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
         """Computes Pauli expansion of self from Pauli expansions of terms."""
 
         def extend_term(
-            pauli_names: str, qubits: Tuple[cirq.Qid, ...], all_qubits: Tuple[cirq.Qid, ...]
+            pauli_names: str, qubits: tuple[cirq.Qid, ...], all_qubits: tuple[cirq.Qid, ...]
         ) -> str:
             """Extends Pauli product on qubits to product on all_qubits."""
             assert len(pauli_names) == len(qubits)
@@ -328,8 +311,8 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
 
         def extend(
             expansion: value.LinearDict[str],
-            qubits: Tuple[cirq.Qid, ...],
-            all_qubits: Tuple[cirq.Qid, ...],
+            qubits: tuple[cirq.Qid, ...],
+            all_qubits: tuple[cirq.Qid, ...],
         ) -> value.LinearDict[str]:
             """Extends Pauli expansion on qubits to expansion on all_qubits."""
             return value.LinearDict(
@@ -360,7 +343,7 @@ def _is_linear_dict_of_unit_pauli_string(linear_dict: value.LinearDict[UnitPauli
 
 
 def _pauli_string_from_unit(
-    unit: UnitPauliStringT, coefficient: Union[int, float, cirq.TParamValComplex] = 1
+    unit: UnitPauliStringT, coefficient: int | float | cirq.TParamValComplex = 1
 ):
     return PauliString(qubit_pauli_map=dict(unit), coefficient=coefficient)
 
@@ -418,7 +401,7 @@ class PauliSum:
     4.0+0.0j
     """
 
-    def __init__(self, linear_dict: Optional[value.LinearDict[UnitPauliStringT]] = None):
+    def __init__(self, linear_dict: value.LinearDict[UnitPauliStringT] | None = None):
         """Construct a PauliSum from a linear dictionary.
 
         Note, the preferred method of constructing PauliSum objects is either implicitly
@@ -470,7 +453,7 @@ class PauliSum:
         return PauliSum() + val
 
     @classmethod
-    def from_pauli_strings(cls, terms: Union[PauliString, List[PauliString]]) -> PauliSum:
+    def from_pauli_strings(cls, terms: PauliString | list[PauliString]) -> PauliSum:
         """Returns a PauliSum by combining `cirq.PauliString` terms.
 
         Args:
@@ -482,7 +465,7 @@ class PauliSum:
         """
         if isinstance(terms, PauliString):
             terms = [terms]
-        termdict: DefaultDict[UnitPauliStringT, value.Scalar] = defaultdict(lambda: 0)
+        termdict: defaultdict[UnitPauliStringT, value.Scalar] = defaultdict(lambda: 0)
         for pstring in terms:
             key = frozenset(pstring._qubit_pauli_map.items())
             termdict[key] += pstring.coefficient
@@ -490,7 +473,7 @@ class PauliSum:
 
     @classmethod
     def from_boolean_expression(
-        cls, boolean_expr: sympy.Expr, qubit_map: Dict[str, cirq.Qid]
+        cls, boolean_expr: sympy.Expr, qubit_map: dict[str, cirq.Qid]
     ) -> PauliSum:
         """Builds the Hamiltonian representation of a Boolean expression.
 
@@ -542,7 +525,7 @@ class PauliSum:
         raise ValueError(f'Unsupported type: {type(boolean_expr)}')
 
     @property
-    def qubits(self) -> Tuple[raw_types.Qid, ...]:
+    def qubits(self) -> tuple[raw_types.Qid, ...]:
         """The sorted list of qubits used in this PauliSum."""
         qs = {q for k in self._linear_dict.keys() for q, _ in k}
         return tuple(sorted(qs))
@@ -579,7 +562,7 @@ class PauliSum:
         factory = type(self)
         return factory(self._linear_dict.copy())
 
-    def matrix(self, qubits: Optional[Iterable[raw_types.Qid]] = None) -> np.ndarray:
+    def matrix(self, qubits: Iterable[raw_types.Qid] | None = None) -> np.ndarray:
         """Returns the matrix of this PauliSum in computational basis of qubits.
 
         Args:
@@ -883,7 +866,7 @@ class ProjectorSum:
     """List of mappings representing a sum of projector operators."""
 
     def __init__(
-        self, linear_dict: Optional[value.LinearDict[FrozenSet[Tuple[raw_types.Qid, int]]]] = None
+        self, linear_dict: value.LinearDict[frozenset[tuple[raw_types.Qid, int]]] | None = None
     ):
         """Constructor for ProjectorSum
 
@@ -892,7 +875,7 @@ class ProjectorSum:
                 number. The tuple is a projector onto the qubit and the complex number is the
                 weight of these projections.
         """
-        self._linear_dict: value.LinearDict[FrozenSet[Tuple[raw_types.Qid, int]]] = (
+        self._linear_dict: value.LinearDict[frozenset[tuple[raw_types.Qid, int]]] = (
             linear_dict if linear_dict is not None else value.LinearDict({})
         )
 
@@ -900,11 +883,11 @@ class ProjectorSum:
         return self._linear_dict
 
     @property
-    def qubits(self) -> Tuple[raw_types.Qid, ...]:
+    def qubits(self) -> tuple[raw_types.Qid, ...]:
         qs = {q for k in self._linear_dict.keys() for q, _ in k}
         return tuple(sorted(qs))
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         linear_dict = []
         for projector_dict, scalar in dict(self._linear_dict).items():
             key = [[k, v] for k, v in dict(projector_dict).items()]
@@ -922,9 +905,7 @@ class ProjectorSum:
         return cls(linear_dict=value.LinearDict(converted_dict))
 
     @classmethod
-    def from_projector_strings(
-        cls, terms: Union[ProjectorString, List[ProjectorString]]
-    ) -> ProjectorSum:
+    def from_projector_strings(cls, terms: ProjectorString | list[ProjectorString]) -> ProjectorSum:
         """Builds a ProjectorSum from one or more ProjectorString(s).
 
         Args:
@@ -935,7 +916,7 @@ class ProjectorSum:
         """
         if isinstance(terms, ProjectorString):
             terms = [terms]
-        termdict: DefaultDict[FrozenSet[Tuple[raw_types.Qid, int]], value.Scalar] = defaultdict(
+        termdict: defaultdict[frozenset[tuple[raw_types.Qid, int]], value.Scalar] = defaultdict(
             lambda: 0.0
         )
         for pstring in terms:
@@ -946,7 +927,7 @@ class ProjectorSum:
     def copy(self) -> ProjectorSum:
         return ProjectorSum(self._linear_dict.copy())
 
-    def matrix(self, projector_qids: Optional[Iterable[raw_types.Qid]] = None) -> csr_matrix:
+    def matrix(self, projector_qids: Iterable[raw_types.Qid] | None = None) -> csr_matrix:
         """Returns the matrix of self in computational basis of qubits.
 
         Args:
@@ -1024,7 +1005,7 @@ class ProjectorSum:
     def __bool__(self) -> bool:
         return bool(self._linear_dict)
 
-    def __iadd__(self, other: Union[ProjectorString, ProjectorSum]):
+    def __iadd__(self, other: ProjectorString | ProjectorSum):
         if isinstance(other, ProjectorString):
             other = ProjectorSum.from_projector_strings(other)
         elif not isinstance(other, ProjectorSum):
@@ -1032,7 +1013,7 @@ class ProjectorSum:
         self._linear_dict += other._linear_dict
         return self
 
-    def __add__(self, other: Union[ProjectorString, ProjectorSum]):
+    def __add__(self, other: ProjectorString | ProjectorSum):
         if isinstance(other, ProjectorString):
             other = ProjectorSum.from_projector_strings(other)
         elif not isinstance(other, ProjectorSum):
@@ -1041,7 +1022,7 @@ class ProjectorSum:
         result += other
         return result
 
-    def __isub__(self, other: Union[ProjectorString, ProjectorSum]):
+    def __isub__(self, other: ProjectorString | ProjectorSum):
         if isinstance(other, ProjectorString):
             other = ProjectorSum.from_projector_strings(other)
         elif not isinstance(other, ProjectorSum):
@@ -1049,7 +1030,7 @@ class ProjectorSum:
         self._linear_dict -= other._linear_dict
         return self
 
-    def __sub__(self, other: Union[ProjectorString, ProjectorSum]):
+    def __sub__(self, other: ProjectorString | ProjectorSum):
         if isinstance(other, ProjectorString):
             other = ProjectorSum.from_projector_strings(other)
         elif not isinstance(other, ProjectorSum):

cirq/ops/matrix_gates.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Iterable, List, Optional, Tuple, TYPE_CHECKING
+from typing import Any, Iterable, TYPE_CHECKING
 
 import numpy as np
 
@@ -55,8 +55,8 @@ class MatrixGate(raw_types.Gate):
         self,
         matrix: np.ndarray,
         *,
-        name: Optional[str] = None,
-        qid_shape: Optional[Iterable[int]] = None,
+        name: str | None = None,
+        qid_shape: Iterable[int] | None = None,
         unitary_check: bool = True,
         unitary_check_rtol: float = 1e-5,
         unitary_check_atol: float = 1e-8,
@@ -115,7 +115,7 @@ class MatrixGate(raw_types.Gate):
         """Creates a new MatrixGate with the same matrix and a new name."""
         return MatrixGate(self._matrix, name=name, qid_shape=self._qid_shape, unitary_check=False)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'matrix': self._matrix.tolist(),
             'qid_shape': self._qid_shape,
@@ -126,7 +126,7 @@ class MatrixGate(raw_types.Gate):
     def _from_json_dict_(cls, matrix, qid_shape, name=None, **kwargs):
         return cls(matrix=np.array(matrix), qid_shape=qid_shape, name=name)
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self._qid_shape
 
     def __pow__(self, exponent: Any) -> MatrixGate:
@@ -149,10 +149,10 @@ class MatrixGate(raw_types.Gate):
         result[linalg.slice_for_qubits_equal_to([j], 1)] *= np.conj(p)
         return MatrixGate(matrix=result.reshape(self._matrix.shape), qid_shape=self._qid_shape)
 
-    def _decompose_(self, qubits: Tuple[cirq.Qid, ...]) -> cirq.OP_TREE:
+    def _decompose_(self, qubits: tuple[cirq.Qid, ...]) -> cirq.OP_TREE:
         from cirq.circuits import Circuit
 
-        decomposed: List[cirq.Operation] = NotImplemented
+        decomposed: list[cirq.Operation] = NotImplemented
         if self._qid_shape == (2,):
             decomposed = [
                 g.on(qubits[0])
@@ -199,7 +199,7 @@ class MatrixGate(raw_types.Gate):
         rest = [f'#{i+1}' for i in range(1, n_qubits)]
         return protocols.CircuitDiagramInfo(wire_symbols=[main, *rest])
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         args.validate_version('2.0', '3.0')
         if self._qid_shape == (2,):
             return protocols.qasm(

cirq/ops/measure_util.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Callable, Dict, Iterable, List, Optional, overload, Tuple, TYPE_CHECKING, Union
+from typing import Callable, Iterable, overload, TYPE_CHECKING
 
 import numpy as np
 
@@ -32,8 +32,7 @@ def _default_measurement_key(qubits: Iterable[raw_types.Qid]) -> str:
 
 
 def measure_single_paulistring(
-    pauli_observable: pauli_string.PauliString,
-    key: Optional[Union[str, cirq.MeasurementKey]] = None,
+    pauli_observable: pauli_string.PauliString, key: str | cirq.MeasurementKey | None = None
 ) -> raw_types.Operation:
     """Returns a single PauliMeasurementGate which measures the pauli observable
 
@@ -68,7 +67,7 @@ def measure_single_paulistring(
 
 def measure_paulistring_terms(
     pauli_basis: pauli_string.PauliString, key_func: Callable[[raw_types.Qid], str] = str
-) -> List[raw_types.Operation]:
+) -> list[raw_types.Operation]:
     """Returns a list of operations individually measuring qubits in the pauli basis.
 
     Args:
@@ -97,8 +96,8 @@ def measure_paulistring_terms(
 @overload
 def measure(
     *target: raw_types.Qid,
-    key: Optional[Union[str, cirq.MeasurementKey]] = None,
-    invert_mask: Tuple[bool, ...] = (),
+    key: str | cirq.MeasurementKey | None = None,
+    invert_mask: tuple[bool, ...] = (),
 ) -> raw_types.Operation:
     pass
 
@@ -107,17 +106,17 @@ def measure(
 def measure(
     __target: Iterable[raw_types.Qid],
     *,
-    key: Optional[Union[str, cirq.MeasurementKey]] = None,
-    invert_mask: Tuple[bool, ...] = (),
+    key: str | cirq.MeasurementKey | None = None,
+    invert_mask: tuple[bool, ...] = (),
 ) -> raw_types.Operation:
     pass
 
 
 def measure(
     *target,
-    key: Optional[Union[str, cirq.MeasurementKey]] = None,
-    invert_mask: Tuple[bool, ...] = (),
-    confusion_map: Optional[Dict[Tuple[int, ...], np.ndarray]] = None,
+    key: str | cirq.MeasurementKey | None = None,
+    invert_mask: tuple[bool, ...] = (),
+    confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
 ) -> raw_types.Operation:
     """Returns a single MeasurementGate applied to all the given qubits.
 
@@ -172,20 +171,20 @@ M = measure
 @overload
 def measure_each(
     *qubits: raw_types.Qid, key_func: Callable[[raw_types.Qid], str] = str
-) -> List[raw_types.Operation]:
+) -> list[raw_types.Operation]:
     pass
 
 
 @overload
 def measure_each(
     __qubits: Iterable[raw_types.Qid], *, key_func: Callable[[raw_types.Qid], str] = str
-) -> List[raw_types.Operation]:
+) -> list[raw_types.Operation]:
     pass
 
 
 def measure_each(
     *qubits, key_func: Callable[[raw_types.Qid], str] = str
-) -> List[raw_types.Operation]:
+) -> list[raw_types.Operation]:
     """Returns a list of operations individually measuring the given qubits.
 
     The qubits are measured in the computational basis.

cirq/ops/measurement_gate.py

@@ -14,18 +14,7 @@
 
 from __future__ import annotations
 
-from typing import (
-    Any,
-    Dict,
-    FrozenSet,
-    Iterable,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Iterable, Mapping, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -49,11 +38,11 @@ class MeasurementGate(raw_types.Gate):
 
     def __init__(
         self,
-        num_qubits: Optional[int] = None,
-        key: Union[str, cirq.MeasurementKey] = '',
-        invert_mask: Tuple[bool, ...] = (),
-        qid_shape: Optional[Tuple[int, ...]] = None,
-        confusion_map: Optional[Dict[Tuple[int, ...], np.ndarray]] = None,
+        num_qubits: int | None = None,
+        key: str | cirq.MeasurementKey = '',
+        invert_mask: tuple[bool, ...] = (),
+        qid_shape: tuple[int, ...] | None = None,
+        confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
     ) -> None:
         """Inits MeasurementGate.
 
@@ -106,20 +95,20 @@ class MeasurementGate(raw_types.Gate):
         return self._mkey
 
     @property
-    def invert_mask(self) -> Tuple[bool, ...]:
+    def invert_mask(self) -> tuple[bool, ...]:
         return self._invert_mask
 
     @property
-    def confusion_map(self) -> Dict[Tuple[int, ...], np.ndarray]:
+    def confusion_map(self) -> dict[tuple[int, ...], np.ndarray]:
         return self._confusion_map
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self._qid_shape
 
     def _has_unitary_(self) -> bool:
         return False
 
-    def with_key(self, key: Union[str, cirq.MeasurementKey]) -> MeasurementGate:
+    def with_key(self, key: str | cirq.MeasurementKey) -> MeasurementGate:
         """Creates a measurement gate with a new key but otherwise identical."""
         if key == self.key:
             return self
@@ -131,14 +120,14 @@ class MeasurementGate(raw_types.Gate):
             confusion_map=self.confusion_map,
         )
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         return self.with_key(self.mkey._with_key_path_(path))
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         return self.with_key(self.mkey._with_key_path_prefix_(prefix))
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ):
         return self.with_key(protocols.with_rescoped_keys(self.mkey, path, bindable_keys))
 
@@ -164,7 +153,7 @@ class MeasurementGate(raw_types.Gate):
             confusion_map=self.confusion_map,
         )
 
-    def full_invert_mask(self) -> Tuple[bool, ...]:
+    def full_invert_mask(self) -> tuple[bool, ...]:
         """Returns the invert mask for all qubits.
 
         If the user supplies a partial invert_mask, this returns that mask
@@ -224,7 +213,7 @@ class MeasurementGate(raw_types.Gate):
 
         return protocols.CircuitDiagramInfo(symbols)
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         if self.confusion_map or not all(d == 2 for d in self._qid_shape):
             return NotImplemented
         args.validate_version('2.0', '3.0')
@@ -275,8 +264,8 @@ class MeasurementGate(raw_types.Gate):
         )
         return self.key, self.full_invert_mask(), self._qid_shape, hashable_cmap
 
-    def _json_dict_(self) -> Dict[str, Any]:
-        other: Dict[str, Any] = {}
+    def _json_dict_(self) -> dict[str, Any]:
+        other: dict[str, Any] = {}
         if not all(d == 2 for d in self._qid_shape):
             other['qid_shape'] = self._qid_shape
         if self.confusion_map:
@@ -301,7 +290,7 @@ class MeasurementGate(raw_types.Gate):
             confusion_map={tuple(k): np.array(v) for k, v in confusion_map or []},
         )
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         return True
 
     def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]) -> bool: