cirq-core 1.6.0.dev20250423233500__py3-none-any.whl → 1.6.0.dev20250425004112__py3-none-any.whl

cirq/ops/parity_gates.py

@@ -14,6 +14,8 @@
 
 """Quantum gates that phase with respect to product-of-pauli observables."""
 
+from __future__ import annotations
+
 from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
@@ -117,14 +119,14 @@ class XXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _has_stabilizer_effect_(self) -> bool:
         return self.exponent % 2 in (0, 0.5, 1, 1.5)
 
-    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Tuple[cirq.Qid, ...]) -> Iterator[cirq.OP_TREE]:
         yield common_gates.YPowGate(exponent=-0.5).on_each(*qubits)
         yield ZZPowGate(exponent=self.exponent, global_shift=self.global_shift)(*qubits)
         yield common_gates.YPowGate(exponent=0.5).on_each(*qubits)
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, protocols.CircuitDiagramInfo]:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('XX', 'XX'), exponent=self._diagram_exponent(args)
         )
@@ -226,14 +228,12 @@ class YYPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _has_stabilizer_effect_(self) -> bool:
         return self.exponent % 2 in (0, 0.5, 1, 1.5)
 
-    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Tuple[cirq.Qid, ...]) -> Iterator[cirq.OP_TREE]:
         yield common_gates.XPowGate(exponent=0.5).on_each(*qubits)
         yield ZZPowGate(exponent=self.exponent, global_shift=self.global_shift)(*qubits)
         yield common_gates.XPowGate(exponent=-0.5).on_each(*qubits)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('YY', 'YY'), exponent=self._diagram_exponent(args)
         )
@@ -281,8 +281,8 @@ class ZZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         )(qubits[0], qubits[1])
 
     def _decompose_into_clifford_with_qubits_(
-        self, qubits: Sequence['cirq.Qid']
-    ) -> Sequence[Union['cirq.Operation', Sequence['cirq.Operation']]]:
+        self, qubits: Sequence[cirq.Qid]
+    ) -> Sequence[Union[cirq.Operation, Sequence[cirq.Operation]]]:
         if not self._has_stabilizer_effect_():
             return NotImplemented
         if self.exponent % 2 == 0:
@@ -319,14 +319,12 @@ class ZZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('ZZ', 'ZZ'), exponent=self._diagram_exponent(args)
         )
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
         if protocols.is_parameterized(self):
             return None
 
@@ -342,7 +340,7 @@ class ZZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
 
         return args.target_tensor
 
-    def _phase_by_(self, phase_turns: float, qubit_index: int) -> "ZZPowGate":
+    def _phase_by_(self, phase_turns: float, qubit_index: int) -> ZZPowGate:
         return self
 
     def __str__(self) -> str:
@@ -382,8 +380,8 @@ class MSGate(XXPowGate):
         return type(self)(rads=exponent * np.pi / 2)
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, protocols.CircuitDiagramInfo]:
         angle_str = self._format_exponent_as_angle(args, order=4)
         symbol = f'MS({angle_str})'
         return protocols.CircuitDiagramInfo(wire_symbols=(symbol, symbol))
@@ -407,7 +405,7 @@ class MSGate(XXPowGate):
         return protocols.obj_to_dict_helper(self, ["rads"])
 
     @classmethod
-    def _from_json_dict_(cls, rads: float, **kwargs: Any) -> 'MSGate':
+    def _from_json_dict_(cls, rads: float, **kwargs: Any) -> MSGate:
         return cls(rads=rads)
 
 

cirq/ops/pauli_gates.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 abc
 from types import NotImplementedType
 from typing import Any, cast, Dict, Tuple, TYPE_CHECKING, Union
@@ -39,14 +42,14 @@ class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
     of private subclasses are the X, Y, or Z Pauli gates defined below.
     """
 
-    _XYZ: Tuple['Pauli', 'Pauli', 'Pauli']
+    _XYZ: Tuple[Pauli, Pauli, Pauli]
 
     @staticmethod
-    def by_index(index: int) -> 'Pauli':
+    def by_index(index: int) -> Pauli:
         return Pauli._XYZ[index % 3]
 
     @staticmethod
-    def by_relative_index(p: 'Pauli', relative_index: int) -> 'Pauli':
+    def by_relative_index(p: Pauli, relative_index: int) -> Pauli:
         return Pauli._XYZ[(p._index + relative_index) % 3]
 
     def __init__(self, index: int, name: str) -> None:
@@ -63,16 +66,16 @@ class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
             return NotImplemented
         return self is other
 
-    def third(self, second: 'Pauli') -> 'Pauli':
+    def third(self, second: Pauli) -> Pauli:
         return Pauli._XYZ[(-self._index - second._index) % 3]
 
-    def relative_index(self, second: 'Pauli') -> int:
+    def relative_index(self, second: Pauli) -> int:
         """Relative index of self w.r.t. second in the (X, Y, Z) cycle."""
         return (self._index - second._index + 1) % 3 - 1
 
     def phased_pauli_product(
-        self, other: Union['cirq.Pauli', 'identity.IdentityGate']
-    ) -> Tuple[complex, Union['cirq.Pauli', 'identity.IdentityGate']]:
+        self, other: Union[cirq.Pauli, identity.IdentityGate]
+    ) -> Tuple[complex, Union[cirq.Pauli, identity.IdentityGate]]:
         if self == other:
             return 1, identity.I
         if other is identity.I:
@@ -89,7 +92,7 @@ class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
             return NotImplemented
         return (other._index - self._index) % 3 == 1
 
-    def on(self, *qubits: 'cirq.Qid') -> 'SingleQubitPauliStringGateOperation':
+    def on(self, *qubits: cirq.Qid) -> SingleQubitPauliStringGateOperation:
         """Returns an application of this gate to the given qubits.
 
         Args:
@@ -109,10 +112,10 @@ class _PauliX(Pauli, common_gates.XPowGate):
         Pauli.__init__(self, index=0, name='X')
         common_gates.XPowGate.__init__(self, exponent=1.0)
 
-    def __pow__(self, exponent: 'cirq.TParamVal') -> common_gates.XPowGate:
+    def __pow__(self, exponent: cirq.TParamVal) -> common_gates.XPowGate:
         return common_gates.XPowGate(exponent=exponent) if exponent != 1 else _PauliX()
 
-    def _with_exponent(self, exponent: 'cirq.TParamVal') -> common_gates.XPowGate:
+    def _with_exponent(self, exponent: cirq.TParamVal) -> common_gates.XPowGate:
         return self.__pow__(exponent)
 
     @classmethod
@@ -122,7 +125,7 @@ class _PauliX(Pauli, common_gates.XPowGate):
         return Pauli._XYZ[0]
 
     @property
-    def basis(self) -> Dict[int, '_XEigenState']:
+    def basis(self) -> Dict[int, _XEigenState]:
         from cirq.value.product_state import _XEigenState
 
         return {+1: _XEigenState(+1), -1: _XEigenState(-1)}
@@ -133,10 +136,10 @@ class _PauliY(Pauli, common_gates.YPowGate):
         Pauli.__init__(self, index=1, name='Y')
         common_gates.YPowGate.__init__(self, exponent=1.0)
 
-    def __pow__(self, exponent: 'cirq.TParamVal') -> common_gates.YPowGate:
+    def __pow__(self, exponent: cirq.TParamVal) -> common_gates.YPowGate:
         return common_gates.YPowGate(exponent=exponent) if exponent != 1 else _PauliY()
 
-    def _with_exponent(self, exponent: 'cirq.TParamVal') -> common_gates.YPowGate:
+    def _with_exponent(self, exponent: cirq.TParamVal) -> common_gates.YPowGate:
         return self.__pow__(exponent)
 
     @classmethod
@@ -146,7 +149,7 @@ class _PauliY(Pauli, common_gates.YPowGate):
         return Pauli._XYZ[1]
 
     @property
-    def basis(self) -> Dict[int, '_YEigenState']:
+    def basis(self) -> Dict[int, _YEigenState]:
         from cirq.value.product_state import _YEigenState
 
         return {+1: _YEigenState(+1), -1: _YEigenState(-1)}
@@ -157,10 +160,10 @@ class _PauliZ(Pauli, common_gates.ZPowGate):
         Pauli.__init__(self, index=2, name='Z')
         common_gates.ZPowGate.__init__(self, exponent=1.0)
 
-    def __pow__(self, exponent: 'cirq.TParamVal') -> common_gates.ZPowGate:
+    def __pow__(self, exponent: cirq.TParamVal) -> common_gates.ZPowGate:
         return common_gates.ZPowGate(exponent=exponent) if exponent != 1 else _PauliZ()
 
-    def _with_exponent(self, exponent: 'cirq.TParamVal') -> common_gates.ZPowGate:
+    def _with_exponent(self, exponent: cirq.TParamVal) -> common_gates.ZPowGate:
         return self.__pow__(exponent)
 
     @classmethod
@@ -170,7 +173,7 @@ class _PauliZ(Pauli, common_gates.ZPowGate):
         return Pauli._XYZ[2]
 
     @property
-    def basis(self) -> Dict[int, '_ZEigenState']:
+    def basis(self) -> Dict[int, _ZEigenState]:
         from cirq.value.product_state import _ZEigenState
 
         return {+1: _ZEigenState(+1), -1: _ZEigenState(-1)}

cirq/ops/pauli_interaction_gate.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Any, Dict, Iterator, List, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -35,8 +37,8 @@ PAULI_EIGEN_MAP: Dict[pauli_gates.Pauli, Tuple[np.ndarray, np.ndarray]] = {
 class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     """A CZ conjugated by arbitrary single qubit Cliffords."""
 
-    CZ: 'PauliInteractionGate'
-    CNOT: 'PauliInteractionGate'
+    CZ: PauliInteractionGate
+    CNOT: PauliInteractionGate
 
     def __init__(
         self,
@@ -66,7 +68,7 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         self._invert1 = invert1
 
     @property
-    def pauli0(self) -> 'cirq.Pauli':
+    def pauli0(self) -> cirq.Pauli:
         return self._pauli0
 
     @property
@@ -74,7 +76,7 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         return self._invert0
 
     @property
-    def pauli1(self) -> 'cirq.Pauli':
+    def pauli1(self) -> cirq.Pauli:
         return self._pauli1
 
     @property
@@ -98,7 +100,7 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
             return 0
         return index
 
-    def _with_exponent(self, exponent: value.TParamVal) -> 'PauliInteractionGate':
+    def _with_exponent(self, exponent: value.TParamVal) -> PauliInteractionGate:
         return PauliInteractionGate(
             self.pauli0, self.invert0, self.pauli1, self.invert1, exponent=exponent
         )
@@ -114,7 +116,7 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         comp0 = np.eye(4) - comp1
         return [(0, comp0), (1, comp1)]
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         q0, q1 = qubits
         right_gate0 = SingleQubitCliffordGate.from_single_map(z_to=(self.pauli0, self.invert0))
         right_gate1 = SingleQubitCliffordGate.from_single_map(z_to=(self.pauli1, self.invert1))
@@ -127,14 +129,8 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         yield right_gate0(q0)
         yield right_gate1(q1)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
-        labels: Dict['cirq.Pauli', str] = {
-            pauli_gates.X: 'X',
-            pauli_gates.Y: 'Y',
-            pauli_gates.Z: '@',
-        }
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
+        labels: Dict[cirq.Pauli, str] = {pauli_gates.X: 'X', pauli_gates.Y: 'Y', pauli_gates.Z: '@'}
         l0 = labels[self.pauli0]
         l1 = labels[self.pauli1]
         # Add brackets around letter if inverted

cirq/ops/pauli_measurement_gate.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import (
     Any,
     cast,
@@ -50,8 +52,8 @@ class PauliMeasurementGate(raw_types.Gate):
 
     def __init__(
         self,
-        observable: Union['cirq.BaseDensePauliString', Iterable['cirq.Pauli']],
-        key: Union[str, 'cirq.MeasurementKey'] = '',
+        observable: Union[cirq.BaseDensePauliString, Iterable[cirq.Pauli]],
+        key: Union[str, cirq.MeasurementKey] = '',
     ) -> None:
         """Inits PauliMeasurementGate.
 
@@ -89,7 +91,7 @@ class PauliMeasurementGate(raw_types.Gate):
         return str(self.mkey)
 
     @property
-    def mkey(self) -> 'cirq.MeasurementKey':
+    def mkey(self) -> cirq.MeasurementKey:
         return self._mkey
 
     def _qid_shape_(self) -> Tuple[int, ...]:
@@ -98,29 +100,29 @@ class PauliMeasurementGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return False
 
-    def with_key(self, key: Union[str, 'cirq.MeasurementKey']) -> 'PauliMeasurementGate':
+    def with_key(self, key: Union[str, cirq.MeasurementKey]) -> PauliMeasurementGate:
         """Creates a pauli measurement gate with a new key but otherwise identical."""
         if key == self.key:
             return self
         return PauliMeasurementGate(self._observable, key=key)
 
-    def _with_key_path_(self, path: Tuple[str, ...]) -> 'PauliMeasurementGate':
+    def _with_key_path_(self, path: Tuple[str, ...]) -> PauliMeasurementGate:
         return self.with_key(self.mkey._with_key_path_(path))
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]) -> 'PauliMeasurementGate':
+    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]) -> PauliMeasurementGate:
         return self.with_key(self.mkey._with_key_path_prefix_(prefix))
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
-    ) -> 'PauliMeasurementGate':
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+    ) -> PauliMeasurementGate:
         return self.with_key(protocols.with_rescoped_keys(self.mkey, path, bindable_keys))
 
-    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> 'PauliMeasurementGate':
+    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> PauliMeasurementGate:
         return self.with_key(protocols.with_measurement_key_mapping(self.mkey, key_map))
 
     def with_observable(
-        self, observable: Union['cirq.BaseDensePauliString', Iterable['cirq.Pauli']]
-    ) -> 'PauliMeasurementGate':
+        self, observable: Union[cirq.BaseDensePauliString, Iterable[cirq.Pauli]]
+    ) -> PauliMeasurementGate:
         """Creates a pauli measurement gate with the new observable and same key."""
         if (
             observable
@@ -136,16 +138,16 @@ class PauliMeasurementGate(raw_types.Gate):
     def _measurement_key_name_(self) -> str:
         return self.key
 
-    def _measurement_key_obj_(self) -> 'cirq.MeasurementKey':
+    def _measurement_key_obj_(self) -> cirq.MeasurementKey:
         return self.mkey
 
-    def observable(self) -> 'cirq.DensePauliString':
+    def observable(self) -> cirq.DensePauliString:
         """Pauli observable which should be measured by the gate."""
         return self._observable
 
     def _decompose_(
-        self, qubits: Tuple['cirq.Qid', ...]
-    ) -> Iterator['protocols.decompose_protocol.DecomposeResult']:
+        self, qubits: Tuple[cirq.Qid, ...]
+    ) -> Iterator[protocols.decompose_protocol.DecomposeResult]:
         any_qubit = qubits[0]
         to_z_ops = op_tree.freeze_op_tree(self._observable.on(*qubits).to_z_basis_ops())
         xor_decomp = tuple(pauli_string_phasor.xor_nonlocal_decompose(qubits, any_qubit))
@@ -157,9 +159,7 @@ class PauliMeasurementGate(raw_types.Gate):
         yield protocols.inverse(xor_decomp)
         yield protocols.inverse(to_z_ops)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         coefficient = '' if self._observable.coefficient == 1 else '-'
         symbols = [
             f'M({"" if i else coefficient}{self._observable[i]})'
@@ -176,7 +176,7 @@ class PauliMeasurementGate(raw_types.Gate):
 
         return protocols.CircuitDiagramInfo(tuple(symbols))
 
-    def _op_repr_(self, qubits: Sequence['cirq.Qid']) -> str:
+    def _op_repr_(self, qubits: Sequence[cirq.Qid]) -> str:
         args = [repr(self._observable.on(*qubits))]
         if self.key != _default_measurement_key(qubits):
             args.append(f'key={self.mkey!r}')
@@ -193,7 +193,7 @@ class PauliMeasurementGate(raw_types.Gate):
         return {'observable': self._observable, 'key': self.key}
 
     @classmethod
-    def _from_json_dict_(cls, observable, key, **kwargs) -> 'PauliMeasurementGate':
+    def _from_json_dict_(cls, observable, key, **kwargs) -> PauliMeasurementGate:
         return cls(observable=observable, key=value.MeasurementKey.parse_serialized(key))