cirq-core 1.5.0.dev20250226204345__py3-none-any.whl → 1.5.0.dev20250226222923__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.5.0.dev20250226204345"
+__version__ = "1.5.0.dev20250226222923"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.5.0.dev20250226204345"
+    assert cirq.__version__ == "1.5.0.dev20250226222923"

cirq/ops/controlled_gate.py

@@ -30,11 +30,13 @@ import numpy as np
 
 from cirq import protocols, value, _import
 from cirq.ops import (
-    raw_types,
+    control_values as cv,
     controlled_operation as cop,
-    op_tree,
+    diagonal_gate as dg,
+    global_phase_op as gp,
     matrix_gates,
-    control_values as cv,
+    op_tree,
+    raw_types,
 )
 
 if TYPE_CHECKING:
@@ -157,13 +159,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 +176,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,9 +208,18 @@ class ControlledGate(raw_types.Gate):
                 )
             )
             if self != controlled_z:
-                return protocols.decompose_once_with_qubits(
-                    controlled_z, qubits, NotImplemented, context=context
-                )
+                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]
 
         if isinstance(self.sub_gate, matrix_gates.MatrixGate):
             # Default decompositions of 2/3 qubit `cirq.MatrixGate` ignores global phase, which is
@@ -328,7 +348,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

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from types import NotImplementedType
-from typing import Union, Tuple, cast
+from typing import Any, cast, Optional, Sequence, Tuple, Union
 
 import numpy as np
 import pytest
@@ -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,61 @@ 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.GlobalPhaseGate(1j**0.7),
+        cirq.ZPowGate(exponent=1.2, global_shift=0.3),
+        cirq.CZPowGate(exponent=1.2, global_shift=0.3),
+        cirq.CCZPowGate(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))
+        if len(decomposed) < 1000:  # CCCCCZ rounding error explodes
+            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-1)
 
 
 def test_pow_inverse():

cirq/ops/controlled_operation.py

@@ -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 (

cirq/ops/global_phase_op.py

@@ -21,6 +21,7 @@ import sympy
 
 import cirq
 from cirq import value, protocols
+from cirq._compat import proper_repr
 from cirq.ops import raw_types, controlled_gate, control_values as cv
 
 
@@ -68,10 +69,10 @@ class GlobalPhaseGate(raw_types.Gate):
         return str(self.coefficient)
 
     def __repr__(self) -> str:
-        return f'cirq.GlobalPhaseGate({self.coefficient!r})'
+        return f'cirq.GlobalPhaseGate({proper_repr(self.coefficient)})'
 
     def _op_repr_(self, qubits: Sequence['cirq.Qid']) -> str:
-        return f'cirq.global_phase_operation({self.coefficient!r})'
+        return f'cirq.global_phase_operation({proper_repr(self.coefficient)})'
 
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['coefficient'])

cirq/ops/global_phase_op_test.py

@@ -33,7 +33,7 @@ def test_init():
 
 
 def test_protocols():
-    for p in [1, 1j, -1]:
+    for p in [1, 1j, -1, sympy.Symbol('s')]:
         cirq.testing.assert_implements_consistent_protocols(cirq.global_phase_operation(p))
 
     np.testing.assert_allclose(

{cirq_core-1.5.0.dev20250226204345.dist-info → cirq_core-1.5.0.dev20250226222923.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250226204345
+Version: 1.5.0.dev20250226222923
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers

{cirq_core-1.5.0.dev20250226204345.dist-info → cirq_core-1.5.0.dev20250226222923.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=Qq3ZcfgD-Nb81cEppQdJqhAyrVqXKtfXZYGXT0p-Wh0,34718
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=p9gMHJscbtDDkfHOaulvd3Aer0pwUF5AXpL89XR8dNw,8402
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=cUoPyOhB5bj5gnlY_O3Hrw65QsxGmxH-JOL1UQC2ftQ,1206
-cirq/_version_test.py,sha256=Gm3PtQBJC67hG4qCMnQL_TjCiGmw56m83AnS1H3-T5E,147
+cirq/_version.py,sha256=CKWJ2BvRhdloQnAyu-09wRIGEKC0k3vjuJbO3i4TT7o,1206
+cirq/_version_test.py,sha256=xdKx0vf8ykrjruFtuUY2DFmW7SjrLE0SnuoYRZYJX0o,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=p-vEOa-8GQ2cFIAdze-kd6C1un1uRvtujVPljVKaHBg,13557
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -281,9 +281,9 @@ cirq/ops/common_gates.py,sha256=izKH25lp0i_1Vrx9gwGzOIk1PxzOmMnq4MlFu4da4Vk,5817
 cirq/ops/common_gates_test.py,sha256=tNymwCOXCgVe6JnrHSq7kwzCO-ucQZYHdBF9cvdZRMo,46731
 cirq/ops/control_values.py,sha256=nNDN6pgz_aWkUfrpOZ9zHHD42AGFaplWhVQj9rmJwbQ,13410
 cirq/ops/control_values_test.py,sha256=iDtdQjL39u80MaR16XLp00LRZqWgJqC54cIeADWf0IY,12906
-cirq/ops/controlled_gate.py,sha256=8ELuov5mOUp_cNwwrwMEjB4NwDph4Cpi7ezABx86W8Y,14261
-cirq/ops/controlled_gate_test.py,sha256=oasofj1Qu4iD2xJffAGDSDB8FN0xzhn5t912rqkKUXI,23083
-cirq/ops/controlled_operation.py,sha256=7X6NgihCuV5iaK-ya9cYZHlBAgN-eFcOFZ3PhGYlkFY,13998
+cirq/ops/controlled_gate.py,sha256=g5pCZMcCbQFhAUeNUndMtnUVnTt8YoOaPql07Bc2Ogg,15511
+cirq/ops/controlled_gate_test.py,sha256=6Z_HaIbXXKOJOhwb2l_Dmtfx9tcggl_vYf8pkB_UDms,25205
+cirq/ops/controlled_operation.py,sha256=DBTv3zvynztbSE1PSTU3JXeurz7zb8In5gmeg6LLxyk,14057
 cirq/ops/controlled_operation_test.py,sha256=iRRkzxMmsChYiWYMuz5-q3xq2mWV1wJY8Y8QQ1ieP5c,16443
 cirq/ops/dense_pauli_string.py,sha256=cDEWmS_r0mD4djxgUdxfE9zCsefB5P6pbkGP89stbIE,24457
 cirq/ops/dense_pauli_string_test.py,sha256=duvgzhgTV9wuem4kDSwtL62SEUCThkz1tdP984-C4_s,21504
@@ -301,8 +301,8 @@ cirq/ops/gate_operation.py,sha256=VHyA2T-G7afqEjYhEA7yRT72tsQOPGxg8ULsGrSDBJc,13
 cirq/ops/gate_operation_test.py,sha256=3sXTtOR3tkrF6C0jCcDexC0qrHCiqcjRClsvc9NXPq8,17457
 cirq/ops/gateset.py,sha256=Tx1CIlve0RhnX9jHZsCVw7EHtfC6b3drbBncmCEtcsQ,21634
 cirq/ops/gateset_test.py,sha256=BY5UJ1k3NC0jz0d4yocyO1qcQU6e4UbN9mapWE7z7AM,16361
-cirq/ops/global_phase_op.py,sha256=4qYUov6BnBql2_yqUHI9DE60fLiLmCsKI9ZkfMLRRyo,4826
-cirq/ops/global_phase_op_test.py,sha256=FjtUsohIYabTtiGytvPQw9Rzkqd6dlT7qrj4oltDbTI,9814
+cirq/ops/global_phase_op.py,sha256=Un7IBSkKP_cpgViUOQIsIpuySfQK2qs9WXWvdUZiTEs,4885
+cirq/ops/global_phase_op_test.py,sha256=C-YMN5ja9IKKgmwC5w2sPDBpFr8p0pJrE5WFikCVZOg,9833
 cirq/ops/greedy_qubit_manager.py,sha256=O9qY8GB1KGxm3B7JEjq50sGVD51bNwTSupJpi3WUeAc,4039
 cirq/ops/greedy_qubit_manager_test.py,sha256=iVZDKes-r08raTiJHpYNmP-Dp89ok3hIU-QboL2BHdw,3300
 cirq/ops/identity.py,sha256=mlmyTQknjlomA8RdqS1SZOmyB4SXPSly1PDW75yfTJo,5892
@@ -1202,8 +1202,8 @@ cirq/work/sampler.py,sha256=bE5tmVkcR6cZZMLETxDfHehdsYUMbx2RvBeIBetehI4,19187
 cirq/work/sampler_test.py,sha256=hL2UWx3dz2ukZVNxWftiKVvJcQoLplLZdQm-k1QcA40,13282
 cirq/work/zeros_sampler.py,sha256=x1C7cup66a43n-3tm8QjhiqJa07qcJW10FxNp9jJ59Q,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.5.0.dev20250226204345.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250226204345.dist-info/METADATA,sha256=M5LP0p68YIfn74tPtQH9mXOGucUhy1ghTOTEcIjLiCQ,4817
-cirq_core-1.5.0.dev20250226204345.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250226204345.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250226204345.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250226222923.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250226222923.dist-info/METADATA,sha256=44Cbr9yUHFf9p1lHch-GG7R9DfOwETmOc7cqp-s3hRk,4817
+cirq_core-1.5.0.dev20250226222923.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250226222923.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250226222923.dist-info/RECORD,,