cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/ops/common_gates.py

@@ -25,12 +25,13 @@ Each of these are implemented as EigenGates, which means that they can be
 raised to a power (i.e. cirq.H**0.5). See the definition in EigenGate.
 """
 
+from types import NotImplementedType
 from typing import (
     Any,
     cast,
     Collection,
-    List,
     Dict,
+    List,
     Optional,
     Sequence,
     Tuple,
@@ -45,12 +46,9 @@ import cirq
 from cirq import protocols, value
 from cirq._compat import proper_repr
 from cirq._doc import document
-from cirq.ops import controlled_gate, eigen_gate, gate_features, raw_types, control_values as cv
-
-from cirq.type_workarounds import NotImplementedType
-
-from cirq.ops.swap_gates import ISWAP, SWAP, ISwapPowGate, SwapPowGate
+from cirq.ops import control_values as cv, controlled_gate, eigen_gate, gate_features, raw_types
 from cirq.ops.measurement_gate import MeasurementGate
+from cirq.ops.swap_gates import ISWAP, ISwapPowGate, SWAP, SwapPowGate
 
 if TYPE_CHECKING:
     import cirq
@@ -179,7 +177,7 @@ class XPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.X.on(*qubits)
         if self.exponent % 2 == 1.5:
             return SingleQubitCliffordGate.X_nsqrt.on(*qubits)
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _trace_distance_bound_(self) -> Optional[float]:
         if self._is_parameterized_() or self._dimension != 2:
@@ -260,11 +258,12 @@ class XPowGate(eigen_gate.EigenGate):
         return result
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
-        if protocols.is_parameterized(self) or self._dimension != 2:
-            return NotImplemented
+        if self._dimension != 2:
+            return NotImplemented  # pragma: no cover
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
-        angle = np.pi * self._exponent / 2
-        return value.LinearDict({'I': phase * np.cos(angle), 'X': -1j * phase * np.sin(angle)})
+        lib = sympy if protocols.is_parameterized(self) else np
+        angle = lib.pi * self._exponent / 2
+        return value.LinearDict({'I': phase * lib.cos(angle), 'X': -1j * phase * lib.sin(angle)})
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'
@@ -274,7 +273,7 @@ class XPowGate(eigen_gate.EigenGate):
         )
 
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         if self._global_shift == 0:
             if self._exponent == 1:
                 return args.format('x {0};\n', qubits[0])
@@ -290,9 +289,7 @@ class XPowGate(eigen_gate.EigenGate):
 
     def _phase_by_(self, phase_turns, qubit_index):
         """See `cirq.SupportsPhase`."""
-        return cirq.ops.phased_x_gate.PhasedXPowGate(
-            exponent=self._exponent, phase_exponent=phase_turns * 2
-        )
+        return _phased_x_or_pauli_gate(exponent=self._exponent, phase_exponent=phase_turns * 2)
 
     def _has_stabilizer_effect_(self) -> Optional[bool]:
         if self._is_parameterized_() or self._dimension != 2:
@@ -327,12 +324,6 @@ class XPowGate(eigen_gate.EigenGate):
             d['dimension'] = self.dimension
         return d
 
-    def _value_equality_values_(self):
-        return (*super()._value_equality_values_(), self._dimension)
-
-    def _value_equality_approximate_values_(self):
-        return (*super()._value_equality_approximate_values_(), self._dimension)
-
 
 class Rx(XPowGate):
     r"""A gate with matrix $e^{-i X t/2}$ that rotates around the X axis of the Bloch sphere by $t$.
@@ -376,7 +367,7 @@ class Rx(XPowGate):
         return f'cirq.Rx(rads={proper_repr(self._rads)})'
 
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         return args.format('rx({0:half_turns}) {1};\n', self._exponent, qubits[0])
 
     def _json_dict_(self) -> Dict[str, Any]:
@@ -452,7 +443,7 @@ class YPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.Y.on(*qubits)
         if self.exponent % 2 == 1.5:
             return SingleQubitCliffordGate.Y_nsqrt.on(*qubits)
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
         return [
@@ -466,11 +457,10 @@ class YPowGate(eigen_gate.EigenGate):
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
-        if protocols.is_parameterized(self):
-            return NotImplemented
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
-        angle = np.pi * self._exponent / 2
-        return value.LinearDict({'I': phase * np.cos(angle), 'Y': -1j * phase * np.sin(angle)})
+        lib = sympy if protocols.is_parameterized(self) else np
+        angle = lib.pi * self._exponent / 2
+        return value.LinearDict({'I': phase * lib.cos(angle), 'Y': -1j * phase * lib.sin(angle)})
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'
@@ -480,7 +470,7 @@ class YPowGate(eigen_gate.EigenGate):
         )
 
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         if self._exponent == 1 and self.global_shift != -0.5:
             return args.format('y {0};\n', qubits[0])
 
@@ -492,7 +482,7 @@ class YPowGate(eigen_gate.EigenGate):
 
     def _phase_by_(self, phase_turns, qubit_index):
         """See `cirq.SupportsPhase`."""
-        return cirq.ops.phased_x_gate.PhasedXPowGate(
+        return _phased_x_or_pauli_gate(
             exponent=self._exponent, phase_exponent=0.5 + phase_turns * 2
         )
 
@@ -562,7 +552,7 @@ class Ry(YPowGate):
         return f'cirq.Ry(rads={proper_repr(self._rads)})'
 
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         return args.format('ry({0:half_turns}) {1};\n', self._exponent, qubits[0])
 
     def _json_dict_(self) -> Dict[str, Any]:
@@ -658,7 +648,7 @@ class ZPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.Z.on(*qubits)
         if self.exponent % 2 == 1.5:
             return SingleQubitCliffordGate.Z_nsqrt.on(*qubits)
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def in_su2(self) -> 'Rz':
         """Returns an equal-up-global-phase gate from the group SU2."""
@@ -766,11 +756,12 @@ class ZPowGate(eigen_gate.EigenGate):
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
-        if protocols.is_parameterized(self) or self._dimension != 2:
-            return NotImplemented
+        if self._dimension != 2:
+            return NotImplemented  # pragma: no cover
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
-        angle = np.pi * self._exponent / 2
-        return value.LinearDict({'I': phase * np.cos(angle), 'Z': -1j * phase * np.sin(angle)})
+        lib = sympy if protocols.is_parameterized(self) else np
+        angle = lib.pi * self._exponent / 2
+        return value.LinearDict({'I': phase * lib.cos(angle), 'Z': -1j * phase * lib.sin(angle)})
 
     def _phase_by_(self, phase_turns: float, qubit_index: int):
         return self
@@ -793,7 +784,7 @@ class ZPowGate(eigen_gate.EigenGate):
         return protocols.CircuitDiagramInfo(wire_symbols=('Z',), exponent=e)
 
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
 
         if self.global_shift == 0:
             if self._exponent == 1:
@@ -863,12 +854,6 @@ class ZPowGate(eigen_gate.EigenGate):
             d['dimension'] = self.dimension
         return d
 
-    def _value_equality_values_(self):
-        return (*super()._value_equality_values_(), self._dimension)
-
-    def _value_equality_approximate_values_(self):
-        return (*super()._value_equality_approximate_values_(), self._dimension)
-
 
 class Rz(ZPowGate):
     r"""A gate with matrix $e^{-i Z t/2}$ that rotates around the Z axis of the Bloch sphere by $t$.
@@ -912,7 +897,7 @@ class Rz(ZPowGate):
         return f'cirq.Rz(rads={proper_repr(self._rads)})'
 
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         return args.format('rz({0:half_turns}) {1};\n', self._exponent, qubits[0])
 
     def _json_dict_(self) -> Dict[str, Any]:
@@ -983,7 +968,7 @@ class HPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.H.on(*qubits)
         if self.exponent % 2 == 0:
             return []
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
         if self._exponent != 1:
@@ -1018,7 +1003,7 @@ class HPowGate(eigen_gate.EigenGate):
         )
 
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         if self._exponent == 0:
             return args.format('id {0};\n', qubits[0])
         elif self._exponent == 1 and self._global_shift == 0:
@@ -1081,7 +1066,7 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             return PauliInteractionGate.CZ.on(*qubits)
         if self.exponent % 2 == 0:
             return []
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 1, 1, 0])), (1, np.diag([0, 0, 0, 1]))]
@@ -1206,7 +1191,7 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
         if self._exponent != 1:
             return None  # Don't have an equivalent gate in QASM
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         return args.format('cz {0},{1};\n', qubits[0], qubits[1])
 
     def _has_stabilizer_effect_(self) -> Optional[bool]:
@@ -1276,7 +1261,7 @@ class CXPowGate(eigen_gate.EigenGate):
             return PauliInteractionGate.CNOT.on(*qubits)
         if self.exponent % 2 == 0:
             return []
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _decompose_(self, qubits):
         c, t = qubits
@@ -1407,7 +1392,7 @@ class CXPowGate(eigen_gate.EigenGate):
     def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
         if self._exponent != 1:
             return None  # Don't have an equivalent gate in QASM
-        args.validate_version('2.0')
+        args.validate_version('2.0', '3.0')
         return args.format('cx {0},{1};\n', qubits[0], qubits[1])
 
     def _has_stabilizer_effect_(self) -> Optional[bool]:
@@ -1555,3 +1540,17 @@ document(
     $$
     """,
 )
+
+
+def _phased_x_or_pauli_gate(
+    exponent: Union[float, sympy.Expr], phase_exponent: Union[float, sympy.Expr]
+) -> Union['cirq.PhasedXPowGate', 'cirq.XPowGate', 'cirq.YPowGate']:
+    """Return PhasedXPowGate or X or Y gate if equivalent at the given phase_exponent."""
+    if not isinstance(phase_exponent, sympy.Expr) or phase_exponent.is_constant():
+        half_turns = value.canonicalize_half_turns(float(phase_exponent))
+        match half_turns:
+            case 0.0:
+                return XPowGate(exponent=exponent)
+            case 0.5:
+                return YPowGate(exponent=exponent)
+    return cirq.ops.PhasedXPowGate(exponent=exponent, phase_exponent=phase_exponent)

cirq/ops/common_gates_test.py

@@ -245,11 +245,12 @@ def test_rot_gates_eq():
     eq.add_equality_group(cirq.YPowGate(), cirq.YPowGate(exponent=1), cirq.Y)
     eq.add_equality_group(cirq.ZPowGate(), cirq.ZPowGate(exponent=1), cirq.Z)
     eq.add_equality_group(
-        cirq.ZPowGate(exponent=1, global_shift=-0.5), cirq.ZPowGate(exponent=5, global_shift=-0.5)
+        cirq.ZPowGate(exponent=1, global_shift=-0.5),
+        cirq.ZPowGate(exponent=5, global_shift=-0.5),
+        cirq.ZPowGate(exponent=5, global_shift=-0.1),
     )
     eq.add_equality_group(cirq.ZPowGate(exponent=3, global_shift=-0.5))
     eq.add_equality_group(cirq.ZPowGate(exponent=1, global_shift=-0.1))
-    eq.add_equality_group(cirq.ZPowGate(exponent=5, global_shift=-0.1))
     eq.add_equality_group(
         cirq.CNotPowGate(), cirq.CXPowGate(), cirq.CNotPowGate(exponent=1), cirq.CNOT
     )
@@ -307,6 +308,11 @@ def test_h_str():
     assert str(cirq.H**0.5) == 'H**0.5'
 
 
+def test_phase_exponent():
+    assert cirq.XPowGate(exponent=0.5).phase_exponent == 0.0
+    assert cirq.YPowGate(exponent=0.5).phase_exponent == 0.5
+
+
 def test_x_act_on_tableau():
     with pytest.raises(TypeError, match="Failed to act"):
         cirq.act_on(cirq.X, ExampleSimulationState(), qubits=())
@@ -1300,3 +1306,13 @@ def test_wrong_dims():
 
     with pytest.raises(ValueError, match='Wrong shape'):
         _ = cirq.Z.on(cirq.LineQid(0, dimension=3))
+
+
+@pytest.mark.parametrize('gate_type', [cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate])
+@pytest.mark.parametrize('exponent', [sympy.Symbol('s'), sympy.Symbol('s') * 2])
+def test_parameterized_pauli_expansion(gate_type, exponent):
+    gate = gate_type(exponent=exponent)
+    pauli = cirq.pauli_expansion(gate)
+    gate_resolved = cirq.resolve_parameters(gate, {'s': 0.5})
+    pauli_resolved = cirq.resolve_parameters(pauli, {'s': 0.5})
+    assert cirq.approx_eq(pauli_resolved, cirq.pauli_expansion(gate_resolved))

cirq/ops/control_values.py

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import abc
-from functools import cached_property
-from typing import Collection, Tuple, TYPE_CHECKING, Any, Dict, Iterator, Optional, Sequence, Union
 import itertools
+from functools import cached_property
+from typing import Any, Collection, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
 from cirq import protocols, value
 
@@ -275,7 +275,7 @@ class SumOfProducts(AbstractControlValues):
 
         if len(self._conjunctions) == 1:
             # Use a simpler diagram if there's only 1 term.
-            return protocols.CircuitDiagramInfo(
+            return protocols.CircuitDiagramInfo(  # pragma: no cover
                 wire_symbols=["@" if x == 1 else f"({x})" for x in self._conjunctions[0]]
             )
 

cirq/ops/control_values_test.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import cirq
 import pytest
 
+import cirq
+
 
 def test_init_sum_of_products_raises():
     # data shouldn't be empty.

cirq/ops/controlled_gate.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from types import NotImplementedType
 from typing import (
     AbstractSet,
     Any,
@@ -21,21 +22,21 @@ from typing import (
     Optional,
     Sequence,
     Tuple,
-    Union,
     TYPE_CHECKING,
+    Union,
 )
 
 import numpy as np
 
-from cirq import protocols, value, _import
+from cirq import _import, protocols, value
 from cirq.ops import (
-    raw_types,
+    control_values as cv,
     controlled_operation as cop,
+    diagonal_gate as dg,
+    global_phase_op as gp,
     op_tree,
-    matrix_gates,
-    control_values as cv,
+    raw_types,
 )
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
@@ -157,13 +158,13 @@ class ControlledGate(raw_types.Gate):
     def _decompose_with_context_(
         self, qubits: Tuple['cirq.Qid', ...], context: Optional['cirq.DecompositionContext'] = None
     ) -> Union[None, NotImplementedType, 'cirq.OP_TREE']:
+        control_qubits = list(qubits[: self.num_controls()])
         if (
             protocols.has_unitary(self.sub_gate)
             and protocols.num_qubits(self.sub_gate) == 1
             and self._qid_shape_() == (2,) * len(self._qid_shape_())
             and isinstance(self.control_values, cv.ProductOfSums)
         ):
-            control_qubits = list(qubits[: self.num_controls()])
             invert_ops: List['cirq.Operation'] = []
             for cvals, cqbit in zip(self.control_values, qubits[: self.num_controls()]):
                 if set(cvals) == {0}:
@@ -174,11 +175,20 @@ class ControlledGate(raw_types.Gate):
                 protocols.unitary(self.sub_gate), control_qubits, qubits[-1]
             )
             return invert_ops + decomposed_ops + invert_ops
-
+        if isinstance(self.sub_gate, gp.GlobalPhaseGate):
+            # A controlled global phase is a diagonal gate, where each active control value index
+            # is set equal to the phase angle.
+            shape = self.control_qid_shape
+            if protocols.is_parameterized(self.sub_gate) or set(shape) != {2}:
+                # Could work in theory, but DiagonalGate decompose does not support them.
+                return NotImplemented
+            angle = np.angle(complex(self.sub_gate.coefficient))
+            rads = np.zeros(shape=shape)
+            for hot in self.control_values.expand():
+                rads[hot] = angle
+            return dg.DiagonalGate(diag_angles_radians=[*rads.flatten()]).on(*qubits)
         if isinstance(self.sub_gate, common_gates.CZPowGate):
-            z_sub_gate = common_gates.ZPowGate(
-                exponent=self.sub_gate.exponent, global_shift=self.sub_gate.global_shift
-            )
+            z_sub_gate = common_gates.ZPowGate(exponent=self.sub_gate.exponent)
             num_controls = self.num_controls() + 1
             control_values = self.control_values & cv.ProductOfSums(((1,),))
             control_qid_shape = self.control_qid_shape + (2,)
@@ -197,15 +207,18 @@ class ControlledGate(raw_types.Gate):
                 )
             )
             if self != controlled_z:
-                return protocols.decompose_once_with_qubits(
-                    controlled_z, qubits, NotImplemented, context=context
-                )
-
-        if isinstance(self.sub_gate, matrix_gates.MatrixGate):
-            # Default decompositions of 2/3 qubit `cirq.MatrixGate` ignores global phase, which is
-            # local phase in the controlled variant and hence cannot be ignored.
-            return NotImplemented
-
+                result = controlled_z.on(*qubits)
+                if self.sub_gate.global_shift == 0:
+                    return result
+                # Reconstruct the controlled global shift of the subgate.
+                total_shift = self.sub_gate.exponent * self.sub_gate.global_shift
+                phase_gate = gp.GlobalPhaseGate(1j ** (2 * total_shift))
+                controlled_phase_op = phase_gate.controlled(
+                    num_controls=self.num_controls(),
+                    control_values=self.control_values,
+                    control_qid_shape=self.control_qid_shape,
+                ).on(*control_qubits)
+                return [result, controlled_phase_op]
         result = protocols.decompose_once_with_qubits(
             self.sub_gate,
             qubits[self.num_controls() :],
@@ -255,7 +268,7 @@ class ControlledGate(raw_types.Gate):
     def _has_mixture_(self) -> bool:
         return protocols.has_mixture(self.sub_gate)
 
-    def _mixture_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _mixture_(self) -> Union[Sequence[tuple[float, np.ndarray]], NotImplementedType]:
         qubits = line_qubit.LineQid.for_gate(self)
         op = self.sub_gate.on(*qubits[self.num_controls() :])
         c_op = cop.ControlledOperation(qubits[: self.num_controls()], op, self.control_values)
@@ -294,7 +307,7 @@ class ControlledGate(raw_types.Gate):
             return None
         u = protocols.unitary(self.sub_gate, default=None)
         if u is None:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         angle_list = np.append(np.angle(np.linalg.eigvals(u)), 0)
         return protocols.trace_distance_from_angle_list(angle_list)
 
@@ -328,7 +341,7 @@ class ControlledGate(raw_types.Gate):
         return str(self.control_values) + str(self.sub_gate)
 
     def __repr__(self) -> str:
-        if self.num_controls() == 1 and self.control_values.is_trivial:
+        if self.control_qid_shape == (2,) and self.control_values.is_trivial:
             return f'cirq.ControlledGate(sub_gate={self.sub_gate!r})'
 
         if self.control_values.is_trivial and set(self.control_qid_shape) == {2}:

cirq/ops/controlled_gate_test.py

@@ -12,14 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Union, Tuple, cast
+from types import NotImplementedType
+from typing import Any, cast, Optional, Sequence, Tuple, Union
 
 import numpy as np
 import pytest
 import sympy
 
 import cirq
-from cirq.type_workarounds import NotImplementedType
 
 
 class GateUsingWorkspaceForApplyUnitary(cirq.testing.SingleQubitGate):
@@ -408,6 +408,11 @@ def test_unitary():
             ),
             True,
         ),
+        (cirq.GlobalPhaseGate(-1), True),
+        (cirq.GlobalPhaseGate(1j**0.7), True),
+        (cirq.GlobalPhaseGate(sympy.Symbol("s")), False),
+        (cirq.CZPowGate(exponent=1.2, global_shift=0.3), True),
+        (cirq.CZPowGate(exponent=sympy.Symbol("s"), global_shift=0.3), False),
         # Single qudit gate with dimension 4.
         (cirq.MatrixGate(np.kron(*(cirq.unitary(cirq.H),) * 2), qid_shape=(4,)), False),
         (cirq.MatrixGate(cirq.testing.random_unitary(4, random_state=1234)), False),
@@ -420,11 +425,73 @@ def test_unitary():
     ],
 )
 def test_controlled_gate_is_consistent(gate: cirq.Gate, should_decompose_to_target):
-    cgate = cirq.ControlledGate(gate)
+    _test_controlled_gate_is_consistent(gate, should_decompose_to_target)
+
+
+@pytest.mark.parametrize(
+    'gate',
+    [
+        cirq.I,
+        cirq.GlobalPhaseGate(1),
+        cirq.GlobalPhaseGate(-1),
+        cirq.GlobalPhaseGate(1j),
+        cirq.GlobalPhaseGate(1j**0.7),
+        cirq.Z,
+        cirq.ZPowGate(exponent=1.2, global_shift=0.3),
+        cirq.CZ,
+        cirq.CZPowGate(exponent=1.2, global_shift=0.3),
+        cirq.CCZ,
+        cirq.CCZPowGate(exponent=1.2, global_shift=0.3),
+        cirq.X,
+        cirq.XPowGate(exponent=1.2, global_shift=0.3),
+        cirq.CX,
+        cirq.CXPowGate(exponent=1.2, global_shift=0.3),
+        cirq.CCX,
+        cirq.CCXPowGate(exponent=1.2, global_shift=0.3),
+    ],
+)
+@pytest.mark.parametrize(
+    'control_qid_shape, control_values, should_decompose_to_target',
+    [
+        ([2, 2], None, True),
+        ([2, 2], xor_control_values, False),
+        ([3], None, False),
+        ([3, 4], xor_control_values, False),
+    ],
+)
+def test_nontrivial_controlled_gate_is_consistent(
+    gate: cirq.Gate,
+    control_qid_shape: Sequence[int],
+    control_values: Any,
+    should_decompose_to_target: bool,
+):
+    _test_controlled_gate_is_consistent(
+        gate, should_decompose_to_target, control_qid_shape, control_values
+    )
+
+
+def _test_controlled_gate_is_consistent(
+    gate: cirq.Gate,
+    should_decompose_to_target: bool,
+    control_qid_shape: Optional[Sequence[int]] = None,
+    control_values: Any = None,
+):
+    cgate = cirq.ControlledGate(
+        gate, control_qid_shape=control_qid_shape, control_values=control_values
+    )
     cirq.testing.assert_implements_consistent_protocols(cgate)
     cirq.testing.assert_decompose_ends_at_default_gateset(
         cgate, ignore_known_gates=not should_decompose_to_target
     )
+    # The above only decompose once, which doesn't check that the sub-gate's phase is handled.
+    # We need to check full decomposition here.
+    if not cirq.is_parameterized(gate):
+        shape = cirq.qid_shape(cgate)
+        qids = cirq.LineQid.for_qid_shape(shape)
+        decomposed = cirq.decompose(cgate.on(*qids))
+        first_op = cirq.IdentityGate(qid_shape=shape).on(*qids)  # To ensure same qid order
+        circuit = cirq.Circuit(first_op, *decomposed)
+        np.testing.assert_allclose(cirq.unitary(cgate), cirq.unitary(circuit), atol=1e-13)
 
 
 def test_pow_inverse():

cirq/ops/controlled_operation.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from types import NotImplementedType
 from typing import (
     AbstractSet,
     Any,
@@ -21,24 +22,23 @@ from typing import (
     Optional,
     Sequence,
     Tuple,
-    Union,
     TYPE_CHECKING,
+    Union,
 )
 
 import numpy as np
 
 from cirq import protocols, qis, value
 from cirq.ops import (
-    controlled_gate,
     common_gates,
+    control_values as cv,
+    controlled_gate,
     eigen_gate,
     gate_operation,
     matrix_gates,
     op_tree,
     raw_types,
-    control_values as cv,
 )
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
@@ -212,6 +212,7 @@ class ControlledOperation(raw_types.Operation):
             hasattr(self._sub_operation, "gate")
             and len(self._controls) == 1
             and self.control_values == cv.ProductOfSums(((1,),))
+            and all(q.dimension == 2 for q in self.qubits)
         ):
             gate = self.sub_operation.gate
             if (
@@ -296,7 +297,7 @@ class ControlledOperation(raw_types.Operation):
             return None
         u = protocols.unitary(self.sub_operation, default=None)
         if u is None:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         angle_list = np.append(np.angle(np.linalg.eigvals(u)), 0)
         return protocols.trace_distance_from_angle_list(angle_list)
 

cirq/ops/controlled_operation_test.py

@@ -14,6 +14,7 @@
 
 import itertools
 import re
+from types import NotImplementedType
 from typing import cast, Tuple, Union
 
 import numpy as np
@@ -22,7 +23,6 @@ import sympy
 
 import cirq
 from cirq import protocols
-from cirq.type_workarounds import NotImplementedType
 
 
 class GateUsingWorkspaceForApplyUnitary(cirq.testing.SingleQubitGate):
@@ -159,7 +159,7 @@ def test_str():
             return ()
 
         def with_qubits(self, *new_qubits: cirq.Qid):
-            pass
+            return self
 
         def __str__(self):
             return "Op(q2)"
@@ -170,7 +170,11 @@ def test_str():
     assert str(cirq.ControlledOperation([c1, c2], SingleQubitOp())) == "CC(c1, c2, Op(q2))"
 
     assert (
-        str(cirq.ControlledOperation([c1, c2.with_dimension(3)], SingleQubitOp()))
+        str(
+            cirq.ControlledOperation(
+                [c1, c2.with_dimension(3)], SingleQubitOp().with_qubits(cirq.q(1))
+            )
+        )
         == "CC(c1, c2 (d=3), Op(q2))"
     )