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

cirq/ops/gate_operation.py

@@ -14,6 +14,8 @@
 
 """Basic types defining qubits, gates, and operations."""
 
+from __future__ import annotations
+
 import re
 import warnings
 from types import NotImplementedType
@@ -51,7 +53,7 @@ class GateOperation(raw_types.Operation):
     Objects of this type are immutable.
     """
 
-    def __init__(self, gate: 'cirq.Gate', qubits: Sequence['cirq.Qid']) -> None:
+    def __init__(self, gate: cirq.Gate, qubits: Sequence[cirq.Qid]) -> None:
         """Inits GateOperation.
 
         Args:
@@ -63,19 +65,19 @@ class GateOperation(raw_types.Operation):
         self._qubits = tuple(qubits)
 
     @property
-    def gate(self) -> 'cirq.Gate':
+    def gate(self) -> cirq.Gate:
         """The gate applied by the operation."""
         return self._gate
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> Tuple[cirq.Qid, ...]:
         """The qubits targeted by the operation."""
         return self._qubits
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:
+    def with_qubits(self, *new_qubits: cirq.Qid) -> Self:
         return cast(Self, self.gate.on(*new_qubits))
 
-    def with_gate(self, new_gate: 'cirq.Gate') -> 'cirq.Operation':
+    def with_gate(self, new_gate: cirq.Gate) -> cirq.Operation:
         if self.gate is new_gate:
             # As GateOperation is immutable, this can return the original.
             return self
@@ -109,7 +111,7 @@ class GateOperation(raw_types.Operation):
         return new_gate.on(*self.qubits)
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
     ):
         new_gate = protocols.with_rescoped_keys(self.gate, path, bindable_keys)
         if new_gate is self.gate:
@@ -142,10 +144,10 @@ class GateOperation(raw_types.Operation):
 
     def _group_interchangeable_qubits(
         self,
-    ) -> Tuple[Union['cirq.Qid', Tuple[int, FrozenSet['cirq.Qid']]], ...]:
+    ) -> Tuple[Union[cirq.Qid, Tuple[int, FrozenSet[cirq.Qid]]], ...]:
         if not isinstance(self.gate, gate_features.InterchangeableQubitsGate):
             return self.qubits
-        groups: Dict[int, List['cirq.Qid']] = {}
+        groups: Dict[int, List[cirq.Qid]] = {}
         for i, q in enumerate(self.qubits):
             k = self.gate.qubit_index_to_equivalence_group_key(i)
             groups.setdefault(k, []).append(q)
@@ -160,12 +162,12 @@ class GateOperation(raw_types.Operation):
     def _num_qubits_(self):
         return len(self._qubits)
 
-    def _decompose_(self) -> 'cirq.OP_TREE':
+    def _decompose_(self) -> cirq.OP_TREE:
         return self._decompose_with_context_()
 
     def _decompose_with_context_(
-        self, context: Optional['cirq.DecompositionContext'] = None
-    ) -> 'cirq.OP_TREE':
+        self, context: Optional[cirq.DecompositionContext] = None
+    ) -> cirq.OP_TREE:
         return protocols.decompose_once_with_qubits(
             self.gate, self.qubits, NotImplemented, flatten=False, context=context
         )
@@ -177,7 +179,7 @@ class GateOperation(raw_types.Operation):
         return NotImplemented
 
     def _apply_unitary_(
-        self, args: 'protocols.ApplyUnitaryArgs'
+        self, args: protocols.ApplyUnitaryArgs
     ) -> Union[np.ndarray, None, NotImplementedType]:
         getter = getattr(self.gate, '_apply_unitary_', None)
         if getter is not None:
@@ -218,7 +220,7 @@ class GateOperation(raw_types.Operation):
         return NotImplemented
 
     def _apply_channel_(
-        self, args: 'protocols.ApplyChannelArgs'
+        self, args: protocols.ApplyChannelArgs
     ) -> Union[np.ndarray, None, NotImplementedType]:
         getter = getattr(self.gate, '_apply_channel_', None)
         if getter is not None:
@@ -256,7 +258,7 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _measurement_key_obj_(self) -> Optional['cirq.MeasurementKey']:
+    def _measurement_key_obj_(self) -> Optional[cirq.MeasurementKey]:
         getter = getattr(self.gate, '_measurement_key_obj_', None)
         if getter is not None:
             return getter()
@@ -264,13 +266,13 @@ class GateOperation(raw_types.Operation):
 
     def _measurement_key_objs_(
         self,
-    ) -> Union[FrozenSet['cirq.MeasurementKey'], NotImplementedType, None]:
+    ) -> Union[FrozenSet[cirq.MeasurementKey], NotImplementedType, None]:
         getter = getattr(self.gate, '_measurement_key_objs_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase'):
+    def _act_on_(self, sim_state: cirq.SimulationStateBase):
         getter = getattr(self.gate, '_act_on_', None)
         if getter is not None:
             return getter(sim_state, self.qubits)
@@ -288,15 +290,11 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.Operation':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> cirq.Operation:
         resolved_gate = protocols.resolve_parameters(self.gate, resolver, recursive)
         return self.with_gate(resolved_gate)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.circuit_diagram_info(self.gate, args, NotImplemented)
 
     def _decompose_into_clifford_(self):
@@ -311,13 +309,13 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _phase_by_(self, phase_turns: float, qubit_index: int) -> 'GateOperation':
+    def _phase_by_(self, phase_turns: float, qubit_index: int) -> GateOperation:
         phased_gate = protocols.phase_by(self.gate, phase_turns, qubit_index, default=None)
         if phased_gate is None:
             return NotImplemented
         return GateOperation(phased_gate, self._qubits)
 
-    def __pow__(self, exponent: Any) -> 'cirq.Operation':
+    def __pow__(self, exponent: Any) -> cirq.Operation:
         """Raise gate to a power, then reapply to the same qubits.
 
         Only works if the gate implements cirq.ExtrapolatableEffect.
@@ -348,7 +346,7 @@ class GateOperation(raw_types.Operation):
     def __rmul__(self, other: Any) -> Any:
         return self.gate._rmul_with_qubits(self._qubits, other)
 
-    def _qasm_(self, args: 'protocols.QasmArgs') -> Optional[str]:
+    def _qasm_(self, args: protocols.QasmArgs) -> Optional[str]:
         if isinstance(self.gate, ops.GlobalPhaseGate):
             warnings.warn(
                 "OpenQASM 2.0 does not support global phase."
@@ -370,11 +368,11 @@ class GateOperation(raw_types.Operation):
 
     def controlled_by(
         self,
-        *control_qubits: 'cirq.Qid',
+        *control_qubits: cirq.Qid,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,
-    ) -> 'cirq.Operation':
+    ) -> cirq.Operation:
         if len(control_qubits) == 0:
             return self
         qubits = tuple(control_qubits)

cirq/ops/gateset.py

@@ -14,6 +14,8 @@
 
 """Functionality for grouping and validating Cirq gates."""
 
+from __future__ import annotations
+
 from typing import (
     Any,
     Callable,
@@ -37,7 +39,7 @@ if TYPE_CHECKING:
 
 
 def _gate_str(
-    gate: Union[raw_types.Gate, Type[raw_types.Gate], 'cirq.GateFamily'],
+    gate: Union[raw_types.Gate, Type[raw_types.Gate], cirq.GateFamily],
     gettr: Callable[[Any], str] = str,
 ) -> str:
     return gettr(gate) if not isinstance(gate, type) else f'{gate.__module__}.{gate.__name__}'
@@ -291,7 +293,7 @@ class GateFamily:
         tags_to_accept=(),
         tags_to_ignore=(),
         **kwargs,
-    ) -> 'GateFamily':
+    ) -> GateFamily:
         if isinstance(gate, str):
             gate = protocols.cirq_type_from_json(gate)
         return cls(
@@ -370,7 +372,7 @@ class Gateset:
 
     def with_params(
         self, *, name: Optional[str] = None, unroll_circuit_op: Optional[bool] = None
-    ) -> 'Gateset':
+    ) -> Gateset:
         """Returns a copy of this Gateset with identical gates and new values for named arguments.
 
         If a named argument is None then corresponding value of this Gateset is used instead.
@@ -445,7 +447,7 @@ class Gateset:
 
         return any(item in gate_family for gate_family in self._gates)
 
-    def validate(self, circuit_or_optree: Union['cirq.AbstractCircuit', op_tree.OP_TREE]) -> bool:
+    def validate(self, circuit_or_optree: Union[cirq.AbstractCircuit, op_tree.OP_TREE]) -> bool:
         """Validates gates forming `circuit_or_optree` should be contained in Gateset.
 
         Args:
@@ -518,7 +520,7 @@ class Gateset:
         }
 
     @classmethod
-    def _from_json_dict_(cls, gates, name, unroll_circuit_op, **kwargs) -> 'Gateset':
+    def _from_json_dict_(cls, gates, name, unroll_circuit_op, **kwargs) -> Gateset:
         # This parameter was deprecated in 0.16, but we keep this logic here for backwards
         # compatibility.
         if 'accept_global_phase_op' in kwargs:

cirq/ops/global_phase_op.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 """A no-qubit global phase operation."""
 
+from __future__ import annotations
+
 from types import NotImplementedType
 from typing import AbstractSet, Any, cast, Collection, Dict, Optional, Sequence, Tuple, Union
 
@@ -27,14 +29,14 @@ from cirq.ops import control_values as cv, controlled_gate, raw_types
 
 @value.value_equality(approximate=True)
 class GlobalPhaseGate(raw_types.Gate):
-    def __init__(self, coefficient: 'cirq.TParamValComplex', atol: float = 1e-8) -> None:
+    def __init__(self, coefficient: cirq.TParamValComplex, atol: float = 1e-8) -> None:
         if not isinstance(coefficient, sympy.Basic):
             if abs(1 - abs(coefficient)) > atol:
                 raise ValueError(f'Coefficient is not unitary: {coefficient!r}')
         self._coefficient = coefficient
 
     @property
-    def coefficient(self) -> 'cirq.TParamValComplex':
+    def coefficient(self) -> cirq.TParamValComplex:
         return self._coefficient
 
     def _value_equality_values_(self) -> Any:
@@ -43,7 +45,7 @@ class GlobalPhaseGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def __pow__(self, power) -> 'cirq.GlobalPhaseGate':
+    def __pow__(self, power) -> cirq.GlobalPhaseGate:
         if isinstance(power, (int, float)):
             return GlobalPhaseGate(self.coefficient**power)
         return NotImplemented
@@ -53,9 +55,7 @@ class GlobalPhaseGate(raw_types.Gate):
             return NotImplemented
         return np.array([[self.coefficient]])
 
-    def _apply_unitary_(
-        self, args: 'cirq.ApplyUnitaryArgs'
-    ) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
         if not self._has_unitary_():
             return NotImplemented
         assert not cirq.is_parameterized(self)
@@ -71,7 +71,7 @@ class GlobalPhaseGate(raw_types.Gate):
     def __repr__(self) -> str:
         return f'cirq.GlobalPhaseGate({proper_repr(self.coefficient)})'
 
-    def _op_repr_(self, qubits: Sequence['cirq.Qid']) -> str:
+    def _op_repr_(self, qubits: Sequence[cirq.Qid]) -> str:
         return f'cirq.global_phase_operation({proper_repr(self.coefficient)})'
 
     def _json_dict_(self) -> Dict[str, Any]:
@@ -87,8 +87,8 @@ class GlobalPhaseGate(raw_types.Gate):
         return protocols.parameter_names(self.coefficient)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.GlobalPhaseGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> cirq.GlobalPhaseGate:
         coefficient = protocols.resolve_parameters(self.coefficient, resolver, recursive)
         return GlobalPhaseGate(coefficient=coefficient)
 
@@ -120,7 +120,7 @@ class GlobalPhaseGate(raw_types.Gate):
 
 
 def global_phase_operation(
-    coefficient: 'cirq.TParamValComplex', atol: float = 1e-8
-) -> 'cirq.GateOperation':
+    coefficient: cirq.TParamValComplex, atol: float = 1e-8
+) -> cirq.GateOperation:
     """Creates an operation that represents a global phase on the state."""
     return GlobalPhaseGate(coefficient, atol)()

cirq/ops/greedy_qubit_manager.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 Iterable, List, Set, TYPE_CHECKING
 
 from cirq.ops import named_qubit, qid_util, qubit_manager
@@ -49,25 +51,25 @@ class GreedyQubitManager(qubit_manager.QubitManager):
             maximize_reuse: Flag to control a FIFO vs LIFO strategy, defaults to False (FIFO).
         """
         self._prefix = prefix
-        self._used_qubits: Set['cirq.Qid'] = set()
-        self._free_qubits: List['cirq.Qid'] = []
+        self._used_qubits: Set[cirq.Qid] = set()
+        self._free_qubits: List[cirq.Qid] = []
         self._size = 0
         self.maximize_reuse = maximize_reuse
         self.resize(size)
 
-    def _allocate_qid(self, name: str, dim: int) -> 'cirq.Qid':
+    def _allocate_qid(self, name: str, dim: int) -> cirq.Qid:
         return qid_util.q(name) if dim == 2 else named_qubit.NamedQid(name, dimension=dim)
 
     def resize(self, new_size: int, dim: int = 2) -> None:
         if new_size <= self._size:
             return
-        new_qubits: List['cirq.Qid'] = [
+        new_qubits: List[cirq.Qid] = [
             self._allocate_qid(f'{self._prefix}_{s}', dim) for s in range(self._size, new_size)
         ]
         self._free_qubits = new_qubits + self._free_qubits
         self._size = new_size
 
-    def qalloc(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qalloc(self, n: int, dim: int = 2) -> List[cirq.Qid]:
         if not n:
             return []
         self.resize(self._size + n - len(self._free_qubits), dim=dim)
@@ -76,11 +78,11 @@ class GreedyQubitManager(qubit_manager.QubitManager):
         self._used_qubits.update(ret_qubits)
         return ret_qubits
 
-    def qfree(self, qubits: Iterable['cirq.Qid']) -> None:
+    def qfree(self, qubits: Iterable[cirq.Qid]) -> None:
         qs = list(dict(zip(qubits, qubits)).keys())
         assert self._used_qubits.issuperset(qs), "Only managed qubits currently in-use can be freed"
         self._used_qubits = self._used_qubits.difference(qs)
         self._free_qubits.extend(qs)
 
-    def qborrow(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qborrow(self, n: int, dim: int = 2) -> List[cirq.Qid]:
         return self.qalloc(n, dim)

cirq/ops/identity.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 """IdentityGate."""
 
+from __future__ import annotations
+
 import numbers
 from types import NotImplementedType
 from typing import Any, Dict, Optional, Sequence, Tuple, TYPE_CHECKING, Union
@@ -63,7 +65,7 @@ class IdentityGate(raw_types.Gate):
         if len(self._qid_shape) != num_qubits:
             raise ValueError('len(qid_shape) != num_qubits')
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']):
+    def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]):
         return True
 
     def _qid_shape_(self) -> Tuple[int, ...]:
@@ -89,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) -> Optional[np.ndarray]:
         return args.target_tensor
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
@@ -104,7 +106,7 @@ class IdentityGate(raw_types.Gate):
             return f'cirq.IdentityGate({len(self._qid_shape)})'
         return f'cirq.IdentityGate(qid_shape={self._qid_shape!r})'
 
-    def _decompose_(self, qubits) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits) -> cirq.OP_TREE:
         return []
 
     def __str__(self) -> str:
@@ -124,7 +126,7 @@ class IdentityGate(raw_types.Gate):
             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):
@@ -140,7 +142,7 @@ class IdentityGate(raw_types.Gate):
             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, ...]) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         return ''.join([args.format('id {0};\n', qubit) for qubit in qubits])
 
@@ -163,7 +165,7 @@ document(
 )
 
 
-def identity_each(*qubits: 'cirq.Qid') -> 'cirq.Operation':
+def identity_each(*qubits: cirq.Qid) -> cirq.Operation:
     """Returns a single IdentityGate applied to all the given qubits.
 
     Args:

cirq/ops/kraus_channel.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 from typing import Any, Dict, FrozenSet, Iterable, Mapping, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
@@ -29,7 +32,7 @@ class KrausChannel(raw_types.Gate):
     def __init__(
         self,
         kraus_ops: Iterable[np.ndarray],
-        key: Union[str, 'cirq.MeasurementKey', None] = None,
+        key: Union[str, cirq.MeasurementKey, None] = None,
         validate: bool = False,
     ):
         kraus_ops = list(kraus_ops)
@@ -56,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: Union[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)
 
@@ -80,7 +83,7 @@ class KrausChannel(raw_types.Gate):
             return NotImplemented
         return str(self._key)
 
-    def _measurement_key_obj_(self) -> 'cirq.MeasurementKey':
+    def _measurement_key_obj_(self) -> cirq.MeasurementKey:
         if self._key is None:
             return NotImplemented
         return self._key
@@ -101,7 +104,7 @@ class KrausChannel(raw_types.Gate):
         )
 
     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,