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

cirq/sim/simulation_state_test.py

@@ -22,7 +22,7 @@ from cirq.sim import simulation_state
 from cirq.testing import PhaseUsingCleanAncilla, PhaseUsingDirtyAncilla
 
 
-class DummyQuantumState(cirq.QuantumStateRepresentation):
+class ExampleQuantumState(cirq.QuantumStateRepresentation):
     def copy(self, deep_copy_buffers=True):
         pass
 
@@ -33,9 +33,9 @@ class DummyQuantumState(cirq.QuantumStateRepresentation):
         return self
 
 
-class DummySimulationState(cirq.SimulationState):
+class ExampleSimulationState(cirq.SimulationState):
     def __init__(self, qubits=cirq.LineQubit.range(2)):
-        super().__init__(state=DummyQuantumState(), qubits=qubits)
+        super().__init__(state=ExampleQuantumState(), qubits=qubits)
 
     def _act_on_fallback_(
         self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
@@ -73,13 +73,13 @@ class Composite(cirq.Gate):
 
 
 def test_measurements():
-    args = DummySimulationState()
+    args = ExampleSimulationState()
     args.measure([cirq.LineQubit(0)], "test", [False], {})
     assert args.log_of_measurement_results["test"] == [5]
 
 
 def test_decompose():
-    args = DummySimulationState()
+    args = ExampleSimulationState()
     assert simulation_state.strat_act_on_from_apply_decompose(
         Composite(), args, [cirq.LineQubit(0)]
     )
@@ -91,14 +91,14 @@ def test_decompose_for_gate_allocating_qubits_raises():
             anc = cirq.NamedQubit("anc")
             yield cirq.CNOT(*qubits, anc)
 
-    args = DummySimulationState()
+    args = ExampleSimulationState()
 
     with pytest.raises(TypeError, match="add_qubits but not remove_qubits"):
         simulation_state.strat_act_on_from_apply_decompose(Composite(), args, [cirq.LineQubit(0)])
 
 
 def test_mapping():
-    args = DummySimulationState()
+    args = ExampleSimulationState()
     assert list(iter(args)) == cirq.LineQubit.range(2)
     r1 = args[cirq.LineQubit(0)]
     assert args is r1
@@ -109,7 +109,7 @@ def test_mapping():
 def test_swap_bad_dimensions():
     q0 = cirq.LineQubit(0)
     q1 = cirq.LineQid(1, 3)
-    args = DummySimulationState()
+    args = ExampleSimulationState()
     with pytest.raises(ValueError, match='Cannot swap different dimensions'):
         args.swap(q0, q1)
 
@@ -117,14 +117,14 @@ def test_swap_bad_dimensions():
 def test_rename_bad_dimensions():
     q0 = cirq.LineQubit(0)
     q1 = cirq.LineQid(1, 3)
-    args = DummySimulationState()
+    args = ExampleSimulationState()
     with pytest.raises(ValueError, match='Cannot rename to different dimensions'):
         args.rename(q0, q1)
 
 
 def test_transpose_qubits():
     q0, q1, q2 = cirq.LineQubit.range(3)
-    args = DummySimulationState()
+    args = ExampleSimulationState()
     assert args.transpose_to_qubit_order((q1, q0)).qubits == (q1, q0)
     with pytest.raises(ValueError, match='Qubits do not match'):
         args.transpose_to_qubit_order((q0, q2))
@@ -133,7 +133,7 @@ def test_transpose_qubits():
 
 
 def test_field_getters():
-    args = DummySimulationState()
+    args = ExampleSimulationState()
     assert args.prng is np.random
     assert args.qubit_map == {q: i for i, q in enumerate(cirq.LineQubit.range(2))}
 
@@ -164,9 +164,8 @@ def test_delegating_gate_channel(exp):
     control_circuit = cirq.Circuit(cirq.H(q))
     control_circuit.append(cirq.ZPowGate(exponent=exp).on(q))
 
-    with pytest.raises(TypeError, match="DensityMatrixSimulator doesn't support"):
-        # TODO: This test should pass once we extend support to DensityMatrixSimulator.
-        assert_test_circuit_for_dm_simulator(test_circuit, control_circuit)
+    assert_test_circuit_for_sv_simulator(test_circuit, control_circuit)
+    assert_test_circuit_for_dm_simulator(test_circuit, control_circuit)
 
 
 @pytest.mark.parametrize('num_ancilla', [1, 2, 3])

cirq/sim/simulator_test.py

@@ -134,8 +134,7 @@ def test_intermediate_simulator():
 
     simulator.simulate_moment_steps.side_effect = steps
     circuit = mock.Mock(cirq.Circuit)
-    param_resolver = mock.Mock(cirq.ParamResolver)
-    param_resolver.param_dict = {}
+    param_resolver = cirq.ParamResolver({})
     qubit_order = mock.Mock(cirq.QubitOrder)
     result = simulator.simulate(
         program=circuit, param_resolver=param_resolver, qubit_order=qubit_order, initial_state=2
@@ -163,9 +162,7 @@ def test_intermediate_sweeps():
 
     simulator.simulate_moment_steps.side_effect = steps
     circuit = mock.Mock(cirq.Circuit)
-    param_resolvers = [mock.Mock(cirq.ParamResolver), mock.Mock(cirq.ParamResolver)]
-    for resolver in param_resolvers:
-        resolver.param_dict = {}
+    param_resolvers = [cirq.ParamResolver({}), cirq.ParamResolver({})]
     qubit_order = mock.Mock(cirq.QubitOrder)
     results = simulator.simulate_sweep(
         program=circuit, params=param_resolvers, qubit_order=qubit_order, initial_state=2
@@ -435,7 +432,7 @@ def test_monte_carlo_on_unknown_channel():
 
 
 def test_iter_definitions():
-    dummy_trial_result = SimulationTrialResult(params={}, measurements={}, final_simulator_state=[])
+    mock_trial_result = SimulationTrialResult(params={}, measurements={}, final_simulator_state=[])
 
     class FakeNonIterSimulatorImpl(
         SimulatesAmplitudes, SimulatesExpectationValues, SimulatesFinalState
@@ -472,7 +469,7 @@ def test_iter_definitions():
             qubit_order: cirq.QubitOrderOrList = cirq.QubitOrder.DEFAULT,
             initial_state: Any = None,
         ) -> List[SimulationTrialResult]:
-            return [dummy_trial_result]
+            return [mock_trial_result]
 
     non_iter_sim = FakeNonIterSimulatorImpl()
     q0 = cirq.LineQubit(0)
@@ -488,9 +485,9 @@ def test_iter_definitions():
     ev_iter = non_iter_sim.simulate_expectation_values_sweep_iter(circuit, obs, params)
     assert next(ev_iter) == [1.0]
 
-    assert non_iter_sim.simulate_sweep(circuit, params) == [dummy_trial_result]
+    assert non_iter_sim.simulate_sweep(circuit, params) == [mock_trial_result]
     state_iter = non_iter_sim.simulate_sweep_iter(circuit, params)
-    assert next(state_iter) == dummy_trial_result
+    assert next(state_iter) == mock_trial_result
 
 
 def test_missing_iter_definitions():

cirq/sim/state_vector_simulation_state.py

@@ -387,7 +387,7 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
         for strat in strats:
             result = strat(action, self, qubits)
             if result is False:
-                break  # coverage: ignore
+                break  # pragma: no cover
             if result is True:
                 return True
             assert result is NotImplemented, str(result)

cirq/study/resolver.py

@@ -36,8 +36,11 @@ document(
     ParamResolverOrSimilarType, """Something that can be used to turn parameters into values."""
 )
 
+# Used to mark values that are not found in a dict.
+_NOT_FOUND = object()
+
 # Used to mark values that are being resolved recursively to detect loops.
-_RecursionFlag = object()
+_RECURSION_FLAG = object()
 
 
 def _is_param_resolver_or_similar_type(obj: Any):
@@ -72,7 +75,7 @@ class ParamResolver:
 
         self._param_hash: Optional[int] = None
         self._param_dict = cast(ParamDictType, {} if param_dict is None else param_dict)
-        for key in self.param_dict:
+        for key in self._param_dict:
             if isinstance(key, sympy.Expr) and not isinstance(key, sympy.Symbol):
                 raise TypeError(f'ParamResolver keys cannot be (non-symbol) formulas ({key})')
         self._deep_eval_map: ParamDictType = {}
@@ -120,32 +123,30 @@ class ParamResolver:
         if v is not NotImplemented:
             return v
 
-        # Handles 2 cases:
-        # Input is a string and maps to a number in the dictionary
-        # Input is a symbol and maps to a number in the dictionary
-        # In both cases, return it directly.
-        if value in self.param_dict:
-            # Note: if the value is in the dictionary, it will be a key type
-            # Add a cast to make mypy happy.
-            param_value = self.param_dict[cast('cirq.TParamKey', value)]
+        # Handle string or symbol
+        if isinstance(value, (str, sympy.Symbol)):
+            string = value if isinstance(value, str) else value.name
+            symbol = value if isinstance(value, sympy.Symbol) else sympy.Symbol(value)
+            param_value = self._param_dict.get(string, _NOT_FOUND)
+            if param_value is _NOT_FOUND:
+                param_value = self._param_dict.get(symbol, _NOT_FOUND)
+            if param_value is _NOT_FOUND:
+                # Symbol or string cannot be resolved if not in param dict; return as symbol.
+                return symbol
             v = _resolve_value(param_value)
             if v is not NotImplemented:
                 return v
+            if isinstance(param_value, str):
+                param_value = sympy.Symbol(param_value)
+            elif not isinstance(param_value, sympy.Basic):
+                return value  # type: ignore[return-value]
+            if recursive:
+                param_value = self._value_of_recursive(value)
+            return param_value  # type: ignore[return-value]
 
-        # Input is a string and is not in the dictionary.
-        # Treat it as a symbol instead.
-        if isinstance(value, str):
-            # If the string is in the param_dict as a value, return it.
-            # Otherwise, try using the symbol instead.
-            return self.value_of(sympy.Symbol(value), recursive)
-
-        # Input is a symbol (sympy.Symbol('a')) and its string maps to a number
-        # in the dictionary ({'a': 1.0}).  Return it.
-        if isinstance(value, sympy.Symbol) and value.name in self.param_dict:
-            param_value = self.param_dict[value.name]
-            v = _resolve_value(param_value)
-            if v is not NotImplemented:
-                return v
+        if not isinstance(value, sympy.Basic):
+            # No known way to resolve this variable, return unchanged.
+            return value
 
         # The following resolves common sympy expressions
         # If sympy did its job and wasn't slower than molasses,
@@ -171,10 +172,6 @@ class ParamResolver:
                 return np.float_power(cast(complex, base), cast(complex, exponent))
             return np.power(cast(complex, base), cast(complex, exponent))
 
-        if not isinstance(value, sympy.Basic):
-            # No known way to resolve this variable, return unchanged.
-            return value
-
         # Input is either a sympy formula or the dictionary maps to a
         # formula.  Use sympy to resolve the value.
         # Note that sympy.subs() is slow, so we want to avoid this and
@@ -186,7 +183,7 @@ class ParamResolver:
             # Note that a sympy.SympifyError here likely means
             # that one of the expressions was not parsable by sympy
             # (such as a function returning NotImplemented)
-            v = value.subs(self.param_dict, simultaneous=True)
+            v = value.subs(self._param_dict, simultaneous=True)
 
             if v.free_symbols:
                 return v
@@ -197,23 +194,26 @@ class ParamResolver:
             else:
                 return float(v)
 
+        return self._value_of_recursive(value)
+
+    def _value_of_recursive(self, value: 'cirq.TParamKey') -> 'cirq.TParamValComplex':
         # Recursive parameter resolution. We can safely assume that value is a
         # single symbol, since combinations are handled earlier in the method.
         if value in self._deep_eval_map:
             v = self._deep_eval_map[value]
-            if v is not _RecursionFlag:
-                return v
-            raise RecursionError('Evaluation of {value} indirectly contains itself.')
+            if v is _RECURSION_FLAG:
+                raise RecursionError('Evaluation of {value} indirectly contains itself.')
+            return v
 
         # There isn't a full evaluation for 'value' yet. Until it's ready,
         # map value to None to identify loops in component evaluation.
-        self._deep_eval_map[value] = _RecursionFlag  # type: ignore
+        self._deep_eval_map[value] = _RECURSION_FLAG  # type: ignore
 
         v = self.value_of(value, recursive=False)
         if v == value:
             self._deep_eval_map[value] = v
         else:
-            self._deep_eval_map[value] = self.value_of(v, recursive)
+            self._deep_eval_map[value] = self.value_of(v, recursive=True)
         return self._deep_eval_map[value]
 
     def _resolve_parameters_(self, resolver: 'ParamResolver', recursive: bool) -> 'ParamResolver':
@@ -224,17 +224,17 @@ class ParamResolver:
         new_dict.update(
             {k: resolver.value_of(v, recursive) for k, v in new_dict.items()}  # type: ignore[misc]
         )
-        if recursive and self.param_dict:
+        if recursive and self._param_dict:
             new_resolver = ParamResolver(cast(ParamDictType, new_dict))
             # Resolve down to single-step mappings.
             return ParamResolver()._resolve_parameters_(new_resolver, recursive=True)
         return ParamResolver(cast(ParamDictType, new_dict))
 
     def __iter__(self) -> Iterator[Union[str, sympy.Expr]]:
-        return iter(self.param_dict)
+        return iter(self._param_dict)
 
     def __bool__(self) -> bool:
-        return bool(self.param_dict)
+        return bool(self._param_dict)
 
     def __getitem__(
         self, key: Union['cirq.TParamKey', 'cirq.TParamValComplex']
@@ -243,13 +243,13 @@ class ParamResolver:
 
     def __hash__(self) -> int:
         if self._param_hash is None:
-            self._param_hash = hash(frozenset(self.param_dict.items()))
+            self._param_hash = hash(frozenset(self._param_dict.items()))
         return self._param_hash
 
     def __eq__(self, other):
         if not isinstance(other, ParamResolver):
             return NotImplemented
-        return self.param_dict == other.param_dict
+        return self._param_dict == other._param_dict
 
     def __ne__(self, other):
         return not self == other
@@ -257,7 +257,7 @@ class ParamResolver:
     def __repr__(self) -> str:
         param_dict_repr = (
             '{'
-            + ', '.join([f'{proper_repr(k)}: {proper_repr(v)}' for k, v in self.param_dict.items()])
+            + ', '.join(f'{proper_repr(k)}: {proper_repr(v)}' for k, v in self._param_dict.items())
             + '}'
         )
         return f'cirq.ParamResolver({param_dict_repr})'
@@ -265,7 +265,7 @@ class ParamResolver:
     def _json_dict_(self) -> Dict[str, Any]:
         return {
             # JSON requires mappings to have keys of basic types.
-            'param_dict': list(self.param_dict.items())
+            'param_dict': list(self._param_dict.items())
         }
 
     @classmethod

cirq/study/resolver_test.py

@@ -53,10 +53,10 @@ def test_value_of_transformed_types(val, resolved):
 
 @pytest.mark.parametrize('val,resolved', [(sympy.I, 1j)])
 def test_value_of_substituted_types(val, resolved):
-    _assert_consistent_resolution(val, resolved, True)
+    _assert_consistent_resolution(val, resolved)
 
 
-def _assert_consistent_resolution(v, resolved, subs_called=False):
+def _assert_consistent_resolution(v, resolved):
     """Asserts that parameter resolution works consistently.
 
     The ParamResolver.value_of method can resolve any Sympy expression -
@@ -70,7 +70,7 @@ def _assert_consistent_resolution(v, resolved, subs_called=False):
     Args:
         v: the value to resolve
         resolved: the expected resolution result
-        subs_called: if True, it is expected that the slow subs method is called
+
     Raises:
         AssertionError in case resolution assertion fail.
     """
@@ -93,9 +93,7 @@ def _assert_consistent_resolution(v, resolved, subs_called=False):
     # symbol based resolution
     s = SubsAwareSymbol('a')
     assert r.value_of(s) == resolved, f"expected {resolved}, got {r.value_of(s)}"
-    assert (
-        subs_called == s.called
-    ), f"For pass-through type {type(v)} sympy.subs shouldn't have been called."
+    assert not s.called, f"For pass-through type {type(v)} sympy.subs shouldn't have been called."
     assert isinstance(
         r.value_of(s), type(resolved)
     ), f"expected {type(resolved)} got {type(r.value_of(s))}"
@@ -243,15 +241,18 @@ def test_custom_resolved_value():
 
 
 def test_custom_value_not_implemented():
-    class Bar:
+    class BarImplicit:
+        pass
+
+    class BarExplicit:
         def _resolved_value_(self):
             return NotImplemented
 
-    b = sympy.Symbol('b')
-    bar = Bar()
-    r = cirq.ParamResolver({b: bar})
-    with pytest.raises(sympy.SympifyError):
-        _ = r.value_of(b)
+    for cls in [BarImplicit, BarExplicit]:
+        b = sympy.Symbol('b')
+        bar = cls()
+        r = cirq.ParamResolver({b: bar})
+        assert r.value_of(b) == b
 
 
 def test_compose():

cirq/testing/__init__.py

@@ -30,7 +30,10 @@ from cirq.testing.consistent_act_on import assert_all_implemented_act_on_effects
 
 from cirq.testing.consistent_channels import assert_consistent_channel, assert_consistent_mixture
 
-from cirq.testing.consistent_controlled_gate_op import assert_controlled_and_controlled_by_identical
+from cirq.testing.consistent_controlled_gate_op import (
+    assert_controlled_and_controlled_by_identical,
+    assert_controlled_unitary_consistent,
+)
 
 from cirq.testing.consistent_decomposition import (
     assert_decompose_ends_at_default_gateset,

cirq/testing/circuit_compare.py

@@ -218,7 +218,7 @@ def _first_differing_moment_index(
     for i, (m1, m2) in enumerate(itertools.zip_longest(circuit1, circuit2)):
         if m1 != m2:
             return i
-    return None  # coverage: ignore
+    return None  # pragma: no cover
 
 
 def assert_circuits_have_same_unitary_given_final_permutation(

cirq/testing/circuit_compare_test.py

@@ -484,7 +484,7 @@ def test_assert_has_consistent_qid_shape():
 
     class ConsistentOp(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # coverage: ignore
+            raise NotImplementedError  # pragma: no cover
 
         @property
         def qubits(self):
@@ -496,47 +496,47 @@ def test_assert_has_consistent_qid_shape():
         def _qid_shape_(self):
             return (1, 2, 3, 4)
 
-    # The 'coverage: ignore' comments in the InconsistentOp classes is needed
+    # The 'pragma: no cover' comments in the InconsistentOp classes is needed
     # because test_assert_has_consistent_qid_shape may only need to check two of
     # the three methods before finding an inconsistency and throwing an error.
     class InconsistentOp1(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # coverage: ignore
+            raise NotImplementedError  # pragma: no cover
 
         @property
         def qubits(self):
             return cirq.LineQubit.range(2)
 
         def _num_qubits_(self):
-            return 4  # coverage: ignore
+            return 4  # pragma: no cover
 
         def _qid_shape_(self):
-            return (1, 2, 3, 4)  # coverage: ignore
+            return (1, 2, 3, 4)  # pragma: no cover
 
     class InconsistentOp2(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # coverage: ignore
+            raise NotImplementedError  # pragma: no cover
 
         @property
         def qubits(self):
-            return cirq.LineQubit.range(4)  # coverage: ignore
+            return cirq.LineQubit.range(4)  # pragma: no cover
 
         def _num_qubits_(self):
             return 2
 
         def _qid_shape_(self):
-            return (1, 2, 3, 4)  # coverage: ignore
+            return (1, 2, 3, 4)  # pragma: no cover
 
     class InconsistentOp3(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # coverage: ignore
+            raise NotImplementedError  # pragma: no cover
 
         @property
         def qubits(self):
-            return cirq.LineQubit.range(4)  # coverage: ignore
+            return cirq.LineQubit.range(4)  # pragma: no cover
 
         def _num_qubits_(self):
-            return 4  # coverage: ignore
+            return 4  # pragma: no cover
 
         def _qid_shape_(self):
             return 1, 2

cirq/testing/consistent_controlled_gate_op.py

@@ -14,7 +14,8 @@
 
 from typing import Sequence, Optional, Union, Collection
 
-from cirq import devices, ops
+from cirq import devices, ops, protocols
+import numpy as np
 
 
 def assert_controlled_and_controlled_by_identical(
@@ -34,6 +35,19 @@ def assert_controlled_and_controlled_by_identical(
         _assert_gate_consistent(gate, num_control, control_value)
 
 
+def assert_controlled_unitary_consistent(gate: ops.Gate):
+    """Checks that unitary of ControlledGate(gate) is consistent with gate.controlled()."""
+
+    u_orig = protocols.unitary(ops.ControlledGate(gate))
+    u_controlled = protocols.unitary(gate.controlled())
+    np.testing.assert_allclose(
+        u_orig,
+        u_controlled,
+        atol=1e-6,
+        err_msg=f"Unitary for gate.controlled() is inconsistent for {gate=}",
+    )
+
+
 def _assert_gate_consistent(
     gate: ops.Gate,
     num_controls: int,

cirq/testing/consistent_controlled_gate_op_test.py

@@ -23,8 +23,7 @@ from cirq.ops import control_values as cv
 
 
 class GoodGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
-        # coverage: ignore
+    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:  # pragma: no cover
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
 
@@ -41,7 +40,6 @@ class BadGateOperation(cirq.GateOperation):
 
 class BadGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
     def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
-        # coverage: ignore
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
     def on(self, *qubits: 'cirq.Qid') -> 'cirq.Operation':
@@ -76,3 +74,14 @@ def test_assert_controlled_and_controlled_by_identical():
         cirq.testing.assert_controlled_and_controlled_by_identical(
             GoodGate(), num_controls=[1, 2], control_values=[(1,), (1, 1, 1)]
         )
+
+
+def test_assert_controlled_unitary_consistent():
+    cirq.testing.assert_controlled_and_controlled_by_identical(
+        GoodGate(exponent=0.5, global_shift=1 / 3)
+    )
+
+    with pytest.raises(AssertionError):
+        cirq.testing.assert_controlled_and_controlled_by_identical(
+            BadGate(exponent=0.5, global_shift=1 / 3)
+        )

cirq/testing/consistent_decomposition.py

@@ -54,7 +54,6 @@ def assert_decompose_is_consistent_with_unitary(val: Any, ignoring_global_phase:
     if ignoring_global_phase:
         lin_alg_utils.assert_allclose_up_to_global_phase(actual, expected, atol=1e-8)
     else:
-        # coverage: ignore
         np.testing.assert_allclose(actual, expected, atol=1e-8)
 
 

cirq/testing/consistent_protocols.py

@@ -36,7 +36,10 @@ from cirq.testing.consistent_pauli_expansion import (
 from cirq.testing.consistent_resolve_parameters import assert_consistent_resolve_parameters
 from cirq.testing.consistent_specified_has_unitary import assert_specifies_has_unitary_if_unitary
 from cirq.testing.equivalent_repr_eval import assert_equivalent_repr
-from cirq.testing.consistent_controlled_gate_op import assert_controlled_and_controlled_by_identical
+from cirq.testing.consistent_controlled_gate_op import (
+    assert_controlled_and_controlled_by_identical,
+    assert_controlled_unitary_consistent,
+)
 from cirq.testing.consistent_unitary import assert_unitary_is_consistent
 
 
@@ -167,6 +170,8 @@ def _assert_meets_standards_helper(
         assert_eigen_shifts_is_consistent_with_eigen_components(val)
     if isinstance(val, ops.Gate) and protocols.has_mixture(val):
         assert_controlled_and_controlled_by_identical(val)
+        if protocols.has_unitary(val):
+            assert_controlled_unitary_consistent(val)
 
 
 def assert_commutes_magic_method_consistent_with_unitaries(

cirq/testing/consistent_protocols_test.py

@@ -87,8 +87,7 @@ class GoodGate(cirq.testing.SingleQubitGate):
     def __pow__(self, exponent: Union[float, sympy.Expr]) -> 'GoodGate':
         new_exponent = cirq.mul(self.exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
-            # coverage: ignore
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return GoodGate(phase_exponent=self.phase_exponent, exponent=new_exponent)
 
     def __repr__(self):
@@ -114,8 +113,7 @@ class GoodGate(cirq.testing.SingleQubitGate):
 
     def __eq__(self, other):
         if not isinstance(other, type(self)):
-            # coverage: ignore
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return self._identity_tuple() == other._identity_tuple()
 
 
@@ -132,8 +130,7 @@ class BadGateParameterNames(GoodGate):
 class BadGateApplyUnitaryToTensor(GoodGate):
     def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
         if self.exponent != 1 or cirq.is_parameterized(self):
-            # coverage: ignore
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
 
         zero = cirq.slice_for_qubits_equal_to(args.axes, 0)
         one = cirq.slice_for_qubits_equal_to(args.axes, 1)
@@ -154,8 +151,7 @@ class BadGateDecompose(GoodGate):
         z = cirq.Z(q) ** self.phase_exponent
         x = cirq.X(q) ** (2 * self.exponent)
         if cirq.is_parameterized(z):
-            # coverage: ignore
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return z**-1, x, z
 
 
@@ -176,8 +172,7 @@ class BadGateRepr(GoodGate):
     def __repr__(self):
         args = [f'phase_exponent={2 * self.phase_exponent!r}']
         if self.exponent != 1:
-            # coverage: ignore
-            args.append(f'exponent={proper_repr(self.exponent)}')
+            args.append(f'exponent={proper_repr(self.exponent)}')  # pragma: no cover
         return f"BadGateRepr({', '.join(args)})"
 
 

cirq/testing/consistent_qasm.py

@@ -27,8 +27,7 @@ def assert_qasm_is_consistent_with_unitary(val: Any):
     # Only test if qiskit is installed.
     try:
         import qiskit
-    except ImportError:
-        # coverage: ignore
+    except ImportError:  # pragma: no cover
         warnings.warn(
             "Skipped assert_qasm_is_consistent_with_unitary because "
             "qiskit isn't installed to verify against."
@@ -101,8 +100,7 @@ qreg q[{num_qubits}];
         )
 
 
-def assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, unitary):
-    # coverage: ignore
+def assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, unitary):  # pragma: no cover
     try:
         # We don't want to require qiskit as a dependency but
         # if Qiskit is installed, test QASM output against it.