cirq-core 1.6.0.dev20250501173104__py3-none-any.whl → 1.6.0.dev20250501192724__py3-none-any.whl

cirq/transformers/eject_phased_paulis.py

@@ -14,6 +14,8 @@
 
 """Transformer pass that pushes 180° rotations around axes in the XY plane later in the circuit."""
 
+from __future__ import annotations
+
 from typing import cast, Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
@@ -29,12 +31,12 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer(add_deep_support=True)
 def eject_phased_paulis(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     atol: float = 1e-8,
     eject_parameterized: bool = False,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Transformer pass to push X, Y, PhasedX & (certain) PhasedXZ gates to the end of the circuit.
 
     As the gates get pushed, they may absorb Z gates, cancel against other
@@ -60,7 +62,7 @@ def eject_phased_paulis(
     held_w_phases: Dict[ops.Qid, value.TParamVal] = {}
     tags_to_ignore = set(context.tags_to_ignore) if context else set()
 
-    def map_func(op: 'cirq.Operation', _: int) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
         # Dump if `op` marked with a no compile tag.
         if set(op.tags) & tags_to_ignore:
             return [_dump_held(op.qubits, held_w_phases, atol), op]
@@ -107,7 +109,7 @@ def eject_phased_paulis(
 
 def _absorb_z_into_w(
     op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+) -> cirq.OP_TREE:
     """Absorbs a Z^t gate into a W(a) flip.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -128,7 +130,7 @@ def _absorb_z_into_w(
 
 def _dump_held(
     qubits: Iterable[ops.Qid], held_w_phases: Dict[ops.Qid, value.TParamVal], atol: float
-) -> Iterator['cirq.OP_TREE']:
+) -> Iterator[cirq.OP_TREE]:
     # Note: sorting is to avoid non-determinism in the insertion order.
     for q in sorted(qubits):
         p = held_w_phases.get(q)
@@ -140,7 +142,7 @@ def _dump_held(
 
 def _dump_into_measurement(
     op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+) -> cirq.OP_TREE:
     measurement = cast(ops.MeasurementGate, cast(ops.GateOperation, op).gate)
     new_measurement = measurement.with_bits_flipped(
         *[i for i, q in enumerate(op.qubits) if q in held_w_phases]
@@ -152,7 +154,7 @@ def _dump_into_measurement(
 
 def _potential_cross_whole_w(
     op: ops.Operation, atol: float, held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+) -> cirq.OP_TREE:
     """Grabs or cancels a held W gate against an existing W gate.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -185,7 +187,7 @@ def _potential_cross_whole_w(
 
 def _potential_cross_partial_w(
     op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal], atol: float
-) -> 'cirq.OP_TREE':
+) -> cirq.OP_TREE:
     """Cross the held W over a partial W gate.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -210,7 +212,7 @@ def _potential_cross_partial_w(
     return gate.on(op.qubits[0])
 
 
-def _single_cross_over_cz(op: ops.Operation, qubit_with_w: 'cirq.Qid') -> 'cirq.OP_TREE':
+def _single_cross_over_cz(op: ops.Operation, qubit_with_w: cirq.Qid) -> cirq.OP_TREE:
     """Crosses exactly one W flip over a partial CZ.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -251,7 +253,7 @@ def _single_cross_over_cz(op: ops.Operation, qubit_with_w: 'cirq.Qid') -> 'cirq.
 
 def _double_cross_over_cz(
     op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+) -> cirq.OP_TREE:
     """Crosses two W flips over a partial CZ.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -355,7 +357,7 @@ def _try_get_known_z_half_turns(
 
 def _phased_x_or_pauli_gate(
     exponent: Union[float, sympy.Expr], phase_exponent: Union[float, sympy.Expr], atol: float
-) -> Union['cirq.PhasedXPowGate', 'cirq.XPowGate', 'cirq.YPowGate']:
+) -> Union[cirq.PhasedXPowGate, cirq.XPowGate, cirq.YPowGate]:
     """Return PhasedXPowGate or X or Y gate if equivalent within atol in z-axis turns."""
     if not isinstance(phase_exponent, sympy.Expr) or phase_exponent.is_constant():
         half_turns = value.canonicalize_half_turns(float(phase_exponent))

cirq/transformers/eject_z.py

@@ -14,6 +14,8 @@
 
 """Transformer pass that pushes Z gates later and later in the circuit."""
 
+from __future__ import annotations
+
 from collections import defaultdict
 from typing import Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING
 
@@ -31,7 +33,7 @@ def _is_integer(n):
     return np.isclose(n, np.round(n))
 
 
-def _is_swaplike(gate: 'cirq.Gate'):
+def _is_swaplike(gate: cirq.Gate):
     if isinstance(gate, ops.SwapPowGate):
         return gate.exponent == 1
 
@@ -46,12 +48,12 @@ def _is_swaplike(gate: 'cirq.Gate'):
 
 @transformer_api.transformer(add_deep_support=True)
 def eject_z(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     atol: float = 0.0,
     eject_parameterized: bool = False,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Pushes Z gates towards the end of the circuit.
 
     As the Z gates get pushed they may absorb other Z gates, get absorbed into
@@ -77,7 +79,7 @@ def eject_z(
         lambda: None
     )
 
-    def dump_tracked_phase(qubits: Iterable[ops.Qid]) -> Iterator['cirq.OP_TREE']:
+    def dump_tracked_phase(qubits: Iterable[ops.Qid]) -> Iterator[cirq.OP_TREE]:
         """Zeroes qubit_phase entries by emitting Z gates."""
         for q in qubits:
             p, key = qubit_phase[q], last_phased_xz_op[q]
@@ -87,7 +89,7 @@ def eject_z(
             elif key:
                 phased_xz_replacements[key] = phased_xz_replacements[key].with_z_exponent(p * 2)
 
-    def map_func(op: 'cirq.Operation', moment_index: int) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, moment_index: int) -> cirq.OP_TREE:
         last_phased_xz_op.update({q: None for q in op.qubits})
 
         if tags_to_ignore & set(op.tags):

cirq/transformers/expand_composite.py

@@ -14,6 +14,8 @@
 
 """Transformer pass that expands composite operations via `cirq.decompose`."""
 
+from __future__ import annotations
+
 from typing import Callable, Optional, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
@@ -25,9 +27,9 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer
 def expand_composite(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     no_decomp: Callable[[ops.Operation], bool] = (lambda _: False),
 ):
     """A transformer that expands composite operations via `cirq.decompose`.
@@ -48,7 +50,7 @@ def expand_composite(
           Copy of the transformed input circuit.
     """
 
-    def map_func(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, _) -> cirq.OP_TREE:
         if context and context.deep and isinstance(op.untagged, circuits.CircuitOperation):
             return op
         return protocols.decompose(op, keep=no_decomp, on_stuck_raise=None)

cirq/transformers/gauge_compiling/sqrt_cz_gauge.py

@@ -15,6 +15,8 @@
 """A Gauge transformer for CZ**0.5 and CZ**-0.5 gates."""
 
 
+from __future__ import annotations
+
 from numbers import Real
 from typing import Dict, Sequence, Tuple, TYPE_CHECKING
 
@@ -42,7 +44,7 @@ class SqrtCZGauge(Gauge):
     def weight(self) -> float:
         return 3.0
 
-    def sample(self, gate: 'cirq.Gate', prng: np.random.Generator) -> ConstantGauge:
+    def sample(self, gate: cirq.Gate, prng: np.random.Generator) -> ConstantGauge:
         if prng.choice([True, False]):
             return ConstantGauge(two_qubit_gate=gate)
         swap_qubits = prng.choice([True, False])

cirq/transformers/heuristic_decompositions/two_qubit_gate_tabulation.py

@@ -14,6 +14,9 @@
 
 """Attempt to tabulate single qubit gates required to generate a target 2Q gate
 with a product A k A."""
+
+from __future__ import annotations
+
 from dataclasses import dataclass
 from functools import reduce
 from typing import List, NamedTuple, Sequence, Tuple
@@ -316,7 +319,7 @@ def two_qubit_gate_product_tabulation(
     *,
     sample_scaling: int = 50,
     allow_missed_points: bool = True,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> TwoQubitGateTabulation:
     r"""Generate a TwoQubitGateTabulation for a base two qubit unitary.
 

cirq/transformers/insertion_sort.py

@@ -14,6 +14,8 @@
 
 """Transformer that sorts commuting operations in increasing order of their `.qubits` tuple."""
 
+from __future__ import annotations
+
 from typing import Dict, List, Optional, TYPE_CHECKING
 
 from cirq import circuits, protocols
@@ -25,8 +27,8 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer(add_deep_support=True)
 def insertion_sort_transformer(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+) -> cirq.Circuit:
     """Sorts the operations using their sorted `.qubits` property as comparison key.
 
     Operations are swapped only if they commute.
@@ -35,8 +37,8 @@ def insertion_sort_transformer(
         circuit: input circuit.
         context: optional TransformerContext (not used),
     """
-    final_operations: List['cirq.Operation'] = []
-    qubit_index: Dict['cirq.Qid', int] = {
+    final_operations: List[cirq.Operation] = []
+    qubit_index: Dict[cirq.Qid, int] = {
         q: idx for idx, q in enumerate(sorted(circuit.all_qubits()))
     }
     cached_qubit_indices: Dict[int, List[int]] = {}

cirq/transformers/measurement_transformers.py

@@ -12,6 +12,8 @@
 # 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
@@ -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: Union[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: Optional[cirq.TransformerContext] = 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,9 +169,9 @@ 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']:
+    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:
@@ -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: Optional[cirq.TransformerContext] = 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: Optional[cirq.TransformerContext] = 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 [
                 (
@@ -432,7 +432,7 @@ class _ConfusionChannel(ops.Gate):
     def _kraus_(self) -> Tuple[np.ndarray, ...]:
         return self._kraus
 
-    def _apply_channel_(self, args: 'cirq.ApplyChannelArgs'):
+    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])
@@ -472,7 +472,7 @@ class _ModAdd(ops.ArithmeticGate):
     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]:
@@ -482,7 +482,7 @@ class _ModAdd(ops.ArithmeticGate):
         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/merge_k_qubit_gates.py

@@ -14,6 +14,8 @@
 
 """Transformer pass to merge connected components of k-qubit unitary operations."""
 
+from __future__ import annotations
+
 from typing import Callable, cast, Optional, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
@@ -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: Optional[cirq.TransformerContext] = None,
     k: int = 0,
-    rewriter: Optional[Callable[['cirq.CircuitOperation'], 'cirq.OP_TREE']] = None,
+    rewriter: Optional[Callable[[cirq.CircuitOperation], cirq.OP_TREE]] = 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: Optional[cirq.TransformerContext] = None,
     k: int = 0,
-    rewriter: Optional[Callable[['cirq.CircuitOperation'], 'cirq.OP_TREE']] = None,
-) -> 'cirq.Circuit':
+    rewriter: Optional[Callable[[cirq.CircuitOperation], cirq.OP_TREE]] = 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

@@ -14,6 +14,8 @@
 
 # pylint: skip-file
 
+from __future__ import annotations
+
 from typing import List
 
 import numpy as np
@@ -133,7 +135,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}')
@@ -160,7 +162,7 @@ a: ═════════════════════════
 
     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}'
@@ -220,7 +222,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}')

cirq/transformers/merge_single_qubit_gates.py

@@ -14,6 +14,8 @@
 
 """Transformer passes to combine adjacent single-qubit rotations."""
 
+from __future__ import annotations
+
 from typing import Optional, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
@@ -26,11 +28,11 @@ if TYPE_CHECKING:
 
 @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: Optional[cirq.TransformerContext] = 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 +48,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 +64,11 @@ 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: Optional[cirq.TransformerContext] = 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
@@ -82,7 +84,7 @@ def merge_single_qubit_gates_to_phxz(
         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()
@@ -96,11 +98,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: Optional[cirq.TransformerContext] = 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,7 +116,7 @@ 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
             and protocols.has_unitary(op)
@@ -122,7 +124,7 @@ def merge_single_qubit_moments_to_phxz(
             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) -> Optional[cirq.Moment]:
         if not (can_merge_moment(m1) and can_merge_moment(m2)):
             return None
         ret_ops = []

cirq/transformers/optimize_for_target_gateset.py

@@ -14,6 +14,8 @@
 
 """Transformers to rewrite a circuit using gates from a given target gateset."""
 
+from __future__ import annotations
+
 from typing import Callable, Hashable, Optional, Sequence, TYPE_CHECKING, Union
 
 from cirq import circuits
@@ -24,8 +26,8 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _create_on_stuck_raise_error(gateset: 'cirq.Gateset'):
-    def _value_error_describing_bad_operation(op: 'cirq.Operation') -> ValueError:
+def _create_on_stuck_raise_error(gateset: cirq.Gateset):
+    def _value_error_describing_bad_operation(op: cirq.Operation) -> ValueError:
         return ValueError(f"Unable to convert {op} to target gateset {gateset!r}")
 
     return _value_error_describing_bad_operation
@@ -33,14 +35,14 @@ def _create_on_stuck_raise_error(gateset: 'cirq.Gateset'):
 
 @transformer_api.transformer
 def _decompose_operations_to_target_gateset(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
-    gateset: Optional['cirq.Gateset'] = None,
-    decomposer: Callable[['cirq.Operation', int], dp.DecomposeResult] = lambda *_: NotImplemented,
+    context: Optional[cirq.TransformerContext] = None,
+    gateset: Optional[cirq.Gateset] = None,
+    decomposer: Callable[[cirq.Operation, int], dp.DecomposeResult] = lambda *_: NotImplemented,
     ignore_failures: bool = True,
     tags_to_decompose: Sequence[Hashable] = (),
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Decomposes every operation to `gateset` using `cirq.decompose` and `decomposer`.
 
     This transformer attempts to decompose every operation `op` in the given circuit to `gateset`
@@ -68,7 +70,7 @@ def _decompose_operations_to_target_gateset(
         ValueError: If any input operation fails to convert and `ignore_failures` is False.
     """
 
-    def map_func(op: 'cirq.Operation', moment_index: int):
+    def map_func(op: cirq.Operation, moment_index: int):
         if (
             context
             and context.deep
@@ -97,13 +99,13 @@ def _decompose_operations_to_target_gateset(
 
 @transformer_api.transformer
 def optimize_for_target_gateset(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
-    gateset: Optional['cirq.CompilationTargetGateset'] = None,
+    context: Optional[cirq.TransformerContext] = None,
+    gateset: Optional[cirq.CompilationTargetGateset] = None,
     ignore_failures: bool = True,
     max_num_passes: Union[int, None] = 1,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Transforms the given circuit into an equivalent circuit using gates accepted by `gateset`.
 
     Repeat max_num_passes times or when `max_num_passes=None` until no further changes can be done

cirq/transformers/optimize_for_target_gateset_test.py

@@ -12,14 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
 
 import pytest
 
 import cirq
-from cirq.protocols.decompose_protocol import DecomposeResult
 from cirq.transformers.optimize_for_target_gateset import _decompose_operations_to_target_gateset
 
+if TYPE_CHECKING:
+    from cirq.protocols.decompose_protocol import DecomposeResult
+
 
 def test_decompose_operations_raises_on_stuck():
     c_orig = cirq.Circuit(cirq.X(cirq.NamedQubit("q")).with_tags("ignore"))
@@ -121,7 +125,7 @@ class MatrixGateTargetGateset(cirq.CompilationTargetGateset):
     def num_qubits(self) -> int:
         return 2
 
-    def decompose_to_target_gateset(self, op: 'cirq.Operation', _) -> DecomposeResult:
+    def decompose_to_target_gateset(self, op: cirq.Operation, _) -> DecomposeResult:
         if cirq.num_qubits(op) != 2 or not cirq.has_unitary(op):
             return NotImplemented
         return cirq.MatrixGate(cirq.unitary(op), name="M").on(*op.qubits)