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

cirq/circuits/moment.py

@@ -14,7 +14,11 @@
 
 """A simplified time-slice of operations within a sequenced circuit."""
 
+from __future__ import annotations
+
 import itertools
+from functools import cached_property
+from types import NotImplementedType
 from typing import (
     AbstractSet,
     Any,
@@ -26,35 +30,34 @@ from typing import (
     Iterator,
     List,
     Mapping,
-    overload,
     Optional,
+    overload,
     Sequence,
     Tuple,
     TYPE_CHECKING,
     Union,
 )
-from typing_extensions import Self
 
 import numpy as np
+from typing_extensions import Self
 
-from cirq import protocols, ops, qis, _compat
+from cirq import _compat, ops, protocols, qis
 from cirq._import import LazyLoader
-from cirq.ops import raw_types, op_tree
+from cirq.ops import op_tree, raw_types
 from cirq.protocols import circuit_diagram_info_protocol
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
 
 # Lazy imports to break circular dependencies.
-circuits = LazyLoader("circuits", globals(), "cirq.circuits.circuit")
+circuit = LazyLoader("circuit", globals(), "cirq.circuits.circuit")
 op_tree = LazyLoader("op_tree", globals(), "cirq.ops.op_tree")
 text_diagram_drawer = LazyLoader(
     "text_diagram_drawer", globals(), "cirq.circuits.text_diagram_drawer"
 )
 
 
-def _default_breakdown(qid: 'cirq.Qid') -> Tuple[Any, Any]:
+def _default_breakdown(qid: cirq.Qid) -> Tuple[Any, Any]:
     # Attempt to convert into a position on the complex plane.
     try:
         plane_pos = complex(qid)  # type: ignore
@@ -81,7 +84,7 @@ class Moment:
             are no such operations, returns an empty Moment.
     """
 
-    def __init__(self, *contents: 'cirq.OP_TREE', _flatten_contents: bool = True) -> None:
+    def __init__(self, *contents: cirq.OP_TREE, _flatten_contents: bool = True) -> None:
         """Constructs a moment with the given operations.
 
         Args:
@@ -101,10 +104,10 @@ class Moment:
             if _flatten_contents
             else cast(Tuple['cirq.Operation'], contents)
         )
-        self._sorted_operations: Optional[Tuple['cirq.Operation', ...]] = None
+        self._sorted_operations: Optional[Tuple[cirq.Operation, ...]] = None
 
         # An internal dictionary to support efficient operation access by qubit.
-        self._qubit_to_op: Dict['cirq.Qid', 'cirq.Operation'] = {}
+        self._qubit_to_op: Dict[cirq.Qid, cirq.Operation] = {}
         for op in self.operations:
             for q in op.qubits:
                 # Check that operations don't overlap.
@@ -112,12 +115,11 @@ class Moment:
                     raise ValueError(f'Overlapping operations: {self.operations}')
                 self._qubit_to_op[q] = op
 
-        self._qubits = frozenset(self._qubit_to_op.keys())
-        self._measurement_key_objs: Optional[FrozenSet['cirq.MeasurementKey']] = None
-        self._control_keys: Optional[FrozenSet['cirq.MeasurementKey']] = None
+        self._measurement_key_objs: Optional[FrozenSet[cirq.MeasurementKey]] = None
+        self._control_keys: Optional[FrozenSet[cirq.MeasurementKey]] = None
 
     @classmethod
-    def from_ops(cls, *ops: 'cirq.Operation') -> 'cirq.Moment':
+    def from_ops(cls, *ops: cirq.Operation) -> cirq.Moment:
         """Construct a Moment from the given operations.
 
         This avoids calling `flatten_to_ops` in the moment constructor, which
@@ -131,14 +133,14 @@ class Moment:
         return cls(*ops, _flatten_contents=False)
 
     @property
-    def operations(self) -> Tuple['cirq.Operation', ...]:
+    def operations(self) -> Tuple[cirq.Operation, ...]:
         return self._operations
 
-    @property
-    def qubits(self) -> FrozenSet['cirq.Qid']:
-        return self._qubits
+    @cached_property
+    def qubits(self) -> FrozenSet[cirq.Qid]:
+        return frozenset(self._qubit_to_op)
 
-    def operates_on_single_qubit(self, qubit: 'cirq.Qid') -> bool:
+    def operates_on_single_qubit(self, qubit: cirq.Qid) -> bool:
         """Determines if the moment has operations touching the given qubit.
         Args:
             qubit: The qubit that may or may not be touched by operations.
@@ -147,7 +149,7 @@ class Moment:
         """
         return qubit in self._qubit_to_op
 
-    def operates_on(self, qubits: Iterable['cirq.Qid']) -> bool:
+    def operates_on(self, qubits: Iterable[cirq.Qid]) -> bool:
         """Determines if the moment has operations touching the given qubits.
 
         Args:
@@ -156,9 +158,9 @@ class Moment:
         Returns:
             Whether this moment has operations involving the qubits.
         """
-        return not self._qubits.isdisjoint(qubits)
+        return not self._qubit_to_op.keys().isdisjoint(qubits)
 
-    def operation_at(self, qubit: raw_types.Qid) -> Optional['cirq.Operation']:
+    def operation_at(self, qubit: raw_types.Qid) -> Optional[cirq.Operation]:
         """Returns the operation on a certain qubit for the moment.
 
         Args:
@@ -172,7 +174,7 @@ class Moment:
             return self.__getitem__(qubit)
         return None
 
-    def with_operation(self, operation: 'cirq.Operation') -> 'cirq.Moment':
+    def with_operation(self, operation: cirq.Operation) -> cirq.Moment:
         """Returns an equal moment, but with the given op added.
 
         Args:
@@ -184,14 +186,13 @@ class Moment:
         Raises:
             ValueError: If the operation given overlaps a current operation in the moment.
         """
-        if any(q in self._qubits for q in operation.qubits):
+        if any(q in self._qubit_to_op for q in operation.qubits):
             raise ValueError(f'Overlapping operations: {operation}')
 
         # Use private variables to facilitate a quick copy.
         m = Moment(_flatten_contents=False)
         m._operations = self._operations + (operation,)
         m._sorted_operations = None
-        m._qubits = self._qubits.union(operation.qubits)
         m._qubit_to_op = {**self._qubit_to_op, **{q: operation for q in operation.qubits}}
 
         m._measurement_key_objs = self._measurement_key_objs_().union(
@@ -201,7 +202,7 @@ class Moment:
 
         return m
 
-    def with_operations(self, *contents: 'cirq.OP_TREE') -> 'cirq.Moment':
+    def with_operations(self, *contents: cirq.OP_TREE) -> cirq.Moment:
         """Returns a new moment with the given contents added.
 
         Args:
@@ -221,14 +222,11 @@ class Moment:
         m = Moment(_flatten_contents=False)
         # Use private variables to facilitate a quick copy.
         m._qubit_to_op = self._qubit_to_op.copy()
-        qubits = set(self._qubits)
         for op in flattened_contents:
-            if any(q in qubits for q in op.qubits):
+            if any(q in m._qubit_to_op for q in op.qubits):
                 raise ValueError(f'Overlapping operations: {op}')
-            qubits.update(op.qubits)
             for q in op.qubits:
                 m._qubit_to_op[q] = op
-        m._qubits = frozenset(qubits)
 
         m._operations = self._operations + flattened_contents
         m._sorted_operations = None
@@ -241,7 +239,7 @@ class Moment:
 
         return m
 
-    def without_operations_touching(self, qubits: Iterable['cirq.Qid']) -> 'cirq.Moment':
+    def without_operations_touching(self, qubits: Iterable[cirq.Qid]) -> cirq.Moment:
         """Returns an equal moment, but without ops on the given qubits.
 
         Args:
@@ -267,15 +265,16 @@ class Moment:
     def _parameter_names_(self) -> AbstractSet[str]:
         return {name for op in self for name in protocols.parameter_names(op)}
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.Moment':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> cirq.Moment:
         changed = False
-        resolved_ops: List['cirq.Operation'] = []
+        resolved_ops: List[cirq.Operation] = []
         for op in self:
             resolved_op = protocols.resolve_parameters(op, resolver, recursive)
-            if resolved_op != op:
-                changed = True
+            changed = (
+                changed
+                or resolved_op != op
+                or (protocols.is_parameterized(op) and not protocols.is_parameterized(resolved_op))
+            )
             resolved_ops.append(resolved_op)
         if not changed:
             return self
@@ -295,21 +294,21 @@ class Moment:
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return frozenset(str(key) for key in self._measurement_key_objs_())
 
-    def _measurement_key_objs_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
         if self._measurement_key_objs is None:
             self._measurement_key_objs = frozenset(
                 key for op in self.operations for key in protocols.measurement_key_objs(op)
             )
         return self._measurement_key_objs
 
-    def _control_keys_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
         if self._control_keys is None:
             self._control_keys = frozenset(
                 k for op in self.operations for k in protocols.control_keys(op)
             )
         return self._control_keys
 
-    def _sorted_operations_(self) -> Tuple['cirq.Operation', ...]:
+    def _sorted_operations_(self) -> Tuple[cirq.Operation, ...]:
         if self._sorted_operations is None:
             self._sorted_operations = tuple(sorted(self._operations, key=lambda op: op.qubits))
         return self._sorted_operations
@@ -331,7 +330,7 @@ class Moment:
         )
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
     ):
         return Moment(
             protocols.with_rescoped_keys(op, path, bindable_keys) for op in self.operations
@@ -349,7 +348,7 @@ class Moment:
 
         return self is other or self._sorted_operations_() == other._sorted_operations_()
 
-    def _approx_eq_(self, other: Any, atol: Union[int, float]) -> bool:
+    def _approx_eq_(self, other: Any, atol: float) -> bool:
         """See `cirq.protocols.SupportsApproximateEquality`."""
         if not isinstance(other, type(self)):
             return NotImplemented
@@ -365,7 +364,16 @@ class Moment:
     def __hash__(self):
         return hash((Moment, self._sorted_operations_()))
 
-    def __iter__(self) -> Iterator['cirq.Operation']:
+    def __getstate__(self) -> Dict[str, Any]:
+        # clear cached hash value when pickling, see #6674
+        state = self.__dict__
+        hash_attr = _compat._method_cache_name(self.__hash__)
+        if hash_attr in state:
+            state = state.copy()
+            del state[hash_attr]
+        return state
+
+    def __iter__(self) -> Iterator[cirq.Operation]:
         return iter(self.operations)
 
     def __pow__(self, power):
@@ -394,12 +402,12 @@ class Moment:
     def __str__(self) -> str:
         return self.to_text_diagram()
 
-    def _decompose_(self) -> 'cirq.OP_TREE':
+    def _decompose_(self) -> cirq.OP_TREE:
         """See `cirq.SupportsDecompose`."""
         return self._operations
 
     def transform_qubits(
-        self, qubit_map: Union[Dict['cirq.Qid', 'cirq.Qid'], Callable[['cirq.Qid'], 'cirq.Qid']]
+        self, qubit_map: Union[Dict[cirq.Qid, cirq.Qid], Callable[[cirq.Qid], cirq.Qid]]
     ) -> Self:
         """Returns the same moment, but with different qubits.
 
@@ -413,7 +421,7 @@ class Moment:
         """
         return self.__class__(op.transform_qubits(qubit_map) for op in self.operations)
 
-    def expand_to(self, qubits: Iterable['cirq.Qid']) -> 'cirq.Moment':
+    def expand_to(self, qubits: Iterable[cirq.Qid]) -> cirq.Moment:
         """Returns self expanded to given superset of qubits by making identities explicit.
 
         Args:
@@ -437,7 +445,9 @@ class Moment:
     @_compat.cached_method()
     def _has_kraus_(self) -> bool:
         """Returns True if self has a Kraus representation and self uses <= 10 qubits."""
-        return all(protocols.has_kraus(op) for op in self.operations) and len(self.qubits) <= 10
+        return (
+            all(protocols.has_kraus(op) for op in self.operations) and len(self._qubit_to_op) <= 10
+        )
 
     def _kraus_(self) -> Sequence[np.ndarray]:
         r"""Returns Kraus representation of self.
@@ -462,7 +472,7 @@ class Moment:
         if not self._has_kraus_():
             return NotImplemented
 
-        qubits = sorted(self.qubits)
+        qubits = sorted(self._qubit_to_op)
         n = len(qubits)
         if n < 1:
             return (np.array([[1 + 0j]]),)
@@ -470,13 +480,13 @@ class Moment:
         qubit_to_row_subscript = dict(zip(qubits, 'abcdefghij'))
         qubit_to_col_subscript = dict(zip(qubits, 'ABCDEFGHIJ'))
 
-        def row_subscripts(qs: Sequence['cirq.Qid']) -> str:
+        def row_subscripts(qs: Sequence[cirq.Qid]) -> str:
             return ''.join(qubit_to_row_subscript[q] for q in qs)
 
-        def col_subscripts(qs: Sequence['cirq.Qid']) -> str:
+        def col_subscripts(qs: Sequence[cirq.Qid]) -> str:
             return ''.join(qubit_to_col_subscript[q] for q in qs)
 
-        def kraus_tensors(op: 'cirq.Operation') -> Sequence[np.ndarray]:
+        def kraus_tensors(op: cirq.Operation) -> Sequence[np.ndarray]:
             return tuple(np.reshape(k, (2, 2) * len(op.qubits)) for k in protocols.kraus(op))
 
         input_subscripts = ','.join(
@@ -513,12 +523,12 @@ class Moment:
     def _from_json_dict_(cls, operations, **kwargs):
         return cls.from_ops(*operations)
 
-    def __add__(self, other: 'cirq.OP_TREE') -> 'cirq.Moment':
-        if isinstance(other, circuits.AbstractCircuit):
+    def __add__(self, other: cirq.OP_TREE) -> cirq.Moment:
+        if isinstance(other, circuit.AbstractCircuit):
             return NotImplemented  # Delegate to Circuit.__radd__.
         return self.with_operations(other)
 
-    def __sub__(self, other: 'cirq.OP_TREE') -> 'cirq.Moment':
+    def __sub__(self, other: cirq.OP_TREE) -> cirq.Moment:
         must_remove = set(op_tree.flatten_to_ops(other))
         new_ops = []
         for op in self.operations:
@@ -536,11 +546,11 @@ class Moment:
 
     # pylint: disable=function-redefined
     @overload
-    def __getitem__(self, key: raw_types.Qid) -> 'cirq.Operation':
+    def __getitem__(self, key: raw_types.Qid) -> cirq.Operation:
         pass
 
     @overload
-    def __getitem__(self, key: Iterable[raw_types.Qid]) -> 'cirq.Moment':
+    def __getitem__(self, key: Iterable[raw_types.Qid]) -> cirq.Moment:
         pass
 
     def __getitem__(self, key):
@@ -557,10 +567,10 @@ class Moment:
             return Moment(frozenset(ops_to_keep))
 
     def to_text_diagram(
-        self: 'cirq.Moment',
+        self: cirq.Moment,
         *,
-        xy_breakdown_func: Callable[['cirq.Qid'], Tuple[Any, Any]] = _default_breakdown,
-        extra_qubits: Iterable['cirq.Qid'] = (),
+        xy_breakdown_func: Callable[[cirq.Qid], Tuple[Any, Any]] = _default_breakdown,
+        extra_qubits: Iterable[cirq.Qid] = (),
         use_unicode_characters: bool = True,
         precision: Optional[int] = None,
         include_tags: bool = True,
@@ -589,7 +599,7 @@ class Moment:
         """
 
         # Figure out where to place everything.
-        qs = set(self.qubits) | set(extra_qubits)
+        qs = self._qubit_to_op.keys() | set(extra_qubits)
         points = {xy_breakdown_func(q) for q in qs}
         x_keys = sorted({pt[0] for pt in points}, key=_SortByValFallbackToType)
         y_keys = sorted({pt[1] for pt in points}, key=_SortByValFallbackToType)
@@ -648,37 +658,26 @@ class Moment:
         return diagram.render()
 
     def _commutes_(self, other: Any, *, atol: float = 1e-8) -> Union[bool, NotImplementedType]:
-        """Determines whether Moment commutes with the Operation.
+        """Determines whether Moment commutes with the other Moment or Operation.
 
         Args:
-            other: An Operation object. Other types are not implemented yet.
-                In case a different type is specified, NotImplemented is
-                returned.
+            other: An Operation or Moment object to test for commutativity.
             atol: Absolute error tolerance. If all entries in v1@v2 - v2@v1
                 have a magnitude less than this tolerance, v1 and v2 can be
                 reported as commuting. Defaults to 1e-8.
 
         Returns:
-            True: The Moment and Operation commute OR they don't have shared
-            quibits.
+            True: The Moment commutes with Moment or Operation OR they don't
+                have shared qubits.
             False: The two values do not commute.
             NotImplemented: In case we don't know how to check this, e.g.
-                the parameter type is not supported yet.
+                the parameter type is not supported or commutativity cannot be
+                determined.
         """
-        if not isinstance(other, ops.Operation):
+        if not isinstance(other, (ops.Operation, Moment)):
             return NotImplemented
-
-        other_qubits = set(other.qubits)
-        for op in self.operations:
-            if not other_qubits.intersection(set(op.qubits)):
-                continue
-
-            commutes = protocols.commutes(op, other, atol=atol, default=NotImplemented)
-
-            if not commutes or commutes is NotImplemented:
-                return commutes
-
-        return True
+        other_operations = other.operations if isinstance(other, Moment) else (other,)
+        return raw_types._operations_commutes_impl(self.operations, other_operations, atol=atol)
 
 
 class _SortByValFallbackToType:

cirq/circuits/moment_test.py

@@ -294,6 +294,14 @@ def test_resolve_parameters():
     moment = cirq.Moment(cirq.X(a) ** sympy.Symbol('v'), cirq.Y(b) ** sympy.Symbol('w'))
     resolved_moment = cirq.resolve_parameters(moment, cirq.ParamResolver({'v': 0.1, 'w': 0.2}))
     assert resolved_moment == cirq.Moment(cirq.X(a) ** 0.1, cirq.Y(b) ** 0.2)
+    # sympy constant is resolved to a Python number
+    moment = cirq.Moment(cirq.Rz(rads=sympy.pi).on(a))
+    resolved_moment = cirq.resolve_parameters(moment, {'pi': np.pi})
+    assert resolved_moment == cirq.Moment(cirq.Rz(rads=np.pi).on(a))
+    resolved_gate = resolved_moment.operations[0].gate
+    assert not isinstance(resolved_gate.exponent, sympy.Basic)
+    assert isinstance(resolved_gate.exponent, float)
+    assert not cirq.is_parameterized(resolved_moment)
 
 
 def test_resolve_parameters_no_change():
@@ -672,7 +680,7 @@ def test_text_diagram_does_not_depend_on_insertion_order():
     assert str(m1) == str(m2)
 
 
-def test_commutes():
+def test_commutes_moment_and_operation():
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -680,7 +688,7 @@ def test_commutes():
 
     moment = cirq.Moment([cirq.X(a), cirq.Y(b), cirq.H(c)])
 
-    assert NotImplemented == cirq.commutes(moment, a, default=NotImplemented)
+    assert cirq.commutes(moment, a, default=None) is None
 
     assert cirq.commutes(moment, cirq.X(a))
     assert cirq.commutes(moment, cirq.Y(b))
@@ -692,6 +700,101 @@ def test_commutes():
     assert not cirq.commutes(moment, cirq.H(b))
     assert not cirq.commutes(moment, cirq.X(c))
 
+    # Empty moment commutes with everything
+    moment = cirq.Moment()
+    assert cirq.commutes(moment, cirq.X(a))
+    assert cirq.commutes(moment, cirq.measure(b))
+
+    # Two qubit operation
+    moment = cirq.Moment(cirq.Z(a), cirq.Z(b))
+    assert cirq.commutes(moment, cirq.XX(a, b))
+
+
+def test_commutes_moment_and_moment():
+    a = cirq.NamedQubit('a')
+    b = cirq.NamedQubit('b')
+    c = cirq.NamedQubit('c')
+
+    # Test cases where individual operations don't commute but moments do
+    # Two Z gates (Z⊗Z) commutes with RXX even though individual Z's don't
+    assert not cirq.commutes(cirq.Moment(cirq.Z(a)), cirq.Moment(cirq.XX(a, b)))
+    assert cirq.commutes(cirq.Moment(cirq.Z(a), cirq.Z(b)), cirq.Moment(cirq.XX(a, b)))
+
+    # Moments that do not commute if acting on same qubits
+    assert cirq.commutes(cirq.Moment(cirq.X(a)), cirq.Moment(cirq.Y(b)))
+    assert not cirq.commutes(cirq.Moment(cirq.X(a)), cirq.Moment(cirq.Y(a)))
+
+    # Moments commute with themselves
+    assert cirq.commutes(
+        cirq.Moment([cirq.X(a), cirq.Y(b), cirq.H(c)]),
+        cirq.Moment([cirq.X(a), cirq.Y(b), cirq.H(c)]),
+    )
+
+
+def test_commutes_moment_with_controls():
+    a, b = cirq.LineQubit.range(2)
+    assert cirq.commutes(
+        cirq.Moment(cirq.measure(a, key='k0')), cirq.Moment(cirq.X(b).with_classical_controls('k1'))
+    )
+    assert cirq.commutes(
+        cirq.Moment(cirq.X(b).with_classical_controls('k1')), cirq.Moment(cirq.measure(a, key='k0'))
+    )
+    assert cirq.commutes(
+        cirq.Moment(cirq.X(a).with_classical_controls('k0')),
+        cirq.Moment(cirq.H(b).with_classical_controls('k0')),
+    )
+    assert cirq.commutes(
+        cirq.Moment(cirq.X(a).with_classical_controls('k0')),
+        cirq.Moment(cirq.X(a).with_classical_controls('k0')),
+    )
+    assert not cirq.commutes(
+        cirq.Moment(cirq.measure(a, key='k0')), cirq.Moment(cirq.X(b).with_classical_controls('k0'))
+    )
+    assert not cirq.commutes(
+        cirq.Moment(cirq.X(b).with_classical_controls('k0')), cirq.Moment(cirq.measure(a, key='k0'))
+    )
+    assert not cirq.commutes(
+        cirq.Moment(cirq.X(a).with_classical_controls('k0')),
+        cirq.Moment(cirq.H(a).with_classical_controls('k0')),
+    )
+
+
+def test_commutes_moment_and_moment_comprehensive():
+    a, b, c, d = cirq.LineQubit.range(4)
+
+    # Basic Z⊗Z commuting with XX at different angles
+    m1 = cirq.Moment([cirq.Z(a), cirq.Z(b)])
+    m2 = cirq.Moment([cirq.XXPowGate(exponent=0.5)(a, b)])
+    assert cirq.commutes(m1, m2)
+
+    # Disjoint qubit sets
+    m1 = cirq.Moment([cirq.X(a), cirq.Y(b)])
+    m2 = cirq.Moment([cirq.Z(c), cirq.H(d)])
+    assert cirq.commutes(m1, m2)
+
+    # Mixed case - some commute individually, some as group
+    m1 = cirq.Moment([cirq.Z(a), cirq.Z(b), cirq.X(c)])
+    m2 = cirq.Moment([cirq.XXPowGate(exponent=0.5)(a, b), cirq.X(c)])
+    assert cirq.commutes(m1, m2)
+
+    # Non-commuting case: X on first qubit, Z on second with XX gate
+    m1 = cirq.Moment([cirq.X(a), cirq.Z(b)])
+    m2 = cirq.Moment([cirq.XX(a, b)])
+    assert not cirq.commutes(m1, m2)
+
+    # Complex case requiring unitary calculation - non-commuting case
+    m1 = cirq.Moment([cirq.Z(a), cirq.Z(b), cirq.Z(c)])
+    m2 = cirq.Moment([cirq.XXPowGate(exponent=0.5)(a, b), cirq.X(c)])
+    assert not cirq.commutes(m1, m2)  # Z⊗Z⊗Z doesn't commute with XX⊗X
+
+
+def test_commutes_handles_non_unitary_operation():
+    a = cirq.NamedQubit('a')
+    op_damp_a = cirq.AmplitudeDampingChannel(gamma=0.1).on(a)
+    assert cirq.commutes(cirq.Moment(cirq.X(a)), op_damp_a, default=None) is None
+    assert cirq.commutes(cirq.Moment(cirq.X(a)), cirq.Moment(op_damp_a), default=None) is None
+    assert cirq.commutes(cirq.Moment(op_damp_a), cirq.Moment(op_damp_a))
+
 
 def test_transform_qubits():
     a, b = cirq.LineQubit.range(2)

cirq/circuits/optimization_pass.py

@@ -13,15 +13,17 @@
 # limitations under the License.
 
 """Defines the OptimizationPass type."""
+
+from __future__ import annotations
+
 import abc
 from collections import defaultdict
-from typing import Dict, Callable, Iterable, Optional, Sequence, TYPE_CHECKING, Tuple, cast
+from typing import Callable, cast, Dict, Iterable, Optional, Sequence, Tuple, TYPE_CHECKING
 
 from cirq import ops
 
 if TYPE_CHECKING:
     import cirq
-    from cirq.ops import Qid
 
 
 class PointOptimizationSummary:
@@ -30,8 +32,8 @@ class PointOptimizationSummary:
     def __init__(
         self,
         clear_span: int,
-        clear_qubits: Iterable['cirq.Qid'],
-        new_operations: 'cirq.OP_TREE',
+        clear_qubits: Iterable[cirq.Qid],
+        new_operations: cirq.OP_TREE,
         preserve_moments: bool = False,
     ) -> None:
         """Inits PointOptimizationSummary.
@@ -87,9 +89,7 @@ class PointOptimizer:
 
     def __init__(
         self,
-        post_clean_up: Callable[
-            [Sequence['cirq.Operation']], 'cirq.OP_TREE'
-        ] = lambda op_list: op_list,
+        post_clean_up: Callable[[Sequence[cirq.Operation]], cirq.OP_TREE] = lambda op_list: op_list,
     ) -> None:
         """Inits PointOptimizer.
 
@@ -100,13 +100,13 @@ class PointOptimizer:
         """
         self.post_clean_up = post_clean_up
 
-    def __call__(self, circuit: 'cirq.Circuit'):
+    def __call__(self, circuit: cirq.Circuit):
         return self.optimize_circuit(circuit)
 
     @abc.abstractmethod
     def optimization_at(
-        self, circuit: 'cirq.Circuit', index: int, op: 'cirq.Operation'
-    ) -> Optional['cirq.PointOptimizationSummary']:
+        self, circuit: cirq.Circuit, index: int, op: cirq.Operation
+    ) -> Optional[cirq.PointOptimizationSummary]:
         """Describes how to change operations near the given location.
 
         For example, this method could realize that the given operation is an
@@ -126,8 +126,8 @@ class PointOptimizer:
             change should be made.
         """
 
-    def optimize_circuit(self, circuit: 'cirq.Circuit'):
-        frontier: Dict['Qid', int] = defaultdict(lambda: 0)
+    def optimize_circuit(self, circuit: cirq.Circuit):
+        frontier: Dict[cirq.Qid, int] = defaultdict(lambda: 0)
         i = 0
         while i < len(circuit):  # Note: circuit may mutate as we go.
             for op in circuit[i].operations:
@@ -137,14 +137,14 @@ class PointOptimizer:
 
                 # Skip if an optimization removed the circuit underneath us.
                 if i >= len(circuit):
-                    continue
+                    continue  # pragma: no cover
                 # Skip if an optimization removed the op we're considering.
                 if op not in circuit[i].operations:
-                    continue
+                    continue  # pragma: no cover
                 opt = self.optimization_at(circuit, i, op)
                 # Skip if the optimization did nothing.
                 if opt is None:
-                    continue
+                    continue  # pragma: no cover
 
                 # Clear target area, and insert new operations.
                 circuit.clear_operations_touching(