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

cirq/ops/greedy_qubit_manager_test.py

@@ -0,0 +1,98 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import cirq
+
+
+class GateAllocInDecompose(cirq.Gate):
+    def __init__(self, num_alloc: int = 1):
+        self.num_alloc = num_alloc
+
+    def _num_qubits_(self) -> int:
+        return 1
+
+    def _decompose_with_context_(self, qubits, context):
+        assert context is not None
+        qm = context.qubit_manager
+        for q in qm.qalloc(self.num_alloc):
+            yield cirq.CNOT(qubits[0], q)
+            qm.qfree([q])
+
+
+def test_greedy_qubit_manager():
+    def make_circuit(qm: cirq.QubitManager):
+        q = cirq.LineQubit.range(2)
+        g = GateAllocInDecompose(1)
+        context = cirq.DecompositionContext(qubit_manager=qm)
+        circuit = cirq.Circuit(
+            cirq.decompose_once(g.on(q[0]), context=context),
+            cirq.decompose_once(g.on(q[1]), context=context),
+        )
+        return circuit
+
+    qm = cirq.GreedyQubitManager(prefix="ancilla", size=1)
+    # Qubit manager with only 1 managed qubit. Will always repeat the same qubit.
+    circuit = make_circuit(qm)
+    cirq.testing.assert_has_diagram(
+        circuit,
+        """
+0: ───────────@───────
+              │
+1: ───────────┼───@───
+              │   │
+ancilla_0: ───X───X───
+        """,
+    )
+
+    qm = cirq.GreedyQubitManager(prefix="ancilla", size=2)
+    # Qubit manager with 2 managed qubits and maximize_reuse=False, tries to minimize adding
+    # additional data dependencies by minimizing qubit reuse.
+    circuit = make_circuit(qm)
+    cirq.testing.assert_has_diagram(
+        circuit,
+        """
+              ┌──┐
+0: ────────────@─────
+               │
+1: ────────────┼@────
+               ││
+ancilla_0: ────X┼────
+                │
+ancilla_1: ─────X────
+              └──┘
+        """,
+    )
+
+    qm = cirq.GreedyQubitManager(prefix="ancilla", size=2, maximize_reuse=True)
+    # Qubit manager with 2 managed qubits and maximize_reuse=True, tries to maximize reuse by
+    # potentially adding new data dependencies.
+    circuit = make_circuit(qm)
+    cirq.testing.assert_has_diagram(
+        circuit,
+        """
+0: ───────────@───────
+              │
+1: ───────────┼───@───
+              │   │
+ancilla_1: ───X───X───
+     """,
+    )
+
+
+def test_greedy_qubit_manager_preserves_order():
+    qm = cirq.GreedyQubitManager(prefix="anc")
+    ancillae = [cirq.q(f"anc_{i}") for i in range(100)]
+    assert qm.qalloc(100) == ancillae
+    qm.qfree(ancillae)
+    assert qm.qalloc(100) == ancillae

cirq/ops/linear_combinations.py

@@ -357,7 +357,7 @@ def _pauli_string_from_unit(unit: UnitPauliStringT, coefficient: Union[int, floa
     return PauliString(qubit_pauli_map=dict(unit), coefficient=coefficient)
 
 
-@value.value_equality(approximate=True)
+@value.value_equality(approximate=True, unhashable=True)
 class PauliSum:
     """Represents operator defined by linear combination of PauliStrings.
 

cirq/ops/named_qubit.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import functools
-from typing import Any, Dict, List, TYPE_CHECKING
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
 
 from cirq import protocols
 from cirq.ops import raw_types
@@ -26,17 +26,52 @@ if TYPE_CHECKING:
 class _BaseNamedQid(raw_types.Qid):
     """The base class for `NamedQid` and `NamedQubit`."""
 
-    def __init__(self, name: str) -> None:
-        self._name = name
-        self._comp_key = _pad_digits(name)
+    _name: str
+    _dimension: int
+    _comp_key: Optional[str] = None
+    _hash: Optional[int] = None
+
+    def __getstate__(self):
+        # Don't save hash when pickling; see #3777.
+        state = self.__dict__
+        if "_hash" in state or "_comp_key" in state:
+            state = state.copy()
+            if "_hash" in state:
+                del state["_hash"]
+            if "_comp_key" in state:
+                del state["_comp_key"]
+        return state
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash((self._name, self._dimension))
+        return self._hash
+
+    def __eq__(self, other):
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseNamedQid):
+            return self._name == other._name and self._dimension == other._dimension
+        return NotImplemented
+
+    def __ne__(self, other):
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseNamedQid):
+            return self._name != other._name or self._dimension != other._dimension
+        return NotImplemented
 
     def _comparison_key(self):
+        if self._comp_key is None:
+            self._comp_key = _pad_digits(self._name)
         return self._comp_key
 
     @property
     def name(self) -> str:
         return self._name
 
+    @property
+    def dimension(self) -> int:
+        return self._dimension
+
     def with_dimension(self, dimension: int) -> 'NamedQid':
         return NamedQid(self._name, dimension=dimension)
 
@@ -59,19 +94,15 @@ class NamedQid(_BaseNamedQid):
             dimension: The dimension of the qid's Hilbert space, i.e.
                 the number of quantum levels.
         """
-        super().__init__(name)
-        self._dimension = dimension
         self.validate_dimension(dimension)
-
-    @property
-    def dimension(self) -> int:
-        return self._dimension
+        self._name = name
+        self._dimension = dimension
 
     def __repr__(self) -> str:
-        return f'cirq.NamedQid({self.name!r}, dimension={self.dimension})'
+        return f'cirq.NamedQid({self._name!r}, dimension={self._dimension})'
 
     def __str__(self) -> str:
-        return f'{self.name} (d={self.dimension})'
+        return f'{self._name} (d={self._dimension})'
 
     @staticmethod
     def range(*args, prefix: str, dimension: int) -> List['NamedQid']:
@@ -95,7 +126,7 @@ class NamedQid(_BaseNamedQid):
         Returns:
             A list of ``NamedQid``\\s.
         """
-        return [NamedQid(prefix + str(i), dimension=dimension) for i in range(*args)]
+        return [NamedQid(f"{prefix}{i}", dimension=dimension) for i in range(*args)]
 
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['name', 'dimension'])
@@ -110,14 +141,20 @@ class NamedQubit(_BaseNamedQid):
     wire for 'qubit3' will correctly come before 'qubit22'.
     """
 
-    @property
-    def dimension(self) -> int:
-        return 2
+    _dimension = 2
+
+    def __init__(self, name: str) -> None:
+        """Initializes a `NamedQubit` with a given name.
+
+        Args:
+            name: The name.
+        """
+        self._name = name
 
     def _cmp_tuple(self):
         cls = NamedQid if type(self) is NamedQubit 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)
+        return (cls.__name__, repr(cls), self._comparison_key(), self._dimension)
 
     def __str__(self) -> str:
         return self._name
@@ -146,7 +183,7 @@ class NamedQubit(_BaseNamedQid):
         Returns:
             A list of ``NamedQubit``\\s.
         """
-        return [NamedQubit(prefix + str(i)) for i in range(*args)]
+        return [NamedQubit(f"{prefix}{i}") for i in range(*args)]
 
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['name'])

cirq/ops/parity_gates.py

@@ -14,7 +14,7 @@
 
 """Quantum gates that phase with respect to product-of-pauli observables."""
 
-from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
+from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING, Sequence
 from typing_extensions import Self
 
 import numpy as np
@@ -22,12 +22,21 @@ import numpy as np
 from cirq import protocols, value
 from cirq._compat import proper_repr
 from cirq._doc import document
-from cirq.ops import gate_features, eigen_gate, common_gates, pauli_gates
+from cirq.ops import (
+    gate_features,
+    eigen_gate,
+    common_gates,
+    pauli_gates,
+    clifford_gate,
+    pauli_interaction_gate,
+)
+
 
 if TYPE_CHECKING:
     import cirq
 
 
+@value.value_equality
 class XXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     r"""The X-parity gate, possibly raised to a power.
 
@@ -86,25 +95,29 @@ class XXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
     def _decompose_into_clifford_with_qubits_(self, qubits):
-        from cirq.ops.clifford_gate import SingleQubitCliffordGate
-        from cirq.ops.pauli_interaction_gate import PauliInteractionGate
-
         if self.exponent % 2 == 0:
             return []
         if self.exponent % 2 == 0.5:
             return [
-                PauliInteractionGate(pauli_gates.X, False, pauli_gates.X, False).on(*qubits),
-                SingleQubitCliffordGate.X_sqrt.on_each(*qubits),
+                pauli_interaction_gate.PauliInteractionGate(
+                    pauli_gates.X, False, pauli_gates.X, False
+                ).on(*qubits),
+                clifford_gate.SingleQubitCliffordGate.X_sqrt.on_each(*qubits),
             ]
         if self.exponent % 2 == 1:
-            return [SingleQubitCliffordGate.X.on_each(*qubits)]
+            return [clifford_gate.SingleQubitCliffordGate.X.on_each(*qubits)]
         if self.exponent % 2 == 1.5:
             return [
-                PauliInteractionGate(pauli_gates.X, False, pauli_gates.X, False).on(*qubits),
-                SingleQubitCliffordGate.X_nsqrt.on_each(*qubits),
+                pauli_interaction_gate.PauliInteractionGate(
+                    pauli_gates.X, False, pauli_gates.X, False
+                ).on(*qubits),
+                clifford_gate.SingleQubitCliffordGate.X_nsqrt.on_each(*qubits),
             ]
         return NotImplemented
 
+    def _has_stabilizer_effect_(self) -> bool:
+        return self.exponent % 2 in (0, 0.5, 1, 1.5)
+
     def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> 'cirq.OP_TREE':
         yield common_gates.YPowGate(exponent=-0.5).on_each(*qubits)
         yield ZZPowGate(exponent=self.exponent, global_shift=self.global_shift)(*qubits)
@@ -133,6 +146,7 @@ class XXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         )
 
 
+@value.value_equality
 class YYPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     r"""The Y-parity gate, possibly raised to a power.
 
@@ -190,25 +204,29 @@ class YYPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
     def _decompose_into_clifford_with_qubits_(self, qubits):
-        from cirq.ops.clifford_gate import SingleQubitCliffordGate
-        from cirq.ops.pauli_interaction_gate import PauliInteractionGate
-
         if self.exponent % 2 == 0:
             return []
         if self.exponent % 2 == 0.5:
             return [
-                PauliInteractionGate(pauli_gates.Y, False, pauli_gates.Y, False).on(*qubits),
-                SingleQubitCliffordGate.Y_sqrt.on_each(*qubits),
+                pauli_interaction_gate.PauliInteractionGate(
+                    pauli_gates.Y, False, pauli_gates.Y, False
+                ).on(*qubits),
+                clifford_gate.SingleQubitCliffordGate.Y_sqrt.on_each(*qubits),
             ]
         if self.exponent % 2 == 1:
-            return [SingleQubitCliffordGate.Y.on_each(*qubits)]
+            return [clifford_gate.SingleQubitCliffordGate.Y.on_each(*qubits)]
         if self.exponent % 2 == 1.5:
             return [
-                PauliInteractionGate(pauli_gates.Y, False, pauli_gates.Y, False).on(*qubits),
-                SingleQubitCliffordGate.Y_nsqrt.on_each(*qubits),
+                pauli_interaction_gate.PauliInteractionGate(
+                    pauli_gates.Y, False, pauli_gates.Y, False
+                ).on(*qubits),
+                clifford_gate.SingleQubitCliffordGate.Y_nsqrt.on_each(*qubits),
             ]
         return NotImplemented
 
+    def _has_stabilizer_effect_(self) -> bool:
+        return self.exponent % 2 in (0, 0.5, 1, 1.5)
+
     def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> 'cirq.OP_TREE':
         yield common_gates.XPowGate(exponent=0.5).on_each(*qubits)
         yield ZZPowGate(exponent=self.exponent, global_shift=self.global_shift)(*qubits)
@@ -237,6 +255,7 @@ class YYPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         )
 
 
+@value.value_equality
 class ZZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     r"""The Z-parity gate, possibly raised to a power.
 
@@ -262,6 +281,34 @@ class ZZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             exponent=-2 * self.exponent, global_shift=-self.global_shift / 2
         )(qubits[0], qubits[1])
 
+    def _decompose_into_clifford_with_qubits_(
+        self, qubits: Sequence['cirq.Qid']
+    ) -> Sequence[Union['cirq.Operation', Sequence['cirq.Operation']]]:
+        if not self._has_stabilizer_effect_():
+            return NotImplemented
+        if self.exponent % 2 == 0:
+            return []
+        if self.exponent % 2 == 1:
+            return clifford_gate.SingleQubitCliffordGate.Z.on_each(*qubits)
+
+        if self.exponent % 2 == 0.5:
+            return [
+                pauli_interaction_gate.PauliInteractionGate(
+                    pauli_gates.Z, False, pauli_gates.Z, False
+                ).on(*qubits),
+                clifford_gate.SingleQubitCliffordGate.Z_sqrt.on_each(*qubits),
+            ]
+        else:
+            return [
+                pauli_interaction_gate.PauliInteractionGate(
+                    pauli_gates.Z, False, pauli_gates.Z, False
+                ).on(*qubits),
+                clifford_gate.SingleQubitCliffordGate.Z_nsqrt.on_each(*qubits),
+            ]
+
+    def _has_stabilizer_effect_(self) -> bool:
+        return self.exponent % 2 in (0, 0.5, 1, 1.5)
+
     def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0, 0, 1])), (1, np.diag([0, 1, 1, 0]))]
 

cirq/ops/parity_gates_test.py

@@ -257,8 +257,24 @@ def test_trace_distance():
 
 def test_ms_arguments():
     eq_tester = cirq.testing.EqualsTester()
-    eq_tester.add_equality_group(cirq.ms(np.pi / 2), cirq.ops.MSGate(rads=np.pi / 2))
-    eq_tester.add_equality_group(cirq.XXPowGate(global_shift=-0.5))
+    eq_tester.add_equality_group(
+        cirq.ms(np.pi / 2), cirq.ops.MSGate(rads=np.pi / 2), cirq.XXPowGate(global_shift=-0.5)
+    )
+    eq_tester.add_equality_group(
+        cirq.ms(np.pi / 4), cirq.XXPowGate(exponent=0.5, global_shift=-0.5)
+    )
+    eq_tester.add_equality_group(cirq.XX)
+    eq_tester.add_equality_group(cirq.XX**0.5)
+
+
+def test_ms_equal_up_to_global_phase():
+    assert cirq.equal_up_to_global_phase(cirq.ms(np.pi / 2), cirq.XX)
+    assert cirq.equal_up_to_global_phase(cirq.ms(np.pi / 4), cirq.XX**0.5)
+    assert not cirq.equal_up_to_global_phase(cirq.ms(np.pi / 4), cirq.XX)
+
+    assert cirq.ms(np.pi / 2) in cirq.GateFamily(cirq.XX)
+    assert cirq.ms(np.pi / 4) in cirq.GateFamily(cirq.XX**0.5)
+    assert cirq.ms(np.pi / 4) not in cirq.GateFamily(cirq.XX)
 
 
 def test_ms_str():
@@ -316,3 +332,26 @@ def test_json_serialization():
         json_text=cirq.to_json(cirq.ms(np.pi / 2)), resolvers=[custom_resolver]
     ) == cirq.ms(np.pi / 2)
     assert custom_resolver('X') is None
+
+
+@pytest.mark.parametrize('gate_cls', (cirq.XXPowGate, cirq.YYPowGate, cirq.ZZPowGate))
+@pytest.mark.parametrize(
+    'exponent,is_clifford',
+    ((0, True), (0.5, True), (0.75, False), (1, True), (1.5, True), (-1.5, True)),
+)
+def test_clifford_protocols(gate_cls: type[cirq.EigenGate], exponent: float, is_clifford: bool):
+    gate = gate_cls(exponent=exponent)
+    assert hasattr(gate, '_decompose_into_clifford_with_qubits_')
+    if is_clifford:
+        clifford_decomposition = cirq.Circuit(
+            gate._decompose_into_clifford_with_qubits_(cirq.LineQubit.range(2))
+        )
+        assert cirq.has_stabilizer_effect(gate)
+        assert cirq.has_stabilizer_effect(clifford_decomposition)
+        if exponent == 0:
+            assert clifford_decomposition == cirq.Circuit()
+        else:
+            np.testing.assert_allclose(cirq.unitary(gate), cirq.unitary(clifford_decomposition))
+    else:
+        assert not cirq.has_stabilizer_effect(gate)
+        assert gate._decompose_into_clifford_with_qubits_(cirq.LineQubit.range(2)) is NotImplemented

cirq/ops/pauli_gates.py

@@ -26,7 +26,7 @@ if TYPE_CHECKING:
         _XEigenState,
         _YEigenState,
         _ZEigenState,
-    )  # coverage: ignore
+    )  # pragma: no cover
 
 
 class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
@@ -186,7 +186,7 @@ document(
 
     This is the `exponent=1` instance of the `cirq.XPowGate`.
 
-    The untary matrix of `cirq.X` is:
+    The unitary matrix of `cirq.X` is:
     $$
     \begin{bmatrix}
         0 & 1 \\

cirq/ops/pauli_string.py

@@ -92,7 +92,7 @@ document(
     """,
 )
 
-PAULI_GATE_LIKE = Union['cirq.Pauli', 'cirq.IdentityGate', str, int,]
+PAULI_GATE_LIKE = Union['cirq.Pauli', 'cirq.IdentityGate', str, int]
 document(
     PAULI_GATE_LIKE,
     """An object that can be interpreted as a Pauli gate.
@@ -1387,8 +1387,7 @@ class MutablePauliString(Generic[TKey]):
                     if gate.invert1:
                         self.inplace_after(gate.pauli0(q0))
 
-                else:
-                    # coverage: ignore
+                else:  # pragma: no cover
                     raise NotImplementedError(f"Unrecognized decomposed Clifford: {op!r}")
         return self
 
@@ -1617,7 +1616,7 @@ def _pass_single_clifford_gate_over(
     after_to_before: bool = False,
 ) -> bool:
     if qubit not in pauli_map:
-        return False  # coverage: ignore
+        return False  # pragma: no cover
     if not after_to_before:
         gate **= -1
     pauli, inv = gate.pauli_tuple(pauli_map[qubit])

cirq/ops/pauli_string_raw_types_test.py

@@ -48,12 +48,12 @@ def test_op_calls_validate():
 def test_on_wrong_number_qubits():
     q0, q1, q2 = _make_qubits(3)
 
-    class DummyGate(cirq.PauliStringGateOperation):
+    class ExampleGate(cirq.PauliStringGateOperation):
         def map_qubits(self, qubit_map):
             ps = self.pauli_string.map_qubits(qubit_map)
-            return DummyGate(ps)
+            return ExampleGate(ps)
 
-    g = DummyGate(cirq.PauliString({q0: cirq.X, q1: cirq.Y}))
+    g = ExampleGate(cirq.PauliString({q0: cirq.X, q1: cirq.Y}))
 
     _ = g.with_qubits(q1, q2)
     with pytest.raises(ValueError):

cirq/ops/pauli_string_test.py

@@ -732,11 +732,11 @@ def test_pass_operations_over_cz():
 
 
 def test_pass_operations_over_no_common_qubits():
-    class DummyGate(cirq.testing.SingleQubitGate):
+    class ExampleGate(cirq.testing.SingleQubitGate):
         pass
 
     q0, q1 = _make_qubits(2)
-    op0 = DummyGate()(q1)
+    op0 = ExampleGate()(q1)
     ps_before = cirq.PauliString({q0: cirq.Z})
     ps_after = cirq.PauliString({q0: cirq.Z})
     _assert_pass_over([op0], ps_before, ps_after)
@@ -1765,8 +1765,7 @@ def test_mutable_pauli_string_inplace_conjugate_by():
             self._qubits = qubits
 
         @property
-        def qubits(self):
-            # coverage: ignore
+        def qubits(self):  # pragma: no cover
             return self._qubits
 
         def with_qubits(self, *new_qubits):

cirq/ops/random_gate_channel_test.py

@@ -219,13 +219,13 @@ def test_stabilizer_supports_probability():
 
 
 def test_unsupported_stabilizer_safety():
-    from cirq.protocols.act_on_protocol_test import DummySimulationState
+    from cirq.protocols.act_on_protocol_test import ExampleSimulationState
 
     with pytest.raises(TypeError, match="act_on"):
         for _ in range(100):
-            cirq.act_on(cirq.X.with_probability(0.5), DummySimulationState(), qubits=())
+            cirq.act_on(cirq.X.with_probability(0.5), ExampleSimulationState(), qubits=())
     with pytest.raises(TypeError, match="act_on"):
-        cirq.act_on(cirq.X.with_probability(sympy.Symbol('x')), DummySimulationState(), qubits=())
+        cirq.act_on(cirq.X.with_probability(sympy.Symbol('x')), ExampleSimulationState(), qubits=())
 
     q = cirq.LineQubit(0)
     c = cirq.Circuit((cirq.X(q) ** 0.25).with_probability(0.5), cirq.measure(q, key='m'))

cirq/ops/raw_types.py

@@ -671,7 +671,7 @@ class Operation(metaclass=abc.ABCMeta):
         # Don't create gigantic matrices.
         shape = protocols.qid_shape_protocol.qid_shape(circuit12)
         if np.prod(shape, dtype=np.int64) > 2**10:
-            return NotImplemented  # coverage: ignore
+            return NotImplemented  # pragma: no cover
 
         m12 = protocols.unitary_protocol.unitary(circuit12, default=None)
         m21 = protocols.unitary_protocol.unitary(circuit21, default=None)

cirq/ops/raw_types_test.py

@@ -356,7 +356,7 @@ def test_gate_shape_protocol():
 def test_operation_shape():
     class FixedQids(cirq.Operation):
         def with_qubits(self, *new_qids):
-            raise NotImplementedError  # coverage: ignore
+            raise NotImplementedError  # pragma: no cover
 
     class QubitOp(FixedQids):
         @property
@@ -787,9 +787,9 @@ def test_tagged_act_on():
             pass
 
     q = cirq.LineQubit(1)
-    from cirq.protocols.act_on_protocol_test import DummySimulationState
+    from cirq.protocols.act_on_protocol_test import ExampleSimulationState
 
-    args = DummySimulationState()
+    args = ExampleSimulationState()
     cirq.act_on(YesActOn()(q).with_tags("test"), args)
     with pytest.raises(TypeError, match="Failed to act"):
         cirq.act_on(NoActOn()(q).with_tags("test"), args)
@@ -798,11 +798,11 @@ def test_tagged_act_on():
 
 
 def test_single_qubit_gate_validates_on_each():
-    class Dummy(cirq.testing.SingleQubitGate):
+    class Example(cirq.testing.SingleQubitGate):
         def matrix(self):
             pass
 
-    g = Dummy()
+    g = Example()
     assert g.num_qubits() == 1
 
     test_qubits = [cirq.NamedQubit(str(i)) for i in range(3)]

cirq/ops/three_qubit_gates.py

@@ -206,11 +206,13 @@ class CCZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         """
         if num_controls == 0:
             return self
+        sub_gate: 'cirq.Gate' = self
+        if self._global_shift == 0:
+            sub_gate = controlled_gate.ControlledGate(
+                common_gates.ZPowGate(exponent=self._exponent), num_controls=2
+            )
         return controlled_gate.ControlledGate(
-            controlled_gate.ControlledGate(
-                common_gates.ZPowGate(exponent=self._exponent, global_shift=self._global_shift),
-                num_controls=2,
-            ),
+            sub_gate,
             num_controls=num_controls,
             control_values=control_values,
             control_qid_shape=control_qid_shape,
@@ -518,11 +520,13 @@ class CCXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         """
         if num_controls == 0:
             return self
+        sub_gate: 'cirq.Gate' = self
+        if self._global_shift == 0:
+            sub_gate = controlled_gate.ControlledGate(
+                common_gates.XPowGate(exponent=self._exponent), num_controls=2
+            )
         return controlled_gate.ControlledGate(
-            controlled_gate.ControlledGate(
-                common_gates.XPowGate(exponent=self._exponent, global_shift=self._global_shift),
-                num_controls=2,
-            ),
+            sub_gate,
             num_controls=num_controls,
             control_values=control_values,
             control_qid_shape=control_qid_shape,