Merge branch 'main' into u/maffoo/moment-eq

Author: maffoo

cirq-core/cirq/_compat.py

@@ -67,6 +67,10 @@ def with_debug(value: bool) -> Iterator[None]:
     from backports.cached_property import cached_property  # type: ignore[no-redef]
 
 
+# Sentinel used by wrapped_no_args below when method has not yet been cached.
+_NOT_FOUND = object()
+
+
 TFunc = TypeVar('TFunc', bound=Callable)
 
 
@@ -103,9 +107,11 @@ def decorator(func):
 
             @functools.wraps(func)
             def wrapped_no_args(self):
-                if not hasattr(self, cache_name):
-                    object.__setattr__(self, cache_name, func(self))
-                return getattr(self, cache_name)
+                result = getattr(self, cache_name, _NOT_FOUND)
+                if result is _NOT_FOUND:
+                    result = func(self)
+                    object.__setattr__(self, cache_name, result)
+                return result
 
             return wrapped_no_args
 

cirq-core/cirq/circuits/circuit.py

@@ -29,14 +29,14 @@
     AbstractSet,
     Any,
     Callable,
-    Mapping,
-    MutableSequence,
     cast,
     Dict,
     FrozenSet,
     Iterable,
     Iterator,
     List,
+    Mapping,
+    MutableSequence,
     Optional,
     overload,
     Sequence,
@@ -58,9 +58,9 @@
 from cirq.circuits._bucket_priority_queue import BucketPriorityQueue
 from cirq.circuits.circuit_operation import CircuitOperation
 from cirq.circuits.insert_strategy import InsertStrategy
+from cirq.circuits.moment import Moment
 from cirq.circuits.qasm_output import QasmOutput
 from cirq.circuits.text_diagram_drawer import TextDiagramDrawer
-from cirq.circuits.moment import Moment
 from cirq.protocols import circuit_diagram_info_protocol
 from cirq.type_workarounds import NotImplementedType
 
@@ -203,19 +203,24 @@ def unfreeze(self, copy: bool = True) -> 'cirq.Circuit':
             copy: If True and 'self' is a Circuit, returns a copy that circuit.
         """
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return bool(self.moments)
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         if not isinstance(other, AbstractCircuit):
             return NotImplemented
-        return tuple(self.moments) == tuple(other.moments)
+        return other is self or (
+            len(self.moments) == len(other.moments)
+            and all(m0 == m1 for m0, m1 in zip(self.moments, other.moments))
+        )
 
     def _approx_eq_(self, other: Any, atol: Union[int, float]) -> bool:
         """See `cirq.protocols.SupportsApproximateEquality`."""
         if not isinstance(other, AbstractCircuit):
             return NotImplemented
-        return cirq.protocols.approx_eq(tuple(self.moments), tuple(other.moments), atol=atol)
+        return other is self or cirq.protocols.approx_eq(
+            tuple(self.moments), tuple(other.moments), atol=atol
+        )
 
     def __ne__(self, other) -> bool:
         return not self == other

cirq-core/cirq/contrib/quimb/mps_simulator_test.py

@@ -335,7 +335,7 @@ def test_random_circuits_equal_more_rows():
     assert_same_output_as_dense(circuit, qubits)
 
 
-def test_supremacy_equal_more_cols():
+def test_random_circuits_equal_more_cols():
     circuit = cirq.testing.random_circuit(
         qubits=cirq.GridQubit.rect(2, 3), n_moments=6, op_density=1.0
     )

cirq-core/cirq/devices/grid_qubit.py

@@ -33,14 +33,15 @@ class _BaseGridQid(ops.Qid):
     _row: int
     _col: int
     _dimension: int
+    _comp_key: Optional[Tuple[int, int]] = None
     _hash: Optional[int] = None
 
     def __hash__(self) -> int:
         if self._hash is None:
             self._hash = hash((self._row, self._col, self._dimension))
         return self._hash
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseGridQid):
             return self is other or (
@@ -50,7 +51,7 @@ def __eq__(self, other):
             )
         return NotImplemented
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseGridQid):
             return self is not other and (
@@ -60,8 +61,38 @@ def __ne__(self, other):
             )
         return NotImplemented
 
+    def __lt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 < k1 or (k0 == k1 and self._dimension < other._dimension)
+        return super().__lt__(other)
+
+    def __le__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 < k1 or (k0 == k1 and self._dimension <= other._dimension)
+        return super().__le__(other)
+
+    def __ge__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 > k1 or (k0 == k1 and self._dimension >= other._dimension)
+        return super().__ge__(other)
+
+    def __gt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 > k1 or (k0 == k1 and self._dimension > other._dimension)
+        return super().__gt__(other)
+
     def _comparison_key(self):
-        return self._row, self._col
+        if self._comp_key is None:
+            self._comp_key = self._row, self._col
+        return self._comp_key
 
     @property
     def row(self) -> int:
@@ -359,11 +390,6 @@ def __getnewargs__(self):
     def _with_row_col(self, row: int, col: int) -> 'GridQubit':
         return GridQubit(row, col)
 
-    def _cmp_tuple(self):
-        cls = GridQid if type(self) is GridQubit else type(self)
-        # Must be same as Qid._cmp_tuple but with cls in place of type(self).
-        return (cls.__name__, repr(cls), self._comparison_key(), self.dimension)
-
     @staticmethod
     def square(diameter: int, top: int = 0, left: int = 0) -> List['GridQubit']:
         """Returns a square of GridQubits.

cirq-core/cirq/devices/line_qubit.py

@@ -37,20 +37,52 @@ def __hash__(self) -> int:
             self._hash = hash((self._x, self._dimension))
         return self._hash
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseLineQid):
             return self is other or (self._x == other._x and self._dimension == other._dimension)
         return NotImplemented
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseLineQid):
             return self is not other and (
                 self._x != other._x or self._dimension != other._dimension
             )
         return NotImplemented
 
+    def __lt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x < other._x or (
+                self._x == other._x and self._dimension < other._dimension
+            )
+        return super().__lt__(other)
+
+    def __le__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x < other._x or (
+                self._x == other._x and self._dimension <= other._dimension
+            )
+        return super().__le__(other)
+
+    def __ge__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x > other._x or (
+                self._x == other._x and self._dimension >= other._dimension
+            )
+        return super().__ge__(other)
+
+    def __gt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x > other._x or (
+                self._x == other._x and self._dimension > other._dimension
+            )
+        return super().__gt__(other)
+
     def _comparison_key(self):
         return self._x
 
@@ -279,12 +311,6 @@ def __getnewargs__(self):
     def _with_x(self, x: int) -> 'LineQubit':
         return LineQubit(x)
 
-    def _cmp_tuple(self):
-        cls = LineQid if type(self) is LineQubit else type(self)
-        # Must be the same as Qid._cmp_tuple but with cls in place of
-        # type(self).
-        return (cls.__name__, repr(cls), self._comparison_key(), self._dimension)
-
     @staticmethod
     def range(*range_args) -> List['LineQubit']:
         """Returns a range of line qubits.

cirq-core/cirq/experiments/__init__.py

@@ -20,6 +20,7 @@
     TomographyResult,
     two_qubit_randomized_benchmarking,
     two_qubit_state_tomography,
+    parallel_single_qubit_randomized_benchmarking,
 )
 
 from cirq.experiments.fidelity_estimation import (