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

cirq/protocols/act_on_protocol_test.py

@@ -20,7 +20,7 @@ import pytest
 import cirq
 
 
-class DummyQuantumState(cirq.QuantumStateRepresentation):
+class ExampleQuantumState(cirq.QuantumStateRepresentation):
     def copy(self, deep_copy_buffers=True):
         pass
 
@@ -28,9 +28,9 @@ class DummyQuantumState(cirq.QuantumStateRepresentation):
         pass
 
 
-class DummySimulationState(cirq.SimulationState):
+class ExampleSimulationState(cirq.SimulationState):
     def __init__(self, fallback_result: Any = NotImplemented):
-        super().__init__(prng=np.random.RandomState(), state=DummyQuantumState())
+        super().__init__(prng=np.random.RandomState(), state=ExampleQuantumState())
         self.fallback_result = fallback_result
 
     def _act_on_fallback_(
@@ -43,18 +43,18 @@ op = cirq.X(cirq.LineQubit(0))
 
 
 def test_act_on_fallback_succeeds():
-    state = DummySimulationState(fallback_result=True)
+    state = ExampleSimulationState(fallback_result=True)
     cirq.act_on(op, state)
 
 
 def test_act_on_fallback_fails():
-    state = DummySimulationState(fallback_result=NotImplemented)
+    state = ExampleSimulationState(fallback_result=NotImplemented)
     with pytest.raises(TypeError, match='Failed to act'):
         cirq.act_on(op, state)
 
 
 def test_act_on_fallback_errors():
-    state = DummySimulationState(fallback_result=False)
+    state = ExampleSimulationState(fallback_result=False)
     with pytest.raises(ValueError, match='_act_on_fallback_ must return True or NotImplemented'):
         cirq.act_on(op, state)
 
@@ -71,7 +71,7 @@ def test_act_on_errors():
         def _act_on_(self, sim_state):
             return False
 
-    state = DummySimulationState(fallback_result=True)
+    state = ExampleSimulationState(fallback_result=True)
     with pytest.raises(ValueError, match='_act_on_ must return True or NotImplemented'):
         cirq.act_on(Op(), state)
 
@@ -85,7 +85,7 @@ def test_qubits_not_allowed_for_operations():
         def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:  # type: ignore[empty-body]
             pass
 
-    state = DummySimulationState()
+    state = ExampleSimulationState()
     with pytest.raises(
         ValueError, match='Calls to act_on should not supply qubits if the action is an Operation'
     ):
@@ -93,6 +93,6 @@ def test_qubits_not_allowed_for_operations():
 
 
 def test_qubits_should_be_defined_for_operations():
-    state = DummySimulationState()
+    state = ExampleSimulationState()
     with pytest.raises(ValueError, match='Calls to act_on should'):
         cirq.act_on(cirq.KrausChannel([np.array([[1, 0], [0, 0]])]), state, qubits=None)

cirq/protocols/apply_channel_protocol.py

@@ -41,13 +41,16 @@ class ApplyChannelArgs:
     r"""Arguments for efficiently performing a channel.
 
     A channel performs the mapping
-        $$
-        X \rightarrow \sum_i A_i X A_i^\dagger
-        $$
+
+    $$
+    X \rightarrow \sum_i A_i X A_i^\dagger
+    $$
+
     for operators $A_i$ that satisfy the normalization condition
-        $$
-        \sum_i A_i^\dagger A_i = I.
-        $$
+
+    $$
+    \sum_i A_i^\dagger A_i = I.
+    $$
 
     The receiving object is expected to mutate `target_tensor` so that it
     contains the density matrix after multiplication, and then return

cirq/protocols/apply_unitary_protocol_test.py

@@ -201,7 +201,7 @@ def test_apply_unitary_args_tensor_manipulation():
                 )
                 * 1j
             )  # yapf: disable
-            # Flatten last two axes and add a dummy index to the end of
+            # Flatten last two axes and add another fake index to the end of
             # target_tensor so np.matmul treats it like an array of two-qubit
             # column vectors.
             new_shape = args.target_tensor.shape[:-2] + (4, 1)

cirq/protocols/equal_up_to_global_phase_protocol_test.py

@@ -83,7 +83,7 @@ def test_equal_up_to_global_mixed_array_types():
     assert not cirq.equal_up_to_global_phase([], [[]], atol=0.0)
 
 
-# Dummy container class implementing _equal_up_to_global_phase_
+# Example container class implementing _equal_up_to_global_phase_
 # for homogeneous comparison, with nontrivial getter.
 class A:
     def __init__(self, val):
@@ -95,7 +95,7 @@ class A:
         return cirq.equal_up_to_global_phase(self.val[0], other.val[0], atol=atol)
 
 
-# Dummy container class implementing _equal_up_to_global_phase_
+# Example container class implementing _equal_up_to_global_phase_
 # for heterogeneous comparison.
 class B:
     def __init__(self, val):

cirq/protocols/has_stabilizer_effect_protocol.py

@@ -15,8 +15,18 @@
 from typing import Any, Optional
 
 from cirq.ops.clifford_gate import SingleQubitCliffordGate
+from cirq.ops.dense_pauli_string import DensePauliString
+from cirq._import import LazyLoader
+import cirq.protocols.unitary_protocol as unitary_protocol
+import cirq.protocols.has_unitary_protocol as has_unitary_protocol
+import cirq.protocols.qid_shape_protocol as qid_shape_protocol
+import cirq.protocols.decompose_protocol as decompose_protocol
 
-from cirq import protocols
+pauli_string_decomposition = LazyLoader(
+    "pauli_string_decomposition",
+    globals(),
+    "cirq.transformers.analytical_decompositions.pauli_string_decomposition",
+)
 
 
 def has_stabilizer_effect(val: Any) -> bool:
@@ -29,6 +39,7 @@ def has_stabilizer_effect(val: Any) -> bool:
         _strat_has_stabilizer_effect_from_has_stabilizer_effect,
         _strat_has_stabilizer_effect_from_gate,
         _strat_has_stabilizer_effect_from_unitary,
+        _strat_has_stabilizer_effect_from_decompose,
     ]
     for strat in strats:
         result = strat(val)
@@ -62,9 +73,44 @@ def _strat_has_stabilizer_effect_from_unitary(val: Any) -> Optional[bool]:
     2x2 unitaries.
     """
     # Do not try this strategy if there is no unitary or if the number of
-    # qubits is not 1 since that would be expensive.
-    qid_shape = protocols.qid_shape(val, default=None)
-    if qid_shape is None or len(qid_shape) != 1 or not protocols.has_unitary(val):
+    # qubits is greater than 3 since that would be expensive.
+    qid_shape = qid_shape_protocol.qid_shape(val, default=None)
+    if (
+        qid_shape is None
+        or len(qid_shape) > 3
+        or qid_shape != (2,) * len(qid_shape)
+        or not has_unitary_protocol.has_unitary(val)
+    ):
         return None
-    unitary = protocols.unitary(val)
-    return SingleQubitCliffordGate.from_unitary(unitary) is not None
+    unitary = unitary_protocol.unitary(val)
+    if len(qid_shape) == 1:
+        return SingleQubitCliffordGate.from_unitary(unitary) is not None
+
+    # Check if the action of the unitary on each single qubit pauli string leads to a pauli product.
+    # Source: https://quantumcomputing.stackexchange.com/a/13158
+    for q_idx in range(len(qid_shape)):
+        for g in 'XZ':
+            pauli_string = ['I'] * len(qid_shape)
+            pauli_string[q_idx] = g
+            ps = DensePauliString(pauli_string)
+            p = ps._unitary_()
+            if not pauli_string_decomposition.unitary_to_pauli_string(
+                (unitary @ p @ unitary.T.conj())
+            ):
+                return False
+    return True
+
+
+def _strat_has_stabilizer_effect_from_decompose(val: Any) -> Optional[bool]:
+    qid_shape = qid_shape_protocol.qid_shape(val, default=None)
+    if qid_shape is None or len(qid_shape) <= 3:
+        return None
+
+    decomposition = decompose_protocol.decompose_once(val, default=None)
+    if decomposition is None:
+        return None
+    for op in decomposition:
+        res = has_stabilizer_effect(op)
+        if not res:
+            return res
+    return True

cirq/protocols/has_stabilizer_effect_protocol_test.py

@@ -49,11 +49,9 @@ class EmptyOp(cirq.Operation):
 
     @property
     def qubits(self):
-        # coverage: ignore
         return (q,)
 
-    def with_qubits(self, *new_qubits):
-        # coverage: ignore
+    def with_qubits(self, *new_qubits):  # pragma: no cover
         return self
 
 
@@ -94,6 +92,10 @@ class OpWithUnitary(EmptyOp):
     def _unitary_(self):
         return self.unitary
 
+    @property
+    def qubits(self):
+        return cirq.LineQubit.range(self.unitary.shape[0].bit_length() - 1)
+
 
 def test_inconclusive():
     assert not cirq.has_stabilizer_effect(object())
@@ -127,9 +129,20 @@ def test_via_unitary():
     op3 = OpWithUnitary(np.array([[1, 0], [0, np.sqrt(1j)]]))
     assert not cirq.has_stabilizer_effect(op3)
 
+    # 2+ qubit cliffords
+    assert cirq.has_stabilizer_effect(cirq.CNOT)
+    assert cirq.has_stabilizer_effect(cirq.XX)
+    assert cirq.has_stabilizer_effect(cirq.ZZ)
+
+    # Non Cliffords
+    assert not cirq.has_stabilizer_effect(cirq.T)
+    assert not cirq.has_stabilizer_effect(cirq.CCNOT)
+    assert not cirq.has_stabilizer_effect(cirq.CCZ)
+
 
-def test_via_unitary_not_supported():
-    # Unitaries larger than 2x2 are not yet supported.
-    op = OpWithUnitary(cirq.unitary(cirq.CNOT))
-    assert not cirq.has_stabilizer_effect(op)
-    assert not cirq.has_stabilizer_effect(op)
+def test_via_decompose():
+    assert cirq.has_stabilizer_effect(cirq.Circuit(cirq.H.on_each(cirq.LineQubit.range(4))))
+    assert not cirq.has_stabilizer_effect(cirq.Circuit(cirq.T.on_each(cirq.LineQubit.range(4))))
+    assert not cirq.has_stabilizer_effect(
+        OpWithUnitary(cirq.unitary(cirq.Circuit(cirq.T.on_each(cirq.LineQubit.range(4)))))
+    )

cirq/protocols/has_unitary_protocol_test.py

@@ -213,9 +213,7 @@ class EmptyOp(cirq.Operation):
 
     @property
     def qubits(self):
-        # coverage: ignore
         return ()
 
-    def with_qubits(self, *new_qubits):
-        # coverage: ignore
+    def with_qubits(self, *new_qubits):  # pragma: no cover
         return self

cirq/protocols/json_serialization.py

@@ -113,7 +113,7 @@ def _register_resolver(dict_factory: Callable[[], Dict[str, ObjectFactory]]) ->
 class SupportsJSON(Protocol):
     """An object that can be turned into JSON dictionaries.
 
-    The magic method _json_dict_ must return a trivially json-serializable
+    The magic method `_json_dict_` must return a trivially json-serializable
     type or other objects that support the SupportsJSON protocol.
 
     During deserialization, a class must be able to be resolved (see
@@ -150,7 +150,7 @@ def obj_to_dict_helper(obj: Any, attribute_names: Iterable[str]) -> Dict[str, An
     """Construct a dictionary containing attributes from obj
 
     This is useful as a helper function in objects implementing the
-    SupportsJSON protocol, particularly in the _json_dict_ method.
+    SupportsJSON protocol, particularly in the `_json_dict_` method.
 
     In addition to keys and values specified by `attribute_names`, the
     returned dictionary has an additional key "cirq_type" whose value
@@ -169,7 +169,7 @@ def obj_to_dict_helper(obj: Any, attribute_names: Iterable[str]) -> Dict[str, An
 
 # pylint: enable=redefined-builtin
 def dataclass_json_dict(obj: Any) -> Dict[str, Any]:
-    """Return a dictionary suitable for _json_dict_ from a dataclass.
+    """Return a dictionary suitable for `_json_dict_` from a dataclass.
 
     Dataclasses keep track of their relevant fields, so we can automatically generate these.
 
@@ -303,7 +303,7 @@ class CirqEncoder(json.JSONEncoder):
         if isinstance(o, datetime.datetime):
             return {'cirq_type': 'datetime.datetime', 'timestamp': o.timestamp()}
 
-        return super().default(o)  # coverage: ignore
+        return super().default(o)  # pragma: no cover
 
 
 def _cirq_object_hook(d, resolvers: Sequence[JsonResolver], context_map: Dict[str, Any]):
@@ -607,7 +607,7 @@ def to_json(
         cls: Passed to json.dump; the default value of CirqEncoder
             enables the serialization of Cirq objects which implement
             the SupportsJSON protocol. To support serialization of 3rd
-            party classes, prefer adding the _json_dict_ magic method
+            party classes, prefer adding the `_json_dict_` magic method
             to your classes rather than overriding this default.
     """
     if has_serializable_by_keys(obj):
@@ -631,7 +631,7 @@ def to_json(
                             return _json_dict_with_cirq_type(candidate.obj)
                         else:
                             return _json_dict_with_cirq_type(_SerializedKey(candidate.key))
-                raise ValueError("Object mutated during serialization.")  # coverage: ignore
+                raise ValueError("Object mutated during serialization.")  # pragma: no cover
 
         cls = ContextualEncoder
 

cirq/protocols/json_serialization_test.py

@@ -237,7 +237,7 @@ def test_not_yet_serializable_no_superfluous(mod_spec: ModuleJsonTestSpec):
 
 
 @pytest.mark.parametrize('mod_spec', MODULE_TEST_SPECS, ids=repr)
-def test_mutually_exclusive_blacklist(mod_spec: ModuleJsonTestSpec):
+def test_mutually_exclusive_lists(mod_spec: ModuleJsonTestSpec):
     common = set(mod_spec.should_not_be_serialized) & set(mod_spec.not_yet_serializable)
     assert len(common) == 0, (
         f"Defined in both {mod_spec.name} 'Not yet serializable' "
@@ -489,8 +489,7 @@ def test_json_test_data_coverage(mod_spec: ModuleJsonTestSpec, cirq_obj_name: st
     json_path2 = test_data_path / f'{cirq_obj_name}.json_inward'
     deprecation_deadline = mod_spec.deprecated.get(cirq_obj_name)
 
-    if not json_path.exists() and not json_path2.exists():
-        # coverage: ignore
+    if not json_path.exists() and not json_path2.exists():  # pragma: no cover
         pytest.fail(
             f"Hello intrepid developer. There is a new public or "
             f"serializable object named '{cirq_obj_name}' in the module '{mod_spec.name}' "
@@ -634,10 +633,9 @@ def test_to_from_json_gzip():
 def _eval_repr_data_file(path: pathlib.Path, deprecation_deadline: Optional[str]):
     content = path.read_text()
     ctx_managers: List[contextlib.AbstractContextManager] = [contextlib.suppress()]
-    if deprecation_deadline:
+    if deprecation_deadline:  # pragma: no cover
         # we ignore coverage here, because sometimes there are no deprecations at all in any of the
         # modules
-        # coverage: ignore
         ctx_managers = [cirq.testing.assert_deprecated(deadline=deprecation_deadline, count=None)]
 
     for deprecation in TESTED_MODULES.values():
@@ -681,12 +679,10 @@ def assert_repr_and_json_test_data_agree(
         )
         with ctx_manager:
             json_obj = cirq.read_json(json_text=json_from_file)
-    except ValueError as ex:  # coverage: ignore
-        # coverage: ignore
+    except ValueError as ex:  # pragma: no cover
         if "Could not resolve type" in str(ex):
             mod_path = mod_spec.name.replace(".", "/")
             rel_resolver_cache_path = f"{mod_path}/json_resolver_cache.py"
-            # coverage: ignore
             pytest.fail(
                 f"{rel_json_path} can't be parsed to JSON.\n"
                 f"Maybe an entry is missing from the "
@@ -694,17 +690,14 @@ def assert_repr_and_json_test_data_agree(
             )
         else:
             raise ValueError(f"deprecation: {deprecation_deadline} - got error: {ex}")
-    except AssertionError as ex:  # coverage: ignore
-        # coverage: ignore
+    except AssertionError as ex:  # pragma: no cover
         raise ex
-    except Exception as ex:  # coverage: ignore
-        # coverage: ignore
+    except Exception as ex:  # pragma: no cover
         raise IOError(f'Failed to parse test json data from {rel_json_path}.') from ex
 
     try:
         repr_obj = _eval_repr_data_file(repr_path, deprecation_deadline)
-    except Exception as ex:  # coverage: ignore
-        # coverage: ignore
+    except Exception as ex:  # pragma: no cover
         raise IOError(f'Failed to parse test repr data from {rel_repr_path}.') from ex
 
     assert proper_eq(json_obj, repr_obj), (

cirq/protocols/json_test_data/InsertionNoiseModel.json

@@ -0,0 +1,91 @@
+[
+    {
+        "cirq_type": "InsertionNoiseModel",
+        "ops_added": [
+            [
+            {
+                "cirq_type": "OpIdentifier",
+                "gate_type": "XPowGate",
+                "qubits": [
+                {
+                    "cirq_type": "LineQubit",
+                    "x": 0
+                }
+                ]
+            },
+            {
+                "cirq_type": "GateOperation",
+                "gate": {
+                "cirq_type": "BitFlipChannel",
+                "p": 0.2
+                },
+                "qubits": [
+                {
+                    "cirq_type": "LineQubit",
+                    "x": 0
+                }
+                ]
+            }
+            ]
+        ],
+        "prepend": false,
+        "require_physical_tag": false
+    },
+    {
+        "cirq_type": "InsertionNoiseModel",
+        "ops_added": [
+            [
+            {
+                "cirq_type": "OpIdentifier",
+                "gate_type": "XPowGate",
+                "qubits": [
+                {
+                    "cirq_type": "LineQubit",
+                    "x": 0
+                }
+                ]
+            },
+            {
+                "cirq_type": "GateOperation",
+                "gate": {
+                "cirq_type": "BitFlipChannel",
+                "p": 0.2
+                },
+                "qubits": [
+                {
+                    "cirq_type": "LineQubit",
+                    "x": 0
+                }
+                ]
+            }
+            ],
+            [
+            {
+                "cirq_type": "OpIdentifier",
+                "gate_type": "HPowGate",
+                "qubits": [
+                {
+                    "cirq_type": "LineQubit",
+                    "x": 1
+                }
+                ]
+            },
+            {
+                "cirq_type": "GateOperation",
+                "gate": {
+                "cirq_type": "BitFlipChannel",
+                "p": 0.1
+                },
+                "qubits": [
+                {
+                    "cirq_type": "LineQubit",
+                    "x": 1
+                }
+                ]
+            }
+            ]
+        ],
+        "prepend": false,
+        "require_physical_tag": false
+    }
+]

cirq/protocols/json_test_data/InsertionNoiseModel.repr

@@ -0,0 +1,4 @@
+[
+cirq.devices.InsertionNoiseModel(ops_added={cirq.devices.noise_utils.OpIdentifier(cirq.ops.common_gates.XPowGate, cirq.LineQubit(0)): cirq.bit_flip(p=0.2).on(cirq.LineQubit(0))}, prepend=False, require_physical_tag=False),
+cirq.devices.InsertionNoiseModel(ops_added={cirq.devices.noise_utils.OpIdentifier(cirq.ops.common_gates.XPowGate, cirq.LineQubit(0)): cirq.bit_flip(p=0.2).on(cirq.LineQubit(0)), cirq.devices.noise_utils.OpIdentifier(cirq.ops.common_gates.HPowGate, cirq.LineQubit(1)): cirq.bit_flip(p=0.1).on(cirq.LineQubit(1))}, prepend=False, require_physical_tag=False)
+]

cirq/protocols/json_test_data/OpIdentifier.json

@@ -1,10 +1,45 @@
-{
-  "cirq_type": "OpIdentifier",
-  "gate_type": "XPowGate",
-  "qubits": [
-    {
-      "cirq_type": "LineQubit",
-      "x": 1
-    }
-  ]
-}
+[
+  {
+    "cirq_type": "OpIdentifier",
+    "gate_type": "XPowGate",
+    "qubits": [
+      {
+        "cirq_type": "LineQubit",
+        "x": 1
+      }
+    ]
+  },
+  {
+    "cirq_type": "OpIdentifier",
+    "gate_type": {
+      "cirq_type": "CliffordGate",
+      "n": 1,
+      "rs": [
+        false,
+        false
+      ],
+      "xs": [
+        [
+          true
+        ],
+        [
+          false
+        ]
+      ],
+      "zs": [
+        [
+          false
+        ],
+        [
+          true
+        ]
+      ]
+    },
+    "qubits": [
+      {
+        "cirq_type": "LineQubit",
+        "x": 0
+      }
+    ]
+  }
+]

cirq/protocols/json_test_data/OpIdentifier.repr

@@ -1,4 +1,10 @@
+[
 cirq.devices.noise_utils.OpIdentifier(
     cirq.ops.common_gates.XPowGate,
     cirq.LineQubit(1)
-)
+),
+cirq.devices.noise_utils.OpIdentifier(
+    cirq.CliffordGate.from_clifford_tableau(cirq.CliffordTableau(1,rs=np.array([False, False],dtype=np.dtype('bool')), xs=np.array([[True], [False]], dtype=np.dtype('bool')),zs=np.array([[False], [True]], dtype=np.dtype('bool')), initial_state=0)),
+    cirq.LineQubit(0)
+)
+]

cirq/protocols/json_test_data/spec.py

@@ -58,6 +58,7 @@ TestSpec = ModuleJsonTestSpec(
         'ZerosSampler',
     ],
     should_not_be_serialized=[
+        'ClassicalStateSimulator',
         # Heatmaps
         'Heatmap',
         'TwoQubitInteractionHeatmap',
@@ -89,6 +90,9 @@ TestSpec = ModuleJsonTestSpec(
         'LineInitialMapper',
         'MappingManager',
         'RouteCQC',
+        # Qubit Managers,
+        'SimpleQubitManager',
+        'GreedyQubitManager',
         # global objects
         'CONTROL_TAG',
         'PAULI_BASIS',

cirq/protocols/measurement_key_protocol_test.py

@@ -146,7 +146,7 @@ def test_non_measurement_with_key():
             assert False
 
         def num_qubits(self) -> int:
-            return 2  # coverage: ignore
+            return 2  # pragma: no cover
 
     assert not cirq.is_measurement(NonMeasurementGate())
 

cirq/protocols/unitary_protocol_test.py

@@ -64,7 +64,7 @@ class ReturnsMatrix(cirq.Gate):
         return m1
 
     def num_qubits(self):
-        return 1  # coverage: ignore
+        return 1  # pragma: no cover
 
 
 class FullyImplemented(cirq.Gate):
@@ -131,7 +131,7 @@ class DecomposableNoUnitary(cirq.Operation):
             yield ReturnsNotImplemented()(q)
 
 
-class DummyOperation(cirq.Operation):
+class ExampleOperation(cirq.Operation):
     qubits = ()
     with_qubits = NotImplemented
 
@@ -142,7 +142,7 @@ class DummyOperation(cirq.Operation):
         return ()
 
 
-class DummyComposite:
+class ExampleComposite:
     def _decompose_(self):
         return ()
 
@@ -209,7 +209,6 @@ def _test_gate_that_allocates_qubits(gate):
 def test_decompose_gate_that_allocates_clean_qubits(
     theta: float, phase_state: int, target_bitsize: int, ancilla_bitsize: int
 ):
-
     gate = testing.PhaseUsingCleanAncilla(theta, phase_state, target_bitsize, ancilla_bitsize)
     _test_gate_that_allocates_qubits(gate)
 
@@ -220,7 +219,6 @@ def test_decompose_gate_that_allocates_clean_qubits(
 def test_decompose_gate_that_allocates_dirty_qubits(
     phase_state: int, target_bitsize: int, ancilla_bitsize: int
 ):
-
     gate = testing.PhaseUsingDirtyAncilla(phase_state, target_bitsize, ancilla_bitsize)
     _test_gate_that_allocates_qubits(gate)
 
@@ -233,9 +231,9 @@ def test_decompose_and_get_unitary():
         _strat_unitary_from_decompose(DecomposableOperation((a, b), True)), m2
     )
     np.testing.assert_allclose(_strat_unitary_from_decompose(DecomposableOrder((a, b, c))), m3)
-    np.testing.assert_allclose(_strat_unitary_from_decompose(DummyOperation((a,))), np.eye(2))
-    np.testing.assert_allclose(_strat_unitary_from_decompose(DummyOperation((a, b))), np.eye(4))
-    np.testing.assert_allclose(_strat_unitary_from_decompose(DummyComposite()), np.eye(1))
+    np.testing.assert_allclose(_strat_unitary_from_decompose(ExampleOperation((a,))), np.eye(2))
+    np.testing.assert_allclose(_strat_unitary_from_decompose(ExampleOperation((a, b))), np.eye(4))
+    np.testing.assert_allclose(_strat_unitary_from_decompose(ExampleComposite()), np.eye(1))
     np.testing.assert_allclose(_strat_unitary_from_decompose(OtherComposite()), m2)
 
 
@@ -250,11 +248,11 @@ def test_decomposed_has_unitary():
 
     # Operations
     assert cirq.has_unitary(DecomposableOperation((a, b), True))
-    assert cirq.has_unitary(DummyOperation((a,)))
-    assert cirq.has_unitary(DummyOperation((a, b)))
+    assert cirq.has_unitary(ExampleOperation((a,)))
+    assert cirq.has_unitary(ExampleOperation((a, b)))
 
     # No qid shape
-    assert cirq.has_unitary(DummyComposite())
+    assert cirq.has_unitary(ExampleComposite())
     assert cirq.has_unitary(OtherComposite())
 
 
@@ -269,12 +267,12 @@ def test_decomposed_unitary():
     np.testing.assert_allclose(cirq.unitary(DecomposableOperation((a,), True)), m1)
     np.testing.assert_allclose(cirq.unitary(DecomposableOperation((a, b), True)), m2)
     np.testing.assert_allclose(cirq.unitary(DecomposableOrder((a, b, c))), m3)
-    np.testing.assert_allclose(cirq.unitary(DummyOperation((a,))), np.eye(2))
-    np.testing.assert_allclose(cirq.unitary(DummyOperation((a, b))), np.eye(4))
+    np.testing.assert_allclose(cirq.unitary(ExampleOperation((a,))), np.eye(2))
+    np.testing.assert_allclose(cirq.unitary(ExampleOperation((a, b))), np.eye(4))
     assert cirq.unitary(DecomposableNoUnitary((a,)), None) is None
 
     # No qid shape
-    np.testing.assert_allclose(cirq.unitary(DummyComposite()), np.eye(1))
+    np.testing.assert_allclose(cirq.unitary(ExampleComposite()), np.eye(1))
     np.testing.assert_allclose(cirq.unitary(OtherComposite()), m2)
 
 
@@ -305,8 +303,7 @@ def test_unitary_from_apply_unitary():
         def qubits(self):
             return (self.q,)
 
-        def with_qubits(self, *new_qubits):
-            # coverage: ignore
+        def with_qubits(self, *new_qubits):  # pragma: no cover
             return ApplyOp(*new_qubits)
 
         def _apply_unitary_(self, args):