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

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap.py

@@ -20,6 +20,8 @@ References:
     https://arxiv.org/abs/2105.06074
 """
 
+from __future__ import annotations
+
 from typing import Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -34,7 +36,7 @@ if TYPE_CHECKING:
 
 
 def parameterized_2q_op_to_sqrt_iswap_operations(
-    op: 'cirq.Operation', *, use_sqrt_iswap_inv: bool = False
+    op: cirq.Operation, *, use_sqrt_iswap_inv: bool = False
 ) -> protocols.decompose_protocol.DecomposeResult:
     """Tries to decompose a parameterized 2q operation into √iSWAP's + parameterized 1q rotations.
 
@@ -68,9 +70,7 @@ def parameterized_2q_op_to_sqrt_iswap_operations(
     return NotImplemented
 
 
-def _sqrt_iswap_inv(
-    a: 'cirq.Qid', b: 'cirq.Qid', use_sqrt_iswap_inv: bool = True
-) -> 'cirq.OP_TREE':
+def _sqrt_iswap_inv(a: cirq.Qid, b: cirq.Qid, use_sqrt_iswap_inv: bool = True) -> cirq.OP_TREE:
     """Optree implementing `cirq.SQRT_ISWAP_INV(a, b)` using √iSWAPs.
 
     Args:
@@ -89,7 +89,7 @@ def _sqrt_iswap_inv(
 
 
 def _cphase_symbols_to_sqrt_iswap(
-    a: 'cirq.Qid', b: 'cirq.Qid', turns: 'cirq.TParamVal', use_sqrt_iswap_inv: bool = True
+    a: cirq.Qid, b: cirq.Qid, turns: cirq.TParamVal, use_sqrt_iswap_inv: bool = True
 ):
     """Implements `cirq.CZ(a, b) ** turns` using two √iSWAPs and single qubit rotations.
 
@@ -136,7 +136,7 @@ def _cphase_symbols_to_sqrt_iswap(
 
 
 def _swap_symbols_to_sqrt_iswap(
-    a: 'cirq.Qid', b: 'cirq.Qid', turns: 'cirq.TParamVal', use_sqrt_iswap_inv: bool = True
+    a: cirq.Qid, b: cirq.Qid, turns: cirq.TParamVal, use_sqrt_iswap_inv: bool = True
 ):
     """Implements `cirq.SWAP(a, b) ** turns` using two √iSWAPs and single qubit rotations.
 
@@ -170,7 +170,7 @@ def _swap_symbols_to_sqrt_iswap(
 
 
 def _iswap_symbols_to_sqrt_iswap(
-    a: 'cirq.Qid', b: 'cirq.Qid', turns: 'cirq.TParamVal', use_sqrt_iswap_inv: bool = True
+    a: cirq.Qid, b: cirq.Qid, turns: cirq.TParamVal, use_sqrt_iswap_inv: bool = True
 ):
     """Implements `cirq.ISWAP(a, b) ** turns` using two √iSWAPs and single qubit rotations.
 
@@ -202,10 +202,10 @@ def _iswap_symbols_to_sqrt_iswap(
 
 
 def _fsim_symbols_to_sqrt_iswap(
-    a: 'cirq.Qid',
-    b: 'cirq.Qid',
-    theta: 'cirq.TParamVal',
-    phi: 'cirq.TParamVal',
+    a: cirq.Qid,
+    b: cirq.Qid,
+    theta: cirq.TParamVal,
+    phi: cirq.TParamVal,
     use_sqrt_iswap_inv: bool = True,
 ):
     """Implements `cirq.FSimGate(theta, phi)(a, b)` using two √iSWAPs and single qubit rotations.
@@ -229,8 +229,8 @@ def _fsim_symbols_to_sqrt_iswap(
 
 
 def two_qubit_matrix_to_sqrt_iswap_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     mat: np.ndarray,
     *,
     required_sqrt_iswap_count: Optional[int] = None,
@@ -238,7 +238,7 @@ def two_qubit_matrix_to_sqrt_iswap_operations(
     atol: float = 1e-8,
     check_preconditions: bool = True,
     clean_operations: bool = False,
-) -> Sequence['cirq.Operation']:
+) -> Sequence[cirq.Operation]:
     """Decomposes a two-qubit operation into ZPow/XPow/YPow/sqrt-iSWAP gates.
 
     This method uses the KAK decomposition of the matrix to determine how many
@@ -300,13 +300,13 @@ def two_qubit_matrix_to_sqrt_iswap_operations(
 
 
 def _kak_decomposition_to_sqrt_iswap_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     kak: linalg.KakDecomposition,
     required_sqrt_iswap_count: Optional[int] = None,
     use_sqrt_iswap_inv: bool = False,
     atol: float = 1e-8,
-) -> Sequence['cirq.Operation']:
+) -> Sequence[cirq.Operation]:
     single_qubit_operations, _ = _single_qubit_matrices_with_sqrt_iswap(
         kak, required_sqrt_iswap_count, atol=atol
     )
@@ -325,14 +325,14 @@ def _kak_decomposition_to_sqrt_iswap_operations(
 
 
 def _decomp_to_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
-    two_qubit_gate: 'cirq.Gate',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
+    two_qubit_gate: cirq.Gate,
     single_qubit_operations: Sequence[Tuple[np.ndarray, np.ndarray]],
     u0_before: np.ndarray = np.eye(2),
     u0_after: np.ndarray = np.eye(2),
     atol: float = 1e-8,
-) -> Sequence['cirq.Operation']:
+) -> Sequence[cirq.Operation]:
     """Converts a sequence of single-qubit unitary matrices on two qubits into a
     list of operations with interleaved two-qubit gates."""
     two_qubit_op = two_qubit_gate(q0, q1)
@@ -401,9 +401,7 @@ def _decomp_to_operations(
 
 
 def _single_qubit_matrices_with_sqrt_iswap(
-    kak: 'cirq.KakDecomposition',
-    required_sqrt_iswap_count: Optional[int] = None,
-    atol: float = 1e-8,
+    kak: cirq.KakDecomposition, required_sqrt_iswap_count: Optional[int] = None, atol: float = 1e-8
 ) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
     """Computes the sequence of interleaved single-qubit unitary matrices in the
     sqrt-iSWAP decomposition."""
@@ -476,7 +474,7 @@ def _in_3sqrt_iswap_region(
 
 
 def _decomp_0_matrices(
-    kak: 'cirq.KakDecomposition', atol: float = 1e-8
+    kak: cirq.KakDecomposition, atol: float = 1e-8
 ) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 0-SQRT_ISWAP decomposition.
 
@@ -494,7 +492,7 @@ def _decomp_0_matrices(
 
 
 def _decomp_1sqrt_iswap_matrices(
-    kak: 'cirq.KakDecomposition', atol: float = 1e-8
+    kak: cirq.KakDecomposition, atol: float = 1e-8
 ) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 1-SQRT_ISWAP decomposition.
 
@@ -507,7 +505,7 @@ def _decomp_1sqrt_iswap_matrices(
 
 
 def _decomp_2sqrt_iswap_matrices(
-    kak: 'cirq.KakDecomposition', atol: float = 1e-8
+    kak: cirq.KakDecomposition, atol: float = 1e-8
 ) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 2-SQRT_ISWAP decomposition.
 
@@ -570,7 +568,7 @@ def _decomp_2sqrt_iswap_matrices(
 
 
 def _decomp_3sqrt_iswap_matrices(
-    kak: 'cirq.KakDecomposition', atol: float = 1e-8
+    kak: cirq.KakDecomposition, atol: float = 1e-8
 ) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 3-SQRT_ISWAP decomposition.
 

cirq/transformers/drop_empty_moments.py

@@ -14,6 +14,8 @@
 
 """Transformer pass that removes empty moments from a circuit."""
 
+from __future__ import annotations
+
 from typing import Optional, TYPE_CHECKING
 
 from cirq.transformers import transformer_api, transformer_primitives
@@ -24,8 +26,8 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer
 def drop_empty_moments(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+) -> cirq.Circuit:
     """Removes empty moments from a circuit.
 
     Args:

cirq/transformers/drop_negligible_operations.py

@@ -14,6 +14,8 @@
 
 """Transformer pass that removes operations with tiny effects."""
 
+from __future__ import annotations
+
 from typing import Optional, TYPE_CHECKING
 
 from cirq import protocols
@@ -25,11 +27,11 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer
 def drop_negligible_operations(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     atol: float = 1e-8,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Removes operations with tiny effects.
 
     An operation `op` is considered to have a tiny effect if
@@ -47,7 +49,7 @@ def drop_negligible_operations(
     if context is None:
         context = transformer_api.TransformerContext()
 
-    def map_func(op: 'cirq.Operation', _: int) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
         return (
             op
             if protocols.num_qubits(op) > 10

cirq/transformers/dynamical_decoupling.py

@@ -14,6 +14,8 @@
 
 """Transformer pass that adds dynamical decoupling operations to a circuit."""
 
+from __future__ import annotations
+
 from functools import reduce
 from itertools import cycle
 from typing import Dict, Optional, Tuple, TYPE_CHECKING, Union
@@ -204,12 +206,12 @@ def _need_merge_pulled_through(op_at_q: ops.Operation, is_at_last_busy_moment: b
 
 @transformer_api.transformer
 def add_dynamical_decoupling(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     schema: Union[str, Tuple[ops.Gate, ...]] = 'DEFAULT',
     single_qubit_gate_moments_only: bool = True,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Adds dynamical decoupling gate operations to a given circuit.
     This transformer might add new moments thus change structure of the original circuit.
 
@@ -284,7 +286,7 @@ def add_dynamical_decoupling(
             transformed_moments.extend(moments_to_be_appended)
 
         # Step 2, calc updated_moment with insertions / merges.
-        updated_moment_ops: set['cirq.Operation'] = set()
+        updated_moment_ops: set[cirq.Operation] = set()
         for q in orig_circuit.all_qubits():
             op_at_q = moment.operation_at(q)
             remaining_pulled_through_gate = pulled_through.get(q)

cirq/transformers/dynamical_decoupling_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Sequence, Tuple, Union
 
 import numpy as np
@@ -21,7 +23,7 @@ import cirq
 from cirq import add_dynamical_decoupling
 
 
-def assert_sim_eq(circuit1: 'cirq.AbstractCircuit', circuit2: 'cirq.AbstractCircuit'):
+def assert_sim_eq(circuit1: cirq.AbstractCircuit, circuit2: cirq.AbstractCircuit):
     # Simulate 2 circuits and compare final states.
     sampler = cirq.Simulator(dtype=np.complex128)
     psi0 = sampler.simulate(cirq.drop_terminal_measurements(circuit1)).final_state_vector
@@ -31,9 +33,9 @@ def assert_sim_eq(circuit1: 'cirq.AbstractCircuit', circuit2: 'cirq.AbstractCirc
 
 
 def assert_dd(
-    input_circuit: 'cirq.AbstractCircuit',
-    expected_circuit: Union[str, 'cirq.AbstractCircuit'],
-    schema: Union[str, Tuple['cirq.Gate', ...]] = 'DEFAULT',
+    input_circuit: cirq.AbstractCircuit,
+    expected_circuit: Union[str, cirq.AbstractCircuit],
+    schema: Union[str, Tuple[cirq.Gate, ...]] = 'DEFAULT',
     single_qubit_gate_moments_only: bool = True,
 ):
     transformed_circuit = add_dynamical_decoupling(
@@ -86,7 +88,7 @@ def test_no_insertion():
         ('Y_YINV', (cirq.Y, cirq.Y**-1)),
     ],
 )
-def test_insert_provided_schema(schema: str, inserted_gates: Sequence['cirq.Gate']):
+def test_insert_provided_schema(schema: str, inserted_gates: Sequence[cirq.Gate]):
     """Test case diagrams.
     Input:
     a: ───H───@───────────M───
@@ -252,7 +254,7 @@ def test_pull_through_h_gate_case2(single_qubit_gate_moments_only: bool):
         ),
     ],
 )
-def test_invalid_dd_schema(schema: Union[str, Tuple['cirq.Gate', ...]], error_msg_regex):
+def test_invalid_dd_schema(schema: Union[str, Tuple[cirq.Gate, ...]], error_msg_regex):
     a = cirq.NamedQubit('a')
     input_circuit = cirq.Circuit(cirq.H(a))
     with pytest.raises(ValueError, match=error_msg_regex):

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]] = {}