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

cirq/ops/common_channels.py

@@ -14,8 +14,10 @@
 
 """Quantum channels that are commonly used in the literature."""
 
+from __future__ import annotations
+
 import itertools
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, Iterable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -51,10 +53,10 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
 
     def __init__(
         self,
-        p_x: Optional[float] = None,
-        p_y: Optional[float] = None,
-        p_z: Optional[float] = None,
-        error_probabilities: Optional[Dict[str, float]] = None,
+        p_x: float | None = None,
+        p_y: float | None = None,
+        p_z: float | None = None,
+        error_probabilities: dict[str, float] | None = None,
         tol: float = 1e-8,
     ) -> None:
         r"""The asymmetric depolarizing channel.
@@ -108,7 +110,7 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
             self._num_qubits = 1
             self._error_probabilities = {'I': p_i, 'X': p_x, 'Y': p_y, 'Z': p_z}
 
-    def _mixture_(self) -> Sequence[Tuple[float, np.ndarray]]:
+    def _mixture_(self) -> Sequence[tuple[float, np.ndarray]]:
         ps = []
         for pauli in self._error_probabilities:
             Pi = np.identity(1)
@@ -139,15 +141,13 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
     def __str__(self) -> str:
         return 'asymmetric_depolarize(' + f"error_probabilities={self._error_probabilities})"
 
-    def _circuit_diagram_info_(
-        self, args: 'protocols.CircuitDiagramInfoArgs'
-    ) -> Union[str, Iterable[str]]:
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> str | Iterable[str]:
         if self._num_qubits == 1:
             if args.precision is not None:
                 return (
                     f"A({self.p_x:.{args.precision}g},"
-                    + f"{self.p_y:.{args.precision}g},"
-                    + f"{self.p_z:.{args.precision}g})"
+                    f"{self.p_y:.{args.precision}g},"
+                    f"{self.p_z:.{args.precision}g})"
                 )
             return f"A({self.p_x},{self.p_y},{self.p_z})"
         if args.precision is not None:
@@ -189,19 +189,19 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
         return self._error_probabilities.get('Z', 0.0)
 
     @property
-    def error_probabilities(self) -> Dict[str, float]:
+    def error_probabilities(self) -> dict[str, float]:
         """A dictionary from Pauli gates to probability"""
         return self._error_probabilities
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['error_probabilities'])
 
 
 def asymmetric_depolarize(
-    p_x: Optional[float] = None,
-    p_y: Optional[float] = None,
-    p_z: Optional[float] = None,
-    error_probabilities: Optional[Dict[str, float]] = None,
+    p_x: float | None = None,
+    p_y: float | None = None,
+    p_z: float | None = None,
+    error_probabilities: dict[str, float] | None = None,
     tol: float = 1e-8,
 ) -> AsymmetricDepolarizingChannel:
     r"""Returns an `AsymmetricDepolarizingChannel` with the given parameters.
@@ -294,7 +294,7 @@ class DepolarizingChannel(raw_types.Gate):
     def _qid_shape_(self):
         return (2,) * self._n_qubits
 
-    def _mixture_(self) -> Sequence[Tuple[float, np.ndarray]]:
+    def _mixture_(self) -> Sequence[tuple[float, np.ndarray]]:
         return self._delegate._mixture_()
 
     def _has_mixture_(self) -> bool:
@@ -313,8 +313,8 @@ class DepolarizingChannel(raw_types.Gate):
             return f"depolarize(p={self._p})"
         return f"depolarize(p={self._p},n_qubits={self._n_qubits})"
 
-    def _circuit_diagram_info_(self, args: 'protocols.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
-        result: Tuple[str, ...]
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> tuple[str, ...]:
+        result: tuple[str, ...]
         if args.precision is not None:
             result = (f"D({self._p:.{args.precision}g})",)
         else:
@@ -337,7 +337,7 @@ class DepolarizingChannel(raw_types.Gate):
         """The number of qubits"""
         return self._n_qubits
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         if self._n_qubits == 1:
             return protocols.obj_to_dict_helper(self, ['p'])
         return protocols.obj_to_dict_helper(self, ['p', 'n_qubits'])
@@ -462,7 +462,7 @@ class GeneralizedAmplitudeDampingChannel(raw_types.Gate):
     def __str__(self) -> str:
         return f'generalized_amplitude_damp(p={self._p!r},gamma={self._gamma!r})'
 
-    def _circuit_diagram_info_(self, args: 'protocols.CircuitDiagramInfoArgs') -> str:
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> str:
         if args.precision is not None:
             f = '{:.' + str(args.precision) + 'g}'
             return f'GAD({f},{f})'.format(self._p, self._gamma)
@@ -478,7 +478,7 @@ class GeneralizedAmplitudeDampingChannel(raw_types.Gate):
         """The probability of energy transfer."""
         return self._gamma
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['p', 'gamma'])
 
 
@@ -591,7 +591,7 @@ class AmplitudeDampingChannel(raw_types.Gate):
     def __str__(self) -> str:
         return f'amplitude_damp(gamma={self._gamma!r})'
 
-    def _circuit_diagram_info_(self, args: 'protocols.CircuitDiagramInfoArgs') -> str:
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> str:
         if args.precision is not None:
             f = '{:.' + str(args.precision) + 'g}'
             return f'AD({f})'.format(self._gamma)
@@ -602,7 +602,7 @@ class AmplitudeDampingChannel(raw_types.Gate):
         """The probability of the interaction being dissipative."""
         return self._gamma
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['gamma'])
 
 
@@ -681,17 +681,17 @@ class ResetChannel(raw_types.Gate):
         """
         self._dimension = dimension
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         return True
 
-    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 args.format('reset {0};\n', qubits[0])
 
     def _qid_shape_(self):
         return (self._dimension,)
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']):
+    def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]):
         if len(qubits) != 1:
             return NotImplemented
 
@@ -714,7 +714,7 @@ class ResetChannel(raw_types.Gate):
         channel[:, 0, :] = np.eye(self._dimension)
         return channel
 
-    def _apply_channel_(self, args: 'cirq.ApplyChannelArgs'):
+    def _apply_channel_(self, args: cirq.ApplyChannelArgs):
         configs = []
         for i in range(self._dimension):
             s1 = transformations._SliceConfig(
@@ -742,7 +742,7 @@ class ResetChannel(raw_types.Gate):
     def __str__(self) -> str:
         return 'reset'
 
-    def _circuit_diagram_info_(self, args: 'protocols.CircuitDiagramInfoArgs') -> str:
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> str:
         return 'R'
 
     @property
@@ -750,11 +750,11 @@ class ResetChannel(raw_types.Gate):
         """The dimension of the qudit being reset."""
         return self._dimension
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['dimension'])
 
 
-def reset(qubit: 'cirq.Qid') -> raw_types.Operation:
+def reset(qubit: cirq.Qid) -> raw_types.Operation:
     """Returns a `cirq.ResetChannel` on the given qubit.
 
     This can also be used with the alias `cirq.R`.
@@ -765,7 +765,7 @@ def reset(qubit: 'cirq.Qid') -> raw_types.Operation:
 R = reset
 
 
-def reset_each(*qubits: 'cirq.Qid') -> List[raw_types.Operation]:
+def reset_each(*qubits: cirq.Qid) -> list[raw_types.Operation]:
     """Returns a list of `cirq.ResetChannel` instances on the given qubits."""
     return [ResetChannel(q.dimension).on(q) for q in qubits]
 
@@ -815,7 +815,7 @@ class PhaseDampingChannel(raw_types.Gate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _apply_channel_(self, args: 'cirq.ApplyChannelArgs'):
+    def _apply_channel_(self, args: cirq.ApplyChannelArgs):
         if self._gamma == 0:
             return args.target_tensor
         if self._gamma != 1:
@@ -850,7 +850,7 @@ class PhaseDampingChannel(raw_types.Gate):
     def __str__(self) -> str:
         return f'phase_damp(gamma={self._gamma!r})'
 
-    def _circuit_diagram_info_(self, args: 'protocols.CircuitDiagramInfoArgs') -> str:
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> str:
         if args.precision is not None:
             f = '{:.' + str(args.precision) + 'g}'
             return f'PD({f})'.format(self._gamma)
@@ -861,7 +861,7 @@ class PhaseDampingChannel(raw_types.Gate):
         """The damping constant."""
         return self._gamma
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['gamma'])
 
 
@@ -940,7 +940,7 @@ class PhaseFlipChannel(raw_types.Gate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _mixture_(self) -> Sequence[Tuple[float, np.ndarray]]:
+    def _mixture_(self) -> Sequence[tuple[float, np.ndarray]]:
         mixture = self._delegate._mixture_()
         # just return identity and z term
         return (mixture[0], mixture[3])
@@ -957,7 +957,7 @@ class PhaseFlipChannel(raw_types.Gate):
     def __str__(self) -> str:
         return f'phase_flip(p={self._p!r})'
 
-    def _circuit_diagram_info_(self, args: 'protocols.CircuitDiagramInfoArgs') -> str:
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> str:
         if args.precision is not None:
             f = '{:.' + str(args.precision) + 'g}'
             return f'PF({f})'.format(self._p)
@@ -968,7 +968,7 @@ class PhaseFlipChannel(raw_types.Gate):
         """The probability of a phase flip."""
         return self._p
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['p'])
 
 
@@ -1011,7 +1011,7 @@ def _phase_flip(p: float) -> PhaseFlipChannel:
     return PhaseFlipChannel(p)
 
 
-def phase_flip(p: Optional[float] = None) -> Union[common_gates.ZPowGate, PhaseFlipChannel]:
+def phase_flip(p: float | None = None) -> common_gates.ZPowGate | PhaseFlipChannel:
     r"""Returns a PhaseFlipChannel that flips a qubit's phase with probability p.
 
     If `p` is None, return a guaranteed phase flip in the form of a Z operation.
@@ -1093,7 +1093,7 @@ class BitFlipChannel(raw_types.Gate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _mixture_(self) -> Sequence[Tuple[float, Any]]:
+    def _mixture_(self) -> Sequence[tuple[float, Any]]:
         return ((1 - self._p, identity.I), (self._p, pauli_gates.X))
 
     def _has_mixture_(self) -> bool:
@@ -1108,7 +1108,7 @@ class BitFlipChannel(raw_types.Gate):
     def __str__(self) -> str:
         return f'bit_flip(p={self._p!r})'
 
-    def _circuit_diagram_info_(self, args: 'protocols.CircuitDiagramInfoArgs') -> str:
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> str:
         if args.precision is not None:
             f = '{:.' + str(args.precision) + 'g}'
             return f'BF({f})'.format(self._p)
@@ -1119,7 +1119,7 @@ class BitFlipChannel(raw_types.Gate):
         """The probability of a bit flip."""
         return self._p
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['p'])
 
 
@@ -1157,7 +1157,7 @@ def _bit_flip(p: float) -> BitFlipChannel:
     return BitFlipChannel(p)
 
 
-def bit_flip(p: Optional[float] = None) -> Union[common_gates.XPowGate, BitFlipChannel]:
+def bit_flip(p: float | None = None) -> common_gates.XPowGate | BitFlipChannel:
     r"""Construct a BitFlipChannel that flips a qubit state with probability p.
 
     If p is None, this returns a guaranteed flip in the form of an X operation.