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

cirq/contrib/acquaintance/shift.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Any, Dict, Iterator, Sequence, Tuple, TYPE_CHECKING
+from typing import Any, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import ops, value
 from cirq.contrib.acquaintance.permutation import PermutationGate, SwapPermutationGate
@@ -60,7 +60,7 @@ class CircularShiftGate(PermutationGate):
             for k in range(i, j, 2):
                 yield swap_gate(*qubits[k : k + 2])
 
-    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         if args.known_qubit_count is None:
             return NotImplemented  # pragma: no cover
         direction_symbols = ('╲', '╱') if args.use_unicode_characters else ('\\', '/')
@@ -72,7 +72,7 @@ class CircularShiftGate(PermutationGate):
         )
         return wire_symbols
 
-    def permutation(self) -> Dict[int, int]:
+    def permutation(self) -> dict[int, int]:
         shift = self.shift % self.num_qubits()
         permuted_indices = itertools.chain(range(shift, self.num_qubits()), range(shift))
         return {s: i for i, s in enumerate(permuted_indices)}

cirq/contrib/acquaintance/shift_swap_network.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import functools
 import itertools
-from typing import Dict, Iterable, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Iterable, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import ops
 from cirq.contrib.acquaintance.gates import acquaint
@@ -93,7 +93,7 @@ class ShiftSwapNetworkGate(PermutationGate):
                 parts[k] = parts_qubits[: len(right_part)]
                 parts[k + 1] = parts_qubits[len(right_part) :]
 
-    def qubit_count(self, side: Optional[str] = None) -> int:
+    def qubit_count(self, side: str | None = None) -> int:
         if side is None:
             return sum(self.qubit_count(side) for side in self.part_lens)
         return sum(self.part_lens[side])
@@ -101,7 +101,7 @@ class ShiftSwapNetworkGate(PermutationGate):
     def num_qubits(self) -> int:
         return self.qubit_count()
 
-    def permutation(self) -> Dict[int, int]:
+    def permutation(self) -> dict[int, int]:
         return dict(
             zip(
                 range(self.num_qubits()),
@@ -112,7 +112,7 @@ class ShiftSwapNetworkGate(PermutationGate):
             )
         )
 
-    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         qubit_count = self.qubit_count()
         assert args.known_qubit_count in (None, qubit_count)
 

cirq/contrib/acquaintance/strategies/cubic.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Iterable, Sequence, Tuple, TYPE_CHECKING, TypeVar
+from typing import Iterable, Sequence, TYPE_CHECKING, TypeVar
 
 from cirq import circuits, ops
 from cirq.contrib.acquaintance.gates import acquaint
@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 TItem = TypeVar('TItem')
 
 
-def skip_and_wrap_around(items: Sequence[TItem]) -> Tuple[TItem, ...]:
+def skip_and_wrap_around(items: Sequence[TItem]) -> tuple[TItem, ...]:
     n_items = len(items)
     positions = {
         p: i

cirq/contrib/acquaintance/strategies/quartic_paired.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import cast, Iterable, List, Sequence, Tuple, TYPE_CHECKING
+from typing import cast, Iterable, Sequence, TYPE_CHECKING
 
 from cirq import circuits
 from cirq.contrib.acquaintance.gates import acquaint, SwapNetworkGate
@@ -24,7 +24,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence[cirq.Qid]]) -> List[cirq.Qid]:
+def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence[cirq.Qid]]) -> list[cirq.Qid]:
     """Takes a sequence of qubit pairs and returns a sequence in which every
     pair is at distance two.
 
@@ -35,7 +35,7 @@ def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence[cirq.Qid]]) -> Lis
     if set(len(qubit_pair) for qubit_pair in qubit_pairs) != set((2,)):
         raise ValueError('set(len(qubit_pair) for qubit_pair in qubit_pairs) != set((2,))')
     n_pairs = len(qubit_pairs)
-    qubits: List[cirq.Qid] = []
+    qubits: list[cirq.Qid] = []
     for i in range(0, 2 * (n_pairs // 2), 2):
         qubits += [
             qubit_pairs[i][0],
@@ -49,15 +49,15 @@ def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence[cirq.Qid]]) -> Lis
 
 
 def quartic_paired_acquaintance_strategy(
-    qubit_pairs: Iterable[Tuple[cirq.Qid, cirq.Qid]],
-) -> Tuple[cirq.Circuit, Sequence[cirq.Qid]]:
+    qubit_pairs: Iterable[tuple[cirq.Qid, cirq.Qid]],
+) -> tuple[cirq.Circuit, Sequence[cirq.Qid]]:
     """Acquaintance strategy for pairs of pairs.
 
     Implements UpCCGSD ansatz from arXiv:1810.02327.
     """
 
     qubit_pairs = tuple(
-        cast(Tuple['cirq.Qid', 'cirq.Qid'], tuple(qubit_pair)) for qubit_pair in qubit_pairs
+        cast(tuple['cirq.Qid', 'cirq.Qid'], tuple(qubit_pair)) for qubit_pair in qubit_pairs
     )
     qubits = qubit_pairs_to_qubit_order(qubit_pairs)
     n_qubits = len(qubits)

cirq/contrib/bayesian_network/bayesian_network_gate.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import math
-from typing import Any, cast, Dict, Iterator, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, Iterator, Sequence, TYPE_CHECKING
 
 from sympy.combinatorics import GrayCode
 
@@ -96,8 +96,8 @@ class BayesianNetworkGate(raw_types.Gate):
 
     def __init__(
         self,
-        init_probs: List[Tuple[str, Optional[float]]],
-        arc_probs: List[Tuple[str, Tuple[str], List[float]]],
+        init_probs: list[tuple[str, float | None]],
+        arc_probs: list[tuple[str, tuple[str], list[float]]],
     ):
         """Builds a BayesianNetworkGate.
 
@@ -175,28 +175,27 @@ class BayesianNetworkGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return True
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return (2,) * len(self._init_probs)
 
     def _value_equality_values_(self):
         return self._init_probs, self._arc_probs
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'init_probs': self._init_probs, 'arc_probs': self._arc_probs}
 
     @classmethod
     def _from_json_dict_(
         cls,
-        init_probs: List[List[Union[str, Optional[float]]]],
-        arc_probs: List[List[Union[str, List[str], List[float]]]],
+        init_probs: list[list[str | float | None]],
+        arc_probs: list[list[str | list[str] | list[float]]],
         **kwargs,
     ) -> BayesianNetworkGate:
         converted_init_probs = cast(
-            List[Tuple[str, Optional[float]]],
-            [(param, init_prob) for param, init_prob in init_probs],
+            list[tuple[str, float | None]], [(param, init_prob) for param, init_prob in init_probs]
         )
         converted_cond_probs = cast(
-            List[Tuple[str, Tuple[str], List[float]]],
+            list[tuple[str, tuple[str], list[float]]],
             [(target, tuple(params), cond_probs) for target, params, cond_probs in arc_probs],
         )
         return cls(converted_init_probs, converted_cond_probs)

cirq/contrib/circuitdag/circuit_dag.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import functools
-from typing import Any, Callable, cast, Dict, Generic, Iterator, TypeVar
+from typing import Any, Callable, cast, Generic, Iterator, TypeVar
 
 import networkx
 
@@ -132,7 +132,7 @@ class CircuitDag(networkx.DiGraph):
         for node, attr in g2.nodes(data=True):
             attr['val'] = node.val
 
-        def node_match(attr1: Dict[Any, Any], attr2: Dict[Any, Any]) -> bool:
+        def node_match(attr1: dict[Any, Any], attr2: dict[Any, Any]) -> bool:
             return attr1['val'] == attr2['val']
 
         return networkx.is_isomorphic(g1, g2, node_match=node_match)

cirq/contrib/custom_simulators/custom_state_simulator.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Generic, Sequence, Type, TYPE_CHECKING
+from typing import Any, Generic, Sequence, TYPE_CHECKING
 
 from cirq import sim
 from cirq.sim.simulation_state import TSimulationState
@@ -47,7 +47,7 @@ class CustomStateSimulator(
 
     def __init__(
         self,
-        state_type: Type[TSimulationState],
+        state_type: type[TSimulationState],
         *,
         noise: cirq.NOISE_MODEL_LIKE = None,
         split_untangled_states: bool = False,
@@ -66,7 +66,7 @@ class CustomStateSimulator(
     def _create_simulator_trial_result(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[TSimulationState],
     ) -> CustomStateTrialResult[TSimulationState]:
         return CustomStateTrialResult(

cirq/contrib/custom_simulators/custom_state_simulator_test.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import List, Sequence, Tuple
+from typing import Sequence
 
 import numpy as np
 import sympy
@@ -24,7 +24,7 @@ from cirq.contrib.custom_simulators.custom_state_simulator import CustomStateSim
 
 
 class ComputationalBasisState(cirq.qis.QuantumStateRepresentation):
-    def __init__(self, initial_state: List[int]):
+    def __init__(self, initial_state: list[int]):
         self.basis = initial_state
 
     def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisState:
@@ -136,7 +136,7 @@ def test_parameterized_repetitions():
 
 
 class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
-    def __init__(self, initial_state: List[int]):
+    def __init__(self, initial_state: list[int]):
         self.basis = initial_state
 
     def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisProductState:
@@ -150,7 +150,7 @@ class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple[ComputationalBasisProductState, ComputationalBasisProductState]:
+    ) -> tuple[ComputationalBasisProductState, ComputationalBasisProductState]:
         extracted = ComputationalBasisProductState(
             [self.basis[i] for i in axes]
         )  # pragma: no cover

cirq/contrib/graph_device/graph_device.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import abc
 import itertools
-from typing import cast, Iterable, Optional, Tuple, TYPE_CHECKING
+from typing import cast, Iterable, TYPE_CHECKING
 
 from cirq import devices, ops, value
 from cirq.contrib.graph_device.hypergraph import UndirectedHypergraph
@@ -122,8 +122,8 @@ class UndirectedGraphDevice(devices.Device):
 
     def __init__(
         self,
-        device_graph: Optional[UndirectedHypergraph] = None,
-        crosstalk_graph: Optional[UndirectedHypergraph] = None,
+        device_graph: UndirectedHypergraph | None = None,
+        crosstalk_graph: UndirectedHypergraph | None = None,
     ) -> None:
         """Inits UndirectedGraphDevice.
 
@@ -152,8 +152,8 @@ class UndirectedGraphDevice(devices.Device):
         self.crosstalk_graph = crosstalk_graph
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
-        return cast(Tuple['cirq.Qid', ...], tuple(sorted(self.device_graph.vertices)))
+    def qubits(self) -> tuple[cirq.Qid, ...]:
+        return cast(tuple['cirq.Qid', ...], tuple(sorted(self.device_graph.vertices)))
 
     @property
     def edges(self):

cirq/contrib/graph_device/hypergraph.py

@@ -16,17 +16,17 @@ from __future__ import annotations
 
 import itertools
 import random
-from typing import Any, Dict, FrozenSet, Hashable, Iterable, Mapping, Optional, Set, Tuple, Union
+from typing import Any, Hashable, Iterable, Mapping
 
-AdjacencyList = Set[FrozenSet[Hashable]]
+AdjacencyList = set[frozenset[Hashable]]
 
 
 class UndirectedHypergraph:
     def __init__(
         self,
         *,
-        vertices: Optional[Iterable[Hashable]] = None,
-        labelled_edges: Optional[Dict[Iterable[Hashable], Any]] = None,
+        vertices: Iterable[Hashable] | None = None,
+        labelled_edges: dict[Iterable[Hashable], Any] | None = None,
     ) -> None:
         """A labelled, undirected hypergraph.
 
@@ -37,23 +37,23 @@ class UndirectedHypergraph:
                 automatically added.
         """
 
-        self._adjacency_lists: Dict[Hashable, AdjacencyList] = {}
-        self._labelled_edges: Dict[FrozenSet[Hashable], Any] = {}
+        self._adjacency_lists: dict[Hashable, AdjacencyList] = {}
+        self._labelled_edges: dict[frozenset[Hashable], Any] = {}
         if vertices is not None:
             self.add_vertices(vertices)
         if labelled_edges is not None:
             self.add_edges(labelled_edges)
 
     @property
-    def vertices(self) -> Tuple[Hashable, ...]:
+    def vertices(self) -> tuple[Hashable, ...]:
         return tuple(self._adjacency_lists.keys())
 
     @property
-    def edges(self) -> Tuple[FrozenSet[Hashable], ...]:
+    def edges(self) -> tuple[frozenset[Hashable], ...]:
         return tuple(self._labelled_edges.keys())
 
     @property
-    def labelled_edges(self) -> Dict[FrozenSet, Any]:
+    def labelled_edges(self) -> dict[frozenset, Any]:
         return dict(self._labelled_edges)
 
     def add_vertex(self, vertex: Hashable) -> None:
@@ -82,7 +82,7 @@ class UndirectedHypergraph:
             self._adjacency_lists[vertex].update((vertices,))
         self._labelled_edges[vertices] = label
 
-    def add_edges(self, edges: Dict[Iterable[Hashable], Any]):
+    def add_edges(self, edges: dict[Iterable[Hashable], Any]):
         for vertices, label in edges.items():
             self.add_edge(vertices, label)
 
@@ -104,7 +104,7 @@ class UndirectedHypergraph:
 
     @classmethod
     def random(
-        cls, vertices: Union[int, Iterable], edge_probs: Mapping[int, float]
+        cls, vertices: int | Iterable, edge_probs: Mapping[int, float]
     ) -> UndirectedHypergraph:
         """A random hypergraph.
 
@@ -127,5 +127,5 @@ class UndirectedHypergraph:
             for potential_edge in itertools.combinations(vertices, edge_size):
                 if random.random() < edge_prob:
                     edges.append(potential_edge)
-        labelled_edges: Dict[Iterable[Hashable], Any] = {edge: None for edge in edges}
+        labelled_edges: dict[Iterable[Hashable], Any] = {edge: None for edge in edges}
         return cls(vertices=vertices, labelled_edges=labelled_edges)

cirq/contrib/graph_device/uniform_graph_device.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Hashable, Iterable, Mapping, Optional
+from typing import Any, Hashable, Iterable, Mapping
 
 from cirq import devices, ops
 from cirq.contrib.graph_device.graph_device import UndirectedGraphDevice, UndirectedGraphDeviceEdge
@@ -22,7 +22,7 @@ from cirq.contrib.graph_device.hypergraph import UndirectedHypergraph
 
 
 def uniform_undirected_graph_device(
-    edges: Iterable[Iterable[ops.Qid]], edge_label: Optional[UndirectedGraphDeviceEdge] = None
+    edges: Iterable[Iterable[ops.Qid]], edge_label: UndirectedGraphDeviceEdge | None = None
 ) -> UndirectedGraphDevice:
     """An undirected graph device all of whose edges are the same.
 
@@ -31,13 +31,13 @@ def uniform_undirected_graph_device(
         edge_label: The label to apply to all edges. Defaults to None.
     """
 
-    labelled_edges: Dict[Iterable[Hashable], Any] = {frozenset(edge): edge_label for edge in edges}
+    labelled_edges: dict[Iterable[Hashable], Any] = {frozenset(edge): edge_label for edge in edges}
     device_graph = UndirectedHypergraph(labelled_edges=labelled_edges)
     return UndirectedGraphDevice(device_graph=device_graph)
 
 
 def uniform_undirected_linear_device(
-    n_qubits: int, edge_labels: Mapping[int, Optional[UndirectedGraphDeviceEdge]]
+    n_qubits: int, edge_labels: Mapping[int, UndirectedGraphDeviceEdge | None]
 ) -> UndirectedGraphDevice:
     """A uniform , undirected graph device whose qubits are arranged
     on a line.

cirq/contrib/paulistring/clifford_optimize.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import cast, Tuple
+from typing import cast
 
 from cirq import circuits, ops, protocols, transformers
 from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGateset
@@ -31,7 +31,7 @@ def clifford_optimized_circuit(circuit: circuits.Circuit, atol: float = 1e-8) ->
 
     def find_merge_point(
         start_i: int, string_op: ops.PauliStringPhasor, stop_at_cz: bool
-    ) -> Tuple[int, ops.PauliStringPhasor, int]:
+    ) -> tuple[int, ops.PauliStringPhasor, int]:
         STOP = 0
         CONTINUE = 1
         SKIP = 2

cirq/contrib/paulistring/clifford_target_gateset.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from enum import Enum
 from types import NotImplementedType
-from typing import cast, List, Type, TYPE_CHECKING, Union
+from typing import cast, TYPE_CHECKING
 
 from cirq import linalg, ops, protocols, transformers
 
@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 
 def _matrix_to_clifford_op(
     mat: np.ndarray, qubit: cirq.Qid, *, atol: float
-) -> Union[ops.Operation, NotImplementedType]:
+) -> ops.Operation | NotImplementedType:
     rotations = transformers.single_qubit_matrix_to_pauli_rotations(mat, atol)
     clifford_gate = ops.SingleQubitCliffordGate.I
     for pauli, half_turns in rotations:
@@ -48,7 +48,7 @@ def _matrix_to_pauli_string_phasors(
     mat: np.ndarray, qubit: cirq.Qid, *, keep_clifford: bool, atol: float
 ) -> ops.OP_TREE:
     rotations = transformers.single_qubit_matrix_to_pauli_rotations(mat, atol)
-    out_ops: List[ops.GateOperation] = []
+    out_ops: list[ops.GateOperation] = []
     for pauli, half_turns in rotations:
         if keep_clifford and linalg.all_near_zero_mod(half_turns, 0.5):
             cliff_gate = ops.SingleQubitCliffordGate.from_quarter_turns(
@@ -97,7 +97,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         """
         self.atol = atol
         self.single_qubit_target = single_qubit_target
-        gates: List[Union[cirq.Gate, Type[cirq.Gate]]] = [ops.CZ, ops.MeasurementGate]
+        gates: list[cirq.Gate | type[cirq.Gate]] = [ops.CZ, ops.MeasurementGate]
         if single_qubit_target in [
             self.SingleQubitTarget.SINGLE_QUBIT_CLIFFORDS,
             self.SingleQubitTarget.PAULI_STRING_PHASORS_AND_CLIFFORDS,
@@ -112,7 +112,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
 
     def _decompose_single_qubit_operation(
         self, op: cirq.Operation, _
-    ) -> Union[NotImplementedType, cirq.OP_TREE]:
+    ) -> NotImplementedType | cirq.OP_TREE:
         if not protocols.has_unitary(op):
             return NotImplemented
         mat = protocols.unitary(op)
@@ -129,7 +129,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
 
     def _decompose_two_qubit_operation(
         self, op: cirq.Operation, _
-    ) -> Union[NotImplementedType, cirq.OP_TREE]:
+    ) -> NotImplementedType | cirq.OP_TREE:
         if not protocols.has_unitary(op):
             return NotImplemented
         return transformers.two_qubit_matrix_to_cz_operations(
@@ -141,7 +141,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         )
 
     @property
-    def postprocess_transformers(self) -> List[cirq.TRANSFORMER]:
+    def postprocess_transformers(self) -> list[cirq.TRANSFORMER]:
         """List of transformers which should be run after decomposing individual operations."""
 
         def rewriter(o: cirq.CircuitOperation):

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import itertools
 import time
-from typing import cast, Dict, FrozenSet, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import cast, Sequence, TYPE_CHECKING
 
 import attrs
 import numpy as np
@@ -50,7 +50,7 @@ class PauliStringMeasurementResult:
     mitigated_stddev: float
     unmitigated_expectation: float
     unmitigated_stddev: float
-    calibration_result: Optional[SingleQubitReadoutCalibrationResult] = None
+    calibration_result: SingleQubitReadoutCalibrationResult | None = None
 
 
 @attrs.frozen
@@ -63,11 +63,11 @@ class CircuitToPauliStringsMeasurementResult:
     """
 
     circuit: circuits.FrozenCircuit
-    results: List[PauliStringMeasurementResult]
+    results: list[PauliStringMeasurementResult]
 
 
 def _commute_or_identity(
-    op1: Union[ops.Pauli, ops.IdentityGate], op2: Union[ops.Pauli, ops.IdentityGate]
+    op1: ops.Pauli | ops.IdentityGate, op2: ops.Pauli | ops.IdentityGate
 ) -> bool:
     if op1 == ops.I or op2 == ops.I:
         return True
@@ -77,7 +77,7 @@ def _commute_or_identity(
 def _are_two_pauli_strings_qubit_wise_commuting(
     pauli_str1: ops.PauliString,
     pauli_str2: ops.PauliString,
-    all_qubits: Union[list[ops.Qid], FrozenSet[ops.Qid]],
+    all_qubits: list[ops.Qid] | frozenset[ops.Qid],
 ) -> bool:
     for qubit in all_qubits:
         op1 = pauli_str1.get(qubit, default=ops.I)
@@ -89,7 +89,7 @@ def _are_two_pauli_strings_qubit_wise_commuting(
 
 
 def _validate_group_paulis_qwc(
-    pauli_strs: list[ops.PauliString], all_qubits: Union[list[ops.Qid], FrozenSet[ops.Qid]]
+    pauli_strs: list[ops.PauliString], all_qubits: list[ops.Qid] | frozenset[ops.Qid]
 ):
     """Checks if a group of Pauli strings are Qubit-Wise Commuting.
 
@@ -130,14 +130,14 @@ def _validate_single_pauli_string(pauli_str: ops.PauliString):
 
 
 def _validate_input(
-    circuits_to_pauli: Union[
-        Dict[circuits.FrozenCircuit, list[ops.PauliString]],
-        Dict[circuits.FrozenCircuit, list[list[ops.PauliString]]],
-    ],
+    circuits_to_pauli: (
+        dict[circuits.FrozenCircuit, list[ops.PauliString]]
+        | dict[circuits.FrozenCircuit, list[list[ops.PauliString]]]
+    ),
     pauli_repetitions: int,
     readout_repetitions: int,
     num_random_bitstrings: int,
-    rng_or_seed: Union[np.random.Generator, int],
+    rng_or_seed: np.random.Generator | int,
 ):
     if not circuits_to_pauli:
         raise ValueError("Input circuits must not be empty.")
@@ -146,7 +146,7 @@ def _validate_input(
         if not isinstance(circuit, circuits.FrozenCircuit):
             raise TypeError("All keys in 'circuits_to_pauli' must be FrozenCircuit instances.")
 
-    first_value: Union[list[ops.PauliString], list[list[ops.PauliString]]] = next(
+    first_value: list[ops.PauliString] | list[list[ops.PauliString]] = next(
         iter(circuits_to_pauli.values())  # type: ignore
     )
     for circuit, pauli_strs_list in circuits_to_pauli.items():
@@ -198,23 +198,23 @@ def _validate_input(
 
 
 def _normalize_input_paulis(
-    circuits_to_pauli: Union[
-        Dict[circuits.FrozenCircuit, list[ops.PauliString]],
-        Dict[circuits.FrozenCircuit, list[list[ops.PauliString]]],
-    ],
-) -> Dict[circuits.FrozenCircuit, list[list[ops.PauliString]]]:
+    circuits_to_pauli: (
+        dict[circuits.FrozenCircuit, list[ops.PauliString]]
+        | dict[circuits.FrozenCircuit, list[list[ops.PauliString]]]
+    ),
+) -> dict[circuits.FrozenCircuit, list[list[ops.PauliString]]]:
     first_value = next(iter(circuits_to_pauli.values()))
     if (
         first_value
         and isinstance(first_value, list)
         and isinstance(first_value[0], ops.PauliString)
     ):
-        input_dict = cast(Dict[circuits.FrozenCircuit, List[ops.PauliString]], circuits_to_pauli)
-        normalized_circuits_to_pauli: Dict[circuits.FrozenCircuit, list[list[ops.PauliString]]] = {}
+        input_dict = cast(dict[circuits.FrozenCircuit, list[ops.PauliString]], circuits_to_pauli)
+        normalized_circuits_to_pauli: dict[circuits.FrozenCircuit, list[list[ops.PauliString]]] = {}
         for circuit, paulis in input_dict.items():
             normalized_circuits_to_pauli[circuit] = [[ps] for ps in paulis]
         return normalized_circuits_to_pauli
-    return cast(Dict[circuits.FrozenCircuit, List[List[ops.PauliString]]], circuits_to_pauli)
+    return cast(dict[circuits.FrozenCircuit, list[list[ops.PauliString]]], circuits_to_pauli)
 
 
 def _pauli_strings_to_basis_change_ops(
@@ -282,7 +282,7 @@ def _process_pauli_measurement_results(
     qubits: list[ops.Qid],
     pauli_string_groups: list[list[ops.PauliString]],
     circuit_results: list[ResultDict],
-    calibration_results: Dict[Tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult],
+    calibration_results: dict[tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult],
     pauli_repetitions: int,
     timestamp: float,
     disable_readout_mitigation: bool = False,
@@ -310,7 +310,7 @@ def _process_pauli_measurement_results(
         A list of PauliStringMeasurementResult.
     """
 
-    pauli_measurement_results: List[PauliStringMeasurementResult] = []
+    pauli_measurement_results: list[PauliStringMeasurementResult] = []
 
     for pauli_group_index, circuit_result in enumerate(circuit_results):
         measurement_results = circuit_result.measurements["m"]
@@ -368,16 +368,16 @@ def _process_pauli_measurement_results(
 
 
 def measure_pauli_strings(
-    circuits_to_pauli: Union[
-        Dict[circuits.FrozenCircuit, List[ops.PauliString]],
-        Dict[circuits.FrozenCircuit, List[List[ops.PauliString]]],
-    ],
+    circuits_to_pauli: (
+        dict[circuits.FrozenCircuit, list[ops.PauliString]]
+        | dict[circuits.FrozenCircuit, list[list[ops.PauliString]]]
+    ),
     sampler: work.Sampler,
     pauli_repetitions: int,
     readout_repetitions: int,
     num_random_bitstrings: int,
-    rng_or_seed: Union[np.random.Generator, int],
-) -> List[CircuitToPauliStringsMeasurementResult]:
+    rng_or_seed: np.random.Generator | int,
+) -> list[CircuitToPauliStringsMeasurementResult]:
     """Measures expectation values of Pauli strings on given circuits with/without
     readout error mitigation.
 
@@ -392,11 +392,11 @@ def measure_pauli_strings(
 
     Args:
         circuits_to_pauli: A dictionary mapping circuits to either:
-            - A list of QWC groups (List[List[ops.PauliString]]). Each QWC group
+            - A list of QWC groups (list[list[ops.PauliString]]). Each QWC group
               is a list of PauliStrings that are mutually Qubit-Wise Commuting.
               Pauli strings within the same group will be calculated using the
               same measurement results.
-            - A list of PauliStrings (List[ops.PauliString]). In this case, each
+            - A list of PauliStrings (list[ops.PauliString]). In this case, each
               PauliString is treated as its own measurement group.
         sampler: The sampler to use.
         pauli_repetitions: The number of repetitions for each circuit when measuring
@@ -460,7 +460,7 @@ def measure_pauli_strings(
     )
 
     # Process the results to calculate expectation values
-    results: List[CircuitToPauliStringsMeasurementResult] = []
+    results: list[CircuitToPauliStringsMeasurementResult] = []
     circuit_result_index = 0
     for input_circuit, pauli_string_groups in normalized_circuits_to_pauli.items():