cirq-core 1.6.0.dev20250520054601__py3-none-any.whl → 1.6.0.dev20250520181654__py3-none-any.whl

cirq/contrib/quimb/mps_simulator.py

@@ -21,7 +21,7 @@ from __future__ import annotations
 
 import dataclasses
 import math
-from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
+from typing import Any, Sequence, TYPE_CHECKING
 
 import numpy as np
 import quimb.tensor as qtn
@@ -43,7 +43,7 @@ class MPSOptions:
     # How to split the tensor. Refer to the Quimb documentation for the exact meaning.
     method: str = 'svds'
     # If integer, the maxmimum number of singular values to keep, regardless of ``cutoff``.
-    max_bond: Optional[int] = None
+    max_bond: int | None = None
     # Method with which to apply the cutoff threshold. Refer to the Quimb documentation.
     cutoff_mode: str = 'rsum2'
     # The threshold below which to discard singular values. Refer to the Quimb documentation.
@@ -63,7 +63,7 @@ class MPSSimulator(
         noise: cirq.NOISE_MODEL_LIKE = None,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         simulation_options: MPSOptions = MPSOptions(),
-        grouping: Optional[Dict[cirq.Qid, int]] = None,
+        grouping: dict[cirq.Qid, int] | None = None,
     ):
         """Creates instance of `MPSSimulator`.
 
@@ -86,7 +86,7 @@ class MPSSimulator(
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union[int, MPSState],
+        initial_state: int | MPSState,
         qubits: Sequence[cirq.Qid],
         classical_data: cirq.ClassicalDataStore,
     ) -> MPSState:
@@ -122,7 +122,7 @@ class MPSSimulator(
     def _create_simulator_trial_result(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[MPSState],
     ) -> MPSTrialResult:
         """Creates a single trial results with the measurements.
@@ -147,7 +147,7 @@ class MPSTrialResult(simulator_base.SimulationTrialResultBase['MPSState']):
     def __init__(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[MPSState],
     ) -> None:
         super().__init__(
@@ -212,11 +212,11 @@ class _MPSHandler(qis.QuantumStateRepresentation):
 
     def __init__(
         self,
-        qid_shape: Tuple[int, ...],
-        grouping: Dict[int, int],
-        M: List[qtn.Tensor],
+        qid_shape: tuple[int, ...],
+        grouping: dict[int, int],
+        M: list[qtn.Tensor],
         format_i: str,
-        estimated_gate_error_list: List[float],
+        estimated_gate_error_list: list[float],
         simulation_options: MPSOptions = MPSOptions(),
     ):
         """Creates an MPSQuantumState
@@ -241,8 +241,8 @@ class _MPSHandler(qis.QuantumStateRepresentation):
     def create(
         cls,
         *,
-        qid_shape: Tuple[int, ...],
-        grouping: Dict[int, int],
+        qid_shape: tuple[int, ...],
+        grouping: dict[int, int],
         initial_state: int = 0,
         simulation_options: MPSOptions = MPSOptions(),
     ):
@@ -342,7 +342,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
         sorted_ind = tuple(sorted(state_vector.inds))
         return state_vector.fuse({'i': sorted_ind}).data
 
-    def partial_trace(self, keep_axes: Set[int]) -> np.ndarray:
+    def partial_trace(self, keep_axes: set[int]) -> np.ndarray:
         """Traces out all qubits except keep_axes.
 
         Args:
@@ -484,8 +484,8 @@ class _MPSHandler(qis.QuantumStateRepresentation):
 
     def _measure(
         self, axes: Sequence[int], prng: np.random.RandomState, collapse_state_vector=True
-    ) -> List[int]:
-        results: List[int] = []
+    ) -> list[int]:
+        results: list[int] = []
 
         if collapse_state_vector:
             state = self
@@ -523,7 +523,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
 
     def measure(
         self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
-    ) -> List[int]:
+    ) -> list[int]:
         """Measures the MPS.
 
         Args:
@@ -547,7 +547,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
             The samples in order.
         """
 
-        measurements: List[List[int]] = []
+        measurements: list[list[int]] = []
         prng = value.parse_random_state(seed)
 
         for _ in range(repetitions):
@@ -566,9 +566,9 @@ class MPSState(SimulationState[_MPSHandler]):
         qubits: Sequence[cirq.Qid],
         prng: np.random.RandomState,
         simulation_options: MPSOptions = MPSOptions(),
-        grouping: Optional[Dict[cirq.Qid, int]] = None,
+        grouping: dict[cirq.Qid, int] | None = None,
         initial_state: int = 0,
-        classical_data: Optional[cirq.ClassicalDataStore] = None,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Creates and MPSState
 
@@ -622,7 +622,7 @@ class MPSState(SimulationState[_MPSHandler]):
         """
         return self._state.state_vector()
 
-    def partial_trace(self, keep_qubits: Set[cirq.Qid]) -> np.ndarray:
+    def partial_trace(self, keep_qubits: set[cirq.Qid]) -> np.ndarray:
         """Traces out all qubits except keep_qubits.
 
         Args:

cirq/contrib/quimb/state_vector.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import warnings
-from typing import cast, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import cast, Sequence, TYPE_CHECKING
 
 import quimb
 import quimb.tensor as qtn
@@ -30,10 +30,8 @@ QUIMB_VERSION = _get_quimb_version()
 
 
 def circuit_to_tensors(
-    circuit: cirq.Circuit,
-    qubits: Optional[Sequence[cirq.Qid]] = None,
-    initial_state: Union[int, None] = 0,
-) -> Tuple[List[qtn.Tensor], Dict[cirq.Qid, int], None]:
+    circuit: cirq.Circuit, qubits: Sequence[cirq.Qid] | None = None, initial_state: int | None = 0
+) -> tuple[list[qtn.Tensor], dict[cirq.Qid, int], None]:
     """Given a circuit, construct a tensor network representation.
 
     Indices are named "i{i}_q{x}" where i is a time index and x is a
@@ -67,7 +65,7 @@ def circuit_to_tensors(
 
     qubit_frontier = {q: 0 for q in qubits}
     positions = None
-    tensors: List[qtn.Tensor] = []
+    tensors: list[qtn.Tensor] = []
 
     if initial_state == 0:
         for q in qubits:
@@ -94,7 +92,7 @@ def circuit_to_tensors(
 
 
 def tensor_state_vector(
-    circuit: cirq.Circuit, qubits: Optional[Sequence[cirq.Qid]] = None
+    circuit: cirq.Circuit, qubits: Sequence[cirq.Qid] | None = None
 ) -> np.ndarray:
     """Given a circuit contract a tensor network into a final state vector."""
     if qubits is None:
@@ -107,9 +105,7 @@ def tensor_state_vector(
     return tn.to_dense(f_inds)
 
 
-def tensor_unitary(
-    circuit: cirq.Circuit, qubits: Optional[Sequence[cirq.Qid]] = None
-) -> np.ndarray:
+def tensor_unitary(circuit: cirq.Circuit, qubits: Sequence[cirq.Qid] | None = None) -> np.ndarray:
     """Given a circuit contract a tensor network into a dense unitary
     of the circuit."""
     if qubits is None:

cirq/contrib/quirk/export_to_quirk.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import json
 import urllib.parse
-from typing import Any, cast, Iterable, List, Tuple
+from typing import Any, cast, Iterable
 
 from cirq import circuits, devices, ops, protocols
 from cirq.contrib.quirk.linearize_circuit import linearize_circuit_qubits
@@ -42,7 +42,7 @@ def _try_convert_to_quirk_gate(op: ops.Operation, prefer_unknown_gate_to_failure
 
 def _to_quirk_cols(
     op: ops.Operation, prefer_unknown_gate_to_failure: bool
-) -> Iterable[Tuple[List[Any], bool]]:
+) -> Iterable[tuple[list[Any], bool]]:
     gate = _try_convert_to_quirk_gate(op, prefer_unknown_gate_to_failure)
     qubits = cast(Iterable[devices.LineQubit], op.qubits)
 
@@ -78,7 +78,7 @@ def circuit_to_quirk_url(
     circuit = circuit.copy()
     linearize_circuit_qubits(circuit)
 
-    cols: List[List[Any]] = []
+    cols: list[list[Any]] = []
     for moment in circuit:
         can_merges = []
         for op in moment.operations:

cirq/contrib/quirk/quirk_gate.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, cast, Dict, Optional, Union
+from typing import Any, Callable, cast
 
 import numpy as np
 import sympy
@@ -70,7 +70,7 @@ def _is_supported_formula(formula: sympy.Basic) -> bool:
     return False
 
 
-def _val_to_quirk_formula(t: Union[float, sympy.Basic]) -> str:
+def _val_to_quirk_formula(t: float | sympy.Basic) -> str:
     if isinstance(t, sympy.Basic):
         if not set(t.free_symbols) <= {sympy.Symbol('t')}:
             raise ValueError(f'Symbol other than "t": {t!r}.')
@@ -81,7 +81,7 @@ def _val_to_quirk_formula(t: Union[float, sympy.Basic]) -> str:
     return f'{float(t):.4f}'
 
 
-def angle_to_exponent_key(t: Union[float, sympy.Basic]) -> Optional[str]:
+def angle_to_exponent_key(t: float | sympy.Basic) -> str | None:
     if isinstance(t, sympy.Basic):
         if t == sympy.Symbol('t'):
             return '^t'
@@ -109,7 +109,7 @@ def angle_to_exponent_key(t: Union[float, sympy.Basic]) -> Optional[str]:
     return None
 
 
-def single_qubit_matrix_gate(matrix: Optional[np.ndarray]) -> Optional[QuirkOp]:
+def single_qubit_matrix_gate(matrix: np.ndarray | None) -> QuirkOp | None:
     if matrix is None or matrix.shape[0] != 2:
         return None
 
@@ -137,7 +137,7 @@ def single_qubit_matrix_gate(matrix: Optional[np.ndarray]) -> Optional[QuirkOp]:
     return QuirkOp({'id': '?', 'matrix': matrix_repr})
 
 
-def known_quirk_op_for_operation(op: ops.Operation) -> Optional[QuirkOp]:
+def known_quirk_op_for_operation(op: ops.Operation) -> QuirkOp | None:
     if isinstance(op, ops.GateOperation):
         return _gate_to_quirk_op(op.gate)
     if isinstance(op, ops.ControlledOperation):
@@ -145,7 +145,7 @@ def known_quirk_op_for_operation(op: ops.Operation) -> Optional[QuirkOp]:
     return None
 
 
-def _gate_to_quirk_op(gate: ops.Gate) -> Optional[QuirkOp]:
+def _gate_to_quirk_op(gate: ops.Gate) -> QuirkOp | None:
     for gate_type, func in _known_gate_conversions.items():
         if isinstance(gate, gate_type):
             return func(gate)
@@ -178,45 +178,45 @@ def z_to_quirk_op(gate: ops.ZPowGate) -> QuirkOp:
     return xyz_to_quirk_op('z', gate)
 
 
-def cz_to_quirk_op(gate: ops.CZPowGate) -> Optional[QuirkOp]:
+def cz_to_quirk_op(gate: ops.CZPowGate) -> QuirkOp | None:
     return z_to_quirk_op(ops.Z**gate.exponent).controlled()
 
 
-def cnot_to_quirk_op(gate: ops.CXPowGate) -> Optional[QuirkOp]:
+def cnot_to_quirk_op(gate: ops.CXPowGate) -> QuirkOp | None:
     return x_to_quirk_op(ops.X**gate.exponent).controlled()
 
 
-def h_to_quirk_op(gate: ops.HPowGate) -> Optional[QuirkOp]:
+def h_to_quirk_op(gate: ops.HPowGate) -> QuirkOp | None:
     if gate.exponent == 1:
         return QuirkOp('H')
     return None
 
 
-def swap_to_quirk_op(gate: ops.SwapPowGate) -> Optional[QuirkOp]:
+def swap_to_quirk_op(gate: ops.SwapPowGate) -> QuirkOp | None:
     if gate.exponent == 1:
         return QuirkOp('Swap', 'Swap', can_merge=False)
     return None
 
 
-def cswap_to_quirk_op(gate: ops.CSwapGate) -> Optional[QuirkOp]:
+def cswap_to_quirk_op(gate: ops.CSwapGate) -> QuirkOp | None:
     return QuirkOp('•', 'Swap', 'Swap', can_merge=False)
 
 
-def ccx_to_quirk_op(gate: ops.CCXPowGate) -> Optional[QuirkOp]:
+def ccx_to_quirk_op(gate: ops.CCXPowGate) -> QuirkOp | None:
     e = angle_to_exponent_key(gate.exponent)
     if e is None:
         return None
     return QuirkOp('•', '•', 'X' + e, can_merge=False)
 
 
-def ccz_to_quirk_op(gate: ops.CCZPowGate) -> Optional[QuirkOp]:
+def ccz_to_quirk_op(gate: ops.CCZPowGate) -> QuirkOp | None:
     e = angle_to_exponent_key(gate.exponent)
     if e is None:
         return None
     return QuirkOp('•', '•', 'Z' + e, can_merge=False)
 
 
-def controlled_unwrap(op: ops.ControlledOperation) -> Optional[QuirkOp]:
+def controlled_unwrap(op: ops.ControlledOperation) -> QuirkOp | None:
     sub = known_quirk_op_for_operation(op.sub_operation)
     if sub is None:
         return None
@@ -224,7 +224,7 @@ def controlled_unwrap(op: ops.ControlledOperation) -> Optional[QuirkOp]:
 
 
 _known_gate_conversions = cast(
-    Dict[type, Callable[[ops.Gate], Optional[QuirkOp]]],
+    dict[type, Callable[[ops.Gate], QuirkOp | None]],
     {
         ops.CCXPowGate: ccx_to_quirk_op,
         ops.CCZPowGate: ccz_to_quirk_op,

cirq/contrib/routing/device.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Dict, Iterable, Tuple
+from typing import Iterable
 
 import networkx as nx
 
@@ -47,7 +47,7 @@ def _manhattan_distance(qubit1: cirq.GridQubit, qubit2: cirq.GridQubit) -> int:
     return abs(qubit1.row - qubit2.row) + abs(qubit1.col - qubit2.col)
 
 
-def nx_qubit_layout(graph: nx.Graph) -> Dict[cirq.Qid, Tuple[float, float]]:
+def nx_qubit_layout(graph: nx.Graph) -> dict[cirq.Qid, tuple[float, float]]:
     """Return a layout for a graph for nodes which are qubits.
 
     This can be used in place of nx.spring_layout or other networkx layouts.
@@ -64,7 +64,7 @@ def nx_qubit_layout(graph: nx.Graph) -> Dict[cirq.Qid, Tuple[float, float]]:
     >>> nx.draw_networkx(g, pos=pos)
 
     """
-    pos: Dict[cirq.Qid, Tuple[float, float]] = {}
+    pos: dict[cirq.Qid, tuple[float, float]] = {}
 
     _node_to_i_cache = None
     for node in graph.nodes:

cirq/contrib/routing/greedy.py

@@ -15,18 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import (
-    Callable,
-    cast,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    TYPE_CHECKING,
-)
+from typing import Callable, cast, Iterable, Sequence, TYPE_CHECKING
 
 import networkx as nx
 import numpy as np
@@ -42,7 +31,7 @@ if TYPE_CHECKING:
     import cirq
 
 SWAP = cca.SwapPermutationGate()
-QidPair = Tuple[ops.Qid, ops.Qid]
+QidPair = tuple[ops.Qid, ops.Qid]
 
 
 def route_circuit_greedily(
@@ -106,7 +95,7 @@ class _GreedyRouter:
         *,
         max_search_radius: int = 1,
         max_num_empty_steps: int = 5,
-        initial_mapping: Optional[Dict[ops.Qid, ops.Qid]] = None,
+        initial_mapping: dict[ops.Qid, ops.Qid] | None = None,
         can_reorder: Callable[[ops.Operation, ops.Operation], bool] = lambda op1, op2: not set(
             op1.qubits
         )
@@ -117,7 +106,7 @@ class _GreedyRouter:
         self.prng = value.parse_random_state(random_state)
 
         self.device_graph = device_graph
-        self.physical_distances: Dict[QidPair, int] = {
+        self.physical_distances: dict[QidPair, int] = {
             (a, b): d
             for a, neighbor_distances in nx.shortest_path_length(device_graph)
             for b, d in neighbor_distances.items()
@@ -126,9 +115,9 @@ class _GreedyRouter:
         self.remaining_dag = circuitdag.CircuitDag.from_circuit(circuit, can_reorder=can_reorder)
         self.logical_qubits = list(self.remaining_dag.all_qubits())
         self.physical_qubits = list(self.device_graph.nodes)
-        self.edge_sets: Dict[int, List[Sequence[QidPair]]] = {}
+        self.edge_sets: dict[int, list[Sequence[QidPair]]] = {}
 
-        self.physical_ops: List[ops.Operation] = []
+        self.physical_ops: list[ops.Operation] = []
 
         self.set_initial_mapping(initial_mapping)
 
@@ -155,7 +144,7 @@ class _GreedyRouter:
         logical qubits."""
         return (self._log_to_phys[q] for q in qubits)
 
-    def phys_to_log(self, *qubits: cirq.Qid) -> Iterable[Optional[ops.Qid]]:
+    def phys_to_log(self, *qubits: cirq.Qid) -> Iterable[ops.Qid | None]:
         """Returns an iterator over the logical qubits that map to the given
         physical qubits."""
         return (self._phys_to_log[q] for q in qubits)
@@ -176,7 +165,7 @@ class _GreedyRouter:
                 if l is not None:
                     self._log_to_phys[l] = p
 
-    def set_initial_mapping(self, initial_mapping: Optional[Dict[ops.Qid, ops.Qid]] = None):
+    def set_initial_mapping(self, initial_mapping: dict[ops.Qid, ops.Qid] | None = None):
         """Sets the internal state according to an initial mapping.
 
         Args:
@@ -237,7 +226,7 @@ class _GreedyRouter:
         logical qubits."""
         return self.physical_distances[cast(QidPair, tuple(self.log_to_phys(*edge)))]
 
-    def swap_along_path(self, path: Tuple[ops.Qid]):
+    def swap_along_path(self, path: tuple[ops.Qid]):
         """Adds SWAPs to move a logical qubit along a specified path."""
         for i in range(len(path) - 1):
             self.apply_swap(cast(QidPair, path[i : i + 2]))
@@ -317,7 +306,7 @@ class _GreedyRouter:
         assert ops_are_consistent_with_device_graph(self.physical_ops, self.device_graph)
 
 
-def _get_dominated_indices(vectors: List[np.ndarray]) -> Set[int]:
+def _get_dominated_indices(vectors: list[np.ndarray]) -> set[int]:
     """Get the indices of vectors that are element-wise at least some other
     vector.
     """

cirq/contrib/routing/initialization.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import cast, Dict, Hashable, TYPE_CHECKING
+from typing import cast, Hashable, TYPE_CHECKING
 
 import networkx as nx
 from sortedcontainers import SortedDict, SortedSet
@@ -35,7 +35,7 @@ def get_initial_mapping(
     logical_graph: nx.Graph,
     device_graph: nx.Graph,
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-) -> Dict[ops.Qid, ops.Qid]:
+) -> dict[ops.Qid, ops.Qid]:
     """Gets an initial mapping of logical to physical qubits for routing.
 
     Args:

cirq/contrib/routing/swap_network.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, Iterable, TYPE_CHECKING
+from typing import Iterable, TYPE_CHECKING
 
 import cirq.contrib.acquaintance as cca
 from cirq import ops
@@ -37,13 +37,13 @@ class SwapNetwork:
         initial_mapping: The initial mapping from physical to logical qubits.
     """
 
-    def __init__(self, circuit: cirq.Circuit, initial_mapping: Dict[cirq.Qid, cirq.Qid]) -> None:
+    def __init__(self, circuit: cirq.Circuit, initial_mapping: dict[cirq.Qid, cirq.Qid]) -> None:
         if not all(isinstance(i, ops.Qid) for I in initial_mapping.items() for i in I):
             raise ValueError('Mapping must be from Qids to Qids.')
         self.circuit = circuit
         self.initial_mapping = initial_mapping
 
-    def final_mapping(self) -> Dict[cirq.Qid, cirq.Qid]:
+    def final_mapping(self) -> dict[cirq.Qid, cirq.Qid]:
         mapping = dict(self.initial_mapping)
         cca.update_mapping(mapping, self.circuit.all_operations())
         return mapping

cirq/contrib/routing/utils.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import operator
 import re
-from typing import Callable, Iterable, List, TYPE_CHECKING
+from typing import Callable, Iterable, TYPE_CHECKING
 
 import networkx as nx
 
@@ -31,7 +31,7 @@ if TYPE_CHECKING:
 BINARY_OP_PREDICATE = Callable[[ops.Operation, ops.Operation], bool]
 
 
-def get_time_slices(dag: CircuitDag) -> List[nx.Graph]:
+def get_time_slices(dag: CircuitDag) -> list[nx.Graph]:
     """Slices the DAG into logical graphs.
 
     Each time slice is a graph whose vertices are qubits and whose edges

cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import time
-from typing import Dict, List, Optional, Tuple, TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -30,8 +30,8 @@ if TYPE_CHECKING:
 
 def _validate_input(
     input_circuits: list[circuits.Circuit],
-    circuit_repetitions: Union[int, list[int]],
-    rng_or_seed: Union[np.random.Generator, int],
+    circuit_repetitions: int | list[int],
+    rng_or_seed: np.random.Generator | int,
     num_random_bitstrings: int,
     readout_repetitions: int,
 ):
@@ -159,12 +159,12 @@ def _analyze_readout_results(
 def run_shuffled_with_readout_benchmarking(
     input_circuits: list[circuits.Circuit],
     sampler: work.Sampler,
-    circuit_repetitions: Union[int, list[int]],
-    rng_or_seed: Union[np.random.Generator, int],
+    circuit_repetitions: int | list[int],
+    rng_or_seed: np.random.Generator | int,
     num_random_bitstrings: int = 100,
     readout_repetitions: int = 1000,
-    qubits: Optional[Union[List[ops.Qid], List[List[ops.Qid]]]] = None,
-) -> tuple[list[ResultDict], Dict[Tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult]]:
+    qubits: list[ops.Qid] | list[list[ops.Qid]] | None = None,
+) -> tuple[list[ResultDict], dict[tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult]]:
     """Run the circuits in a shuffled order with readout error benchmarking.
 
     Args:
@@ -192,7 +192,7 @@ def run_shuffled_with_readout_benchmarking(
     )
 
     # If input qubits is None, extract qubits from input circuits
-    qubits_to_measure: List[List[ops.Qid]] = []
+    qubits_to_measure: list[list[ops.Qid]] = []
     if qubits is None:
         qubits_set: set[ops.Qid] = set()
         for circuit in input_circuits:

cirq/contrib/svg/svg.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import cast, Dict, List, Tuple, TYPE_CHECKING
+from typing import cast, TYPE_CHECKING
 
 import matplotlib.font_manager
 import matplotlib.textpath
@@ -63,7 +63,7 @@ def _text(x: float, y: float, text: str, fontsize: int = 14):
 
 def _fit_horizontal(
     tdd: cirq.TextDiagramDrawer, ref_boxwidth: float, col_padding: float
-) -> Tuple[List[float], List[float]]:
+) -> tuple[list[float], list[float]]:
     """Figure out the horizontal spacing of columns to fit everything in.
 
     Returns:
@@ -93,7 +93,7 @@ def _fit_horizontal(
 
 def _fit_vertical(
     tdd: cirq.TextDiagramDrawer, ref_boxheight: float, row_padding: float
-) -> Tuple[List[float], List[float], Dict[float, int]]:
+) -> tuple[list[float], list[float], dict[float, int]]:
     """Return data structures used to turn tdd vertical coordinates into
     well-spaced SVG coordinates.
 

cirq/devices/grid_device_metadata.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import cast, FrozenSet, Iterable, Mapping, Optional, Tuple, TYPE_CHECKING
+from typing import cast, Iterable, Mapping, TYPE_CHECKING
 
 import networkx as nx
 
@@ -33,10 +33,10 @@ class GridDeviceMetadata(device.DeviceMetadata):
 
     def __init__(
         self,
-        qubit_pairs: Iterable[Tuple[cirq.GridQubit, cirq.GridQubit]],
+        qubit_pairs: Iterable[tuple[cirq.GridQubit, cirq.GridQubit]],
         gateset: cirq.Gateset,
-        gate_durations: Optional[Mapping[cirq.GateFamily, cirq.Duration]] = None,
-        all_qubits: Optional[Iterable[cirq.GridQubit]] = None,
+        gate_durations: Mapping[cirq.GateFamily, cirq.Duration] | None = None,
+        all_qubits: Iterable[cirq.GridQubit] | None = None,
         compilation_target_gatesets: Iterable[cirq.CompilationTargetGateset] = (),
     ):
         """Create a GridDeviceMetadata object.
@@ -118,16 +118,16 @@ class GridDeviceMetadata(device.DeviceMetadata):
         self._gate_durations = gate_durations
 
     @property
-    def qubit_set(self) -> FrozenSet[cirq.GridQubit]:
+    def qubit_set(self) -> frozenset[cirq.GridQubit]:
         """Returns the set of grid qubits on the device.
 
         Returns:
             Frozenset of qubits on device.
         """
-        return cast(FrozenSet['cirq.GridQubit'], super().qubit_set)
+        return cast(frozenset['cirq.GridQubit'], super().qubit_set)
 
     @property
-    def qubit_pairs(self) -> FrozenSet[FrozenSet[cirq.GridQubit]]:
+    def qubit_pairs(self) -> frozenset[frozenset[cirq.GridQubit]]:
         """Returns the set of all couple-able qubits on the device.
 
         Each element in the outer frozenset is a 2-element frozenset representing a bidirectional
@@ -136,7 +136,7 @@ class GridDeviceMetadata(device.DeviceMetadata):
         return self._qubit_pairs
 
     @property
-    def isolated_qubits(self) -> FrozenSet[cirq.GridQubit]:
+    def isolated_qubits(self) -> frozenset[cirq.GridQubit]:
         """Returns the set of all isolated qubits on the device (if applicable)."""
         return self._isolated_qubits
 
@@ -146,12 +146,12 @@ class GridDeviceMetadata(device.DeviceMetadata):
         return self._gateset
 
     @property
-    def compilation_target_gatesets(self) -> Tuple[cirq.CompilationTargetGateset, ...]:
+    def compilation_target_gatesets(self) -> tuple[cirq.CompilationTargetGateset, ...]:
         """Returns a sequence of valid `cirq.CompilationTargetGateset`s for this device."""
         return self._compilation_target_gatesets
 
     @property
-    def gate_durations(self) -> Optional[Mapping[cirq.GateFamily, cirq.Duration]]:
+    def gate_durations(self) -> Mapping[cirq.GateFamily, cirq.Duration] | None:
         """Get a dictionary mapping from gate family to duration for gates.
 
         To look up the duration of a specific gate instance / gate type / operation which is part of