cirq-core 1.5.0.dev20250404212936__py3-none-any.whl → 1.5.0.dev20250404235631__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.dev20250404212936"
+__version__ = "1.5.0.dev20250404235631"

cirq/_version_test.py

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

cirq/linalg/__init__.py

@@ -82,9 +82,11 @@ from cirq.linalg.tolerance import (
 from cirq.linalg.transformations import (
     apply_matrix_to_slices as apply_matrix_to_slices,
     density_matrix_kronecker_product as density_matrix_kronecker_product,
+    can_numpy_support_shape as can_numpy_support_shape,
     match_global_phase as match_global_phase,
     partial_trace as partial_trace,
     partial_trace_of_state_vector_as_mixture as partial_trace_of_state_vector_as_mixture,
+    phase_delta as phase_delta,
     reflection_matrix_pow as reflection_matrix_pow,
     state_vector_kronecker_product as state_vector_kronecker_product,
     sub_state_vector as sub_state_vector,
@@ -92,5 +94,4 @@ from cirq.linalg.transformations import (
     targeted_left_multiply as targeted_left_multiply,
     to_special as to_special,
     transpose_flattened_array as transpose_flattened_array,
-    can_numpy_support_shape as can_numpy_support_shape,
 )

cirq/linalg/transformations.py

@@ -814,3 +814,17 @@ def _can_numpy_support_dims(num_dims: int) -> bool:
 def can_numpy_support_shape(shape: Sequence[int]) -> bool:
     """Returns whether numpy supports the given shape or not numpy/numpy#5744."""
     return min(shape, default=0) >= 0 and _can_numpy_support_dims(len(shape))
+
+
+def phase_delta(u1: np.ndarray, u2: np.ndarray) -> complex:
+    """Calculates the phase delta of two unitaries.
+
+    The delta is from u1 to u2. i.e. u1 * phase_delta(u1, u2) == u2.
+
+    Assumes but does not verify that inputs are valid unitaries and differ only
+    by phase.
+    """
+    # All cells will have the same phase difference. Just choose the cell with the largest
+    # absolute value, to minimize rounding error.
+    max_index = np.unravel_index(np.abs(u1).argmax(), u1.shape)
+    return u2[max_index] / u1[max_index]

cirq/linalg/transformations_test.py

@@ -653,3 +653,11 @@ def test_transpose_flattened_array(num_dimensions):
 @pytest.mark.parametrize('shape, result', [((), True), (30 * (1,), True), ((-3, 1, -1), False)])
 def test_can_numpy_support_shape(shape: tuple[int, ...], result: bool) -> None:
     assert linalg.can_numpy_support_shape(shape) is result
+
+
+@pytest.mark.parametrize('coeff', [1, 1j, -1, -1j, 1j**0.5, 1j**0.3])
+def test_phase_delta(coeff):
+    u1 = cirq.testing.random_unitary(4)
+    u2 = u1 * coeff
+    np.testing.assert_almost_equal(linalg.phase_delta(u1, u2), coeff)
+    np.testing.assert_almost_equal(u1 * linalg.phase_delta(u1, u2), u2)

cirq/ops/controlled_gate.py

@@ -34,7 +34,6 @@ from cirq.ops import (
     controlled_operation as cop,
     diagonal_gate as dg,
     global_phase_op as gp,
-    matrix_gates,
     op_tree,
     raw_types,
 )
@@ -220,12 +219,6 @@ class ControlledGate(raw_types.Gate):
                     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
-            # local phase in the controlled variant and hence cannot be ignored.
-            return NotImplemented
-
         result = protocols.decompose_once_with_qubits(
             self.sub_gate,
             qubits[self.num_controls() :],

cirq/ops/controlled_gate_test.py

@@ -431,10 +431,23 @@ def test_controlled_gate_is_consistent(gate: cirq.Gate, should_decompose_to_targ
 @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(
@@ -476,10 +489,9 @@ def _test_controlled_gate_is_consistent(
         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)
+        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/matrix_gates.py

@@ -14,13 +14,13 @@
 
 """Quantum gates defined by a matrix."""
 
-from typing import Any, Dict, Iterable, Optional, Tuple, TYPE_CHECKING
+from typing import Any, Dict, Iterable, List, Optional, Tuple, TYPE_CHECKING
 
 import numpy as np
 
 from cirq import _import, linalg, protocols
 from cirq._compat import proper_repr
-from cirq.ops import phased_x_z_gate, raw_types
+from cirq.ops import global_phase_op, identity, phased_x_z_gate, raw_types
 
 if TYPE_CHECKING:
     import cirq
@@ -148,18 +148,34 @@ class MatrixGate(raw_types.Gate):
         return MatrixGate(matrix=result.reshape(self._matrix.shape), qid_shape=self._qid_shape)
 
     def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> 'cirq.OP_TREE':
+        from cirq.circuits import Circuit
+
+        decomposed: List['cirq.Operation'] = NotImplemented
         if self._qid_shape == (2,):
-            return [
+            decomposed = [
                 g.on(qubits[0])
                 for g in single_qubit_decompositions.single_qubit_matrix_to_gates(self._matrix)
             ]
         if self._qid_shape == (2,) * 2:
-            return two_qubit_to_cz.two_qubit_matrix_to_cz_operations(
+            decomposed = two_qubit_to_cz.two_qubit_matrix_to_cz_operations(
                 *qubits, self._matrix, allow_partial_czs=True
             )
         if self._qid_shape == (2,) * 3:
-            return three_qubit_decomposition.three_qubit_matrix_to_operations(*qubits, self._matrix)
-        return NotImplemented
+            decomposed = three_qubit_decomposition.three_qubit_matrix_to_operations(
+                *qubits, self._matrix
+            )
+        if decomposed is NotImplemented:
+            return NotImplemented
+        # The above algorithms ignore phase, but phase is important to maintain if the gate is
+        # controlled. Here, we add it back in with a global phase op.
+        ident = identity.IdentityGate(qid_shape=self._qid_shape).on(*qubits)  # Preserve qid order
+        u = protocols.unitary(Circuit(ident, *decomposed)).reshape(self._matrix.shape)
+        phase_delta = linalg.phase_delta(u, self._matrix)
+        # Phase delta is on the complex unit circle, so if real(phase_delta) >= 1, that means
+        # no phase delta. (>1 is rounding error).
+        if phase_delta.real < 1:
+            decomposed.append(global_phase_op.global_phase_operation(phase_delta))
+        return decomposed
 
     def _has_unitary_(self) -> bool:
         return True

cirq/transformers/analytical_decompositions/three_qubit_decomposition.py

@@ -24,7 +24,7 @@ from cirq import ops, transformers as opt
 
 def three_qubit_matrix_to_operations(
     q0: ops.Qid, q1: ops.Qid, q2: ops.Qid, u: np.ndarray, atol: float = 1e-8
-) -> Sequence[ops.Operation]:
+) -> List[ops.Operation]:
     """Returns operations for a 3 qubit unitary.
 
     The algorithm is described in Shende et al.:

{cirq_core-1.5.0.dev20250404212936.dist-info → cirq_core-1.5.0.dev20250404235631.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250404212936
+Version: 1.5.0.dev20250404235631
 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.dev20250404212936.dist-info → cirq_core-1.5.0.dev20250404235631.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=0m3sYIyxRNv9jvAo6rzJ-cnbpny3KGnAByrbU7bApgQ,34720
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=cfocxtT1BJ4HkfZ-VO8YyIhPP-xfqHDkLrzz6eeO5U0,8421
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=8jkmcBM_XFQvrblAos1u_xMK-SfW0h5cnN-V3TqnVLs,1206
-cirq/_version_test.py,sha256=l0Ucd3Bf6XezY7GuMOsP7cBsseeHmaRjSOicoSEVSXU,147
+cirq/_version.py,sha256=KinPtb06uZbX8CW--RiF5vnOluHAD1sq7bzElrrToKI,1206
+cirq/_version_test.py,sha256=PwTQFs7hoDk7E-ZsPnJZ1KoVIt3qxLszOF88pLVLN_o,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=YVamU72nCUT5dG0bhAvRKVX5lXcZMNTwP3H36v-cYag,13615
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -248,7 +248,7 @@ cirq/interop/quirk/cells/testing_test.py,sha256=Qb__MOXjUrna7Wy6mlRWFyyy78KfzqlK
 cirq/interop/quirk/cells/unsupported_cells.py,sha256=xTE4aKpuVocey_lvWwb8Q1fla6oMqI1S4rc7a2UtDgs,2841
 cirq/interop/quirk/cells/unsupported_cells_test.py,sha256=5bl-maazy7Dr8u6kwK1AhGT4vtHqzIMRKxoMKYC-JWs,2178
 cirq/ion/__init__.py,sha256=F6tf4JZOGpDdxX0FxT42qgq8rF96ZTFHMJ0OV09Yj1c,787
-cirq/linalg/__init__.py,sha256=9WLnBqLQ02FzCIUcchHBMYpOGVcENAjzv7GyDNgh89I,4013
+cirq/linalg/__init__.py,sha256=0dSlIBy-TVzf7b_-rLLlrS8ZFkgCfYg0pJjWs72xYOk,4045
 cirq/linalg/combinators.py,sha256=0tts29gbwQg9lpZvCSX8QKMIMf38NGGdBJqI911m7jA,5336
 cirq/linalg/combinators_test.py,sha256=eRy1FrGujE8UC3pP1X5MfWmKlpjimHTxdiixr-G4nJM,4829
 cirq/linalg/decompositions.py,sha256=9dOJSJuYG8_dk3zdBO5rXDONKkw7SKZd5ZpWK4FnypQ,38652
@@ -261,8 +261,8 @@ cirq/linalg/predicates.py,sha256=vLTRaAYqVf0mk6Qgm53ROhLDtXxxoEhHbYxQN74aGRk,120
 cirq/linalg/predicates_test.py,sha256=syNiyS-clEGeZnbKT7zyR8_ClDnXFYtDnLKozLbitzw,21504
 cirq/linalg/tolerance.py,sha256=a68RNOmCw0ybFwhXOq6DERK5gHAOlPJIRdPuMzV6xuU,1870
 cirq/linalg/tolerance_test.py,sha256=wnmuXIGEn_mugGoNm3AigSgjV2DMFdj8xpgRTMBbO7A,2355
-cirq/linalg/transformations.py,sha256=cUZWPZJq6DISQ4rS02KSObmNwqLHYxIkNCfYijgJLoA,31986
-cirq/linalg/transformations_test.py,sha256=GsqD8_X0N88ECKr44t0O9wAJ6-uJJi0wExivn0Okf7M,25333
+cirq/linalg/transformations.py,sha256=zo9Gwo4VX2uQfN_7iOzQrxI-27uDj7s8eTUe2eJQetU,32519
+cirq/linalg/transformations_test.py,sha256=4GnfQhB1lERteVxvTHXMXxEt4vwQLZBXNJOvnFY3AKY,25636
 cirq/neutral_atoms/__init__.py,sha256=VoQBkmZ5m4TPxjxShRixjqJbnc-IAnAWkGOPu8MBS5o,813
 cirq/neutral_atoms/convert_to_neutral_atom_gates.py,sha256=SsXFh1-NoBGqp4yX8-jIbIw-AK40baA-qh-iTL1wS6Q,1070
 cirq/neutral_atoms/convert_to_neutral_atom_gates_test.py,sha256=svleNo8P_cQLCMfcGLkU896cpLjZKPynDKnJGM2pyJ0,1861
@@ -284,8 +284,8 @@ cirq/ops/common_gates.py,sha256=nTW9PAOdkbDei01ZUx6N-D2V1zslRJnk8WS_-NJSdlg,5833
 cirq/ops/common_gates_test.py,sha256=6y6uPS29Lnby3YesV4YG8fmI1FWqj7BfPQEGbvJl928,46882
 cirq/ops/control_values.py,sha256=Loi_voLNOzPJpjD6AnQz8JrqJLOAUe0jvV3XB_0tTGE,13430
 cirq/ops/control_values_test.py,sha256=K8tbKM6b6PqMEL_lHLFzdrnWF1SkLN0Scft6YMT7FlE,12907
-cirq/ops/controlled_gate.py,sha256=Is4s8-yRZye3gkhg-dlte5zfdAiXYtioC0oP-BXQ37g,15531
-cirq/ops/controlled_gate_test.py,sha256=6Z_HaIbXXKOJOhwb2l_Dmtfx9tcggl_vYf8pkB_UDms,25205
+cirq/ops/controlled_gate.py,sha256=uzQL7scPsKmnu3Kdiw-zF7b4FxdyqvaD6oPkczs1skQ,15234
+cirq/ops/controlled_gate_test.py,sha256=8PprvTdGMfBQOOQ-BpW_decRQU39P2gM_xJfX-fawMo,25512
 cirq/ops/controlled_operation.py,sha256=kfZUj5XISlHJGvm2mzn7-UzNmIFimLMNvn9QhD68Lro,14077
 cirq/ops/controlled_operation_test.py,sha256=kHdHGR6Q6ROgUJqG4DSKOvyrLJhi-u4uMh-rM3QRJ8o,16525
 cirq/ops/dense_pauli_string.py,sha256=nQs4lfm9zSGPGE9p9KAJbEhkldpg9krqTwvIkLePs90,24477
@@ -314,7 +314,7 @@ cirq/ops/kraus_channel.py,sha256=qX828mvPSFgEaG0I3Jhj04y5rD7dUjeEl2HYDn7_7j4,508
 cirq/ops/kraus_channel_test.py,sha256=-E6ExIO3P0y2T74Gx-RMu0kLpy1RWP9wH6UGDI21oFU,4820
 cirq/ops/linear_combinations.py,sha256=PE1o_mvpdnlg3o95iSn5ID18kuxwS2q3DGDuFnlNC90,39916
 cirq/ops/linear_combinations_test.py,sha256=ip-wN8T8nUQviD3ql42eet7k_MQ6DVUfIK8aX-_ygOs,67217
-cirq/ops/matrix_gates.py,sha256=q-lyxDVg5K-eokmZWPN1woUmJkR90IpbNhnFqQgjw4Q,9297
+cirq/ops/matrix_gates.py,sha256=PoaJuONeh7wFQ0iJUtMsN-OdvYW9wm_q8kFBLWu6I1k,10221
 cirq/ops/matrix_gates_test.py,sha256=m5rMwq_sqVvsmkc5opVr3Ikd1ERuULmSRNAvGZUg7ds,14224
 cirq/ops/measure_util.py,sha256=ZaH1Lze4Yk3nYrojn7SILUeIN96p_khIoa25ixXLu6A,7390
 cirq/ops/measure_util_test.py,sha256=Yzlced4nb4DHO-0cM_a-QZGO_3R8oqExkpIALN_pG4A,5307
@@ -1097,7 +1097,7 @@ cirq/transformers/analytical_decompositions/single_qubit_decompositions.py,sha25
 cirq/transformers/analytical_decompositions/single_qubit_decompositions_test.py,sha256=4GfU6wctBoG-OVFqFOE08xymd5dXzY-doE8ZNpsKohI,12308
 cirq/transformers/analytical_decompositions/single_to_two_qubit_isometry.py,sha256=Qmxv4YJgiBSbZUoonwSSBGGmzuPsUQLQbNTk2z59xRg,2439
 cirq/transformers/analytical_decompositions/single_to_two_qubit_isometry_test.py,sha256=qBoSS8OoM2HdOIM_46pSdbWFsQBu0aeQxUqiJ9znlnk,2517
-cirq/transformers/analytical_decompositions/three_qubit_decomposition.py,sha256=3nCZItd7ZZ2IU0ysNuiM0OYn6RQGBCe9kF-H7kWlEBU,9746
+cirq/transformers/analytical_decompositions/three_qubit_decomposition.py,sha256=yrVbl6TKffGltCuDTxSs2vMoe5kMuv7R0yJKtOZjvm4,9742
 cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py,sha256=p9H-XuoQ3jdR5NTcAcbW6Pak69qGfzvBN4N1SDw5eg8,7847
 cirq/transformers/analytical_decompositions/two_qubit_state_preparation.py,sha256=OOjIy4Nw_28CdcmK5OE8uQEzy0wO5ITEF_tSZKaFSMM,6178
 cirq/transformers/analytical_decompositions/two_qubit_state_preparation_test.py,sha256=486hVPQp620r8SPKlhyaFIK8TC5jDngX8WqHY1Hb0Hk,4458
@@ -1209,8 +1209,8 @@ cirq/work/sampler.py,sha256=sW0RhIelGABAKbqTM58shwyyCPgf86JIv9IGdJe__js,19186
 cirq/work/sampler_test.py,sha256=mdk1J-WrvbPUYhY41VhWf9_te4DnXr_XMPcugWwc4-I,13281
 cirq/work/zeros_sampler.py,sha256=8_Ne6dBkDANtTZuql7Eb0Qg_E_P3-_gu-ybFzxTbKAQ,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.5.0.dev20250404212936.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250404212936.dist-info/METADATA,sha256=9L-Fv4MoT-eMxynxNHCPLlpReljxs7aDgUb_etLiID8,4584
-cirq_core-1.5.0.dev20250404212936.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250404212936.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250404212936.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250404235631.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250404235631.dist-info/METADATA,sha256=h1oY0Qt8QuSr4lKNpxi8bG2GYLU8amhYZz7moJH89_U,4584
+cirq_core-1.5.0.dev20250404235631.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250404235631.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250404235631.dist-info/RECORD,,