cirq-core 1.6.0.dev20250416221104__py3-none-any.whl → 1.6.0.dev20250418235304__py3-none-any.whl

cirq/experiments/z_phase_calibration.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 
 """Provides a method to do z-phase calibration for excitation-preserving gates."""
+
+from __future__ import annotations
+
 import multiprocessing
 import multiprocessing.pool
 from typing import Any, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
@@ -32,20 +35,20 @@ if TYPE_CHECKING:
 
 
 def z_phase_calibration_workflow(
-    sampler: 'cirq.Sampler',
-    qubits: Optional[Sequence['cirq.GridQubit']] = None,
-    two_qubit_gate: 'cirq.Gate' = ops.CZ,
+    sampler: cirq.Sampler,
+    qubits: Optional[Sequence[cirq.GridQubit]] = None,
+    two_qubit_gate: cirq.Gate = ops.CZ,
     options: Optional[xeb_fitting.XEBPhasedFSimCharacterizationOptions] = None,
     n_repetitions: int = 10**4,
     n_combinations: int = 10,
     n_circuits: int = 20,
     cycle_depths: Sequence[int] = tuple(np.arange(3, 100, 20)),
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     atol: float = 1e-3,
-    num_workers_or_pool: Union[int, 'multiprocessing.pool.Pool'] = -1,
-    pairs: Optional[Sequence[Tuple['cirq.GridQubit', 'cirq.GridQubit']]] = None,
+    num_workers_or_pool: Union[int, multiprocessing.pool.Pool] = -1,
+    pairs: Optional[Sequence[Tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
     tags: Sequence[Any] = (),
-) -> Tuple[xeb_fitting.XEBCharacterizationResult, 'pd.DataFrame']:
+) -> Tuple[xeb_fitting.XEBCharacterizationResult, pd.DataFrame]:
     """Perform z-phase calibration for excitation-preserving gates.
 
     For a given excitation-preserving two-qubit gate we assume an error model that can be described
@@ -88,7 +91,7 @@ def z_phase_calibration_workflow(
         - A `pd.DataFrame` comparing the before and after fidelities.
     """
 
-    pool: Optional['multiprocessing.pool.Pool'] = None
+    pool: Optional[multiprocessing.pool.Pool] = None
     local_pool = False
     if isinstance(num_workers_or_pool, multiprocessing.pool.Pool):
         pool = num_workers_or_pool  # pragma: no cover
@@ -145,20 +148,20 @@ def z_phase_calibration_workflow(
 
 
 def calibrate_z_phases(
-    sampler: 'cirq.Sampler',
-    qubits: Optional[Sequence['cirq.GridQubit']] = None,
-    two_qubit_gate: 'cirq.Gate' = ops.CZ,
+    sampler: cirq.Sampler,
+    qubits: Optional[Sequence[cirq.GridQubit]] = None,
+    two_qubit_gate: cirq.Gate = ops.CZ,
     options: Optional[xeb_fitting.XEBPhasedFSimCharacterizationOptions] = None,
     n_repetitions: int = 10**4,
     n_combinations: int = 10,
     n_circuits: int = 20,
     cycle_depths: Sequence[int] = tuple(np.arange(3, 100, 20)),
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     atol: float = 1e-3,
-    num_workers_or_pool: Union[int, 'multiprocessing.pool.Pool'] = -1,
-    pairs: Optional[Sequence[Tuple['cirq.GridQubit', 'cirq.GridQubit']]] = None,
+    num_workers_or_pool: Union[int, multiprocessing.pool.Pool] = -1,
+    pairs: Optional[Sequence[Tuple[cirq.GridQubit, cirq.GridQubit]]] = None,
     tags: Sequence[Any] = (),
-) -> Dict[Tuple['cirq.Qid', 'cirq.Qid'], 'cirq.PhasedFSimGate']:
+) -> Dict[Tuple[cirq.Qid, cirq.Qid], cirq.PhasedFSimGate]:
     """Perform z-phase calibration for excitation-preserving gates.
 
     For a given excitation-preserving two-qubit gate we assume an error model that can be described
@@ -238,12 +241,12 @@ def calibrate_z_phases(
 
 
 def plot_z_phase_calibration_result(
-    before_after_df: 'pd.DataFrame',
-    axes: Optional[np.ndarray[Sequence[Sequence['plt.Axes']], np.dtype[np.object_]]] = None,
-    pairs: Optional[Sequence[Tuple['cirq.Qid', 'cirq.Qid']]] = None,
+    before_after_df: pd.DataFrame,
+    axes: Optional[np.ndarray[Sequence[Sequence[plt.Axes]], np.dtype[np.object_]]] = None,
+    pairs: Optional[Sequence[Tuple[cirq.Qid, cirq.Qid]]] = None,
     *,
     with_error_bars: bool = False,
-) -> np.ndarray[Sequence[Sequence['plt.Axes']], np.dtype[np.object_]]:
+) -> np.ndarray[Sequence[Sequence[plt.Axes]], np.dtype[np.object_]]:
     """A helper method to plot the result of running z-phase calibration.
 
     Note that the plotted fidelity is a statistical estimate of the true fidelity and as a result
@@ -301,8 +304,8 @@ class CalibrationTransformer:
 
     def __init__(
         self,
-        target: 'cirq.Gate',
-        calibration_map: Dict[Tuple['cirq.Qid', 'cirq.Qid'], 'cirq.PhasedFSimGate'],
+        target: cirq.Gate,
+        calibration_map: Dict[Tuple[cirq.Qid, cirq.Qid], cirq.PhasedFSimGate],
     ):
         """Create a CalibrationTransformer.
 
@@ -327,10 +330,10 @@ class CalibrationTransformer:
 
     def __call__(
         self,
-        circuit: 'cirq.AbstractCircuit',
+        circuit: cirq.AbstractCircuit,
         *,
         context: Optional[transformer_api.TransformerContext] = None,
-    ) -> 'cirq.Circuit':
+    ) -> cirq.Circuit:
         """Adds 3 ZPowGates around each calibrated gate to cancel the effect of Z phases.
 
         Args:
@@ -340,7 +343,7 @@ class CalibrationTransformer:
         Returns:
             New circuit with the extra ZPowGates.
         """
-        new_moments: List[Union[List[cirq.Operation], 'cirq.Moment']] = []
+        new_moments: List[Union[List[cirq.Operation], cirq.Moment]] = []
         for moment in circuit:
             before = []
             after = []

cirq/experiments/z_phase_calibration_test.py

@@ -72,10 +72,7 @@ class _TestSimulator(cirq.Simulator):
         self.replacement = replacement
 
     def _core_iterator(
-        self,
-        circuit: 'cirq.AbstractCircuit',
-        sim_state,
-        all_measurements_are_terminal: bool = False,
+        self, circuit: cirq.AbstractCircuit, sim_state, all_measurements_are_terminal: bool = False
     ):
         new_circuit = cirq.Circuit(
             [

cirq/interop/quirk/cells/arithmetic_cells.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import inspect
 from typing import (
     Any,
@@ -80,7 +83,7 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
                 raise ValueError(f'Target too small for modulus.\nTarget: {target}\nModulus: {r}')
 
     @property
-    def operation(self) -> '_QuirkArithmeticCallable':
+    def operation(self) -> _QuirkArithmeticCallable:
         return ARITHMETIC_OP_TABLE[self.identifier]
 
     def _value_equality_values_(self) -> Any:
@@ -89,7 +92,7 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
     def registers(self) -> Sequence[Union[int, Sequence[int]]]:
         return [self.target, *self.inputs]
 
-    def with_registers(self, *new_registers: Union[int, Sequence[int]]) -> 'QuirkArithmeticGate':
+    def with_registers(self, *new_registers: Union[int, Sequence[int]]) -> QuirkArithmeticGate:
         if len(new_registers) != len(self.inputs) + 1:
             raise ValueError(
                 'Wrong number of registers.\n'
@@ -109,7 +112,7 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
     def apply(self, *registers: int) -> Union[int, Iterable[int]]:
         return self.operation(*registers)
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> List[str]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> List[str]:
         lettered_args = list(zip(self.operation.letters, self.inputs))
 
         result: List[str] = []
@@ -183,8 +186,8 @@ class ArithmeticCell(Cell):
     def __init__(
         self,
         identifier: str,
-        target: Sequence['cirq.Qid'],
-        inputs: Sequence[Union[None, Sequence['cirq.Qid'], int]],
+        target: Sequence[cirq.Qid],
+        inputs: Sequence[Union[None, Sequence[cirq.Qid], int]],
     ):
         self.identifier = identifier
         self.target = tuple(target)
@@ -204,7 +207,7 @@ class ArithmeticCell(Cell):
             f'\n    {self.inputs!r})'
         )
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         return ArithmeticCell(
             identifier=self.identifier,
             target=Cell._replace_qubits(self.target, qubits),
@@ -218,16 +221,14 @@ class ArithmeticCell(Cell):
     def operation(self):
         return ARITHMETIC_OP_TABLE[self.identifier]
 
-    def with_input(
-        self, letter: str, register: Union[Sequence['cirq.Qid'], int]
-    ) -> 'ArithmeticCell':
+    def with_input(self, letter: str, register: Union[Sequence[cirq.Qid], int]) -> ArithmeticCell:
         new_inputs = [
             reg if letter != reg_letter else register
             for reg, reg_letter in zip(self.inputs, self.operation.letters)
         ]
         return ArithmeticCell(self.identifier, self.target, new_inputs)
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         missing_inputs = [
             letter for reg, letter in zip(self.inputs, self.operation.letters) if reg is None
         ]

cirq/interop/quirk/cells/cell.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import abc
 from typing import (
     Any,
@@ -41,7 +44,7 @@ class Cell(metaclass=abc.ABCMeta):
     """
 
     @classmethod
-    def _replace_qubit(cls, old_qubit: 'cirq.Qid', qubits: List['cirq.Qid']) -> 'cirq.Qid':
+    def _replace_qubit(cls, old_qubit: cirq.Qid, qubits: List[cirq.Qid]) -> cirq.Qid:
         if not isinstance(old_qubit, devices.LineQubit):
             raise ValueError(f'Can only map from line qubits, but got {old_qubit!r}.')
         if not 0 <= old_qubit.x < len(qubits):
@@ -50,12 +53,12 @@ class Cell(metaclass=abc.ABCMeta):
 
     @classmethod
     def _replace_qubits(
-        cls, old_qubits: Iterable['cirq.Qid'], qubits: List['cirq.Qid']
-    ) -> Tuple['cirq.Qid', ...]:
+        cls, old_qubits: Iterable[cirq.Qid], qubits: List[cirq.Qid]
+    ) -> Tuple[cirq.Qid, ...]:
         return tuple(Cell._replace_qubit(e, qubits) for e in old_qubits)
 
     @abc.abstractmethod
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         """Returns the same cell, but targeting different qubits.
 
         It is assumed that the cell is currently targeting `LineQubit`
@@ -84,7 +87,7 @@ class Cell(metaclass=abc.ABCMeta):
         extremely adversarial conditions.
         """
 
-    def with_input(self, letter: str, register: Union[Sequence['cirq.Qid'], int]) -> 'Cell':
+    def with_input(self, letter: str, register: Union[Sequence[cirq.Qid], int]) -> Cell:
         """The same cell, but linked to an explicit input register or constant.
 
         If the cell doesn't need the input, it is returned unchanged.
@@ -99,7 +102,7 @@ class Cell(metaclass=abc.ABCMeta):
         """
         return self
 
-    def controlled_by(self, qubit: 'cirq.Qid') -> 'Cell':
+    def controlled_by(self, qubit: cirq.Qid) -> Cell:
         """The same cell, but with an explicit control on its main operations.
 
         Cells with effects that do not need to be controlled are permitted to
@@ -113,7 +116,7 @@ class Cell(metaclass=abc.ABCMeta):
         """
         return self
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         """Returns operations that implement the cell's main action.
 
         Returns:
@@ -126,7 +129,7 @@ class Cell(metaclass=abc.ABCMeta):
         """
         return ()
 
-    def basis_change(self) -> 'cirq.OP_TREE':
+    def basis_change(self) -> cirq.OP_TREE:
         """Operations to conjugate a column with.
 
         The main distinctions between operations performed during the body of a
@@ -143,7 +146,7 @@ class Cell(metaclass=abc.ABCMeta):
         """
         return ()
 
-    def modify_column(self, column: List[Optional['Cell']]) -> None:
+    def modify_column(self, column: List[Optional[Cell]]) -> None:
         """Applies this cell's modification to its column.
 
         For example, a control cell will add a control qubit to other operations
@@ -159,7 +162,7 @@ class Cell(metaclass=abc.ABCMeta):
             Nothing. The `column` argument is mutated in place.
         """
 
-    def persistent_modifiers(self) -> Dict[str, Callable[['Cell'], 'Cell']]:
+    def persistent_modifiers(self) -> Dict[str, Callable[[Cell], Cell]]:
         """Overridable modifications to apply to the rest of the circuit.
 
         Persistent modifiers apply to all cells in the same column and also to
@@ -186,7 +189,7 @@ class ExplicitOperationsCell(Cell):
     def gate_count(self) -> int:
         return len(self._operations) + 2 * len(self._basis_change)
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         return ExplicitOperationsCell(
             operations=tuple(
                 op.with_qubits(*Cell._replace_qubits(op.qubits, qubits)) for op in self._operations
@@ -200,13 +203,13 @@ class ExplicitOperationsCell(Cell):
     def _value_equality_values_(self):
         return self._operations, self._basis_change
 
-    def basis_change(self) -> 'cirq.OP_TREE':
+    def basis_change(self) -> cirq.OP_TREE:
         return self._basis_change
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         return self._operations
 
-    def controlled_by(self, qubit: 'cirq.Qid') -> 'ExplicitOperationsCell':
+    def controlled_by(self, qubit: cirq.Qid) -> ExplicitOperationsCell:
         return ExplicitOperationsCell(
             [op.controlled_by(qubit) for op in self._operations], self._basis_change
         )
@@ -223,7 +226,7 @@ CellMaker = NamedTuple(
     [
         ('identifier', str),
         ('size', int),
-        ('maker', Callable[[CellMakerArgs], Union[None, 'Cell', 'cirq.Operation']]),
+        ('maker', Callable[[CellMakerArgs], Union[None, Cell, 'cirq.Operation']]),
     ],
 )
 CellMaker.__doc__ = """Turns Quirk identifiers into Cirq operations.

cirq/interop/quirk/cells/composite_cell.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 (
     Callable,
     cast,
@@ -79,7 +81,7 @@ class CompositeCell(Cell):
     def gate_count(self) -> int:
         return self._gate_count
 
-    def _transform_cells(self, func: Callable[[Cell], Cell]) -> 'CompositeCell':
+    def _transform_cells(self, func: Callable[[Cell], Cell]) -> CompositeCell:
         return CompositeCell(
             height=self.height,
             # It is important that this is a generator instead of a list!
@@ -96,18 +98,16 @@ class CompositeCell(Cell):
             self._sub_cell_cols_generator = list(self._sub_cell_cols_generator)
         return cast(List[List[Optional[Cell]]], self._sub_cell_cols_generator)
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         return self._transform_cells(lambda cell: cell.with_line_qubits_mapped_to(qubits))
 
-    def with_input(
-        self, letter: str, register: Union[Sequence['cirq.Qid'], int]
-    ) -> 'CompositeCell':
+    def with_input(self, letter: str, register: Union[Sequence[cirq.Qid], int]) -> CompositeCell:
         return self._transform_cells(lambda cell: cell.with_input(letter, register))
 
-    def controlled_by(self, qubit: 'cirq.Qid') -> 'CompositeCell':
+    def controlled_by(self, qubit: cirq.Qid) -> CompositeCell:
         return self._transform_cells(lambda cell: cell.controlled_by(qubit))
 
-    def circuit(self) -> 'cirq.Circuit':
+    def circuit(self) -> cirq.Circuit:
         result = circuits.Circuit()
         for col in self._sub_cell_cols_sealed():
             body = circuits.Circuit(cell.operations() for cell in col if cell is not None)
@@ -120,7 +120,7 @@ class CompositeCell(Cell):
                 result += basis_change**-1
         return result
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         return self.circuit()
 
 

cirq/interop/quirk/cells/control_cells.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 Any, Iterable, Iterator, List, Optional, TYPE_CHECKING, Union
 
 from cirq import ops, value
@@ -25,7 +27,7 @@ if TYPE_CHECKING:
 class ControlCell(Cell):
     """A modifier that adds controls to other cells in the column."""
 
-    def __init__(self, qubit: 'cirq.Qid', basis_change: Iterable['cirq.Operation']):
+    def __init__(self, qubit: cirq.Qid, basis_change: Iterable[cirq.Operation]):
         self.qubit = qubit
         self._basis_change = tuple(basis_change)
 
@@ -42,7 +44,7 @@ class ControlCell(Cell):
     def gate_count(self) -> int:
         return 0
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         return ControlCell(
             qubit=Cell._replace_qubit(self.qubit, qubits),
             basis_change=tuple(
@@ -51,13 +53,13 @@ class ControlCell(Cell):
             ),
         )
 
-    def modify_column(self, column: List[Optional['Cell']]):
+    def modify_column(self, column: List[Optional[Cell]]):
         for i in range(len(column)):
             gate = column[i]
             if gate is not None:
                 column[i] = gate.controlled_by(self.qubit)
 
-    def basis_change(self) -> 'cirq.OP_TREE':
+    def basis_change(self) -> cirq.OP_TREE:
         return self._basis_change
 
 
@@ -69,7 +71,7 @@ class ParityControlCell(Cell):
     of them are individually satisfied.
     """
 
-    def __init__(self, qubits: Iterable['cirq.Qid'], basis_change: Iterable['cirq.Operation']):
+    def __init__(self, qubits: Iterable[cirq.Qid], basis_change: Iterable[cirq.Operation]):
         self.qubits = list(qubits)
         self._basis_change = list(basis_change)
 
@@ -86,7 +88,7 @@ class ParityControlCell(Cell):
     def gate_count(self) -> int:
         return 0
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         return ParityControlCell(
             qubits=Cell._replace_qubits(self.qubits, qubits),
             basis_change=tuple(
@@ -95,7 +97,7 @@ class ParityControlCell(Cell):
             ),
         )
 
-    def modify_column(self, column: List[Optional['Cell']]):
+    def modify_column(self, column: List[Optional[Cell]]):
         for i in range(len(column)):
             gate = column[i]
             if gate is self:
@@ -109,7 +111,7 @@ class ParityControlCell(Cell):
             elif gate is not None:
                 column[i] = gate.controlled_by(self.qubits[0])
 
-    def basis_change(self) -> Iterator['cirq.OP_TREE']:
+    def basis_change(self) -> Iterator[cirq.OP_TREE]:
         yield from self._basis_change
 
         # Temporarily move the ZZZ..Z parity observable onto a single qubit.
@@ -132,7 +134,7 @@ def generate_all_control_cell_makers() -> Iterator[CellMaker]:
     yield _reg_parity_control("zpar", basis_change=None)
 
 
-def _reg_control(identifier: str, *, basis_change: Optional['cirq.Gate']) -> CellMaker:
+def _reg_control(identifier: str, *, basis_change: Optional[cirq.Gate]) -> CellMaker:
     return CellMaker(
         identifier=identifier,
         size=1,
@@ -142,9 +144,7 @@ def _reg_control(identifier: str, *, basis_change: Optional['cirq.Gate']) -> Cel
     )
 
 
-def _reg_parity_control(
-    identifier: str, *, basis_change: Optional['cirq.Gate'] = None
-) -> CellMaker:
+def _reg_parity_control(identifier: str, *, basis_change: Optional[cirq.Gate] = None) -> CellMaker:
     return CellMaker(
         identifier=identifier,
         size=1,
@@ -155,8 +155,8 @@ def _reg_parity_control(
 
 
 def _basis_else_empty(
-    basis_change: Optional['cirq.Gate'], qureg: Union['cirq.Qid', Iterable['cirq.Qid']]
-) -> Iterable['cirq.Operation']:
+    basis_change: Optional[cirq.Gate], qureg: Union[cirq.Qid, Iterable[cirq.Qid]]
+) -> Iterable[cirq.Operation]:
     if basis_change is None:
         return ()
     return basis_change.on_each(qureg)

cirq/interop/quirk/cells/frequency_space_cells.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 from typing import Callable, Iterator
 
 import sympy
@@ -41,9 +44,7 @@ def generate_all_frequency_space_cell_makers() -> Iterator[CellMaker]:
     )
 
 
-def _family(
-    identifier_prefix: str, gate_maker: Callable[[int], 'cirq.Gate']
-) -> Iterator[CellMaker]:
+def _family(identifier_prefix: str, gate_maker: Callable[[int], cirq.Gate]) -> Iterator[CellMaker]:
     f = lambda args: ExplicitOperationsCell([gate_maker(len(args.qubits)).on(*args.qubits)])
     yield CellMaker(identifier_prefix, 1, f)
     for i in CELL_SIZES:

cirq/interop/quirk/cells/input_cells.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 Iterable, Iterator, List, Optional, TYPE_CHECKING
 
 from cirq.interop.quirk.cells.cell import Cell, CELL_SIZES, CellMaker
@@ -23,17 +25,17 @@ if TYPE_CHECKING:
 class InputCell(Cell):
     """A modifier that provides a quantum input to gates in the same column."""
 
-    def __init__(self, qubits: Iterable['cirq.Qid'], letter: str):
+    def __init__(self, qubits: Iterable[cirq.Qid], letter: str):
         self.qubits = tuple(qubits)
         self.letter = letter
 
     def gate_count(self) -> int:
         return 0
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         return InputCell(qubits=Cell._replace_qubits(self.qubits, qubits), letter=self.letter)
 
-    def modify_column(self, column: List[Optional['Cell']]):
+    def modify_column(self, column: List[Optional[Cell]]):
         for i in range(len(column)):
             cell = column[i]
             if cell is not None:
@@ -50,7 +52,7 @@ class SetDefaultInputCell(Cell):
     def gate_count(self) -> int:
         return 0
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         return self
 
     def persistent_modifiers(self):

cirq/interop/quirk/cells/input_rotation_cells.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 Any, Iterable, Iterator, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
@@ -28,8 +30,8 @@ class InputRotationCell(Cell):
     def __init__(
         self,
         identifier: str,
-        register: Optional[Sequence['cirq.Qid']],
-        base_operation: 'cirq.Operation',
+        register: Optional[Sequence[cirq.Qid]],
+        base_operation: cirq.Operation,
         exponent_sign: int,
     ):
         self.identifier = identifier
@@ -52,7 +54,7 @@ class InputRotationCell(Cell):
     def gate_count(self) -> int:
         return 1
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         return InputRotationCell(
             self.identifier,
             None if self.register is None else Cell._replace_qubits(self.register, qubits),
@@ -62,7 +64,7 @@ class InputRotationCell(Cell):
             exponent_sign=self.exponent_sign,
         )
 
-    def with_input(self, letter: str, register: Union[Sequence['cirq.Qid'], int]) -> 'Cell':
+    def with_input(self, letter: str, register: Union[Sequence[cirq.Qid], int]) -> Cell:
         # Parameterized rotations use input A as their parameter.
         if self.register is None and letter == 'a':
             if isinstance(register, int):
@@ -75,7 +77,7 @@ class InputRotationCell(Cell):
             )
         return self
 
-    def controlled_by(self, qubit: 'cirq.Qid'):
+    def controlled_by(self, qubit: cirq.Qid):
         return InputRotationCell(
             self.identifier,
             self.register,
@@ -83,7 +85,7 @@ class InputRotationCell(Cell):
             self.exponent_sign,
         )
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         if self.register is None:
             raise ValueError("Missing input 'a'")
         return QuirkInputRotationOperation(
@@ -98,8 +100,8 @@ class QuirkInputRotationOperation(ops.Operation):
     def __init__(
         self,
         identifier: str,
-        register: Iterable['cirq.Qid'],
-        base_operation: 'cirq.Operation',
+        register: Iterable[cirq.Qid],
+        base_operation: cirq.Operation,
         exponent_sign: int,
     ):
         if exponent_sign not in [-1, +1]:
@@ -113,7 +115,7 @@ class QuirkInputRotationOperation(ops.Operation):
         return (self.identifier, self.register, self.base_operation, self.exponent_sign)
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> Tuple[cirq.Qid, ...]:
         return tuple(self.base_operation.qubits) + self.register
 
     def with_qubits(self, *new_qubits):
@@ -127,7 +129,7 @@ class QuirkInputRotationOperation(ops.Operation):
             self.exponent_sign,
         )
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs'):
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs):
         sub_result = cirq.circuit_diagram_info(self.base_operation)
         sign_char = '-' if self.exponent_sign == -1 else ''
         symbols = list(sub_result.wire_symbols)
@@ -142,7 +144,7 @@ class QuirkInputRotationOperation(ops.Operation):
     def _has_unitary_(self) -> bool:
         return True
 
-    def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs'):
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs):
         transposed_args = args.with_axes_transposed_to_start()
 
         target_axes = transposed_args.axes[: len(self.base_operation.qubits)]
@@ -184,7 +186,7 @@ def generate_all_input_rotation_cell_makers() -> Iterator[CellMaker]:
     yield _input_rotation_gate("Z^(-A/2^n)", ops.Z, -1)
 
 
-def _input_rotation_gate(identifier: str, gate: 'cirq.Gate', exponent_sign: int) -> CellMaker:
+def _input_rotation_gate(identifier: str, gate: cirq.Gate, exponent_sign: int) -> CellMaker:
     return CellMaker(
         identifier,
         gate.num_qubits(),

cirq/interop/quirk/cells/measurement_cells.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 from typing import cast, Iterable, Iterator, Optional, TYPE_CHECKING
 
 from cirq import ops
@@ -27,7 +30,7 @@ def generate_all_measurement_cell_makers() -> Iterator[CellMaker]:
     yield _measurement("XDetector", basis_change=ops.Y**0.5)
 
 
-def _measurement(identifier: str, basis_change: Optional['cirq.Gate'] = None) -> CellMaker:
+def _measurement(identifier: str, basis_change: Optional[cirq.Gate] = None) -> CellMaker:
     return CellMaker(
         identifier=identifier,
         size=1,