cirq-core 1.2.0.dev20230717225858__py3-none-any.whl → 1.3.0__py3-none-any.whl

cirq/devices/grid_qubit.py

@@ -19,7 +19,7 @@ from typing_extensions import Self
 
 import numpy as np
 
-from cirq import _compat, ops, protocols
+from cirq import ops, protocols
 
 if TYPE_CHECKING:
     import cirq
@@ -29,9 +29,43 @@ if TYPE_CHECKING:
 class _BaseGridQid(ops.Qid):
     """The Base class for `GridQid` and `GridQubit`."""
 
-    def __init__(self, row: int, col: int):
-        self._row = row
-        self._col = col
+    _row: int
+    _col: int
+    _dimension: int
+    _hash: Optional[int] = None
+
+    def __getstate__(self):
+        # Don't save hash when pickling; see #3777.
+        state = self.__dict__
+        if "_hash" in state:
+            state = state.copy()
+            del state["_hash"]
+        return state
+
+    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):
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            return (
+                self._row == other._row
+                and self._col == other._col
+                and self._dimension == other._dimension
+            )
+        return NotImplemented
+
+    def __ne__(self, other):
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            return (
+                self._row != other._row
+                or self._col != other._col
+                or self._dimension != other._dimension
+            )
+        return NotImplemented
 
     def _comparison_key(self):
         return self._row, self._col
@@ -44,6 +78,10 @@ class _BaseGridQid(ops.Qid):
     def col(self) -> int:
         return self._col
 
+    @property
+    def dimension(self) -> int:
+        return self._dimension
+
     def with_dimension(self, dimension: int) -> 'GridQid':
         return GridQid(self._row, self._col, dimension=dimension)
 
@@ -149,13 +187,10 @@ class GridQid(_BaseGridQid):
             dimension: The dimension of the qid's Hilbert space, i.e.
                 the number of quantum levels.
         """
-        super().__init__(row, col)
-        self._dimension = dimension
         self.validate_dimension(dimension)
-
-    @property
-    def dimension(self):
-        return self._dimension
+        self._row = row
+        self._col = col
+        self._dimension = dimension
 
     def _with_row_col(self, row: int, col: int) -> 'GridQid':
         return GridQid(row, col, dimension=self.dimension)
@@ -288,35 +323,11 @@ class GridQubit(_BaseGridQid):
     cirq.GridQubit(5, 4)
     """
 
-    def __getstate__(self):
-        # Don't save hash when pickling; see #3777.
-        state = self.__dict__
-        hash_key = _compat._method_cache_name(self.__hash__)
-        if hash_key in state:
-            state = state.copy()
-            del state[hash_key]
-        return state
-
-    @_compat.cached_method
-    def __hash__(self) -> int:
-        # Explicitly cached for performance (vs delegating to Qid).
-        return super().__hash__()
+    _dimension = 2
 
-    def __eq__(self, other):
-        # Explicitly implemented for performance (vs delegating to Qid).
-        if isinstance(other, GridQubit):
-            return self._row == other._row and self._col == other._col
-        return NotImplemented
-
-    def __ne__(self, other):
-        # Explicitly implemented for performance (vs delegating to Qid).
-        if isinstance(other, GridQubit):
-            return self._row != other._row or self._col != other._col
-        return NotImplemented
-
-    @property
-    def dimension(self) -> int:
-        return 2
+    def __init__(self, row: int, col: int) -> None:
+        self._row = row
+        self._col = col
 
     def _with_row_col(self, row: int, col: int):
         return GridQubit(row, col)

cirq/devices/grid_qubit_test.py

@@ -19,7 +19,6 @@ import numpy as np
 import pytest
 
 import cirq
-from cirq import _compat
 
 
 def test_init():
@@ -45,8 +44,7 @@ def test_pickled_hash():
     q = cirq.GridQubit(3, 4)
     q_bad = cirq.GridQubit(3, 4)
     _ = hash(q_bad)  # compute hash to ensure it is cached.
-    hash_key = _compat._method_cache_name(cirq.GridQubit.__hash__)
-    setattr(q_bad, hash_key, getattr(q_bad, hash_key) + 1)
+    q_bad._hash = q_bad._hash + 1
     assert q_bad == q
     assert hash(q_bad) != hash(q)
     data = pickle.dumps(q_bad)

cirq/devices/insertion_noise_model.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import dataclasses
-from typing import TYPE_CHECKING, Dict, List, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
 
 from cirq import devices
 from cirq.devices import noise_utils
@@ -74,3 +74,23 @@ class InsertionNoiseModel(devices.NoiseModel):
         if self.prepend:
             return [*noise_steps.moments, moment]
         return [moment, *noise_steps.moments]
+
+    def __repr__(self) -> str:
+        return (
+            f'cirq.devices.InsertionNoiseModel(ops_added={self.ops_added},'
+            + f' prepend={self.prepend},'
+            + f' require_physical_tag={self.require_physical_tag})'
+        )
+
+    def _json_dict_(self) -> Dict[str, Any]:
+        return {
+            'ops_added': list(self.ops_added.items()),
+            'prepend': self.prepend,
+            'require_physical_tag': self.require_physical_tag,
+        }
+
+    @classmethod
+    def _from_json_dict_(cls, ops_added, prepend, require_physical_tag, **kwargs):
+        return cls(
+            ops_added=dict(ops_added), prepend=prepend, require_physical_tag=require_physical_tag
+        )

cirq/devices/insertion_noise_model_test.py

@@ -47,6 +47,8 @@ def test_insertion_noise():
     moment_3 = cirq.Moment(cirq.Z(q0), cirq.X(q1))
     assert model.noisy_moment(moment_3, system_qubits=[q0, q1]) == [moment_3]
 
+    cirq.testing.assert_equivalent_repr(model)
+
 
 def test_colliding_noise_qubits():
     # Check that noise affecting other qubits doesn't cause issues.
@@ -61,6 +63,8 @@ def test_colliding_noise_qubits():
         cirq.Moment(cirq.CNOT(q1, q2)),
     ]
 
+    cirq.testing.assert_equivalent_repr(model)
+
 
 def test_prepend():
     q0, q1 = cirq.LineQubit.range(2)
@@ -106,3 +110,5 @@ def test_supertype_matching():
 
     moment_1 = cirq.Moment(cirq.Y(q0))
     assert model.noisy_moment(moment_1, system_qubits=[q0]) == [moment_1, cirq.Moment(cirq.T(q0))]
+
+    cirq.testing.assert_equivalent_repr(model)

cirq/devices/line_qubit.py

@@ -27,19 +27,48 @@ if TYPE_CHECKING:
 class _BaseLineQid(ops.Qid):
     """The base class for `LineQid` and `LineQubit`."""
 
-    def __init__(self, x: int) -> None:
-        """Initializes a line qubit at the given x coordinate."""
-        self._x = x
+    _x: int
+    _dimension: int
+    _hash: Optional[int] = None
+
+    def __getstate__(self):
+        # Don't save hash when pickling; see #3777.
+        state = self.__dict__
+        if "_hash" in state:
+            state = state.copy()
+            del state["_hash"]
+        return state
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash((self._x, self._dimension))
+        return self._hash
+
+    def __eq__(self, other):
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x == other._x and self._dimension == other._dimension
+        return NotImplemented
+
+    def __ne__(self, other):
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x != other._x or self._dimension != other._dimension
+        return NotImplemented
 
     def _comparison_key(self):
-        return self.x
+        return self._x
 
     @property
     def x(self) -> int:
         return self._x
 
+    @property
+    def dimension(self) -> int:
+        return self._dimension
+
     def with_dimension(self, dimension: int) -> 'LineQid':
-        return LineQid(self.x, dimension)
+        return LineQid(self._x, dimension)
 
     def is_adjacent(self, other: 'cirq.Qid') -> bool:
         """Determines if two qubits are adjacent line qubits.
@@ -49,7 +78,7 @@ class _BaseLineQid(ops.Qid):
 
         Returns: True iff other and self are adjacent.
         """
-        return isinstance(other, _BaseLineQid) and abs(self.x - other.x) == 1
+        return isinstance(other, _BaseLineQid) and abs(self._x - other._x) == 1
 
     def neighbors(self, qids: Optional[Iterable[ops.Qid]] = None) -> Set['_BaseLineQid']:
         """Returns qubits that are potential neighbors to this LineQubit
@@ -57,11 +86,7 @@ class _BaseLineQid(ops.Qid):
         Args:
             qids: optional Iterable of qubits to constrain neighbors to.
         """
-        neighbors = set()
-        for q in [self - 1, self + 1]:
-            if qids is None or q in qids:
-                neighbors.add(q)
-        return neighbors
+        return {q for q in [self - 1, self + 1] if qids is None or q in qids}
 
     @abc.abstractmethod
     def _with_x(self, x: int) -> Self:
@@ -69,29 +94,29 @@ class _BaseLineQid(ops.Qid):
 
     def __add__(self, other: Union[int, Self]) -> Self:
         if isinstance(other, _BaseLineQid):
-            if self.dimension != other.dimension:
+            if self._dimension != other._dimension:
                 raise TypeError(
                     "Can only add LineQids with identical dimension. "
-                    f"Got {self.dimension} and {other.dimension}"
+                    f"Got {self._dimension} and {other._dimension}"
                 )
-            return self._with_x(x=self.x + other.x)
+            return self._with_x(x=self._x + other._x)
         if not isinstance(other, int):
             raise TypeError(f"Can only add ints and {type(self).__name__}. Instead was {other}")
-        return self._with_x(self.x + other)
+        return self._with_x(self._x + other)
 
     def __sub__(self, other: Union[int, Self]) -> Self:
         if isinstance(other, _BaseLineQid):
-            if self.dimension != other.dimension:
+            if self._dimension != other._dimension:
                 raise TypeError(
                     "Can only subtract LineQids with identical dimension. "
-                    f"Got {self.dimension} and {other.dimension}"
+                    f"Got {self._dimension} and {other._dimension}"
                 )
-            return self._with_x(x=self.x - other.x)
+            return self._with_x(x=self._x - other._x)
         if not isinstance(other, int):
             raise TypeError(
                 f"Can only subtract ints and {type(self).__name__}. Instead was {other}"
             )
-        return self._with_x(self.x - other)
+        return self._with_x(self._x - other)
 
     def __radd__(self, other: int) -> Self:
         return self + other
@@ -100,16 +125,16 @@ class _BaseLineQid(ops.Qid):
         return -self + other
 
     def __neg__(self) -> Self:
-        return self._with_x(-self.x)
+        return self._with_x(-self._x)
 
     def __complex__(self) -> complex:
-        return complex(self.x)
+        return complex(self._x)
 
     def __float__(self) -> float:
-        return float(self.x)
+        return float(self._x)
 
     def __int__(self) -> int:
-        return int(self.x)
+        return int(self._x)
 
 
 class LineQid(_BaseLineQid):
@@ -137,16 +162,12 @@ class LineQid(_BaseLineQid):
             dimension: The dimension of the qid's Hilbert space, i.e.
                 the number of quantum levels.
         """
-        super().__init__(x)
-        self._dimension = dimension
         self.validate_dimension(dimension)
-
-    @property
-    def dimension(self):
-        return self._dimension
+        self._x = x
+        self._dimension = dimension
 
     def _with_x(self, x: int) -> 'LineQid':
-        return LineQid(x, dimension=self.dimension)
+        return LineQid(x, dimension=self._dimension)
 
     @staticmethod
     def range(*range_args, dimension: int) -> List['LineQid']:
@@ -192,15 +213,15 @@ class LineQid(_BaseLineQid):
         return LineQid.for_qid_shape(qid_shape(val), start=start, step=step)
 
     def __repr__(self) -> str:
-        return f"cirq.LineQid({self.x}, dimension={self.dimension})"
+        return f"cirq.LineQid({self._x}, dimension={self._dimension})"
 
     def __str__(self) -> str:
-        return f"q({self.x}) (d={self.dimension})"
+        return f"q({self._x}) (d={self._dimension})"
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'
     ) -> 'cirq.CircuitDiagramInfo':
-        return protocols.CircuitDiagramInfo(wire_symbols=(f"{self.x} (d={self.dimension})",))
+        return protocols.CircuitDiagramInfo(wire_symbols=(f"{self._x} (d={self._dimension})",))
 
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['x', 'dimension'])
@@ -223,9 +244,15 @@ class LineQubit(_BaseLineQid):
 
     """
 
-    @property
-    def dimension(self) -> int:
-        return 2
+    _dimension = 2
+
+    def __init__(self, x: int) -> None:
+        """Initializes a line qubit at the given x coordinate.
+
+        Args:
+            x: The x coordinate.
+        """
+        self._x = x
 
     def _with_x(self, x: int) -> 'LineQubit':
         return LineQubit(x)
@@ -234,7 +261,7 @@ class LineQubit(_BaseLineQid):
         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)
+        return (cls.__name__, repr(cls), self._comparison_key(), self._dimension)
 
     @staticmethod
     def range(*range_args) -> List['LineQubit']:
@@ -249,15 +276,15 @@ class LineQubit(_BaseLineQid):
         return [LineQubit(i) for i in range(*range_args)]
 
     def __repr__(self) -> str:
-        return f"cirq.LineQubit({self.x})"
+        return f"cirq.LineQubit({self._x})"
 
     def __str__(self) -> str:
-        return f"q({self.x})"
+        return f"q({self._x})"
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'
     ) -> 'cirq.CircuitDiagramInfo':
-        return protocols.CircuitDiagramInfo(wire_symbols=(f"{self.x}",))
+        return protocols.CircuitDiagramInfo(wire_symbols=(f"{self._x}",))
 
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['x'])

cirq/devices/named_topologies.py

@@ -74,7 +74,7 @@ def _node_and_coordinates(
 
 
 def draw_gridlike(
-    graph: nx.Graph, ax: plt.Axes = None, tilted: bool = True, **kwargs
+    graph: nx.Graph, ax: Optional[plt.Axes] = None, tilted: bool = True, **kwargs
 ) -> Dict[Any, Tuple[int, int]]:
     """Draw a grid-like graph using Matplotlib.
 
@@ -93,7 +93,7 @@ def draw_gridlike(
         to NetworkX plotting functionality.
     """
     if ax is None:
-        ax = plt.gca()  # coverage: ignore
+        ax = plt.gca()  # pragma: no cover
 
     if tilted:
         pos = {node: (y, -x) for node, (x, y) in _node_and_coordinates(graph.nodes)}
@@ -295,8 +295,7 @@ def get_placements(
     for big_to_small_map in matcher.subgraph_monomorphisms_iter():
         dedupe[frozenset(big_to_small_map.keys())] = big_to_small_map
         if len(dedupe) > max_placements:
-            # coverage: ignore
-            raise ValueError(
+            raise ValueError(  # pragma: no cover
                 f"We found more than {max_placements} placements. Please use a "
                 f"more constraining `big_graph` or a more constrained `small_graph`."
             )
@@ -367,27 +366,23 @@ def draw_placements(
             this callback is called. The callback should accept `ax` and `i` keyword arguments
             for the current axis and mapping index, respectively.
     """
-    if len(small_to_big_mappings) > max_plots:
-        # coverage: ignore
+    if len(small_to_big_mappings) > max_plots:  # pragma: no cover
         warnings.warn(f"You've provided a lot of mappings. Only plotting the first {max_plots}")
         small_to_big_mappings = small_to_big_mappings[:max_plots]
 
     call_show = False
     if axes is None:
-        # coverage: ignore
-        call_show = True
+        call_show = True  # pragma: no cover
 
     for i, small_to_big_map in enumerate(small_to_big_mappings):
         if axes is not None:
             ax = axes[i]
-        else:
-            # coverage: ignore
+        else:  # pragma: no cover
             ax = plt.gca()
 
         small_mapped = nx.relabel_nodes(small_graph, small_to_big_map)
         if bad_placement_callback is not None:
-            # coverage: ignore
-            if not _is_valid_placement_helper(
+            if not _is_valid_placement_helper(  # pragma: no cover
                 big_graph=big_graph,
                 small_mapped=small_mapped,
                 small_to_big_mapping=small_to_big_map,
@@ -406,7 +401,6 @@ def draw_placements(
         )
         ax.axis('equal')
         if call_show:
-            # coverage: ignore
             # poor man's multi-axis figure: call plt.show() after each plot
             # and jupyter will put the plots one after another.
-            plt.show()
+            plt.show()  # pragma: no cover

cirq/devices/noise_properties.py

@@ -97,7 +97,7 @@ class NoiseModelFromNoiseProperties(devices.NoiseModel):
             # only ops with PHYSICAL_GATE_TAG will receive noise.
             if virtual_ops:
                 # Only subclasses will trigger this case.
-                new_moments.append(circuits.Moment(virtual_ops))  # coverage: ignore
+                new_moments.append(circuits.Moment(virtual_ops))  # pragma: no cover
             if physical_ops:
                 new_moments.append(circuits.Moment(physical_ops))
 

cirq/devices/noise_utils.py

@@ -16,6 +16,7 @@ from typing import TYPE_CHECKING, Any, Dict, Tuple, Type, Union
 import numpy as np
 
 from cirq import ops, protocols, value
+from cirq._compat import proper_repr
 
 if TYPE_CHECKING:
     import cirq
@@ -78,20 +79,21 @@ class OpIdentifier:
         return f'{self.gate_type}{self.qubits}'
 
     def __repr__(self) -> str:
-        fullname = f'{self.gate_type.__module__}.{self.gate_type.__qualname__}'
         qubits = ', '.join(map(repr, self.qubits))
-        return f'cirq.devices.noise_utils.OpIdentifier({fullname}, {qubits})'
+        return f'cirq.devices.noise_utils.OpIdentifier({proper_repr(self.gate_type)}, {qubits})'
 
     def _value_equality_values_(self) -> Any:
         return (self.gate_type, self.qubits)
 
     def _json_dict_(self) -> Dict[str, Any]:
-        gate_json = protocols.json_cirq_type(self._gate_type)
-        return {'gate_type': gate_json, 'qubits': self._qubits}
+        if hasattr(self.gate_type, '__name__'):
+            return {'gate_type': protocols.json_cirq_type(self._gate_type), 'qubits': self._qubits}
+        return {'gate_type': self._gate_type, 'qubits': self._qubits}
 
     @classmethod
     def _from_json_dict_(cls, gate_type, qubits, **kwargs) -> 'OpIdentifier':
-        gate_type = protocols.cirq_type_from_json(gate_type)
+        if isinstance(gate_type, str):
+            gate_type = protocols.cirq_type_from_json(gate_type)
         return cls(gate_type, *qubits)
 
 

cirq/devices/noise_utils_test.py

@@ -62,6 +62,13 @@ def test_op_id_swap():
     assert cirq.CZ(q1, q0) in swap_id
 
 
+def test_op_id_instance():
+    q0 = cirq.LineQubit.range(1)[0]
+    gate = cirq.SingleQubitCliffordGate.from_xz_map((cirq.X, False), (cirq.Z, False))
+    op_id = OpIdentifier(gate, q0)
+    cirq.testing.assert_equivalent_repr(op_id)
+
+
 @pytest.mark.parametrize(
     'decay_constant,num_qubits,expected_output',
     [(0.01, 1, 1 - (0.99 * 1 / 2)), (0.05, 2, 1 - (0.95 * 3 / 4))],

cirq/experiments/fidelity_estimation_test.py

@@ -81,7 +81,7 @@ def test_xeb_fidelity(depolarization, estimator):
         f2 = cirq.xeb_fidelity(
             circuit, bitstrings, qubits, amplitudes=amplitudes, estimator=estimator
         )
-        assert np.abs(f - f2) < 1e-6
+        assert np.abs(f - f2) < 2e-6
 
         fs.append(f)
 

cirq/experiments/qubit_characterizations.py

@@ -15,13 +15,13 @@
 import dataclasses
 import itertools
 
-from typing import Any, Iterator, List, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Any, cast, Iterator, List, Optional, Sequence, Tuple, TYPE_CHECKING
 import numpy as np
 
 from matplotlib import pyplot as plt
 
 # this is for older systems with matplotlib <3.2 otherwise 3d projections fail
-from mpl_toolkits import mplot3d  # pylint: disable=unused-import
+from mpl_toolkits import mplot3d
 from cirq import circuits, ops, protocols
 
 if TYPE_CHECKING:
@@ -89,8 +89,9 @@ class RandomizedBenchMarkResult:
         """
         show_plot = not ax
         if not ax:
-            fig, ax = plt.subplots(1, 1, figsize=(8, 8))
-        ax.set_ylim([0, 1])
+            fig, ax = plt.subplots(1, 1, figsize=(8, 8))  # pragma: no cover
+            ax = cast(plt.Axes, ax)  # pragma: no cover
+        ax.set_ylim((0.0, 1.0))  # pragma: no cover
         ax.plot(self._num_cfds_seq, self._gnd_state_probs, 'ro-', **plot_kwargs)
         ax.set_xlabel(r"Number of Cliffords")
         ax.set_ylabel('Ground State Probability')
@@ -541,7 +542,7 @@ def _find_inv_matrix(mat: np.ndarray, mat_sequence: np.ndarray) -> int:
 def _matrix_bar_plot(
     mat: np.ndarray,
     z_label: str,
-    ax: plt.Axes,
+    ax: mplot3d.axes3d.Axes3D,
     kets: Optional[Sequence[str]] = None,
     title: Optional[str] = None,
     ylim: Tuple[int, int] = (-1, 1),

cirq/experiments/random_quantum_circuit_generation.py

@@ -693,5 +693,5 @@ def _two_qubit_layer(
     prng: 'np.random.RandomState',
 ) -> 'cirq.OP_TREE':
     for a, b in coupled_qubit_pairs:
-        if (a, b) in layer:
+        if (a, b) in layer or (b, a) in layer:
             yield two_qubit_op_factory(a, b, prng)

cirq/experiments/random_quantum_circuit_generation_test.py

@@ -259,6 +259,30 @@ class FakeSycamoreGate(cirq.FSimGate):
     'seed, expected_circuit_length, single_qubit_layers_slice, '
     'two_qubit_layers_slice',
     (
+        (
+            (cirq.q(0, 0), cirq.q(0, 1), cirq.q(0, 2)),
+            4,
+            lambda a, b, _: cirq.CZ(a, b),
+            [[(cirq.q(0, 0), cirq.q(0, 1))], [(cirq.q(0, 1), cirq.q(0, 2))]],
+            (cirq.X**0.5,),
+            True,
+            1234,
+            9,
+            slice(None, None, 2),
+            slice(1, None, 2),
+        ),
+        (
+            (cirq.q(0, 0), cirq.q(0, 1), cirq.q(0, 2)),
+            4,
+            lambda a, b, _: cirq.CZ(a, b),
+            [[(cirq.q(0, 1), cirq.q(0, 0))], [(cirq.q(0, 1), cirq.q(0, 2))]],
+            (cirq.X**0.5,),
+            True,
+            1234,
+            9,
+            slice(None, None, 2),
+            slice(1, None, 2),
+        ),
         (
             cirq.GridQubit.rect(4, 3),
             20,
@@ -406,7 +430,10 @@ def _validate_two_qubit_layers(
             # Operation is two-qubit
             assert cirq.num_qubits(op) == 2
             # Operation fits pattern
-            assert op.qubits in pattern[i % len(pattern)]
+            assert (
+                op.qubits in pattern[i % len(pattern)]
+                or op.qubits[::-1] in pattern[i % len(pattern)]
+            )
             active_pairs.add(op.qubits)
         # All interactions that should be in this layer are present
         assert all(

cirq/experiments/readout_confusion_matrix.py

@@ -278,7 +278,7 @@ class TensoredConfusionMatrices:
             raise ValueError(f"method: {method} should be 'pseudo_inverse' or 'least_squares'.")
 
         if method == 'pseudo_inverse':
-            return result @ self.correction_matrix(qubits)  # coverage: ignore
+            return result @ self.correction_matrix(qubits)  # pragma: no cover
 
         # Least squares minimization.
         cm = self.confusion_matrix(qubits)
@@ -291,11 +291,11 @@ class TensoredConfusionMatrices:
         res = scipy.optimize.minimize(
             func, result, method='SLSQP', constraints=constraints, bounds=bounds
         )
-        if res.success is False:  # coverage: ignore
-            raise ValueError(  # coverage: ignore
-                f"SLSQP optimization for constrained minimization "  # coverage: ignore
-                f"did not converge. Result:\n{res}"  # coverage: ignore
-            )  # coverage: ignore
+        if res.success is False:  # pragma: no cover
+            raise ValueError(  # pragma: no cover
+                f"SLSQP optimization for constrained minimization "  # pragma: no cover
+                f"did not converge. Result:\n{res}"  # pragma: no cover
+            )  # pragma: no cover
         return res.x
 
     def __repr__(self) -> str: