Decompose controlled 1x1 unitary gates generically, not just GlobalPhaseGate

cirq-core/cirq/ops/controlled_gate.py

@@ -177,18 +177,21 @@ def _decompose_with_context_(
                 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.
+        # Handle global phase gates by checking if the unitary is a 1x1 matrix with a global phase
+        unitary = protocols.unitary(self.sub_gate, default=None)
+        if (
+            unitary is not None
+            and unitary.shape == (1, 1)
+            and np.isclose(np.abs(unitary[0, 0]), 1)
+        ):
             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))
+            angle = np.angle(unitary[0, 0])
             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)
+            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)
             num_controls = self.num_controls() + 1

cirq-core/cirq/ops/controlled_gate_test.py

@@ -737,3 +737,36 @@ def test_controlled_mixture():
     c_yes = cirq.ControlledGate(sub_gate=cirq.phase_flip(0.25), num_controls=1)
     assert cirq.has_mixture(c_yes)
     assert cirq.approx_eq(cirq.mixture(c_yes), [(0.75, np.eye(4)), (0.25, cirq.unitary(cirq.CZ))])
+
+
+@pytest.mark.parametrize(
+    "phase,num_controls,control_values",
+    [
+        (0, 1, (1,)),
+        (np.pi / 4, 1, (1,)),
+        (np.pi / 2, 2, (1, 0)),
+        (np.pi, 2, (0, 1)),
+        (2 * np.pi, 3, (1, 1, 1)),
+    ]
+)
+def test_controlled_global_phase_gate_unitary(phase, num_controls, control_values):
+    coefficient = np.exp(1j * phase)
+    sub_gate = cirq.GlobalPhaseGate(coefficient=coefficient)
+    controlled_gate = cirq.ControlledGate(
+        sub_gate=sub_gate, num_controls=num_controls, control_values=control_values
+    )
+    sub_unitary = cirq.unitary(sub_gate, default=None)
+    assert sub_unitary is not None
+    assert sub_unitary.shape == (1, 1)
+    assert np.isclose(np.abs(sub_unitary[0, 0]), 1.0)
+    assert not cirq.is_parameterized(sub_gate)
+
+    dim = 2**num_controls
+    diag_angles = np.zeros(dim)
+    control_index = sum(val * (2**i) for i, val in enumerate(reversed(control_values)))
+    diag_angles[control_index] = np.angle(coefficient)
+    expected_gate = cirq.DiagonalGate(diag_angles_radians=diag_angles)
+    qids = cirq.LineQubit.range(num_controls)
+    actual_unitary = cirq.unitary(controlled_gate)
+    expected_unitary = cirq.unitary(expected_gate.on(*qids))
+    cirq.testing.assert_allclose_up_to_global_phase(actual_unitary, expected_unitary, atol=1e-8)