cirq-core 1.6.0.dev20250625011740__py3-none-any.whl → 1.6.0.dev20250625152617__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 11, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.5.0")'
     )
 
-__version__ = "1.6.0.dev20250625011740"
+__version__ = "1.6.0.dev20250625152617"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version() -> None:
-    assert cirq.__version__ == "1.6.0.dev20250625011740"
+    assert cirq.__version__ == "1.6.0.dev20250625152617"

cirq/ops/common_gates.py

@@ -37,7 +37,14 @@ import cirq
 from cirq import protocols, value
 from cirq._compat import proper_repr
 from cirq._doc import document
-from cirq.ops import control_values as cv, controlled_gate, eigen_gate, gate_features, raw_types
+from cirq.ops import (
+    control_values as cv,
+    controlled_gate,
+    eigen_gate,
+    gate_features,
+    global_phase_op,
+    raw_types,
+)
 from cirq.ops.measurement_gate import MeasurementGate
 from cirq.ops.swap_gates import ISWAP, ISwapPowGate, SWAP, SwapPowGate
 
@@ -235,6 +242,11 @@ class XPowGate(eigen_gate.EigenGate):
                 return cirq.CCXPowGate(exponent=self._exponent)
         return result
 
+    def _decompose_with_context_(
+        self, qubits: tuple[cirq.Qid, ...], context: cirq.DecompositionContext
+    ) -> list[cirq.Operation] | NotImplementedType:
+        return _extract_phase(self, XPowGate, qubits, context)
+
     def _pauli_expansion_(self) -> value.LinearDict[str]:
         if self._dimension != 2:
             return NotImplemented  # pragma: no cover
@@ -487,6 +499,11 @@ class YPowGate(eigen_gate.EigenGate):
             f'global_shift={self._global_shift!r})'
         )
 
+    def _decompose_with_context_(
+        self, qubits: tuple[cirq.Qid, ...], context: cirq.DecompositionContext
+    ) -> list[cirq.Operation] | NotImplementedType:
+        return _extract_phase(self, YPowGate, qubits, context)
+
 
 class Ry(YPowGate):
     r"""A gate with matrix $e^{-i Y t/2}$ that rotates around the Y axis of the Bloch sphere by $t$.
@@ -699,6 +716,11 @@ class ZPowGate(eigen_gate.EigenGate):
                 return cirq.CCZPowGate(exponent=self._exponent)
         return result
 
+    def _decompose_with_context_(
+        self, qubits: tuple[cirq.Qid, ...], context: cirq.DecompositionContext
+    ) -> list[cirq.Operation] | NotImplementedType:
+        return _extract_phase(self, ZPowGate, qubits, context)
+
     def _qid_shape_(self) -> tuple[int, ...]:
         return (self._dimension,)
 
@@ -1131,6 +1153,11 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             control_qid_shape=result.control_qid_shape + (2,),
         )
 
+    def _decompose_with_context_(
+        self, qubits: tuple[cirq.Qid, ...], context: cirq.DecompositionContext
+    ) -> list[cirq.Operation] | NotImplementedType:
+        return _extract_phase(self, CZPowGate, qubits, context)
+
     def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('@', '@'), exponent=self._diagram_exponent(args)
@@ -1486,3 +1513,25 @@ def _phased_x_or_pauli_gate(
             case 0.5:
                 return YPowGate(exponent=exponent)
     return cirq.ops.PhasedXPowGate(exponent=exponent, phase_exponent=phase_exponent)
+
+
+def _extract_phase(
+    gate: cirq.EigenGate,
+    gate_class: type,
+    qubits: tuple[cirq.Qid, ...],
+    context: cirq.DecompositionContext,
+) -> list[cirq.Operation] | NotImplementedType:
+    """Extracts the global phase field to its own gate, or absorbs it if it has no effect.
+
+    This is for use within the decompose handlers, and will return `NotImplemented` if there is no
+    global phase, implying it is already in its simplest form. It will return a list, with the
+    original op minus any global phase first, and the global phase op second. If the resulting
+    global phase is empty (can happen for example in `XPowGate(global_phase=2/3)**3`), then it is
+    excluded from the return value."""
+    if not context.extract_global_phases or gate.global_shift == 0:
+        return NotImplemented
+    result = [gate_class(exponent=gate.exponent).on(*qubits)]
+    phase_gate = global_phase_op.from_phase_and_exponent(gate.global_shift, gate.exponent)
+    if not phase_gate.is_identity():
+        result.append(phase_gate())
+    return result

cirq/ops/common_gates_test.py

@@ -1322,3 +1322,37 @@ def test_parameterized_pauli_expansion(gate_type, exponent) -> None:
     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))
+
+
+@pytest.mark.parametrize('gate_type', [cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZPowGate])
+@pytest.mark.parametrize('exponent', [0, 0.5, 2, 3, -0.5, -2, -3, sympy.Symbol('s')])
+def test_decompose_with_extracted_phases(gate_type: type, exponent: cirq.TParamVal) -> None:
+    context = cirq.DecompositionContext(cirq.SimpleQubitManager(), extract_global_phases=True)
+    test_shift = 2 / 3  # Interesting because e.g. X(shift=2/3) ** 3 == X with no phase
+    gate = gate_type(exponent=exponent, global_shift=test_shift)
+    op = gate.on(*cirq.LineQubit.range(cirq.num_qubits(gate)))
+    decomposed = cirq.decompose(op, context=context)
+
+    # The first gate should be the original gate, but with shift removed.
+    gate0 = decomposed[0].gate
+    assert isinstance(gate0, gate_type)
+    assert isinstance(gate0, cirq.EigenGate)
+    assert gate0.global_shift == 0
+    assert gate0.exponent == exponent
+    if exponent % 3 == 0:
+        # Since test_shift == 2/3, gate**3 nullifies the phase, leaving only the unphased gate.
+        assert len(decomposed) == 1
+    else:
+        # Other exponents emit a global phase gate to compensate.
+        assert len(decomposed) == 2
+        gate1 = decomposed[1].gate
+        assert isinstance(gate1, cirq.GlobalPhaseGate)
+        assert gate1.coefficient == 1j ** (2 * exponent * test_shift)
+
+    # Sanity check that the decomposition is equivalent to the original.
+    decomposed_circuit = cirq.Circuit(decomposed)
+    if cirq.is_parameterized(exponent):
+        resolver = {'s': -1.234}  # arbitrary
+        op = cirq.resolve_parameters(op, resolver)
+        decomposed_circuit = cirq.resolve_parameters(decomposed_circuit, resolver)
+    np.testing.assert_allclose(cirq.unitary(op), cirq.unitary(decomposed_circuit), atol=1e-10)

cirq/ops/controlled_gate.py

@@ -24,7 +24,6 @@ from cirq.ops import (
     control_values as cv,
     controlled_operation as cop,
     diagonal_gate as dg,
-    global_phase_op as gp,
     op_tree,
     raw_types,
 )
@@ -139,12 +138,9 @@ class ControlledGate(raw_types.Gate):
     def _qid_shape_(self) -> tuple[int, ...]:
         return self.control_qid_shape + protocols.qid_shape(self.sub_gate)
 
-    def _decompose_(self, qubits: tuple[cirq.Qid, ...]) -> None | NotImplementedType | cirq.OP_TREE:
-        return self._decompose_with_context_(qubits)
-
     def _decompose_with_context_(
-        self, qubits: tuple[cirq.Qid, ...], context: cirq.DecompositionContext | None = None
-    ) -> None | NotImplementedType | cirq.OP_TREE:
+        self, qubits: tuple[cirq.Qid, ...], context: cirq.DecompositionContext
+    ) -> NotImplementedType | cirq.OP_TREE:
         control_qubits = list(qubits[: self.num_controls()])
         controlled_sub_gate = self.sub_gate.controlled(
             self.num_controls(), self.control_values, self.control_qid_shape
@@ -152,6 +148,25 @@ class ControlledGate(raw_types.Gate):
         # Prefer the subgate controlled version if available
         if self != controlled_sub_gate:
             return controlled_sub_gate.on(*qubits)
+
+        # Try decomposing the subgate next.
+        result = protocols.decompose_once_with_qubits(
+            self.sub_gate,
+            qubits[self.num_controls() :],
+            NotImplemented,
+            flatten=False,
+            # Extract global phases from decomposition, as controlled phases decompose easily.
+            context=context.extracting_global_phases(),
+        )
+        if result is not NotImplemented:
+            return op_tree.transform_op_tree(
+                result,
+                lambda op: op.controlled_by(
+                    *qubits[: self.num_controls()], control_values=self.control_values
+                ),
+            )
+
+        # Finally try brute-force on the unitary.
         if protocols.has_unitary(self.sub_gate) and all(q.dimension == 2 for q in qubits):
             n_qubits = protocols.num_qubits(self.sub_gate)
             # Case 1: Global Phase (1x1 Matrix)
@@ -173,54 +188,9 @@ 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, common_gates.CZPowGate):
-            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,)
-            controlled_z = (
-                z_sub_gate.controlled(
-                    num_controls=num_controls,
-                    control_values=control_values,
-                    control_qid_shape=control_qid_shape,
-                )
-                if protocols.is_parameterized(self)
-                else ControlledGate(
-                    z_sub_gate,
-                    num_controls=num_controls,
-                    control_values=control_values,
-                    control_qid_shape=control_qid_shape,
-                )
-            )
-            if self != controlled_z:
-                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() :],
-            NotImplemented,
-            flatten=False,
-            context=context,
-        )
-        if result is NotImplemented:
-            return NotImplemented
 
-        return op_tree.transform_op_tree(
-            result,
-            lambda op: op.controlled_by(
-                *qubits[: self.num_controls()], control_values=self.control_values
-            ),
-        )
+        # If nothing works, return `NotImplemented`.
+        return NotImplemented
 
     def on(self, *qubits: cirq.Qid) -> cop.ControlledOperation:
         if len(qubits) == 0:

cirq/ops/controlled_gate_test.py

@@ -804,3 +804,31 @@ def test_controlled_global_phase_matrix_gate_decomposes(
     decomposed = cirq.decompose(cg_matrix(*all_qubits))
     assert not any(isinstance(op.gate, cirq.MatrixGate) for op in decomposed)
     np.testing.assert_allclose(cirq.unitary(cirq.Circuit(decomposed)), cirq.unitary(cg_matrix))
+
+
+@pytest.mark.parametrize('gate_type', [cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZPowGate])
+@pytest.mark.parametrize('test_shift', np.pi * (np.random.default_rng(324).random(10) * 2 - 1))
+def test_controlled_phase_extracted_before_decomposition(gate_type, test_shift) -> None:
+    test_shift = 0.123  # arbitrary
+
+    shifted_gate = gate_type(global_shift=test_shift).controlled()
+    unshifted_gate = gate_type().controlled()
+    qs = cirq.LineQubit.range(cirq.num_qubits(shifted_gate))
+    shifted_op = shifted_gate.on(*qs)
+    unshifted_op = unshifted_gate.on(*qs)
+    shifted_decomposition = cirq.decompose(shifted_op)
+    unshifted_decomposition = cirq.decompose(unshifted_op)
+
+    # No brute-force calculation. It's the standard decomposition plus Z for the controlled shift.
+    assert shifted_decomposition[:-1] == unshifted_decomposition
+    z_op = shifted_decomposition[-1]
+    assert z_op.qubits == (qs[0],)
+    z = z_op.gate
+    assert isinstance(z, cirq.ZPowGate)
+    np.testing.assert_approx_equal(z.exponent, test_shift)
+    assert z.global_shift == 0
+
+    # Sanity check that the decomposition is equivalent
+    np.testing.assert_allclose(
+        cirq.unitary(cirq.Circuit(shifted_decomposition)), cirq.unitary(shifted_op), atol=1e-10
+    )

cirq/ops/global_phase_op.py

@@ -92,6 +92,13 @@ class GlobalPhaseGate(raw_types.Gate):
         coefficient = protocols.resolve_parameters(self.coefficient, resolver, recursive)
         return GlobalPhaseGate(coefficient=coefficient)
 
+    def is_identity(self) -> bool:
+        """Checks if gate is equivalent to an identity.
+
+        Returns: True if the coefficient is within rounding error of 1.
+        """
+        return not protocols.is_parameterized(self._coefficient) and np.isclose(self.coefficient, 1)
+
     def controlled(
         self,
         num_controls: int | None = None,
@@ -122,3 +129,23 @@ def global_phase_operation(
 ) -> cirq.GateOperation:
     """Creates an operation that represents a global phase on the state."""
     return GlobalPhaseGate(coefficient, atol)()
+
+
+def from_phase_and_exponent(
+    half_turns: cirq.TParamVal, exponent: cirq.TParamVal
+) -> cirq.GlobalPhaseGate:
+    """Creates a GlobalPhaseGate from the global phase and exponent.
+
+    Args:
+        half_turns: The number of half turns to rotate by.
+        exponent: The power to raise the phase to.
+
+    Returns: A `GlobalPhaseGate` with the corresponding coefficient.
+    """
+    coefficient = 1j ** (2 * half_turns * exponent)
+    coefficient = (
+        complex(coefficient)
+        if isinstance(coefficient, sympy.Expr) and coefficient.is_complex
+        else coefficient
+    )
+    return GlobalPhaseGate(coefficient)

cirq/ops/global_phase_op_test.py

@@ -19,6 +19,7 @@ import pytest
 import sympy
 
 import cirq
+from cirq.ops import global_phase_op
 
 
 def test_init() -> None:
@@ -304,3 +305,22 @@ def test_global_phase_gate_controlled(coeff, exp) -> None:
     assert g.controlled(control_values=xor_control_values) == cirq.ControlledGate(
         g, control_values=xor_control_values
     )
+
+
+def test_is_identity() -> None:
+    g = cirq.GlobalPhaseGate(1)
+    assert g.is_identity()
+    g = cirq.GlobalPhaseGate(1j)
+    assert not g.is_identity()
+    g = cirq.GlobalPhaseGate(-1)
+    assert not g.is_identity()
+
+
+def test_from_phase_and_exponent() -> None:
+    g = global_phase_op.from_phase_and_exponent(2.5, 0.5)
+    assert g.coefficient == np.exp(1.25j * np.pi)
+    a, b = sympy.symbols('a, b')
+    g = global_phase_op.from_phase_and_exponent(a, b)
+    assert g.coefficient == 1j ** (2 * a * b)
+    g = global_phase_op.from_phase_and_exponent(1 / a, a)
+    assert g.coefficient == -1

cirq/ops/three_qubit_gates.py

@@ -106,19 +106,11 @@ class CCZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             elif not b.is_adjacent(c):
                 a, b = b, a
 
-        p = common_gates.T**self._exponent
+        exp = self._exponent
+        p = common_gates.T**exp
         sweep_abc = [common_gates.CNOT(a, b), common_gates.CNOT(b, c)]
-        global_phase = 1j ** (2 * self.global_shift * self._exponent)
-        global_phase = (
-            complex(global_phase)
-            if protocols.is_parameterized(global_phase) and global_phase.is_complex
-            else global_phase
-        )
-        global_phase_operation = (
-            [global_phase_op.global_phase_operation(global_phase)]
-            if protocols.is_parameterized(global_phase) or abs(global_phase - 1.0) > 0
-            else []
-        )
+        global_phase_gate = global_phase_op.from_phase_and_exponent(self.global_shift, exp)
+        global_phase_operation = [] if global_phase_gate.is_identity() else [global_phase_gate()]
         return global_phase_operation + [
             p(a),
             p(b),

cirq/protocols/decompose_protocol.py

@@ -81,9 +81,16 @@ class DecompositionContext:
     Args:
         qubit_manager: A `cirq.QubitManager` instance to allocate clean / dirty ancilla qubits as
             part of the decompose protocol.
+        extract_global_phases: If set, will extract the global phases from
+         `DECOMPOSE_TARGET_GATESET` into independent global phase operations.
     """
 
     qubit_manager: cirq.QubitManager
+    extract_global_phases: bool = False
+
+    def extracting_global_phases(self) -> DecompositionContext:
+        """Returns a copy with the `extract_global_phases` field set."""
+        return dataclasses.replace(self, extract_global_phases=True)
 
 
 class SupportsDecompose(Protocol):

cirq/protocols/decompose_protocol_test.py

@@ -445,3 +445,12 @@ def test_decompose_without_context_succeed() -> None:
             cirq.ops.CleanQubit(1, prefix='_decompose_protocol'),
         )
     ]
+
+
+def test_extracting_global_phases() -> None:
+    qm = cirq.SimpleQubitManager()
+    context = cirq.DecompositionContext(qm)
+    new_context = context.extracting_global_phases()
+    assert not context.extract_global_phases
+    assert new_context.extract_global_phases
+    assert new_context.qubit_manager is qm

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py

@@ -21,26 +21,31 @@ https://arxiv.org/abs/quant-ph/0406176
 
 from __future__ import annotations
 
-from typing import Callable, Iterable, TYPE_CHECKING
+from typing import Callable, cast, Iterable, TYPE_CHECKING
 
 import numpy as np
+from attr import define
 from scipy.linalg import cossin
 
 from cirq import ops
 from cirq.circuits.frozen_circuit import FrozenCircuit
 from cirq.linalg import decompositions, predicates
 from cirq.protocols import unitary_protocol
-from cirq.transformers.analytical_decompositions.three_qubit_decomposition import (
-    three_qubit_matrix_to_operations,
-)
 from cirq.transformers.analytical_decompositions.two_qubit_to_cz import (
     two_qubit_matrix_to_cz_operations,
+    two_qubit_matrix_to_diagonal_and_cz_operations,
 )
 
 if TYPE_CHECKING:
     import cirq
 
 
+@define
+class _TwoQubitGate:
+    location: int
+    matrix: np.ndarray
+
+
 def quantum_shannon_decomposition(
     qubits: list[cirq.Qid], u: np.ndarray, atol: float = 1e-8
 ) -> Iterable[cirq.Operation]:
@@ -67,14 +72,12 @@ def quantum_shannon_decomposition(
         1. _single_qubit_decomposition
             OR
         (Recursive Case)
-        1. _msb_demuxer
-        2. _multiplexed_cossin
-        3. _msb_demuxer
+        1. _recursive_decomposition
 
     Yields:
         A single 2-qubit or 1-qubit operations from OP TREE
         composed from the set
-           { CNOT, rz, ry, ZPowGate }
+           { CNOT, CZ, rz, ry, ZPowGate }
 
     Raises:
         ValueError: If the u matrix is non-unitary
@@ -98,30 +101,92 @@ def quantum_shannon_decomposition(
         yield from _single_qubit_decomposition(qubits[0], u)
         return
 
-    if n == 4:
-        operations = tuple(
-            two_qubit_matrix_to_cz_operations(
-                qubits[0], qubits[1], u, allow_partial_czs=True, clean_operations=True, atol=atol
-            )
+    # Collect all operations from the recursive decomposition
+    shannon_decomp: list[cirq.Operation | list[cirq.Operation]] = [
+        *_recursive_decomposition(qubits, u)
+    ]
+    # Separate all 2-qubit generic gates while keeping track of location
+    two_qubit_gates = [
+        _TwoQubitGate(location=loc, matrix=unitary_protocol.unitary(o))
+        for loc, o in enumerate(cast(list[ops.Operation], shannon_decomp))
+        if isinstance(o.gate, ops.MatrixGate)
+    ]
+    # Apply case A.2 from Shende et al.
+    q0 = qubits[-2]
+    q1 = qubits[-1]
+    for idx in range(len(two_qubit_gates) - 1, 0, -1):
+        diagonal, operations = two_qubit_matrix_to_diagonal_and_cz_operations(
+            q0,
+            q1,
+            two_qubit_gates[idx].matrix,
+            allow_partial_czs=True,
+            clean_operations=True,
+            atol=atol,
         )
-        yield from operations
-        i, j = np.unravel_index(np.argmax(np.abs(u)), u.shape)
-        new_unitary = unitary_protocol.unitary(FrozenCircuit.from_moments(*operations))
-        global_phase = np.angle(u[i, j]) - np.angle(new_unitary[i, j])
-        if np.abs(global_phase) > 1e-9:
-            yield ops.global_phase_operation(np.exp(1j * global_phase))
-        return
+        global_phase = _global_phase_difference(
+            two_qubit_gates[idx].matrix, [ops.MatrixGate(diagonal)(q0, q1), *operations]
+        )
+        if not np.isclose(global_phase, 0, atol=atol):
+            operations.append(ops.global_phase_operation(np.exp(1j * global_phase)))
+        # Replace the generic gate with ops from OP TREE
+        shannon_decomp[two_qubit_gates[idx].location] = operations
+        # Join the diagonal with the unitary to be decomposed in the next step
+        two_qubit_gates[idx - 1].matrix = diagonal @ two_qubit_gates[idx - 1].matrix
+    if len(two_qubit_gates) > 0:
+        operations = two_qubit_matrix_to_cz_operations(
+            q0,
+            q1,
+            two_qubit_gates[0].matrix,
+            allow_partial_czs=True,
+            clean_operations=True,
+            atol=atol,
+        )
+        global_phase = _global_phase_difference(two_qubit_gates[0].matrix, operations)
+        if not np.isclose(global_phase, 0, atol=atol):
+            operations.append(ops.global_phase_operation(np.exp(1j * global_phase)))
+        shannon_decomp[two_qubit_gates[0].location] = operations
+    # Yield the final operations in order
+    yield from cast(Iterable[ops.Operation], ops.flatten_op_tree(shannon_decomp))
+
+
+def _recursive_decomposition(qubits: list[cirq.Qid], u: np.ndarray) -> Iterable[cirq.Operation]:
+    """Recursive step in the quantum shannon decomposition.
+
+    Decomposes n-qubit unitary into generic 2-qubit gates, CNOT, CZ and 1-qubit gates.
+    All generic 2-qubit gates are applied to the two least significant qubits and
+    are not decomposed further here.
+
+    Args:
+        qubits: List of qubits in order of significance
+        u: Numpy array for unitary matrix representing gate to be decomposed
+
+    Calls:
+        1. _msb_demuxer
+        2. _multiplexed_cossin
+        3. _msb_demuxer
+
+    Yields:
+        Generic 2-qubit gates or operations from {ry,rz,CNOT,CZ}.
 
-    if n == 8:
-        operations = tuple(
-            three_qubit_matrix_to_operations(qubits[0], qubits[1], qubits[2], u, atol=atol)
+    Raises:
+        ValueError: If the u matrix is not of shape (2^n,2^n)
+        ValueError: If the u matrix is not of size at least 4
+    """
+    n = u.shape[0]
+    if n & (n - 1):
+        raise ValueError(
+            f"Expected input matrix u to be a (2^n x 2^n) shaped numpy array, \
+                but instead got shape {u.shape}"
         )
-        yield from operations
-        i, j = np.unravel_index(np.argmax(np.abs(u)), u.shape)
-        new_unitary = unitary_protocol.unitary(FrozenCircuit.from_moments(*operations))
-        global_phase = np.angle(u[i, j]) - np.angle(new_unitary[i, j])
-        if np.abs(global_phase) > 1e-9:
-            yield ops.global_phase_operation(np.exp(1j * global_phase))
+
+    if n <= 2:
+        raise ValueError(
+            f"Expected input matrix u for recursive step to have size at least 4, \
+                but it has size {n}"
+        )
+
+    if n == 4:
+        yield ops.MatrixGate(u).on(*qubits)
         return
 
     # Perform a cosine-sine (linalg) decomposition on u
@@ -137,10 +202,30 @@ def quantum_shannon_decomposition(
     # Yield ops from multiplexed Ry part
     yield from _multiplexed_cossin(qubits, theta, ops.ry)
 
+    # Optimization A.1 in Shende et al. - the last CZ gate in the multiplexed Ry part
+    # is merged into the generic multiplexor (u1, u2)
+    # This gate is CZ(qubits[1], qubits[0]) = CZ(qubits[0], qubits[1])
+    # as CZ is symmetric.
+    # For the u1⊕u2 multiplexor operator:
+    # as u1 is the operator in case qubits[0] = |0>,
+    # and u2 is the operator in case qubits[0] = |1>
+    # we can represent the merge by phasing u2 with Z ⊗ I
+    cz_diag = np.concatenate((np.ones(n >> 2), np.full(n >> 2, -1)))
+    u2 = u2 @ np.diag(cz_diag)
+
     # Yield ops from decomposition of multiplexed u1/u2 part
     yield from _msb_demuxer(qubits, u1, u2)
 
 
+def _global_phase_difference(u: np.ndarray, ops: list[cirq.Operation]) -> float:
+    """Returns the difference in global phase between unitary u and
+    a list of operations computing u.
+    """
+    i, j = np.unravel_index(np.argmax(np.abs(u)), u.shape)
+    new_unitary = unitary_protocol.unitary(FrozenCircuit.from_moments(*ops))
+    return np.angle(u[i, j]) - np.angle(new_unitary[i, j])
+
+
 def _single_qubit_decomposition(qubit: cirq.Qid, u: np.ndarray) -> Iterable[cirq.Operation]:
     """Decomposes single-qubit gate, and returns list of operations, keeping phase invariant.
 
@@ -202,11 +287,14 @@ def _msb_demuxer(
         u2: Lower-right quadrant of total unitary to be decomposed (see diagram)
 
     Calls:
-        1. quantum_shannon_decomposition
+        1. _recursive_decomposition
         2. _multiplexed_cossin
-        3. quantum_shannon_decomposition
+        3. _recursive_decomposition
 
-    Yields: Single operation from OP TREE of 2-qubit and 1-qubit operations
+    Yields:
+        Generic 2-qubit gates on the two least significant qubits,
+        CNOT gates with the target not on the two least significant qubits,
+        ry or rz
     """
     # Perform a diagonalization to find values
     u1 = u1.astype(np.complex128)
@@ -231,7 +319,7 @@ def _msb_demuxer(
     # Last term is given by ( I ⊗ W ), demultiplexed
     # Remove most-significant (demuxed) control-qubit
     # Yield operations for QSD on W
-    yield from quantum_shannon_decomposition(demux_qubits[1:], W, atol=1e-6)
+    yield from _recursive_decomposition(demux_qubits[1:], W)
 
     # Use complex phase of d_i to give theta_i (so d_i* gives -theta_i)
     # Observe that middle part looks like Σ_i( Rz(theta_i)⊗|i><i| )
@@ -239,7 +327,7 @@ def _msb_demuxer(
     yield from _multiplexed_cossin(demux_qubits, -np.angle(d), ops.rz)
 
     # Yield operations for QSD on V
-    yield from quantum_shannon_decomposition(demux_qubits[1:], V, atol=1e-6)
+    yield from _recursive_decomposition(demux_qubits[1:], V)
 
 
 def _nth_gray(n: int) -> int:
@@ -263,7 +351,7 @@ def _multiplexed_cossin(
     Calls:
         No major calls
 
-    Yields: Single operation from OP TREE from set 1- and 2-qubit gates: {ry,rz,CNOT}
+    Yields: Single operation from OP TREE from set 1- and 2-qubit gates: {ry,rz,CNOT,CZ}
     """
     # Most significant qubit is main qubit with rotation function applied
     main_qubit = cossin_qubits[0]
@@ -304,4 +392,11 @@ def _multiplexed_cossin(
             yield rot_func(rotation).on(main_qubit)
 
         # Add a CNOT from the select qubit to the main qubit
-        yield ops.CNOT(control_qubits[select_qubit], main_qubit)
+        # Optimization A.1 in Shende et al. - use CZ instead of CNOT for ry rotations
+        if rot_func == ops.ry:
+            # Don't emit the last gate, as it will be merged into the generic multiplexor
+            # in the cosine-sine decomposition
+            if j < len(angles) - 1:
+                yield ops.CZ(control_qubits[select_qubit], main_qubit)
+        else:
+            yield ops.CNOT(control_qubits[select_qubit], main_qubit)

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition_test.py

@@ -20,10 +20,12 @@ from scipy.stats import unitary_group
 
 import cirq
 from cirq.ops import common_gates
+from cirq.testing import random_two_qubit_circuit_with_czs
 from cirq.transformers.analytical_decompositions.quantum_shannon_decomposition import (
     _msb_demuxer,
     _multiplexed_cossin,
     _nth_gray,
+    _recursive_decomposition,
     _single_qubit_decomposition,
     quantum_shannon_decomposition,
 )
@@ -49,6 +51,14 @@ def test_qsd_n_qubit_errors():
         cirq.Circuit(quantum_shannon_decomposition(qubits, np.ones((8, 8))))
 
 
+def test_recursive_decomposition_n_qubit_errors():
+    qubits = [cirq.NamedQubit(f'q{i}') for i in range(3)]
+    with pytest.raises(ValueError, match="shaped numpy array"):
+        cirq.Circuit(_recursive_decomposition(qubits, np.eye(9)))
+    with pytest.raises(ValueError, match="size at least 4"):
+        cirq.Circuit(_recursive_decomposition(qubits, np.eye(2)))
+
+
 def test_random_single_qubit_decomposition():
     U = unitary_group.rvs(2)
     qubit = cirq.NamedQubit('q0')
@@ -80,10 +90,18 @@ def test_multiplexed_cossin():
     multiplexed_ry = np.array(multiplexed_ry)
     qubits = [cirq.NamedQubit(f'q{i}') for i in range(2)]
     circuit = cirq.Circuit(_multiplexed_cossin(qubits, [angle_1, angle_2]))
+    # Add back the CZ gate removed by the A.1 optimization
+    circuit += cirq.CZ(qubits[1], qubits[0])
     # Test return is equal to inital unitary
     assert cirq.approx_eq(multiplexed_ry, circuit.unitary(), atol=1e-9)
     # Test all operations in gate set
-    gates = (common_gates.Rz, common_gates.Ry, common_gates.ZPowGate, common_gates.CXPowGate)
+    gates = (
+        common_gates.Rz,
+        common_gates.Ry,
+        common_gates.ZPowGate,
+        common_gates.CXPowGate,
+        common_gates.CZPowGate,
+    )
     assert all(isinstance(op.gate, gates) for op in circuit.all_operations())
 
 
@@ -203,3 +221,17 @@ def test_qft5():
     )
     new_unitary = cirq.unitary(shannon_circuit)
     np.testing.assert_allclose(new_unitary, desired_unitary, atol=1e-6)
+
+
+def test_random_circuit_decomposition():
+    qubits = cirq.LineQubit.range(3)
+    test_circuit = (
+        random_two_qubit_circuit_with_czs(3, qubits[0], qubits[1])
+        + random_two_qubit_circuit_with_czs(3, qubits[1], qubits[2])
+        + random_two_qubit_circuit_with_czs(3, qubits[0], qubits[2])
+    )
+    circuit = cirq.Circuit(quantum_shannon_decomposition(qubits, test_circuit.unitary()))
+    # Test return is equal to initial unitary
+    assert cirq.approx_eq(test_circuit.unitary(), circuit.unitary(), atol=1e-9)
+    # Test all operations have at most 2 qubits.
+    assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())

cirq/transformers/analytical_decompositions/two_qubit_to_cz.py

@@ -26,7 +26,6 @@ from cirq.linalg.decompositions import extract_right_diag, num_cnots_required
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 from cirq.transformers.eject_phased_paulis import eject_phased_paulis
 from cirq.transformers.eject_z import eject_z
-from cirq.transformers.merge_single_qubit_gates import merge_single_qubit_gates_to_phased_x_and_z
 
 if TYPE_CHECKING:
     import cirq
@@ -81,8 +80,8 @@ def two_qubit_matrix_to_cz_operations(
     if clean_operations:
         if not allow_partial_czs:
             # CZ^t is not allowed for any $t$ except $t=1$.
-            return _remove_partial_czs_or_fail(cleanup_operations(operations), atol=atol)
-        return cleanup_operations(operations)
+            return _remove_partial_czs_or_fail(cleanup_operations(operations, atol=atol), atol=atol)
+        return cleanup_operations(operations, atol=atol)
     return operations
 
 
@@ -182,15 +181,75 @@ def _xx_yy_zz_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float, y:
     yield ops.H(q1)
 
 
-def cleanup_operations(operations: Sequence[ops.Operation]):
+def cleanup_operations(operations: Sequence[ops.Operation], atol: float = 1e-8):
+    operations = _merge_single_qubit_gates(operations, atol=atol)
     circuit = circuits.Circuit(operations)
-    circuit = merge_single_qubit_gates_to_phased_x_and_z(circuit)
     circuit = eject_phased_paulis(circuit)
     circuit = eject_z(circuit)
     circuit = circuits.Circuit(circuit.all_operations(), strategy=circuits.InsertStrategy.EARLIEST)
     return list(circuit.all_operations())
 
 
+def _transform_single_qubit_operations_to_phased_x_and_z(
+    operations: Sequence[ops.Operation], atol: float
+) -> Sequence[ops.Operation]:
+    """Transforms operations on the same qubit to a PhasedXPowGate followed by a Z gate.
+
+    Args:
+        operations: sequence of operations on the same qubit
+        atol: a limit on the amount of absolute error introduced by the
+            transformation.
+    Returns:
+        A PhasedXPowGate followed by a Z gate. If one the gates is not needed, it will be omitted.
+    """
+    u = np.eye(2)
+    for op in operations:
+        u = protocols.unitary(op) @ u
+    return [
+        g(op.qubits[0])
+        for g in single_qubit_decompositions.single_qubit_matrix_to_phased_x_z(u, atol=atol)
+    ]
+
+
+def _merge_single_qubit_gates(
+    operations: Sequence[ops.Operation], atol: float
+) -> Sequence[ops.Operation]:
+    """Merge consecutive single qubit gates.
+
+    Traverses the sequence of operations maintaining a list of consecutive single qubit
+    operations for each qubit. When a 2-qubit gate is encountered, it transforms pending
+    operations to a PhasedXPowGate followed by a Z gate.
+
+    Args:
+        operations: sequence of operations
+        atol: a limit on the amount of absolute error introduced by the
+            transformation.
+    Returns:
+        new sequence of operations after merging gates
+    """
+    merged_ops: list[ops.Operation] = []
+    pending_ops: dict[tuple[cirq.Qid, ...], list[ops.Operation]] = dict()
+    for op in operations:
+        if protocols.num_qubits(op) == 2:
+            for _, qubit_ops in pending_ops.items():
+                merged_ops.extend(
+                    _transform_single_qubit_operations_to_phased_x_and_z(qubit_ops, atol=atol)
+                )
+            pending_ops.clear()
+            # Add the 2-qubit gate
+            merged_ops.append(op)
+        elif protocols.num_qubits(op) == 1:
+            if op.qubits not in pending_ops:
+                pending_ops[op.qubits] = []
+            pending_ops[op.qubits].append(op)
+    # Merge remaining pending operations
+    for _, qubit_ops in pending_ops.items():
+        merged_ops.extend(
+            _transform_single_qubit_operations_to_phased_x_and_z(qubit_ops, atol=atol)
+        )
+    return merged_ops
+
+
 def _kak_decomposition_to_operations(
     q0: cirq.Qid,
     q1: cirq.Qid,

cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py

@@ -261,6 +261,24 @@ def test_decompose_to_diagonal_and_circuit(v) -> None:
     cirq.testing.assert_allclose_up_to_global_phase(circuit_unitary, v, atol=2e-6)
 
 
+@pytest.mark.parametrize(
+    "mat, num_czs",
+    [
+        (cirq.unitary(random_two_qubit_circuit_with_czs(3)), 2),
+        (cirq.unitary(random_two_qubit_circuit_with_czs(2)), 2),
+        (cirq.unitary(random_two_qubit_circuit_with_czs(1)), 1),
+        (cirq.unitary(random_two_qubit_circuit_with_czs(0)), 0),
+    ],
+)
+def test_decompose_to_diagonal_and_circuit_returns_circuit_with_expected_number_of_czs(
+    mat, num_czs
+):
+    b, c = cirq.LineQubit.range(2)
+    _, ops = two_qubit_matrix_to_diagonal_and_cz_operations(b, c, mat, atol=1e-8)
+    circuit = cirq.Circuit(ops)
+    assert len(list(circuit.findall_operations_with_gate_type(cirq.CZPowGate))) == num_czs
+
+
 def test_remove_partial_czs_or_fail() -> None:
     CZ = cirq.CZ(*cirq.LineQubit.range(2))
     assert (

{cirq_core-1.6.0.dev20250625011740.dist-info → cirq_core-1.6.0.dev20250625152617.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cirq-core
-Version: 1.6.0.dev20250625011740
+Version: 1.6.0.dev20250625152617
 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.6.0.dev20250625011740.dist-info → cirq_core-1.6.0.dev20250625152617.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=emXpdD5ZvwLRlFAoQB8YatmZyU3b4e9jg6FppMTUhkU,33900
 cirq/_doc.py,sha256=BrnoABo1hk5RgB3Cgww4zLHUfiyFny0F1V-tOMCbdaU,2909
 cirq/_import.py,sha256=ixBu4EyGl46Ram2cP3p5eZVEFDW5L2DS-VyTjz4N9iw,8429
 cirq/_import_test.py,sha256=oF4izzOVZLc7NZ0aZHFcGv-r01eiFFt_JORx_x7_D4s,1089
-cirq/_version.py,sha256=IH_yywLC2DP2aoKRwaMc-SSgj8xtbawI_twNVETqkKo,1206
-cirq/_version_test.py,sha256=U7bVhNAYqNObqaCFrE56cK-cTnxPKD87NR_9rSy22eY,155
+cirq/_version.py,sha256=WaS6yXNBrQkWyNLtZioFkSEnew96llAnYDIuKKhPb-4,1206
+cirq/_version_test.py,sha256=LhXcrh_kn28Wi96pK1rtGPJU3q_VGDIJsTcF1OWhgYg,155
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=hYyG53VJeV61X0oukK5ndZYega8lkL2FyaL1m0j6h5M,13556
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -283,12 +283,12 @@ cirq/ops/common_channels.py,sha256=BD8-qJDGITOSP0bJVcWGgjbI5dj2dwFkSzzWb-qgfcc,3
 cirq/ops/common_channels_test.py,sha256=Qzw7nDrWgO1GDB7qkN2YUZi3NDswvvBJ9TEnSNakJX4,30755
 cirq/ops/common_gate_families.py,sha256=trK4ZXCKqYahZkyuwaAn-TcjUu7gmI9n9geO8PYiRGE,8606
 cirq/ops/common_gate_families_test.py,sha256=SfIKolQhVIof0uOHljY1QKT9Tu_4WzUsoeCNR2jIOPg,5441
-cirq/ops/common_gates.py,sha256=uNDMUj3mru-WsfLPJrxtiXfKfsZ5y8y3Ngha0AsZaXs,56206
-cirq/ops/common_gates_test.py,sha256=sTkAbPvfVf9p3N1lqnwkI9gJmTwQfIXPAbyVXFTP0NM,47979
+cirq/ops/common_gates.py,sha256=pnyLK2FurjE6idejtAzgRaawiW-AqiM22w7xMkEpxVs,58221
+cirq/ops/common_gates_test.py,sha256=IcUWxDTTTbis0efXz2Kn0zAdclp9R31fZAfCx3E-BOo,49758
 cirq/ops/control_values.py,sha256=GrNi8YJZSZDCl8Su6Ocimvd1R1SejFJjVu2thcJ8VLI,13346
 cirq/ops/control_values_test.py,sha256=Wyn0nwtcpnJvcPVRHmFGb3PtYxvsbpluA5UbPrG7tIo,13067
-cirq/ops/controlled_gate.py,sha256=WaimPh4J5tNGf65t6LLylx8l_RBCnqgQhz8DmUPCN5I,15077
-cirq/ops/controlled_gate_test.py,sha256=_iXDPtWdRkpTi_zgcY9J9c0gDx35pOmlW7HmT6DSzSw,28039
+cirq/ops/controlled_gate.py,sha256=3Hex9AdY6c_DedKoCqqpS4gx9rAgm9KZITbwUBXsoYg,13562
+cirq/ops/controlled_gate_test.py,sha256=jmIOlCx8dC3VId4NynX1ZYy7s7tkLav_d-fjiIZyVh0,29308
 cirq/ops/controlled_operation.py,sha256=l0pjUfru39HBuAbBkRCqJmrJDxah0JOFxXXILcUt0v8,13978
 cirq/ops/controlled_operation_test.py,sha256=qXpnUoeWmOQaTMZPAuuICtX9Idf-JWtdARTsTENv54g,16546
 cirq/ops/dense_pauli_string.py,sha256=1TijNu1D2HIbbnwLbT_f546R2L4OCQtm1bKjqhno1Kg,24234
@@ -307,8 +307,8 @@ cirq/ops/gate_operation.py,sha256=MF8JIYEM6bQu6ft9Eb19hSOillzu8MmaIoXSlmwbm5U,13
 cirq/ops/gate_operation_test.py,sha256=4QwWxCjGXNM__6QGw1kYSbBMh_4783jBZVBJD1ERGPk,18020
 cirq/ops/gateset.py,sha256=9HFW5Sg_jPpao8SEd7XgLdc_6xgUwZfvb6f7pfVPIF8,21492
 cirq/ops/gateset_test.py,sha256=_dpKTEwXuOY-jpev9rBPEcMy4KZ7zd6GmJ5JkvZAeog,16580
-cirq/ops/global_phase_op.py,sha256=Q5GrvuNgpSafUrcYUqEibt8hFoh3ZNeYJ9cp_nJ5PR4,4804
-cirq/ops/global_phase_op_test.py,sha256=cJDGmWlo3qAnW65Y9uCNMxuiOSTO6I1T3cC65ylaCfk,10087
+cirq/ops/global_phase_op.py,sha256=GcERs4X5h5_at6tvJc8-AcM0cVsLCRPlpPkAWMINm54,5711
+cirq/ops/global_phase_op_test.py,sha256=9BBnPZLLmBzHsMoRPMFTAShx87TJnhTLvvgLpHJF4wc,10721
 cirq/ops/greedy_qubit_manager.py,sha256=UTd9cTRbl4GQmf6ai6zqVBn5TR3-Vg84jJu4AN-0cxc,4050
 cirq/ops/greedy_qubit_manager_test.py,sha256=5vSKWsO0q8LwaKJSnOqr0bVQooKt0cwcO7zmPArHRRs,3464
 cirq/ops/identity.py,sha256=jWPE3jWLduXF5JgA0qol2blHXRvFUndClukG6nwGvUE,5862
@@ -374,7 +374,7 @@ cirq/ops/swap_gates.py,sha256=mEDVB4pdBsbenaOahrNtAcE2B1ZPW-4vGq079rECxf4,11743
 cirq/ops/swap_gates_test.py,sha256=8Yee6RgkQahsnB92ZD-rTb9dNqMLXdBKlgWC8qWd2uo,7624
 cirq/ops/tags.py,sha256=nBKqDnPHunxABIOqSAHsVb2hByRAJSfGCJjTC6-AbTY,2307
 cirq/ops/tags_test.py,sha256=EUCAjFYsQ98r6eo8XUNJoQCKMRCc4KvcqXUZAzfPqiE,1210
-cirq/ops/three_qubit_gates.py,sha256=DTxExMVcWRW8mmZnQrW6HQLUYbty0I_INAGaFxUh5DY,28175
+cirq/ops/three_qubit_gates.py,sha256=yPzu3xYz9_bKQCzuRyH3YnB8KHEI1qtdH8whBgHhMkU,27911
 cirq/ops/three_qubit_gates_test.py,sha256=r9bO7noLCUIGhSprE-KUTlnrf16IEoAhy93Obi6oL18,11951
 cirq/ops/two_qubit_diagonal_gate.py,sha256=m2wnFpi0sHA9cxMa2cqwRYGQIlbyTGohMTLdVVQZ2-U,5377
 cirq/ops/two_qubit_diagonal_gate_test.py,sha256=pv24VMf2yQ-2gaHg_EUwWx5tAFvXo47_sKzdbdCPhRY,4100
@@ -399,8 +399,8 @@ cirq/protocols/commutes_protocol.py,sha256=6cJNba3aEsCh_XHIeNTHb0LRzws6ZbxOrKL_r
 cirq/protocols/commutes_protocol_test.py,sha256=9YhBFYAwc-XpU7HrQp-GarKwmwmbgyadUYqlkiG10A8,5885
 cirq/protocols/control_key_protocol.py,sha256=uGgfahCHzsFpUGq6flgTMuqPh20zUSB2AOkSrhyoqwQ,2621
 cirq/protocols/control_key_protocol_test.py,sha256=fNDDkf4mQpA_tKuhX1e2BJN72v9HdGftgd79sOqREJE,1014
-cirq/protocols/decompose_protocol.py,sha256=uNptw0F1SxJRE8TDdcuoLdxd-B50brbJ8S5bQUPzRCs,18729
-cirq/protocols/decompose_protocol_test.py,sha256=sSiycmk4kMYC32IKuTjAoQBzfmM5sE3hzhZd1Dzd6rE,16144
+cirq/protocols/decompose_protocol.py,sha256=zwmrlFmBggInx1u1xZEeBDxaLGRWMGHCp87F7RRQPH4,19129
+cirq/protocols/decompose_protocol_test.py,sha256=s5ELgra5UKExKCjDHUtMOwTZrGmYwxAphCRryRLMM_Q,16456
 cirq/protocols/equal_up_to_global_phase_protocol.py,sha256=y-GPOImHgdjVqXF-qE3SUmlekF6-zI0tgi0E2nTdW1M,4106
 cirq/protocols/equal_up_to_global_phase_protocol_test.py,sha256=EDfWnCuYAVfcvBXHYoZ0lDukNEGG2c53vzP7s8jHLKA,6050
 cirq/protocols/has_stabilizer_effect_protocol.py,sha256=T_CVVpvckp3ZTsWi089mPqbmwOPLlF6GalEKrVK7Hvs,4309
@@ -1102,8 +1102,8 @@ cirq/transformers/analytical_decompositions/cphase_to_fsim.py,sha256=jFWTFjCQ76c
 cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py,sha256=6ZDfSTL7aWSXXfM5DToeX8VxMalWirrCGKKg7QKBGFc,5591
 cirq/transformers/analytical_decompositions/pauli_string_decomposition.py,sha256=7GKdVnN5jvpjABudB0zE1kUn0BPZmuvRZcM2yLMUoWs,4540
 cirq/transformers/analytical_decompositions/pauli_string_decomposition_test.py,sha256=yWHkXXErOxLmnp5t65WUsY9e9iN6L950MZRw5OY3QW0,2172
-cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py,sha256=JF2q79HEK5ZScMlqvnq17j7jAq0RFKpLPkKPnWiwN0c,11798
-cirq/transformers/analytical_decompositions/quantum_shannon_decomposition_test.py,sha256=7oGMrh-ZBVaHmjZjfLI4N_P8aJhxKasu59R8-Uy2G-E,7721
+cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py,sha256=EIrK1PbHRMMhT5wei6rYk8diPEaqEZ0B-9M1chhCfCo,15450
+cirq/transformers/analytical_decompositions/quantum_shannon_decomposition_test.py,sha256=Bk94HEm9a-cywM_Q2TBF6eUYkSJB1GWwJ5QO1J-rMoA,9006
 cirq/transformers/analytical_decompositions/single_qubit_decompositions.py,sha256=6kaQfcXY7je42o-pVprSwgPXCDJXraDXQ9mHyR_BaBk,8428
 cirq/transformers/analytical_decompositions/single_qubit_decompositions_test.py,sha256=oh96QXddCm1v8CrYA5mEnnx_ENXwZi89W6paVZU273I,12344
 cirq/transformers/analytical_decompositions/single_to_two_qubit_isometry.py,sha256=CRZylmI8nA_aq6vXj0WmMce8PIe8OFCjq4_bqYfkenk,2464
@@ -1112,8 +1112,8 @@ cirq/transformers/analytical_decompositions/three_qubit_decomposition.py,sha256=
 cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py,sha256=a21HU4BE82AG2UJU4hUVqymUU7Lw4CLw4-NChX4OpLI,6808
 cirq/transformers/analytical_decompositions/two_qubit_state_preparation.py,sha256=2bIpZOHBHxH2mdbJfDpo6nQgpitOI0ZmoH_5l_nA1nU,6167
 cirq/transformers/analytical_decompositions/two_qubit_state_preparation_test.py,sha256=c-vFBZnybd-Ez4rcs13THGGthzEZ0qw9Iw9sAKbE6yc,4494
-cirq/transformers/analytical_decompositions/two_qubit_to_cz.py,sha256=XwDkm7l8DnRoKcQVgm2X64mmUS16iVDsMFV-35KYHfo,9305
-cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py,sha256=5sSL80lYWquh7fcE6nbYVekEpxLNrHhj0T6G93IOZ7w,10033
+cirq/transformers/analytical_decompositions/two_qubit_to_cz.py,sha256=L2ScuiYW5tbNSc9_DJ4S6Lr_0mpmurVKUzlwLmGdJmw,11513
+cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py,sha256=PLPQRsBCVwGCgtL7nBY6xdI_CG1zxTdIj7fFGpxjU2U,10704
 cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py,sha256=8tYGV41gQBRzJSNUB3bsTMI8vil0TNE4TgqWlEw8BhE,9656
 cirq/transformers/analytical_decompositions/two_qubit_to_fsim_test.py,sha256=bX8ap8VskN-gKxn3F4A8_vhgWO0AErOpP1QVVEtBjmY,7073
 cirq/transformers/analytical_decompositions/two_qubit_to_ms.py,sha256=dP9umZJBgNJ8FbDFFZVgMSyO-NjWJqXmoWyQuTo--0g,3751
@@ -1220,8 +1220,8 @@ cirq/work/sampler.py,sha256=rxbMWvrhu3gfNSBjZKozw28lLKVvBAS_1EGyPdYe8Xg,19041
 cirq/work/sampler_test.py,sha256=SsMrRvLDYELyOAWLKISjkdEfrBwLYWRsT6D8WrsLM3Q,13533
 cirq/work/zeros_sampler.py,sha256=Fs2JWwq0n9zv7_G5Rm-9vPeHUag7uctcMOHg0JTkZpc,2371
 cirq/work/zeros_sampler_test.py,sha256=lQLgQDGBLtfImryys2HzQ2jOSGxHgc7-koVBUhv8qYk,3345
-cirq_core-1.6.0.dev20250625011740.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.6.0.dev20250625011740.dist-info/METADATA,sha256=_q1W3S0aAsqVZyyOY0-P7nQH4q_XAWi4lBx0luZmBqs,4857
-cirq_core-1.6.0.dev20250625011740.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cirq_core-1.6.0.dev20250625011740.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.6.0.dev20250625011740.dist-info/RECORD,,
+cirq_core-1.6.0.dev20250625152617.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.6.0.dev20250625152617.dist-info/METADATA,sha256=fnk4EUEjwRjeZxmyGn_W7MpZMYIIs5bO1ox35RYjOZ0,4857
+cirq_core-1.6.0.dev20250625152617.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cirq_core-1.6.0.dev20250625152617.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.6.0.dev20250625152617.dist-info/RECORD,,