cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/ops/raw_types.py

@@ -16,11 +16,12 @@
 
 import abc
 import functools
+from types import NotImplementedType
 from typing import (
-    cast,
     AbstractSet,
     Any,
     Callable,
+    cast,
     Collection,
     Dict,
     FrozenSet,
@@ -34,15 +35,14 @@ from typing import (
     TYPE_CHECKING,
     Union,
 )
-from typing_extensions import Self
 
 import numpy as np
 import sympy
+from typing_extensions import Self
 
 from cirq import protocols, value
+from cirq._compat import __cirq_debug__, _method_cache_name, cached_method
 from cirq._import import LazyLoader
-from cirq._compat import __cirq_debug__, cached_method
-from cirq.type_workarounds import NotImplementedType
 from cirq.ops import control_values as cv
 
 # Lazy imports to break circular dependencies.
@@ -115,6 +115,15 @@ class Qid(metaclass=abc.ABCMeta):
     def __hash__(self) -> int:
         return hash((Qid, self._comparison_key()))
 
+    def __getstate__(self) -> Dict[str, Any]:
+        # clear cached hash value when pickling, see #6674
+        state = self.__dict__
+        hash_attr = _method_cache_name(self.__hash__)
+        if hash_attr in state:
+            state = state.copy()
+            del state[hash_attr]
+        return state
+
     def __eq__(self, other):
         if not isinstance(other, Qid):
             return NotImplemented
@@ -297,7 +306,7 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
         return operations
 
     def wrap_in_linear_combination(
-        self, coefficient: Union[complex, float, int] = 1
+        self, coefficient: 'cirq.TParamValComplex' = 1
     ) -> 'cirq.LinearCombinationOfGates':
         """Returns a LinearCombinationOfGates with this gate.
 
@@ -328,13 +337,13 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
     def __neg__(self) -> 'cirq.LinearCombinationOfGates':
         return self.wrap_in_linear_combination(coefficient=-1)
 
-    def __mul__(self, other: Union[complex, float, int]) -> 'cirq.LinearCombinationOfGates':
+    def __mul__(self, other: complex) -> 'cirq.LinearCombinationOfGates':
         return self.wrap_in_linear_combination(coefficient=other)
 
-    def __rmul__(self, other: Union[complex, float, int]) -> 'cirq.LinearCombinationOfGates':
+    def __rmul__(self, other: complex) -> 'cirq.LinearCombinationOfGates':
         return self.wrap_in_linear_combination(coefficient=other)
 
-    def __truediv__(self, other: Union[complex, float, int]) -> 'cirq.LinearCombinationOfGates':
+    def __truediv__(self, other: complex) -> 'cirq.LinearCombinationOfGates':
         return self.wrap_in_linear_combination(coefficient=1 / other)
 
     def __pow__(self, power):
@@ -455,6 +464,18 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
         """
         raise NotImplementedError
 
+    def _equal_up_to_global_phase_(
+        self, other: Any, atol: float = 1e-8
+    ) -> Union[NotImplementedType, bool]:
+        """Default fallback for gates that do not implement this protocol."""
+        try:
+            return protocols.equal_up_to_global_phase(
+                protocols.unitary(self), protocols.unitary(other), atol=atol
+            )
+        except TypeError:
+            # Gate has no unitary protocol
+            return NotImplemented
+
     def _commutes_on_qids_(
         self, qids: 'Sequence[cirq.Qid]', other: Any, *, atol: float = 1e-8
     ) -> Union[bool, NotImplementedType, None]:
@@ -545,6 +566,9 @@ class Operation(metaclass=abc.ABCMeta):
         resulting operation to be eventually serialized into JSON, you should
         also restrict the operation to be JSON serializable.
 
+        Please note that tags should be instantiated if classes are
+        used.  Raw types are not allowed.
+
         Args:
             *new_tags: The tags to wrap this operation in.
         """
@@ -557,6 +581,26 @@ class Operation(metaclass=abc.ABCMeta):
     ) -> Self:
         """Returns the same operation, but with different qubits.
 
+        This function will return a new operation with the same gate but
+        with qubits mapped according to the argument.
+
+        For example, the following will translate LineQubits to GridQubits
+        using a grid with 4 columns:
+
+        >>> op = cirq.CZ(cirq.LineQubit(5), cirq.LineQubit(9))
+        >>> op.transform_qubits(lambda q: cirq.GridQubit(q.x // 4, q.x % 4))
+        cirq.CZ(cirq.GridQubit(1, 1), cirq.GridQubit(2, 1))
+
+        This can also be used with a dictionary that has a mapping, such
+        as the following which maps named qubits to line qubits:
+
+        >>> a = cirq.NamedQubit('alice')
+        >>> b = cirq.NamedQubit('bob')
+        >>> d = {a: cirq.LineQubit(4), b: cirq.LineQubit(5)}
+        >>> op = cirq.CNOT(a, b)
+        >>> op.transform_qubits(d)
+        cirq.CNOT(cirq.LineQubit(4), cirq.LineQubit(5))
+
         Args:
             qubit_map: A function or a dict mapping each current qubit into a desired
                 new qubit.
@@ -571,7 +615,7 @@ class Operation(metaclass=abc.ABCMeta):
         if callable(qubit_map):
             transform = qubit_map
         elif isinstance(qubit_map, dict):
-            transform = lambda q: qubit_map.get(q, q)  # type: ignore
+            transform = lambda q: qubit_map.get(q, q)
         else:
             raise TypeError('qubit_map must be a function or dict mapping qubits to qubits.')
         return self.with_qubits(*(transform(q) for q in self.qubits))
@@ -644,41 +688,7 @@ class Operation(metaclass=abc.ABCMeta):
         """Determine if this Operation commutes with the object"""
         if not isinstance(other, Operation):
             return NotImplemented
-
-        self_keys = protocols.measurement_key_objs(self)
-        other_keys = protocols.measurement_key_objs(other)
-        if (
-            not self_keys.isdisjoint(other_keys)
-            or not protocols.control_keys(self).isdisjoint(other_keys)
-            or not protocols.control_keys(other).isdisjoint(self_keys)
-        ):
-            return False
-
-        if hasattr(other, 'qubits') and set(self.qubits).isdisjoint(other.qubits):
-            return True
-
-        from cirq import circuits
-
-        # Remove the classical controls to validate the quantum commutativity. This can be done
-        # because during execution, the two operations will either both be run, in which case they
-        # behave like the suboperations, so if the suboperations commute then these commute. Or
-        # one of them is cold in which case it behaves like the identity, which always commutes.
-        self_raw = self.without_classical_controls()
-        other_raw = other.without_classical_controls()
-        circuit12 = circuits.Circuit(self_raw, other_raw)
-        circuit21 = circuits.Circuit(other_raw, self_raw)
-
-        # Don't create gigantic matrices.
-        shape = protocols.qid_shape_protocol.qid_shape(circuit12)
-        if np.prod(shape, dtype=np.int64) > 2**10:
-            return NotImplemented  # pragma: no cover
-
-        m12 = protocols.unitary_protocol.unitary(circuit12, default=None)
-        m21 = protocols.unitary_protocol.unitary(circuit21, default=None)
-        if m12 is None or m21 is None:
-            return NotImplemented
-
-        return np.allclose(m12, m21, atol=atol)
+        return _operations_commutes_impl([self], [other], atol=atol)
 
     @property
     def classical_controls(self) -> FrozenSet['cirq.Condition']:
@@ -750,7 +760,8 @@ class TaggedOperation(Operation):
     Tags added can be of any type, but they should be Hashable in order
     to allow equality checking.  If you wish to serialize operations into
     JSON, you should restrict yourself to only use objects that have a JSON
-    serialization.
+    serialization.  Tags cannot be raw types and should be instantiated
+    if classes are used.
 
     See `Operation.with_tags()` for more information on intended usage.
     """
@@ -758,6 +769,8 @@ class TaggedOperation(Operation):
     def __init__(self, sub_operation: 'cirq.Operation', *tags: Hashable):
         self._sub_operation = sub_operation
         self._tags = tuple(tags)
+        if any(isinstance(tag, type) for tag in tags):
+            raise ValueError('Tags cannot be types.  Did you forget to instantiate the tag type?')
 
     @property
     def sub_operation(self) -> 'cirq.Operation':
@@ -807,6 +820,9 @@ class TaggedOperation(Operation):
         Overloads Operation.with_tags to create a new TaggedOperation
         that has the tags of this operation combined with the new_tags
         specified as the parameter.
+
+        Please note that tags should be instantiated if classes are
+        used.  Raw types are not allowed.
         """
         if not new_tags:
             return self
@@ -870,7 +886,7 @@ class TaggedOperation(Operation):
     def _has_kraus_(self) -> bool:
         return protocols.has_kraus(self.sub_operation)
 
-    def _kraus_(self) -> Union[Tuple[np.ndarray], NotImplementedType]:
+    def _kraus_(self) -> Union[Tuple[np.ndarray, ...], NotImplementedType]:
         return protocols.kraus(self.sub_operation, NotImplemented)
 
     @cached_method
@@ -886,7 +902,7 @@ class TaggedOperation(Operation):
         sub = getattr(self.sub_operation, "_is_measurement_", None)
         if sub is not None:
             return sub()
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     @cached_method
     def _is_parameterized_(self) -> bool:
@@ -930,7 +946,9 @@ class TaggedOperation(Operation):
         return protocols.trace_distance_bound(self.sub_operation)
 
     def _phase_by_(self, phase_turns: float, qubit_index: int) -> 'cirq.Operation':
-        return protocols.phase_by(self.sub_operation, phase_turns, qubit_index)
+        return protocols.phase_by(
+            self.sub_operation, phase_turns, qubit_index, default=NotImplemented
+        )
 
     def __pow__(self, exponent: Any) -> 'cirq.Operation':
         return self.sub_operation**exponent
@@ -945,7 +963,7 @@ class TaggedOperation(Operation):
         return protocols.qasm(self.sub_operation, args=args, default=None)
 
     def _equal_up_to_global_phase_(
-        self, other: Any, atol: Union[int, float] = 1e-8
+        self, other: Any, atol: float = 1e-8
     ) -> Union[NotImplementedType, bool]:
         return protocols.equal_up_to_global_phase(self.sub_operation, other, atol=atol)
 
@@ -996,7 +1014,7 @@ class _InverseCompositeGate(Gate):
         )
 
     def _has_unitary_(self):
-        from cirq import protocols, devices
+        from cirq import devices, protocols
 
         qubits = devices.LineQid.for_gate(self)
         return all(
@@ -1035,6 +1053,9 @@ class _InverseCompositeGate(Gate):
     def __str__(self) -> str:
         return f'{self._original!s}†'
 
+    def _json_dict_(self) -> Dict[str, Any]:
+        return {'original': self._original}
+
 
 def _validate_qid_shape(val: Any, qubits: Sequence['cirq.Qid']) -> None:
     """Helper function to validate qubits for gates and operations.
@@ -1057,3 +1078,78 @@ def _validate_qid_shape(val: Any, qubits: Sequence['cirq.Qid']) -> None:
         raise ValueError(
             f'Duplicate qids for <{val!r}>. Expected unique qids but got <{qubits!r}>.'
         )
+
+
+def _operations_commutes_impl(
+    ops1: Collection[Operation], ops2: Collection[Operation], *, atol: float
+) -> Union[bool, NotImplementedType]:
+    """Determine if two collections of non-overlapping Operations commute.
+
+    This function implements the commutes protocol for the Operation and Moment classes
+    and is not intended for other use.
+
+    Args:
+        ops1: The first collection of operations.  It is assumed each operation
+            acts on different qubits, i.e., the operations can form a Moment.
+        ops2: The second collection of operations to be checked for commutation
+            with `ops1`.  It is assumed each operation acts on different qubits,
+            i.e., the operations can form a Moment.
+        atol: Absolute error tolerance. If all entries in ops1@ops2 - ops2@ops1
+            have a magnitude less than this tolerance, ops1 and ops2 are considered
+            to commute.
+
+    Returns:
+        True: `ops1` and `ops2` commute (or approximately commute).
+        False: `ops1` and `ops2` do not commute.
+        NotImplemented: The commutativity cannot be determined here.
+    """
+    ops1_keys = frozenset(k for op in ops1 for k in protocols.measurement_key_objs(op))
+    ops2_keys = frozenset(k for op in ops2 for k in protocols.measurement_key_objs(op))
+    ops1_control_keys = frozenset(k for op in ops1 for k in protocols.control_keys(op))
+    ops2_control_keys = frozenset(k for op in ops2 for k in protocols.control_keys(op))
+    if (
+        not ops1_keys.isdisjoint(ops2_keys)
+        or not ops1_control_keys.isdisjoint(ops2_keys)
+        or not ops2_control_keys.isdisjoint(ops1_keys)
+    ):
+        return False
+
+    ops1_qubits = frozenset().union(*(op.qubits for op in ops1))
+    ops2_qubits = frozenset().union(*(op.qubits for op in ops2))
+    if ops1_qubits.isdisjoint(ops2_qubits):
+        return True
+
+    from cirq import circuits
+
+    # Remove the classical controls to validate the quantum commutativity. This can be done
+    # because during execution, the two operations will either both be run, in which case they
+    # behave like the suboperations, so if the suboperations commute then these commute. Or
+    # one of them is cold in which case it behaves like the identity, which always commutes.
+    shared_qubits = ops1_qubits.intersection(ops2_qubits)
+    ops1_raw = [
+        op.without_classical_controls() for op in ops1 if not shared_qubits.isdisjoint(op.qubits)
+    ]
+    ops2_raw = [
+        op.without_classical_controls() for op in ops2 if not shared_qubits.isdisjoint(op.qubits)
+    ]
+    moment1 = circuits.Moment(ops1_raw)
+    moment2 = circuits.Moment(ops2_raw)
+
+    # shortcut if we have equal moments
+    if moment1 == moment2:
+        return True
+
+    circuit12 = circuits.Circuit(moment1, moment2)
+    circuit21 = circuits.Circuit(moment2, moment1)
+
+    # Don't create gigantic matrices.
+    shape = protocols.qid_shape_protocol.qid_shape(circuit12)
+    if np.prod(shape, dtype=np.int64) > 2**10:
+        return NotImplemented  # pragma: no cover
+
+    m12 = protocols.unitary_protocol.unitary(circuit12, default=None)
+    m21 = protocols.unitary_protocol.unitary(circuit21, default=None)
+    if m12 is None or m21 is None:
+        return NotImplemented
+
+    return np.allclose(m12, m21, atol=atol)

cirq/ops/raw_types_test.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import AbstractSet, Iterator, Any
+from typing import AbstractSet, Any, Iterator
 
-import pytest
 import numpy as np
+import pytest
 import sympy
 
 import cirq
@@ -77,6 +77,13 @@ def test_wrapped_qid():
         'dimension': 3,
     }
 
+    assert not ValidQubit('zz') == 4
+    assert ValidQubit('zz') != 4
+    assert ValidQubit('zz') > ValidQubit('aa')
+    assert ValidQubit('zz') <= ValidQubit('zz')
+    assert ValidQubit('zz') >= ValidQubit('zz')
+    assert ValidQubit('zz') >= ValidQubit('aa')
+
 
 def test_qid_dimension():
     assert ValidQubit('a').dimension == 2
@@ -210,6 +217,21 @@ def test_default_validation_and_inverse():
     cirq.testing.assert_implements_consistent_protocols(i, local_vals={'TestGate': TestGate})
 
 
+def test_default_no_qubits():
+    class TestOp(cirq.Operation):
+        def with_qubits(self, *new_qubits):
+            raise NotImplementedError()
+
+        @property
+        def qubits(self):
+            pass
+
+    op = TestOp()
+    assert op.controlled_by(*[]) is op
+    op = TestOp().with_tags("abc")
+    assert op.classical_controls == frozenset()
+
+
 def test_default_inverse():
     class TestGate(cirq.Gate):
         def _num_qubits_(self):
@@ -258,6 +280,7 @@ def test_default_qudit_inverse():
         (cirq.CZ * 1, cirq.CZ / 1),
         (-cirq.CSWAP * 1j, cirq.CSWAP / 1j),
         (cirq.TOFFOLI * 0.5, cirq.TOFFOLI / 2),
+        (-cirq.X * sympy.Symbol('s'), -sympy.Symbol('s') * cirq.X),
     ),
 )
 def test_gate_algebra(expression, expected_result):
@@ -356,7 +379,7 @@ def test_gate_shape_protocol():
 def test_operation_shape():
     class FixedQids(cirq.Operation):
         def with_qubits(self, *new_qids):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
     class QubitOp(FixedQids):
         @property
@@ -458,6 +481,12 @@ def test_tagged_operation():
     assert op.with_qubits(q2).qubits == (q2,)
     assert not cirq.is_measurement(op)
 
+    # Tags can't be types
+    # This is to prevent typos of cirq.X(q1).with_tags(TagType)
+    # when you meant cirq.X(q1).with_tags(TagType())
+    with pytest.raises(ValueError, match="cannot be types"):
+        _ = cirq.X(q1).with_tags(cirq.Circuit)
+
 
 def test_with_tags_returns_same_instance_if_possible():
     untagged = cirq.X(cirq.GridQubit(1, 1))
@@ -652,6 +681,9 @@ def test_tagged_operation_forwards_protocols():
     assert isinstance(controlled_y, cirq.Operation)
     assert not isinstance(controlled_y, cirq.TaggedOperation)
     classically_controlled_y = tagged_y.with_classical_controls("a")
+    assert classically_controlled_y.classical_controls == frozenset(
+        {cirq.KeyCondition(cirq.MeasurementKey(name='a'))}
+    )
     assert classically_controlled_y == y.with_classical_controls("a")
     assert isinstance(classically_controlled_y, cirq.Operation)
     assert not isinstance(classically_controlled_y, cirq.TaggedOperation)
@@ -662,6 +694,8 @@ def test_tagged_operation_forwards_protocols():
     assert cirq.commutes(tagged_x, clifford_x)
     assert cirq.commutes(clifford_x, tagged_x)
     assert cirq.commutes(tagged_x, tagged_x)
+    assert cirq.phase_by(clifford_x, 0.125, 0, default=None) is None
+    assert cirq.phase_by(tagged_x, 0.125, 0, default=None) is None
 
     assert cirq.trace_distance_bound(y**0.001) == cirq.trace_distance_bound(
         (y**0.001).with_tags(tag)

cirq/ops/state_preparation_channel.py

@@ -14,13 +14,13 @@
 
 """Quantum gates to prepare a given target state."""
 
-from typing import Any, Dict, Tuple, Iterable, TYPE_CHECKING
+from typing import Any, Dict, Iterable, Tuple, TYPE_CHECKING
 
 import numpy as np
 
 from cirq import protocols
-from cirq.ops import raw_types
 from cirq._compat import proper_repr
+from cirq.ops import raw_types
 
 if TYPE_CHECKING:
     import cirq

cirq/ops/state_preparation_channel_test.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 
 import numpy as np
-import cirq
 import pytest
 
+import cirq
+
 
 @pytest.mark.parametrize(
     'state',

cirq/ops/swap_gates.py

@@ -25,7 +25,7 @@ raised to a power (i.e. SQRT_ISWAP_INV=cirq.ISWAP**-0.5). See the definition in
 EigenGate.
 """
 
-from typing import Optional, Tuple, TYPE_CHECKING, List
+from typing import cast, List, Optional, Tuple, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -33,7 +33,7 @@ import sympy
 from cirq import protocols, value
 from cirq._compat import proper_repr
 from cirq._doc import document
-from cirq.ops import common_gates, gate_features, eigen_gate
+from cirq.ops import common_gates, eigen_gate, gate_features
 
 if TYPE_CHECKING:
     import cirq
@@ -148,7 +148,7 @@ class SwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate)
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
         if self._exponent != 1:
             return None  # Don't have an equivalent gate in QASM
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         return args.format('swap {0},{1};\n', qubits[0], qubits[1])
 
     def __str__(self) -> str:
@@ -219,6 +219,11 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
         ]
         # yapf: enable
 
+    def _has_stabilizer_effect_(self) -> Optional[bool]:
+        if self._is_parameterized_():
+            return None
+        return self.exponent % 1 == 0
+
     def _decompose_(self, qubits):
         a, b = qubits
 
@@ -294,7 +299,7 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
 def riswap(rads: value.TParamVal) -> ISwapPowGate:
     """Returns gate with matrix exp(+i angle_rads (X⊗X + Y⊗Y) / 2)."""
     pi = sympy.pi if protocols.is_parameterized(rads) else np.pi
-    return ISwapPowGate() ** (2 * rads / pi)
+    return cast(ISwapPowGate, ISwapPowGate() ** (2 * rads / pi))
 
 
 SWAP = SwapPowGate()

cirq/ops/three_qubit_gates.py

@@ -19,6 +19,7 @@ from typing import (
     Any,
     Collection,
     Dict,
+    Iterator,
     List,
     Optional,
     Sequence,
@@ -35,15 +36,14 @@ from cirq._compat import proper_repr
 from cirq._doc import document
 from cirq.ops import (
     common_gates,
+    control_values as cv,
     controlled_gate,
     eigen_gate,
     gate_features,
+    global_phase_op,
     pauli_gates,
     raw_types,
     swap_gates,
-    raw_types,
-    control_values as cv,
-    global_phase_op,
 )
 
 if TYPE_CHECKING:
@@ -163,7 +163,7 @@ class CCZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         if self._exponent != 1:
             return None
 
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         lines = [
             args.format('h {0};\n', qubits[2]),
             args.format('ccx {0},{1},{2};\n', qubits[0], qubits[1], qubits[2]),
@@ -482,7 +482,7 @@ class CCXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         if self._exponent != 1:
             return None
 
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         return args.format('ccx {0},{1},{2};\n', qubits[0], qubits[1], qubits[2])
 
     def __repr__(self) -> str:
@@ -573,7 +573,7 @@ class CSwapGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
 
     def _decompose_inside_control(
         self, target1: 'cirq.Qid', control: 'cirq.Qid', target2: 'cirq.Qid'
-    ) -> 'cirq.OP_TREE':
+    ) -> Iterator['cirq.OP_TREE']:
         """A decomposition assuming the control separates the targets.
 
         target1: ─@─X───────T──────@────────@─────────X───@─────X^-0.5─
@@ -617,7 +617,7 @@ class CSwapGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
 
     def _decompose_outside_control(
         self, control: 'cirq.Qid', near_target: 'cirq.Qid', far_target: 'cirq.Qid'
-    ) -> 'cirq.OP_TREE':
+    ) -> Iterator['cirq.OP_TREE']:
         """A decomposition assuming one of the targets is in the middle.
 
         control: ───T──────@────────@───@────────────@────────────────
@@ -660,7 +660,7 @@ class CSwapGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         return protocols.CircuitDiagramInfo(('@', '×', '×'))
 
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         return args.format('cswap {0},{1},{2};\n', qubits[0], qubits[1], qubits[2])
 
     def _value_equality_values_(self):

cirq/ops/three_qubit_gates_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import itertools
+
 import numpy as np
 import pytest
 import sympy

cirq/ops/two_qubit_diagonal_gate.py

@@ -18,13 +18,14 @@ The gate is used to create a 4x4 matrix with the diagonal elements
 passed as a list.
 """
 
-from typing import AbstractSet, Any, Dict, Tuple, Optional, Sequence, TYPE_CHECKING
+from typing import AbstractSet, Any, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
+
 import numpy as np
 import sympy
 
 from cirq import protocols, value
 from cirq._compat import proper_repr
-from cirq.ops import raw_types, common_gates
+from cirq.ops import common_gates, raw_types
 
 if TYPE_CHECKING:
     import cirq
@@ -93,7 +94,7 @@ class TwoQubitDiagonalGate(raw_types.Gate):
             return None
         return np.diag([np.exp(1j * angle) for angle in self._diag_angles_radians])
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
         x0, x1, x2, x3 = self._diag_angles_radians
         q0, q1 = qubits
         yield common_gates.ZPowGate(exponent=x2 / np.pi).on(q0)

cirq/ops/uniform_superposition_gate.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Sequence, Any, Dict, TYPE_CHECKING
+from typing import Any, Dict, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
+
+from cirq.ops import raw_types
 from cirq.ops.common_gates import H, ry
 from cirq.ops.pauli_gates import X
-from cirq.ops import raw_types
-
 
 if TYPE_CHECKING:
     import cirq
@@ -58,7 +58,7 @@ class UniformSuperpositionGate(raw_types.Gate):
         self._m_value = m_value
         self._num_qubits = num_qubits
 
-    def _decompose_(self, qubits: Sequence["cirq.Qid"]) -> "cirq.OP_TREE":
+    def _decompose_(self, qubits: Sequence["cirq.Qid"]) -> Iterator["cirq.OP_TREE"]:
         """Decomposes the gate into a sequence of standard gates.
         Implements the construction from https://arxiv.org/pdf/2306.11747.
         """

cirq/ops/uniform_superposition_gate_test.py

@@ -14,6 +14,7 @@
 
 import numpy as np
 import pytest
+
 import cirq
 
 

cirq/ops/wait_gate.py

@@ -11,11 +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 typing import AbstractSet, Any, Dict, Optional, Tuple, TYPE_CHECKING, Union
+from typing import AbstractSet, Any, Dict, Optional, Tuple, TYPE_CHECKING
 
-import sympy
-
-from cirq import value, protocols
+from cirq import protocols, value
 from cirq.ops import raw_types
 
 if TYPE_CHECKING:
@@ -136,10 +134,10 @@ class WaitGate(raw_types.Gate):
 def wait(
     *target: 'cirq.Qid',
     duration: 'cirq.DURATION_LIKE' = None,
-    picos: Union[int, float, sympy.Expr] = 0,
-    nanos: Union[int, float, sympy.Expr] = 0,
-    micros: Union[int, float, sympy.Expr] = 0,
-    millis: Union[int, float, sympy.Expr] = 0,
+    picos: 'cirq.TParamVal' = 0,
+    nanos: 'cirq.TParamVal' = 0,
+    micros: 'cirq.TParamVal' = 0,
+    millis: 'cirq.TParamVal' = 0,
 ) -> raw_types.Operation:
     """Creates a WaitGate applied to all the given qubits.