cirq-core 1.5.0.dev20250409225226__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/transformers/measurement_transformers.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 from collections import defaultdict
-from typing import Any, cast, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, Iterable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -33,7 +35,7 @@ class _MeasurementQid(ops.Qid):
     Exactly one qubit will be created per qubit in the measurement gate.
     """
 
-    def __init__(self, key: Union[str, 'cirq.MeasurementKey'], qid: 'cirq.Qid', index: int = 0):
+    def __init__(self, key: str | cirq.MeasurementKey, qid: cirq.Qid, index: int = 0):
         """Initializes the qubit.
 
         Args:
@@ -63,8 +65,8 @@ class _MeasurementQid(ops.Qid):
 
 @transformer_api.transformer
 def defer_measurements(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
+) -> cirq.Circuit:
     """Implements the Deferred Measurement Principle.
 
     Uses the Deferred Measurement Principle to move all measurements to the
@@ -94,11 +96,9 @@ def defer_measurements(
 
     circuit = transformer_primitives.unroll_circuit_op(circuit, deep=True, tags_to_check=None)
     terminal_measurements = {op for _, op in find_terminal_measurements(circuit)}
-    measurement_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]] = defaultdict(
-        list
-    )
+    measurement_qubits: dict[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]] = defaultdict(list)
 
-    def defer(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def defer(op: cirq.Operation, _) -> cirq.OP_TREE:
         if op in terminal_measurements:
             return op
         gate = op.gate
@@ -169,10 +169,10 @@ def defer_measurements(
 
 
 def _all_possible_datastore_states(
-    keys: Iterable[Tuple['cirq.MeasurementKey', int]],
-    measurement_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]],
-) -> Iterable['cirq.ClassicalDataStoreReader']:
-    """The cartesian product of all possible DataStore states for the given keys."""
+    keys: Iterable[tuple[cirq.MeasurementKey, int]],
+    measurement_qubits: dict[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]],
+) -> Iterable[cirq.ClassicalDataStoreReader]:
+    """The Cartesian product of all possible DataStore states for the given keys."""
     # First we get the list of all possible values. So if we have a key mapped to qubits of shape
     # (2, 2) and a key mapped to a qutrit, the possible measurement values are:
     # [((0, 0), (0,)),
@@ -214,10 +214,10 @@ def _all_possible_datastore_states(
 
 @transformer_api.transformer
 def dephase_measurements(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = transformer_api.TransformerContext(deep=True),
-) -> 'cirq.Circuit':
+    context: cirq.TransformerContext | None = transformer_api.TransformerContext(deep=True),
+) -> cirq.Circuit:
     """Changes all measurements to a dephase operation.
 
     This transformer is useful when using a density matrix simulator, when
@@ -240,7 +240,7 @@ def dephase_measurements(
             surprises.
     """
 
-    def dephase(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def dephase(op: cirq.Operation, _) -> cirq.OP_TREE:
         gate = op.gate
         if isinstance(gate, ops.MeasurementGate):
             key = value.MeasurementKey.parse_serialized(gate.key)
@@ -257,10 +257,10 @@ def dephase_measurements(
 
 @transformer_api.transformer
 def drop_terminal_measurements(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = transformer_api.TransformerContext(deep=True),
-) -> 'cirq.Circuit':
+    context: cirq.TransformerContext | None = transformer_api.TransformerContext(deep=True),
+) -> cirq.Circuit:
     """Removes terminal measurements from a circuit.
 
     This transformer is helpful when trying to capture the final state vector
@@ -289,7 +289,7 @@ def drop_terminal_measurements(
     if not circuit.are_all_measurements_terminal():
         raise ValueError('Circuit contains a non-terminal measurement.')
 
-    def flip_inversion(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def flip_inversion(op: cirq.Operation, _) -> cirq.OP_TREE:
         if isinstance(op.gate, ops.MeasurementGate):
             return [
                 (
@@ -426,20 +426,20 @@ class _ConfusionChannel(ops.Gate):
         self._confusion_map = confusion_map.copy()
         self._kraus = tuple(kraus)
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self._shape
 
-    def _kraus_(self) -> Tuple[np.ndarray, ...]:
+    def _kraus_(self) -> tuple[np.ndarray, ...]:
         return self._kraus
 
-    def _apply_channel_(self, args: 'cirq.ApplyChannelArgs'):
-        configs: List[transformations._BuildFromSlicesArgs] = []
+    def _apply_channel_(self, args: cirq.ApplyChannelArgs):
+        configs: list[transformations._BuildFromSlicesArgs] = []
         for i in range(np.prod(self._shape) ** 2):
             scale = cast(complex, self._confusion_map.flat[i])
             if scale == 0:
                 continue
             index: Any = np.unravel_index(i, self._shape * 2)
-            slices: List[transformations._SliceConfig] = []
+            slices: list[transformations._SliceConfig] = []
             axis_count = len(args.left_axes)
             for j in range(axis_count):
                 s1 = transformations._SliceConfig(
@@ -469,20 +469,20 @@ class _ModAdd(ops.ArithmeticGate):
     def __init__(self, dimension: int):
         self._dimension = dimension
 
-    def registers(self) -> Tuple[Tuple[int], Tuple[int]]:
+    def registers(self) -> tuple[tuple[int], tuple[int]]:
         return (self._dimension,), (self._dimension,)
 
-    def with_registers(self, *new_registers) -> '_ModAdd':
+    def with_registers(self, *new_registers) -> _ModAdd:
         raise NotImplementedError()
 
-    def apply(self, *register_values: int) -> Tuple[int, int]:
+    def apply(self, *register_values: int) -> tuple[int, int]:
         return register_values[0], sum(register_values)
 
     def _value_equality_values_(self) -> int:
         return self._dimension
 
 
-def _mod_add(source: 'cirq.Qid', target: 'cirq.Qid') -> 'cirq.Operation':
+def _mod_add(source: cirq.Qid, target: cirq.Qid) -> cirq.Operation:
     assert source.dimension == target.dimension
     if source.dimension == 2:
         # Use a CX gate in 2D case for simplicity.

cirq/transformers/measurement_transformers_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 import sympy

cirq/transformers/merge_k_qubit_gates.py

@@ -14,7 +14,9 @@
 
 """Transformer pass to merge connected components of k-qubit unitary operations."""
 
-from typing import Callable, cast, Optional, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Callable, cast, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
 from cirq.transformers import transformer_api, transformer_primitives
@@ -24,16 +26,16 @@ if TYPE_CHECKING:
 
 
 def _rewrite_merged_k_qubit_unitaries(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     k: int = 0,
-    rewriter: Optional[Callable[['cirq.CircuitOperation'], 'cirq.OP_TREE']] = None,
+    rewriter: Callable[[cirq.CircuitOperation], cirq.OP_TREE] | None = None,
     merged_circuit_op_tag: str = "_merged_k_qubit_unitaries_component",
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     deep = context.deep if context else False
 
-    def map_func(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, _) -> cirq.OP_TREE:
         op_untagged = op.untagged
         if (
             deep
@@ -66,12 +68,12 @@ def _rewrite_merged_k_qubit_unitaries(
 
 @transformer_api.transformer
 def merge_k_qubit_unitaries(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     k: int = 0,
-    rewriter: Optional[Callable[['cirq.CircuitOperation'], 'cirq.OP_TREE']] = None,
-) -> 'cirq.Circuit':
+    rewriter: Callable[[cirq.CircuitOperation], cirq.OP_TREE] | None = None,
+) -> cirq.Circuit:
     """Merges connected components of unitary operations, acting on <= k qubits.
 
     Uses rewriter to convert a connected component of unitary operations acting on <= k-qubits

cirq/transformers/merge_k_qubit_gates_test.py

@@ -12,9 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: skip-file
-
-from typing import List
+from __future__ import annotations
 
 import numpy as np
 import pytest
@@ -24,7 +22,7 @@ import cirq
 
 def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCircuit):
     # Ignore differences that would be caught by follow-up optimizations.
-    followup_transformers: List[cirq.TRANSFORMER] = [
+    followup_transformers: list[cirq.TRANSFORMER] = [
         cirq.drop_negligible_operations,
         cirq.drop_empty_moments,
     ]
@@ -35,7 +33,7 @@ def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCir
     cirq.testing.assert_same_circuits(optimized, expected)
 
 
-def test_merge_1q_unitaries():
+def test_merge_1q_unitaries() -> None:
     q, q2 = cirq.LineQubit.range(2)
     # 1. Combines trivial 1q sequence.
     c = cirq.Circuit(cirq.X(q) ** 0.5, cirq.Z(q) ** 0.5, cirq.X(q) ** -0.5)
@@ -55,7 +53,7 @@ def test_merge_1q_unitaries():
     assert isinstance(c[-1][q].gate, cirq.MatrixGate)
 
 
-def test_respects_nocompile_tags():
+def test_respects_nocompile_tags() -> None:
     q = cirq.NamedQubit("q")
     c = cirq.Circuit(
         [cirq.Z(q), cirq.H(q), cirq.X(q), cirq.H(q), cirq.X(q).with_tags("nocompile"), cirq.H(q)]
@@ -68,12 +66,12 @@ def test_respects_nocompile_tags():
     assert isinstance(c[-1][q].gate, cirq.MatrixGate)
 
 
-def test_ignores_2qubit_target():
+def test_ignores_2qubit_target() -> None:
     c = cirq.Circuit(cirq.CZ(*cirq.LineQubit.range(2)))
     assert_optimizes(optimized=cirq.merge_k_qubit_unitaries(c, k=1), expected=c)
 
 
-def test_ignore_unsupported_gate():
+def test_ignore_unsupported_gate() -> None:
     class UnsupportedExample(cirq.testing.SingleQubitGate):
         pass
 
@@ -81,7 +79,7 @@ def test_ignore_unsupported_gate():
     assert_optimizes(optimized=cirq.merge_k_qubit_unitaries(c, k=1), expected=c)
 
 
-def test_1q_rewrite():
+def test_1q_rewrite() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.X(q0), cirq.Y(q0), cirq.X(q1), cirq.CZ(q0, q1), cirq.Y(q1), cirq.measure(q0, q1)
@@ -96,12 +94,12 @@ def test_1q_rewrite():
     )
 
 
-def test_merge_k_qubit_unitaries_raises():
+def test_merge_k_qubit_unitaries_raises() -> None:
     with pytest.raises(ValueError, match="k should be greater than or equal to 1"):
         _ = cirq.merge_k_qubit_unitaries(cirq.Circuit())
 
 
-def test_merge_complex_circuit_preserving_moment_structure():
+def test_merge_complex_circuit_preserving_moment_structure() -> None:
     q = cirq.LineQubit.range(3)
     c_orig = cirq.Circuit(
         cirq.Moment(cirq.H.on_each(*q)),
@@ -133,7 +131,7 @@ a: ═════════════════════════
     )
     component_id = 0
 
-    def rewriter_merge_to_circuit_op(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
+    def rewriter_merge_to_circuit_op(op: cirq.CircuitOperation) -> cirq.OP_TREE:
         nonlocal component_id
         component_id = component_id + 1
         return op.with_tags(f'{component_id}')
@@ -155,12 +153,13 @@ a: ═════════════════════════
       │                                                                   │                                                       ║
 2: ───#2──────────────────────────────────────────────────────────────────X───────────[ 2: ───Z─── ][3]───M───────────────────────╫───
                                                                                                           ║                       ║
-a: ═══════════════════════════════════════════════════════════════════════════════════════════════════════@═══════════════════════^═══''',
+a: ═══════════════════════════════════════════════════════════════════════════════════════════════════════@═══════════════════════^═══
+        ''',  # noqa: E501
     )
 
     component_id = 0
 
-    def rewriter_replace_with_decomp(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
+    def rewriter_replace_with_decomp(op: cirq.CircuitOperation) -> cirq.OP_TREE:
         nonlocal component_id
         component_id = component_id + 1
         tag = f'{component_id}'
@@ -185,11 +184,12 @@ a: ═════════════════════════
              │                                            │                                                 ║
 2: ───T[1]───iSwap^0.5───T[1]─────────────────────────────X───────────T[3]────────M─────────────────────────╫───
                                                                                   ║                         ║
-a: ═══════════════════════════════════════════════════════════════════════════════@═════════════════════════^═══''',
+a: ═══════════════════════════════════════════════════════════════════════════════@═════════════════════════^═══
+        ''',  # noqa: E501
     )
 
 
-def test_merge_k_qubit_unitaries_deep():
+def test_merge_k_qubit_unitaries_deep() -> None:
     q = cirq.LineQubit.range(2)
     h_cz_y = [cirq.H(q[0]), cirq.CZ(*q), cirq.Y(q[1])]
     c_orig = cirq.Circuit(
@@ -220,7 +220,7 @@ def test_merge_k_qubit_unitaries_deep():
 
     component_id = 0
 
-    def rewriter_merge_to_circuit_op(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
+    def rewriter_merge_to_circuit_op(op: cirq.CircuitOperation) -> cirq.OP_TREE:
         nonlocal component_id
         component_id = component_id + 1
         return op.with_tags(f'{component_id}')
@@ -251,7 +251,7 @@ def test_merge_k_qubit_unitaries_deep():
     cirq.testing.assert_same_circuits(c_new_matrix, c_expected_matrix)
 
 
-def test_merge_k_qubit_unitaries_deep_recurses_on_large_circuit_op():
+def test_merge_k_qubit_unitaries_deep_recurses_on_large_circuit_op() -> None:
     q = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(
         cirq.CircuitOperation(cirq.FrozenCircuit(cirq.X(q[0]), cirq.H(q[0]), cirq.CNOT(*q)))

cirq/transformers/merge_single_qubit_gates.py

@@ -14,23 +14,36 @@
 
 """Transformer passes to combine adjacent single-qubit rotations."""
 
-from typing import Optional, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Callable, cast, Hashable, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
-from cirq.transformers import merge_k_qubit_gates, transformer_api, transformer_primitives
+from cirq.study.resolver import ParamResolver
+from cirq.study.sweeps import dict_to_zip_sweep, ListSweep, ProductOrZipSweepLike, Sweep, Zip
+from cirq.transformers import (
+    align,
+    merge_k_qubit_gates,
+    symbolize,
+    tag_transformers,
+    transformer_api,
+    transformer_primitives,
+)
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 
 if TYPE_CHECKING:
+    import sympy
+
     import cirq
 
 
 @transformer_api.transformer
 def merge_single_qubit_gates_to_phased_x_and_z(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     atol: float = 1e-8,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Replaces runs of single qubit rotations with `cirq.PhasedXPowGate` and `cirq.ZPowGate`.
 
     Specifically, any run of non-parameterized single-qubit unitaries will be replaced by an
@@ -46,7 +59,7 @@ def merge_single_qubit_gates_to_phased_x_and_z(
         Copy of the transformed input circuit.
     """
 
-    def rewriter(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
+    def rewriter(op: cirq.CircuitOperation) -> cirq.OP_TREE:
         u = protocols.unitary(op)
         if protocols.num_qubits(op) == 0:
             return ops.GlobalPhaseGate(u[0, 0]).on()
@@ -62,11 +75,12 @@ def merge_single_qubit_gates_to_phased_x_and_z(
 
 @transformer_api.transformer
 def merge_single_qubit_gates_to_phxz(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
+    merge_tags_fn: Callable[[cirq.CircuitOperation], list[Hashable]] | None = None,
     atol: float = 1e-8,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Replaces runs of single qubit rotations with a single optional `cirq.PhasedXZGate`.
 
     Specifically, any run of non-parameterized single-qubit unitaries will be replaced by an
@@ -75,6 +89,7 @@ def merge_single_qubit_gates_to_phxz(
     Args:
         circuit: Input circuit to transform. It will not be modified.
         context: `cirq.TransformerContext` storing common configurable options for transformers.
+        merge_tags_fn: A callable returns the tags to be added to the merged operation.
         atol: Absolute tolerance to angle error. Larger values allow more negligible gates to be
             dropped, smaller values increase accuracy.
 
@@ -82,12 +97,13 @@ def merge_single_qubit_gates_to_phxz(
         Copy of the transformed input circuit.
     """
 
-    def rewriter(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
-        u = protocols.unitary(op)
-        if protocols.num_qubits(op) == 0:
+    def rewriter(circuit_op: cirq.CircuitOperation) -> cirq.OP_TREE:
+        u = protocols.unitary(circuit_op)
+        if protocols.num_qubits(circuit_op) == 0:
             return ops.GlobalPhaseGate(u[0, 0]).on()
-        gate = single_qubit_decompositions.single_qubit_matrix_to_phxz(u, atol)
-        return gate(op.qubits[0]) if gate else []
+        gate = single_qubit_decompositions.single_qubit_matrix_to_phxz(u, atol) or ops.I
+        phxz_op = gate.on(circuit_op.qubits[0])
+        return phxz_op.with_tags(*merge_tags_fn(circuit_op)) if merge_tags_fn else phxz_op
 
     return merge_k_qubit_gates.merge_k_qubit_unitaries(
         circuit, k=1, context=context, rewriter=rewriter
@@ -96,11 +112,11 @@ def merge_single_qubit_gates_to_phxz(
 
 @transformer_api.transformer
 def merge_single_qubit_moments_to_phxz(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     atol: float = 1e-8,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Merges adjacent moments with only 1-qubit rotations to a single moment with PhasedXZ gates.
 
     Args:
@@ -114,15 +130,15 @@ def merge_single_qubit_moments_to_phxz(
     """
     tags_to_ignore = set(context.tags_to_ignore) if context else set()
 
-    def can_merge_moment(m: 'cirq.Moment'):
+    def can_merge_moment(m: cirq.Moment):
         return all(
-            protocols.num_qubits(op) == 1
+            protocols.num_qubits(op) <= 1
             and protocols.has_unitary(op)
             and tags_to_ignore.isdisjoint(op.tags)
             for op in m
         )
 
-    def merge_func(m1: 'cirq.Moment', m2: 'cirq.Moment') -> Optional['cirq.Moment']:
+    def merge_func(m1: cirq.Moment, m2: cirq.Moment) -> cirq.Moment | None:
         if not (can_merge_moment(m1) and can_merge_moment(m2)):
             return None
         ret_ops = []
@@ -144,6 +160,10 @@ def merge_single_qubit_moments_to_phxz(
                     )
                     if gate:
                         ret_ops.append(gate(q))
+        # Transfer global phase
+        for op in m1.operations + m2.operations:
+            if protocols.num_qubits(op) == 0:
+                ret_ops.append(op)
         return circuits.Moment(ret_ops)
 
     return transformer_primitives.merge_moments(
@@ -152,3 +172,160 @@ def merge_single_qubit_moments_to_phxz(
         deep=context.deep if context else False,
         tags_to_ignore=tuple(tags_to_ignore),
     ).unfreeze(copy=False)
+
+
+def _sweep_on_symbols(sweep: Sweep, symbols: set[sympy.Symbol]) -> Sweep:
+    new_resolvers: list[cirq.ParamResolver] = []
+    for resolver in sweep:
+        param_dict: cirq.ParamMappingType = {s: resolver.value_of(s) for s in symbols}
+        new_resolvers.append(ParamResolver(param_dict))
+    return ListSweep(new_resolvers)
+
+
+def _calc_phxz_sweeps(
+    symbolized_circuit: cirq.Circuit, resolved_circuits: list[cirq.Circuit]
+) -> Sweep:
+    """Returns the phxz sweep of the symbolized_circuit on resolved_circuits.
+
+    Raises:
+        ValueError: Structural mismatch: A `resolved_circuit` contains an unexpected gate type.
+            Expected a `PhasedXZGate` or `IdentityGate` at a position corresponding to a
+            symbolic `PhasedXZGate` in the `symbolized_circuit`.
+    """
+
+    def _extract_axz(op: ops.Operation | None) -> tuple[float, float, float]:
+        if not op or not op.gate or not isinstance(op.gate, ops.IdentityGate | ops.PhasedXZGate):
+            raise ValueError(f"Expect a PhasedXZGate or IdentityGate on op {op}.")
+        if isinstance(op.gate, ops.IdentityGate):
+            return 0.0, 0.0, 0.0  # Identity gate's a, x, z in PhasedXZ
+        return op.gate.axis_phase_exponent, op.gate.x_exponent, op.gate.z_exponent
+
+    values_by_params: dict[sympy.Symbol, tuple[float, ...]] = {}
+    for mid, moment in enumerate(symbolized_circuit):
+        for op in moment.operations:
+            if op.gate and isinstance(op.gate, ops.PhasedXZGate) and protocols.is_parameterized(op):
+                sa, sx, sz = op.gate.axis_phase_exponent, op.gate.x_exponent, op.gate.z_exponent
+                values_by_params[sa], values_by_params[sx], values_by_params[sz] = zip(
+                    *[_extract_axz(c[mid].operation_at(op.qubits[0])) for c in resolved_circuits]
+                )
+
+    return dict_to_zip_sweep(cast(ProductOrZipSweepLike, values_by_params))
+
+
+def merge_single_qubit_gates_to_phxz_symbolized(
+    circuit: cirq.AbstractCircuit,
+    *,
+    context: cirq.TransformerContext | None = None,
+    sweep: Sweep,
+    atol: float = 1e-8,
+) -> tuple[cirq.Circuit, Sweep]:
+    """Merges consecutive single qubit gates as PhasedXZ Gates. Symbolizes if any of
+      the consecutive gates is symbolized.
+
+    Example:
+        >>> q0, q1 = cirq.LineQubit.range(2)
+        >>> c = cirq.Circuit(\
+                    cirq.X(q0),\
+                    cirq.CZ(q0,q1)**sympy.Symbol("cz_exp"),\
+                    cirq.Y(q0)**sympy.Symbol("y_exp"),\
+                    cirq.X(q0))
+        >>> print(c)
+        0: ───X───@──────────Y^y_exp───X───
+                  │
+        1: ───────@^cz_exp─────────────────
+        >>> new_circuit, new_sweep = cirq.merge_single_qubit_gates_to_phxz_symbolized(\
+                c, sweep=cirq.Zip(cirq.Points(key="cz_exp", points=[0, 1]),\
+                                  cirq.Points(key="y_exp",  points=[0, 1])))
+        >>> print(new_circuit)
+        0: ───PhXZ(a=-1,x=1,z=0)───@──────────PhXZ(a=a0,x=x0,z=z0)───
+                                   │
+        1: ────────────────────────@^cz_exp──────────────────────────
+        >>> assert new_sweep[0] == cirq.ParamResolver({'a0': -1, 'x0': 1, 'z0': 0, 'cz_exp': 0})
+        >>> assert new_sweep[1] == cirq.ParamResolver({'a0': -0.5, 'x0': 0, 'z0': -1, 'cz_exp': 1})
+
+    Args:
+        circuit: Input circuit to transform. It will not be modified.
+        context: `cirq.TransformerContext` storing common configurable options for transformers.
+        sweep: Sweep of the symbols in the input circuit. An updated Sweep will be returned
+            based on the transformation.
+        atol: Absolute tolerance to angle error. Larger values allow more negligible gates to be
+            dropped, smaller values increase accuracy.
+
+    Returns:
+        Copy of the transformed input circuit.
+    """
+    deep = context.deep if context else False
+
+    # Tag symbolized single-qubit op.
+    symbolized_single_tag = "_tmp_symbolize_tag"
+
+    circuit_tagged = transformer_primitives.map_operations(
+        circuit,
+        lambda op, _: (
+            op.with_tags(symbolized_single_tag)
+            if protocols.is_parameterized(op) and len(op.qubits) == 1
+            else op
+        ),
+        deep=deep,
+    )
+
+    # Step 0, isolate single qubit symbols and resolve the circuit on them.
+    single_qubit_gate_symbols: set[sympy.Symbol] = set().union(
+        *[
+            protocols.parameter_symbols(op) if symbolized_single_tag in op.tags else set()
+            for op in circuit_tagged.all_operations()
+        ]
+    )
+    # Remaining symbols, e.g., 2 qubit gates' symbols. Sweep of those symbols keeps unchanged.
+    remaining_symbols: set[sympy.Symbol] = set(
+        protocols.parameter_symbols(circuit) - single_qubit_gate_symbols
+    )
+    # If all single qubit gates are not parameterized, call the non-parameterized version of
+    # the transformer.
+    if not single_qubit_gate_symbols:
+        return (merge_single_qubit_gates_to_phxz(circuit, context=context, atol=atol), sweep)
+    sweep_of_single: Sweep = _sweep_on_symbols(sweep, single_qubit_gate_symbols)
+    # Get all resolved circuits from all sets of resolvers in sweep_of_single.
+    resolved_circuits = [
+        protocols.resolve_parameters(circuit_tagged, resolver) for resolver in sweep_of_single
+    ]
+
+    # Step 1, merge single qubit gates per resolved circuit, preserving
+    #  the symbolized_single_tag to indicate the operator is a merged one.
+    merged_circuits: list[cirq.Circuit] = [
+        merge_single_qubit_gates_to_phxz(
+            c,
+            context=context,
+            merge_tags_fn=lambda circuit_op: (
+                [symbolized_single_tag]
+                if any(
+                    symbolized_single_tag in set(op.tags)
+                    for op in circuit_op.circuit.all_operations()
+                )
+                else []
+            ),
+            atol=atol,
+        )
+        for c in resolved_circuits
+    ]
+
+    # Step 2, get the new symbolized circuit by symbolizing on indexed symbolized_single_tag.
+    new_circuit = tag_transformers.remove_tags(  # remove the temp tags used to track merges
+        symbolize.symbolize_single_qubit_gates_by_indexed_tags(
+            tag_transformers.index_tags(  # index all 1-qubit-ops merged from ops with symbols
+                merged_circuits[0],
+                context=transformer_api.TransformerContext(deep=deep),
+                target_tags={symbolized_single_tag},
+            ),
+            symbolize_tag=symbolize.SymbolizeTag(prefix=symbolized_single_tag),
+        ),
+        remove_if=lambda tag: str(tag).startswith(symbolized_single_tag),
+    )
+
+    # Step 3, get N sets of parameterizations as new_sweep.
+    new_sweep = Zip(
+        _calc_phxz_sweeps(new_circuit, merged_circuits),  # phxz sweeps
+        _sweep_on_symbols(sweep, remaining_symbols),  # remaining sweeps
+    )
+
+    return align.align_right(new_circuit), new_sweep