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

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.6.0.dev20250501172111"
+__version__ = "1.6.0.dev20250501192724"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.6.0.dev20250501172111"
+    assert cirq.__version__ == "1.6.0.dev20250501192724"

cirq/transformers/analytical_decompositions/two_qubit_to_cz.py

@@ -14,6 +14,8 @@
 
 """Utility methods for decomposing two-qubit unitaries into CZ gates."""
 
+from __future__ import annotations
+
 from typing import cast, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -31,8 +33,8 @@ if TYPE_CHECKING:
 
 
 def _remove_partial_czs_or_fail(
-    operations: Iterable['cirq.Operation'], atol: float
-) -> List['cirq.Operation']:
+    operations: Iterable[cirq.Operation], atol: float
+) -> List[cirq.Operation]:
     result = []
     for op in operations:
         if isinstance(op.gate, ops.CZPowGate):
@@ -49,8 +51,8 @@ def _remove_partial_czs_or_fail(
 
 
 def two_qubit_matrix_to_cz_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     mat: np.ndarray,
     allow_partial_czs: bool,
     atol: float = 1e-8,
@@ -85,13 +87,13 @@ def two_qubit_matrix_to_cz_operations(
 
 
 def two_qubit_matrix_to_diagonal_and_cz_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     mat: np.ndarray,
     allow_partial_czs: bool = False,
     atol: float = 1e-8,
     clean_operations: bool = True,
-) -> Tuple[np.ndarray, List['cirq.Operation']]:
+) -> Tuple[np.ndarray, List[cirq.Operation]]:
     """Decomposes a 2-qubit unitary to a diagonal and the remaining operations.
 
     For a 2-qubit unitary V, return ops, a list of operations and
@@ -136,7 +138,7 @@ def two_qubit_matrix_to_diagonal_and_cz_operations(
     )
 
 
-def _xx_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float):
+def _xx_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float):
     a = x * -2 / np.pi
     yield ops.H(q1)
     yield ops.CZ(q0, q1)
@@ -145,7 +147,7 @@ def _xx_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float):
     yield ops.H(q1)
 
 
-def _xx_yy_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float, y: float):
+def _xx_yy_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float, y: float):
     a = x * -2 / np.pi
     b = y * -2 / np.pi
     yield ops.X(q0) ** 0.5
@@ -160,9 +162,7 @@ def _xx_yy_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float, y:
     yield ops.X(q0) ** -0.5
 
 
-def _xx_yy_zz_interaction_via_full_czs(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', x: float, y: float, z: float
-):
+def _xx_yy_zz_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float, y: float, z: float):
     a = x * -2 / np.pi + 0.5
     b = y * -2 / np.pi + 0.5
     c = z * -2 / np.pi + 0.5
@@ -192,8 +192,8 @@ def cleanup_operations(operations: Sequence[ops.Operation]):
 
 
 def _kak_decomposition_to_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     kak: linalg.KakDecomposition,
     allow_partial_czs: bool,
     atol: float = 1e-8,
@@ -232,7 +232,7 @@ def _is_trivial_angle(rad: float, atol: float) -> bool:
 
 
 def _parity_interaction(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', rads: float, atol: float, gate: Optional[ops.Gate] = None
+    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: Optional[ops.Gate] = None
 ):
     """Yields a ZZ interaction framed by the given operation."""
     if abs(rads) < atol:
@@ -255,14 +255,14 @@ def _parity_interaction(
         yield g.on(q0), g.on(q1)
 
 
-def _do_single_on(u: np.ndarray, q: 'cirq.Qid', atol: float = 1e-8):
+def _do_single_on(u: np.ndarray, q: cirq.Qid, atol: float = 1e-8):
     for gate in single_qubit_decompositions.single_qubit_matrix_to_gates(u, atol):
         yield gate(q)
 
 
 def _non_local_part(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     interaction_coefficients: Tuple[float, float, float],
     allow_partial_czs: bool,
     atol: float = 1e-8,

cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py

@@ -14,6 +14,8 @@
 
 """Utility methods for decomposing two-qubit unitaries into FSim gates."""
 
+from __future__ import annotations
+
 from typing import Iterable, Iterator, List, Optional, Sequence, TYPE_CHECKING, Union
 
 import numpy as np
@@ -25,11 +27,11 @@ if TYPE_CHECKING:
 
 
 def decompose_two_qubit_interaction_into_four_fsim_gates(
-    interaction: Union['cirq.SupportsUnitary', np.ndarray],
+    interaction: Union[cirq.SupportsUnitary, np.ndarray],
     *,
-    fsim_gate: Union['cirq.FSimGate', 'cirq.ISwapPowGate'],
-    qubits: Optional[Sequence['cirq.Qid']] = None,
-) -> 'cirq.Circuit':
+    fsim_gate: Union[cirq.FSimGate, cirq.ISwapPowGate],
+    qubits: Optional[Sequence[cirq.Qid]] = None,
+) -> cirq.Circuit:
     """Decomposes operations into an FSimGate near theta=pi/2, phi=0.
 
     This decomposition is guaranteed to use exactly four of the given FSim
@@ -110,12 +112,12 @@ def _sticky_0_to_1(v: float, *, atol: float) -> Optional[float]:
 
 def _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
     *,
-    qubits: Sequence['cirq.Qid'],
-    fsim_gate: 'cirq.FSimGate',
+    qubits: Sequence[cirq.Qid],
+    fsim_gate: cirq.FSimGate,
     canonical_x_kak_coefficient: float,
     canonical_y_kak_coefficient: float,
     atol: float = 1e-8,
-) -> List['cirq.Operation']:
+) -> List[cirq.Operation]:
     x = canonical_x_kak_coefficient
     y = canonical_y_kak_coefficient
     assert 0 <= y <= x <= np.pi / 4
@@ -174,10 +176,10 @@ _B = _BGate()
 
 
 def _decompose_two_qubit_interaction_into_two_b_gates(
-    interaction: Union['cirq.SupportsUnitary', np.ndarray, 'cirq.KakDecomposition'],
+    interaction: Union[cirq.SupportsUnitary, np.ndarray, cirq.KakDecomposition],
     *,
-    qubits: Sequence['cirq.Qid'],
-) -> List['cirq.Operation']:
+    qubits: Sequence[cirq.Qid],
+) -> List[cirq.Operation]:
     kak = linalg.kak_decomposition(interaction)
 
     result = _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
@@ -192,8 +194,8 @@ def _decompose_two_qubit_interaction_into_two_b_gates(
 
 
 def _decompose_b_gate_into_two_fsims(
-    *, fsim_gate: 'cirq.FSimGate', qubits: Sequence['cirq.Qid']
-) -> List['cirq.Operation']:
+    *, fsim_gate: cirq.FSimGate, qubits: Sequence[cirq.Qid]
+) -> List[cirq.Operation]:
     kak = linalg.kak_decomposition(_B)
 
     result = _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
@@ -211,8 +213,8 @@ def _decompose_b_gate_into_two_fsims(
 
 
 def _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
-    qubits: Sequence['cirq.Qid'], kak_interaction_coefficients: Iterable[float]
-) -> List['cirq.Operation']:
+    qubits: Sequence[cirq.Qid], kak_interaction_coefficients: Iterable[float]
+) -> List[cirq.Operation]:
     """Decompose using a minimal construction of two-qubit operations.
 
     References:
@@ -236,11 +238,8 @@ def _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
 
 
 def _fix_single_qubit_gates_around_kak_interaction(
-    *,
-    desired: 'cirq.KakDecomposition',
-    operations: List['cirq.Operation'],
-    qubits: Sequence['cirq.Qid'],
-) -> Iterator['cirq.Operation']:
+    *, desired: cirq.KakDecomposition, operations: List[cirq.Operation], qubits: Sequence[cirq.Qid]
+) -> Iterator[cirq.Operation]:
     """Adds single qubit operations to complete a desired interaction.
 
     Args:

cirq/transformers/analytical_decompositions/two_qubit_to_ms.py

@@ -19,6 +19,8 @@ Gate compilation methods implemented here are following the paper below:
     arXiv:1603.07678
 """
 
+from __future__ import annotations
+
 from typing import cast, Iterable, List, Optional, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -31,11 +33,7 @@ if TYPE_CHECKING:
 
 
 def two_qubit_matrix_to_ion_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
-    mat: np.ndarray,
-    atol: float = 1e-8,
-    clean_operations: bool = True,
+    q0: cirq.Qid, q1: cirq.Qid, mat: np.ndarray, atol: float = 1e-8, clean_operations: bool = True
 ) -> List[ops.Operation]:
     """Decomposes a two-qubit operation into MS/single-qubit rotation gates.
 
@@ -56,7 +54,7 @@ def two_qubit_matrix_to_ion_operations(
 
 
 def _kak_decomposition_to_operations(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', kak: linalg.KakDecomposition, atol: float = 1e-8
+    q0: cirq.Qid, q1: cirq.Qid, kak: linalg.KakDecomposition, atol: float = 1e-8
 ) -> List[ops.Operation]:
     """Assumes that the decomposition is canonical."""
     b0, b1 = kak.single_qubit_operations_before
@@ -74,13 +72,13 @@ def _kak_decomposition_to_operations(
     )
 
 
-def _do_single_on(u: np.ndarray, q: 'cirq.Qid', atol: float = 1e-8):
+def _do_single_on(u: np.ndarray, q: cirq.Qid, atol: float = 1e-8):
     for gate in single_qubit_decompositions.single_qubit_matrix_to_gates(u, atol):
         yield gate(q)
 
 
 def _parity_interaction(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', rads: float, atol: float, gate: Optional[ops.Gate] = None
+    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: Optional[ops.Gate] = None
 ):
     """Yields an XX interaction framed by the given operation."""
 
@@ -98,8 +96,8 @@ def _parity_interaction(
 
 
 def _non_local_part(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     interaction_coefficients: Tuple[float, float, float],
     atol: float = 1e-8,
 ):

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):