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

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import itertools
 import random
-from typing import Dict, Sequence
+from typing import Sequence
 
 import numpy as np
 import pytest
@@ -112,7 +112,7 @@ def test_pauli_string_measurement_errors_no_noise() -> None:
     circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
     sampler = cirq.Simulator()
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [_generate_random_pauli_string(qubits) for _ in range(3)]
 
     circuits_with_pauli_expectations = measure_pauli_strings(
@@ -160,7 +160,7 @@ def test_pauli_string_measurement_errors_with_coefficient_no_noise() -> None:
     circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
     sampler = cirq.Simulator()
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [_generate_random_pauli_string(qubits, True) for _ in range(3)]
 
     circuits_with_pauli_expectations = measure_pauli_strings(
@@ -208,7 +208,7 @@ def test_group_pauli_string_measurement_errors_no_noise_with_coefficient() -> No
     circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
     sampler = cirq.Simulator()
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
     circuits_to_pauli[circuit] = [
         _generate_qwc_paulis(
             _generate_random_pauli_string(qubits, enable_coeff=True, allow_pauli_i=False), 100, True
@@ -262,7 +262,7 @@ def test_pauli_string_measurement_errors_with_noise() -> None:
     sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.005, seed=1234)
     simulator = cirq.Simulator()
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [_generate_random_pauli_string(qubits) for _ in range(3)]
 
     circuits_with_pauli_expectations = measure_pauli_strings(
@@ -309,7 +309,7 @@ def test_group_pauli_string_measurement_errors_with_noise() -> None:
     sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.005, seed=1234)
     simulator = cirq.Simulator()
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
     circuits_to_pauli[circuit] = [
         _generate_qwc_paulis(
             _generate_random_pauli_string(qubits, enable_coeff=True, allow_pauli_i=False), 5
@@ -369,7 +369,7 @@ def test_many_circuits_input_measurement_with_noise() -> None:
     circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
     circuit_3 = cirq.FrozenCircuit(_create_ghz(8, qubits_3))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit_1] = [_generate_random_pauli_string(qubits_1) for _ in range(3)]
     circuits_to_pauli[circuit_2] = [_generate_random_pauli_string(qubits_2) for _ in range(3)]
     circuits_to_pauli[circuit_3] = [_generate_random_pauli_string(qubits_3) for _ in range(3)]
@@ -417,7 +417,7 @@ def test_allow_measurement_without_readout_mitigation() -> None:
     circuit = cirq.FrozenCircuit(_create_ghz(7, qubits))
     sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.005, seed=1234)
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [
         _generate_random_pauli_string(qubits, True),
         _generate_random_pauli_string(qubits),
@@ -447,7 +447,7 @@ def test_allow_group_pauli_measurement_without_readout_mitigation() -> None:
     circuit = cirq.FrozenCircuit(_create_ghz(7, qubits))
     sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.005, seed=1234)
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
     circuits_to_pauli[circuit] = [
         _generate_qwc_paulis(_generate_random_pauli_string(qubits, True), 2, True),
         _generate_qwc_paulis(_generate_random_pauli_string(qubits), 4),
@@ -488,7 +488,7 @@ def test_many_circuits_with_coefficient() -> None:
     circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
     circuit_3 = cirq.FrozenCircuit(_create_ghz(8, qubits_3))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit_1] = [_generate_random_pauli_string(qubits_1, True) for _ in range(3)]
     circuits_to_pauli[circuit_2] = [_generate_random_pauli_string(qubits_2, True) for _ in range(3)]
     circuits_to_pauli[circuit_3] = [_generate_random_pauli_string(qubits_3, True) for _ in range(3)]
@@ -547,7 +547,7 @@ def test_many_group_pauli_in_circuits_with_coefficient() -> None:
     circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
     circuit_3 = cirq.FrozenCircuit(_create_ghz(8, qubits_3))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
     circuits_to_pauli[circuit_1] = [
         _generate_qwc_paulis(
             _generate_random_pauli_string(qubits_1, enable_coeff=True, allow_pauli_i=False), 4
@@ -608,7 +608,7 @@ def test_coefficient_not_real_number() -> None:
     random_pauli_string = _generate_random_pauli_string(qubits_1, True) * (3 + 4j)
     circuit_1 = cirq.FrozenCircuit(_create_ghz(3, qubits_1))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit_1] = [
         random_pauli_string,
         _generate_random_pauli_string(qubits_1, True),
@@ -643,7 +643,7 @@ def test_invalid_input_circuit_type() -> None:
     """Test that the input circuit type is not frozen circuit"""
     qubits = cirq.LineQubit.range(5)
 
-    qubits_to_pauli: Dict[tuple, list[cirq.PauliString]] = {}
+    qubits_to_pauli: dict[tuple, list[cirq.PauliString]] = {}
     qubits_to_pauli[tuple(qubits)] = [cirq.PauliString({q: cirq.X for q in qubits})]
     with pytest.raises(
         TypeError, match="All keys in 'circuits_to_pauli' must be FrozenCircuit instances."
@@ -672,7 +672,7 @@ def test_invalid_input_pauli_string_type() -> None:
     circuit_1 = cirq.FrozenCircuit(_create_ghz(5, qubits_1))
     circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, cirq.FrozenCircuit] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, cirq.FrozenCircuit] = {}
     circuits_to_pauli[circuit_1] = [_generate_random_pauli_string(qubits_1)]  # type: ignore
     circuits_to_pauli[circuit_2] = [circuit_1, circuit_2]  # type: ignore
 
@@ -705,7 +705,7 @@ def test_all_pauli_strings_are_pauli_i() -> None:
     circuit_1 = cirq.FrozenCircuit(_create_ghz(5, qubits_1))
     circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit_1] = [
         cirq.PauliString({q: cirq.I for q in qubits_1}),
         cirq.PauliString({q: cirq.X for q in qubits_1}),
@@ -729,7 +729,7 @@ def test_zero_pauli_repetitions() -> None:
 
     circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [cirq.PauliString({q: cirq.X for q in qubits})]
     with pytest.raises(ValueError, match="Must provide non-zero pauli_repetitions."):
         measure_pauli_strings(
@@ -743,7 +743,7 @@ def test_negative_num_random_bitstrings() -> None:
 
     circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [cirq.PauliString({q: cirq.X for q in qubits})]
     with pytest.raises(ValueError, match="Must provide zero or more num_random_bitstrings."):
         measure_pauli_strings(
@@ -757,7 +757,7 @@ def test_zero_readout_repetitions() -> None:
 
     circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [cirq.PauliString({q: cirq.X for q in qubits})]
     with pytest.raises(
         ValueError, match="Must provide non-zero readout_repetitions for readout" + " calibration."
@@ -773,7 +773,7 @@ def test_rng_type_mismatch() -> None:
 
     circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [cirq.PauliString({q: cirq.X for q in qubits})]
     with pytest.raises(ValueError, match="Must provide a numpy random generator or a seed"):
         measure_pauli_strings(
@@ -787,7 +787,7 @@ def test_pauli_type_mismatch() -> None:
 
     circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, int] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, int] = {}
     circuits_to_pauli[circuit] = 1
     with pytest.raises(
         TypeError,
@@ -808,7 +808,7 @@ def test_group_paulis_are_not_qwc() -> None:
     pauli_str1: cirq.PauliString = cirq.PauliString({qubits[0]: cirq.X, qubits[1]: cirq.Y})
     pauli_str2: cirq.PauliString = cirq.PauliString({qubits[0]: cirq.Y})
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [[pauli_str1, pauli_str2]]  # type: ignore
     with pytest.raises(
         ValueError,
@@ -825,7 +825,7 @@ def test_empty_group_paulis_not_allowed() -> None:
 
     circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [[]]  # type: ignore
     with pytest.raises(ValueError, match="Empty group of Pauli strings is not allowed"):
         measure_pauli_strings(
@@ -849,7 +849,7 @@ def test_group_paulis_type_mismatch() -> None:
     circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
     circuit_3 = cirq.FrozenCircuit(_create_ghz(8, qubits_3))
 
-    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli: dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
     circuits_to_pauli[circuit_1] = [
         _generate_qwc_paulis(
             _generate_random_pauli_string(qubits_1, enable_coeff=True, allow_pauli_i=False), 6

cirq/contrib/paulistring/recombine.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, cast, Iterable, List, Sequence, Tuple, Union
+from typing import Any, Callable, cast, Iterable, Sequence
 
 from cirq import circuits, ops, protocols
 from cirq.contrib import circuitdag
@@ -28,7 +28,7 @@ def _sorted_best_string_placements(
     possible_nodes: Iterable[Any],
     output_ops: Sequence[ops.Operation],
     key: Callable[[Any], ops.PauliStringPhasor] = lambda node: node.val,
-) -> List[Tuple[ops.PauliStringPhasor, int, circuitdag.Unique[ops.PauliStringPhasor]]]:
+) -> list[tuple[ops.PauliStringPhasor, int, circuitdag.Unique[ops.PauliStringPhasor]]]:
     sort_key = lambda placement: (-len(placement[0].pauli_string), placement[1])
 
     node_maxes = []
@@ -66,7 +66,7 @@ def _sorted_best_string_placements(
 
 
 def move_pauli_strings_into_circuit(
-    circuit_left: Union[circuits.Circuit, circuitdag.CircuitDag], circuit_right: circuits.Circuit
+    circuit_left: circuits.Circuit | circuitdag.CircuitDag, circuit_right: circuits.Circuit
 ) -> circuits.Circuit:
     if isinstance(circuit_left, circuitdag.CircuitDag):
         string_dag = circuitdag.CircuitDag(pauli_string_reorder_pred, circuit_left)

cirq/contrib/paulistring/separate.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Iterator, Tuple
+from typing import Iterator
 
 from cirq import circuits, ops, transformers
 from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGateset
@@ -22,7 +22,7 @@ from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGates
 
 def convert_and_separate_circuit(
     circuit: circuits.Circuit, leave_cliffords: bool = True, atol: float = 1e-8
-) -> Tuple[circuits.Circuit, circuits.Circuit]:
+) -> tuple[circuits.Circuit, circuits.Circuit]:
     """Converts a circuit into two, one made of PauliStringPhasor and the other Clifford gates.
 
     Args:

cirq/contrib/qasm_import/_parser.py

@@ -17,19 +17,7 @@ from __future__ import annotations
 import dataclasses
 import functools
 import operator
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, cast, Iterable, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -61,7 +49,7 @@ class Qasm:
         self.circuit = c
 
 
-def _generate_op_qubits(args: List[List[ops.Qid]], lineno: int) -> List[List[ops.Qid]]:
+def _generate_op_qubits(args: list[list[ops.Qid]], lineno: int) -> list[list[ops.Qid]]:
     """Generates the Cirq qubits for an operation from the OpenQASM qregs.
 
     OpenQASM gates can be applied on single qubits and qubit registers.
@@ -78,7 +66,7 @@ def _generate_op_qubits(args: List[List[ops.Qid]], lineno: int) -> List[List[ops
             f"Non matching quantum registers of length {reg_sizes} at line {lineno}"
         )
     op_qubits_gen = functools.reduce(
-        cast(Callable[[List['cirq.Qid'], List['cirq.Qid']], List['cirq.Qid']], np.broadcast), args
+        cast(Callable[[list['cirq.Qid'], list['cirq.Qid']], list['cirq.Qid']], np.broadcast), args
     )
     op_qubits = [[q] if isinstance(q, ops.Qid) else q for q in op_qubits_gen]
     if any(len(set(q)) < len(q) for q in op_qubits):
@@ -98,7 +86,7 @@ class QasmGateStatement:
     def __init__(
         self,
         qasm_gate: str,
-        cirq_gate: Union[ops.Gate, Callable[[List[float]], ops.Gate]],
+        cirq_gate: ops.Gate | Callable[[list[float]], ops.Gate],
         num_params: int,
         num_args: int,
     ):
@@ -119,14 +107,14 @@ class QasmGateStatement:
         assert num_args >= 1
         self.num_args = num_args
 
-    def _validate_args(self, args: List[List[ops.Qid]], lineno: int):
+    def _validate_args(self, args: list[list[ops.Qid]], lineno: int):
         if len(args) != self.num_args:
             raise QasmException(
                 f"{self.qasm_gate} only takes {self.num_args} arg(s) (qubits and/or registers), "
                 f"got: {len(args)}, at line {lineno}"
             )
 
-    def _validate_params(self, params: List[value.TParamVal], lineno: int):
+    def _validate_params(self, params: list[value.TParamVal], lineno: int):
         if len(params) != self.num_params:
             raise QasmException(
                 f"{self.qasm_gate} takes {self.num_params} parameter(s), "
@@ -134,7 +122,7 @@ class QasmGateStatement:
             )
 
     def on(
-        self, params: List[value.TParamVal], args: List[List[ops.Qid]], lineno: int
+        self, params: list[value.TParamVal], args: list[list[ops.Qid]], lineno: int
     ) -> Iterable[ops.Operation]:
         self._validate_args(args, lineno)
         self._validate_params(params, lineno)
@@ -159,11 +147,11 @@ class CustomGate:
 
     name: str
     circuit: FrozenCircuit
-    params: Tuple[str, ...]
-    qubits: Tuple[ops.Qid, ...]
+    params: tuple[str, ...]
+    qubits: tuple[ops.Qid, ...]
 
     def on(
-        self, params: List[value.TParamVal], args: List[List[ops.Qid]], lineno: int
+        self, params: list[value.TParamVal], args: list[list[ops.Qid]], lineno: int
     ) -> Iterable[ops.Operation]:
         if len(params) != len(self.params):
             raise QasmException(f"Wrong number of params for '{self.name}' at line {lineno}")
@@ -189,25 +177,25 @@ class QasmParser:
     def __init__(self) -> None:
         self.parser = yacc.yacc(module=self, debug=False, write_tables=False)
         self.circuit = Circuit()
-        self.qregs: Dict[str, int] = {}
-        self.cregs: Dict[str, int] = {}
-        self.gate_set: Dict[str, Union[CustomGate, QasmGateStatement]] = {**self.basic_gates}
+        self.qregs: dict[str, int] = {}
+        self.cregs: dict[str, int] = {}
+        self.gate_set: dict[str, CustomGate | QasmGateStatement] = {**self.basic_gates}
         """The gates available to use in the circuit, including those from libraries, and
          user-defined ones."""
         self.in_custom_gate_scope = False
         """This is set to True when the parser is in the middle of parsing a custom gate
          definition."""
-        self.custom_gate_scoped_params: Set[str] = set()
+        self.custom_gate_scoped_params: set[str] = set()
         """The params declared within the current custom gate definition. Empty if not in
          custom gate scope."""
-        self.custom_gate_scoped_qubits: Dict[str, ops.Qid] = {}
+        self.custom_gate_scoped_qubits: dict[str, ops.Qid] = {}
         """The qubits declared within the current custom gate definition. Empty if not in
          custom gate scope."""
         self.qelibinc = False
         self.lexer = QasmLexer()
         self.supported_format = False
-        self.parsedQasm: Optional[Qasm] = None
-        self.qubits: Dict[str, ops.Qid] = {}
+        self.parsedQasm: Qasm | None = None
+        self.qubits: dict[str, ops.Qid] = {}
         self.functions = {
             'sin': np.sin,
             'cos': np.cos,
@@ -228,7 +216,7 @@ class QasmParser:
             '^': operator.pow,
         }
 
-    basic_gates: Dict[str, QasmGateStatement] = {
+    basic_gates: dict[str, QasmGateStatement] = {
         'CX': QasmGateStatement(qasm_gate='CX', cirq_gate=CX, num_params=0, num_args=2),
         'U': QasmGateStatement(
             qasm_gate='U',
@@ -443,7 +431,7 @@ class QasmParser:
         self._resolve_gate_operation(args=p[5], gate=p[1], p=p, params=p[3])
 
     def _resolve_gate_operation(
-        self, args: List[List[ops.Qid]], gate: str, p: Any, params: List[value.TParamVal]
+        self, args: list[list[ops.Qid]], gate: str, p: Any, params: list[value.TParamVal]
     ):
         if gate not in self.gate_set:
             tip = ", did you forget to include qelib1.inc?" if not self.qelibinc else ""
@@ -693,7 +681,7 @@ class QasmParser:
         """gate_def : GATE ID gate_qubits '{' gate_ops '}'"""
         self._gate_def(p, has_params=False)
 
-    def _gate_def(self, p: List[Any], *, has_params: bool):
+    def _gate_def(self, p: list[Any], *, has_params: bool):
         name = p[2]
         gate_params = tuple(p[4]) if has_params else ()
         offset = 3 if has_params else 0

cirq/contrib/qcircuit/qcircuit_diagram_info.py

@@ -14,8 +14,6 @@
 
 from __future__ import annotations
 
-from typing import Optional, Tuple
-
 from cirq import ops, protocols
 
 
@@ -35,7 +33,7 @@ def escape_text_for_latex(text):
     return r'\text{' + escaped + '}'
 
 
-def get_multigate_parameters(args: protocols.CircuitDiagramInfoArgs) -> Optional[Tuple[int, int]]:
+def get_multigate_parameters(args: protocols.CircuitDiagramInfoArgs) -> tuple[int, int] | None:
     if (args.label_map is None) or (args.known_qubits is None):
         return None
 
@@ -47,7 +45,7 @@ def get_multigate_parameters(args: protocols.CircuitDiagramInfoArgs) -> Optional
     return min_index, n_qubits
 
 
-def hardcoded_qcircuit_diagram_info(op: ops.Operation) -> Optional[protocols.CircuitDiagramInfo]:
+def hardcoded_qcircuit_diagram_info(op: ops.Operation) -> protocols.CircuitDiagramInfo | None:
     if not isinstance(op, ops.GateOperation):
         return None
     symbols = (
@@ -78,7 +76,7 @@ def convert_text_diagram_info_to_qcircuit_diagram_info(
 
 def multigate_qcircuit_diagram_info(
     op: ops.Operation, args: protocols.CircuitDiagramInfoArgs
-) -> Optional[protocols.CircuitDiagramInfo]:
+) -> protocols.CircuitDiagramInfo | None:
     if not (
         isinstance(op, ops.GateOperation) and isinstance(op.gate, ops.InterchangeableQubitsGate)
     ):

cirq/contrib/quantum_volume/quantum_volume.py

@@ -6,7 +6,7 @@ https://arxiv.org/abs/1811.12926.
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Optional, Set, Tuple, TYPE_CHECKING
+from typing import Callable, TYPE_CHECKING
 
 import numpy as np
 
@@ -64,7 +64,7 @@ def generate_model_circuit(
     return circuit
 
 
-def compute_heavy_set(circuit: cirq.Circuit) -> List[int]:
+def compute_heavy_set(circuit: cirq.Circuit) -> list[int]:
     """Classically compute the heavy set of the given circuit.
 
     The heavy set is defined as the output bit-strings that have a greater than
@@ -96,13 +96,13 @@ def compute_heavy_set(circuit: cirq.Circuit) -> List[int]:
 @dataclass
 class CompilationResult:
     circuit: cirq.Circuit
-    mapping: Dict[cirq.Qid, cirq.Qid]
-    parity_map: Dict[cirq.Qid, cirq.Qid]
+    mapping: dict[cirq.Qid, cirq.Qid]
+    parity_map: dict[cirq.Qid, cirq.Qid]
 
 
 def sample_heavy_set(
     compilation_result: CompilationResult,
-    heavy_set: List[int],
+    heavy_set: list[int],
     *,
     repetitions=10_000,
     sampler: cirq.Sampler = cirq.Simulator(),
@@ -158,8 +158,8 @@ def sample_heavy_set(
 
 
 def process_results(
-    mapping: Dict[cirq.Qid, cirq.Qid],
-    parity_mapping: Dict[cirq.Qid, cirq.Qid],
+    mapping: dict[cirq.Qid, cirq.Qid],
+    parity_mapping: dict[cirq.Qid, cirq.Qid],
     trial_result: cirq.Result,
 ) -> pd.DataFrame:
     """Checks the given results for parity and throws away all of the runs that
@@ -176,11 +176,11 @@ def process_results(
 
     """
     # The circuit's mapping from physical qubit to logical qubit.
-    inverse_mapping: Dict[cirq.Qid, cirq.Qid] = {v: k for k, v in mapping.items()}
+    inverse_mapping: dict[cirq.Qid, cirq.Qid] = {v: k for k, v in mapping.items()}
 
     # Calculate all the invalid parity pairs.
     data = trial_result.data
-    bad_measurements: Set[int] = set()
+    bad_measurements: set[int] = set()
     for final_qubit, original_qubit in mapping.items():
         if original_qubit in parity_mapping:
             final_parity_qubit = inverse_mapping[parity_mapping[original_qubit]]
@@ -204,9 +204,9 @@ def compile_circuit(
     *,
     device_graph: nx.Graph,
     routing_attempts: int,
-    compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None,
-    routing_algo_name: Optional[str] = None,
-    router: Optional[Callable[..., ccr.SwapNetwork]] = None,
+    compiler: Callable[[cirq.Circuit], cirq.Circuit] | None = None,
+    routing_algo_name: str | None = None,
+    router: Callable[..., ccr.SwapNetwork] | None = None,
     add_readout_error_correction=False,
 ) -> CompilationResult:
     """Compile the given model circuit onto the given device graph. This uses a
@@ -237,7 +237,7 @@ def compile_circuit(
     compiled_circuit = circuit.copy()
 
     # Optionally add some the parity check bits.
-    parity_map: Dict[cirq.Qid, cirq.Qid] = {}  # original -> parity
+    parity_map: dict[cirq.Qid, cirq.Qid] = {}  # original -> parity
     if add_readout_error_correction:
         num_qubits = len(compiled_circuit.all_qubits())
         # Sort just to make it deterministic.
@@ -262,7 +262,7 @@ def compile_circuit(
         # Github issue: https://github.com/quantumlib/Cirq/issues/2967
         routing_algo_name = 'greedy'
 
-    swap_networks: List[ccr.SwapNetwork] = []
+    swap_networks: list[ccr.SwapNetwork] = []
     for _ in range(routing_attempts):
         swap_network = ccr.route_circuit(
             compiled_circuit, device_graph, router=router, algo_name=routing_algo_name
@@ -313,7 +313,7 @@ class QuantumVolumeResult:
     # The model circuit used.
     model_circuit: cirq.Circuit
     # The heavy set computed from the above model circuit.
-    heavy_set: List[int]
+    heavy_set: list[int]
     # The model circuit after being compiled.
     compiled_circuit: cirq.Circuit
     # The percentage of outputs that this sampler had that were in the heavy
@@ -332,7 +332,7 @@ def prepare_circuits(
     depth: int,
     num_circuits: int,
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-) -> List[Tuple[cirq.Circuit, List[int]]]:
+) -> list[tuple[cirq.Circuit, list[int]]]:
     """Generates circuits and computes their heavy set.
 
     Args:
@@ -358,13 +358,13 @@ def prepare_circuits(
 def execute_circuits(
     *,
     device_graph: nx.Graph,
-    samplers: List[cirq.Sampler],
-    circuits: List[Tuple[cirq.Circuit, List[int]]],
+    samplers: list[cirq.Sampler],
+    circuits: list[tuple[cirq.Circuit, list[int]]],
     routing_attempts: int,
-    compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None,
+    compiler: Callable[[cirq.Circuit], cirq.Circuit] | None = None,
     repetitions: int = 10_000,
     add_readout_error_correction=False,
-) -> List[QuantumVolumeResult]:
+) -> list[QuantumVolumeResult]:
     """Executes the given circuits on the given samplers.
 
     Args
@@ -385,7 +385,7 @@ def execute_circuits(
     """
     # First, compile all of the model circuits.
     print("Compiling model circuits")
-    compiled_circuits: List[CompilationResult] = []
+    compiled_circuits: list[CompilationResult] = []
     for idx, (model_circuit, heavy_set) in enumerate(circuits):
         print(f"  Compiling model circuit #{idx + 1}")
         compiled_circuits.append(
@@ -426,13 +426,13 @@ def calculate_quantum_volume(
     depth: int,
     num_circuits: int,
     device_graph: nx.Graph,
-    samplers: List[cirq.Sampler],
+    samplers: list[cirq.Sampler],
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-    compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None,
+    compiler: Callable[[cirq.Circuit], cirq.Circuit] | None = None,
     repetitions=10_000,
     routing_attempts=30,
     add_readout_error_correction=False,
-) -> List[QuantumVolumeResult]:
+) -> list[QuantumVolumeResult]:
     """Run the quantum volume algorithm.
 
     This algorithm should compute the same values as Algorithm 1 in

cirq/contrib/quimb/density_matrix.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from functools import lru_cache
-from typing import Dict, List, Optional, Sequence, Tuple, Union
+from typing import Sequence
 
 import numpy as np
 import quimb
@@ -13,7 +13,7 @@ import cirq
 
 
 @lru_cache()
-def _qpos_tag(qubits: Union[cirq.Qid, Tuple[cirq.Qid]]):
+def _qpos_tag(qubits: cirq.Qid | tuple[cirq.Qid]):
     """Given a qubit or qubits, return a "position tag" (used for drawing).
 
     For multiple qubits, the tag is for the first qubit.
@@ -25,9 +25,7 @@ def _qpos_tag(qubits: Union[cirq.Qid, Tuple[cirq.Qid]]):
 
 
 @lru_cache()
-def _qpos_y(
-    qubits: Union[cirq.Qid, Tuple[cirq.Qid, ...]], all_qubits: Tuple[cirq.Qid, ...]
-) -> float:
+def _qpos_y(qubits: cirq.Qid | tuple[cirq.Qid, ...], all_qubits: tuple[cirq.Qid, ...]) -> float:
     """Given a qubit or qubits, return the position y value (used for drawing).
 
     For multiple qubits, the position is the mean of the qubit indices.
@@ -47,11 +45,11 @@ def _qpos_y(
 
 
 def _add_to_positions(
-    positions: Dict[Tuple[str, str], Tuple[float, float]],
+    positions: dict[tuple[str, str], tuple[float, float]],
     mi: int,
-    qubits: Union[cirq.Qid, Tuple[cirq.Qid]],
+    qubits: cirq.Qid | tuple[cirq.Qid],
     *,
-    all_qubits: Tuple[cirq.Qid, ...],
+    all_qubits: tuple[cirq.Qid, ...],
     x_scale,
     y_scale,
     x_nudge,
@@ -79,8 +77,8 @@ def _add_to_positions(
 
 
 def circuit_to_density_matrix_tensors(
-    circuit: cirq.Circuit, qubits: Optional[Sequence[cirq.Qid]] = None
-) -> Tuple[List[qtn.Tensor], Dict[cirq.Qid, int], Dict[Tuple[str, str], Tuple[float, float]]]:
+    circuit: cirq.Circuit, qubits: Sequence[cirq.Qid] | None = None
+) -> tuple[list[qtn.Tensor], dict[cirq.Qid, int], dict[tuple[str, str], tuple[float, float]]]:
     """Given a circuit with mixtures or channels, construct a tensor network
     representation of the density matrix.
 
@@ -112,10 +110,10 @@ def circuit_to_density_matrix_tensors(
         qubits = sorted(circuit.all_qubits())  # pragma: no cover
     qubits = tuple(qubits)
 
-    qubit_frontier: Dict[cirq.Qid, int] = {q: 0 for q in qubits}
+    qubit_frontier: dict[cirq.Qid, int] = {q: 0 for q in qubits}
     kraus_frontier = 0
-    positions: Dict[Tuple[str, str], Tuple[float, float]] = {}
-    tensors: List[qtn.Tensor] = []
+    positions: dict[tuple[str, str], tuple[float, float]] = {}
+    tensors: list[qtn.Tensor] = []
 
     x_scale = 2
     y_scale = 3
@@ -199,7 +197,7 @@ def circuit_to_density_matrix_tensors(
 
 
 def tensor_density_matrix(
-    circuit: cirq.Circuit, qubits: Optional[List[cirq.Qid]] = None
+    circuit: cirq.Circuit, qubits: list[cirq.Qid] | None = None
 ) -> np.ndarray:
     """Given a circuit with mixtures or channels, contract a tensor network
     representing the resultant density matrix.