cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/contrib/qasm_import/exception.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 
 class QasmException(Exception):
     def __init__(self, message: str) -> None:

cirq/contrib/qasm_import/qasm.py

@@ -12,11 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cirq import circuits
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from cirq.contrib.qasm_import._parser import QasmParser
 
+if TYPE_CHECKING:
+    import cirq
+
 
-def circuit_from_qasm(qasm: str) -> circuits.Circuit:
+def circuit_from_qasm(qasm: str) -> cirq.Circuit:
     """Parses an OpenQASM string to `cirq.Circuit`.
 
     Args:

cirq/contrib/qasm_import/qasm_test.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 numpy as np
 
 import cirq
@@ -19,7 +22,7 @@ from cirq.contrib.qasm_import import circuit_from_qasm
 from cirq.testing import consistent_qasm as cq
 
 
-def test_consistency_with_qasm_output_and_qiskit():
+def test_consistency_with_qasm_output_and_qiskit() -> None:
     qubits = [cirq.NamedQubit(f'q_{i}') for i in range(4)]
     a, b, c, d = qubits
     circuit1 = cirq.Circuit(
@@ -32,9 +35,9 @@ def test_consistency_with_qasm_output_and_qiskit():
         cirq.H.on(d),
         cirq.S.on(a),
         cirq.T.on(b),
-        cirq.S.on(c) ** -1,
-        cirq.T.on(d) ** -1,
-        cirq.X.on(d) ** 0.125,
+        (cirq.S**-1).on(c),
+        (cirq.T**-1).on(d),
+        (cirq.X**0.125).on(d),
         cirq.TOFFOLI.on(a, b, c),
         cirq.CSWAP.on(d, a, b),
         cirq.SWAP.on(c, d),

cirq/contrib/qcircuit/qcircuit_diagram_info.py

@@ -12,12 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, Tuple
+from __future__ import annotations
 
 from cirq import ops, protocols
 
 
-def escape_text_for_latex(text):
+def escape_text_for_latex(text: str) -> str:
     escaped = (
         text.replace('\\', r'\textbackslash{}')
         .replace('{', r'\{')
@@ -33,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
 
@@ -45,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 = (
@@ -76,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/qcircuit/qcircuit_diagram_info_test.py

@@ -12,11 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 import cirq.contrib.qcircuit as ccq
 
 
-def test_get_qcircuit_diagram_info():
+def test_get_qcircuit_diagram_info() -> None:
+    qubit_map: dict[cirq.LabelEntity, int]
     qubits = cirq.NamedQubit('x'), cirq.NamedQubit('y')
 
     gate = cirq.SwapPowGate(exponent=0.5)

cirq/contrib/qcircuit/qcircuit_pdf.py

@@ -12,24 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 import errno
 import os
+from typing import TYPE_CHECKING
 
 from pylatex import Document, NoEscape, Package
 
-from cirq import circuits
 from cirq.contrib.qcircuit.qcircuit_diagram import circuit_to_latex_using_qcircuit
 
+if TYPE_CHECKING:
+    import cirq
+
 
 def circuit_to_pdf_using_qcircuit_via_tex(
-    circuit: circuits.Circuit,
+    circuit: cirq.Circuit,
     filepath: str,
     pdf_kwargs=None,
     qcircuit_kwargs=None,
     clean_ext=('dvi', 'ps'),
     documentclass='article',
-):
+) -> None:
     """Compiles the QCircuit-based latex diagram of the given circuit.
 
     Args:

cirq/contrib/qcircuit/qcircuit_pdf_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from unittest import mock
 
 import pylatex
@@ -21,7 +23,7 @@ import cirq.contrib.qcircuit.qcircuit_pdf as qcircuit_pdf
 
 
 @mock.patch.object(pylatex.Document, "generate_pdf")
-def test_qcircuit_pdf(mock_generate_pdf):
+def test_qcircuit_pdf(mock_generate_pdf) -> None:
     circuit = cirq.Circuit(cirq.X(cirq.q(0)), cirq.CZ(cirq.q(0), cirq.q(1)))
     qcircuit_pdf.circuit_to_pdf_using_qcircuit_via_tex(circuit, "/tmp/test_file")
     mock_generate_pdf.assert_called_once_with(

cirq/contrib/qcircuit/qcircuit_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 import cirq.contrib.qcircuit as ccq
 import cirq.testing as ct
@@ -43,7 +45,7 @@ def assert_has_qcircuit_diagram(actual: cirq.Circuit, desired: str, **kwargs) ->
     )
 
 
-def test_fallback_diagram():
+def test_fallback_diagram() -> None:
     class MagicGate(cirq.testing.ThreeQubitGate):
         def __str__(self):
             return 'MagicGate'
@@ -77,7 +79,7 @@ def test_fallback_diagram():
     assert_has_qcircuit_diagram(circuit, expected_diagram)
 
 
-def test_teleportation_diagram():
+def test_teleportation_diagram() -> None:
     ali = cirq.NamedQubit('alice')
     car = cirq.NamedQubit('carrier')
     bob = cirq.NamedQubit('bob')
@@ -100,13 +102,13 @@ def test_teleportation_diagram():
  &\lstick{\text{carrier}}& \qw&\gate{\text{H}}       \qw&\control \qw    &\targ    \qw\qwx&\meter          \qw&\control \qw    &         \qw\qwx&\qw\\
  &\lstick{\text{bob}}&     \qw&                      \qw&\targ    \qw\qwx&         \qw    &                \qw&\targ    \qw\qwx&\control \qw\qwx&\qw\\
  \\
-}""".strip()
+}""".strip()  # noqa: E501
     assert_has_qcircuit_diagram(
         circuit, expected_diagram, qubit_order=cirq.QubitOrder.explicit([ali, car, bob])
     )
 
 
-def test_other_diagram():
+def test_other_diagram() -> None:
     a, b, c = cirq.LineQubit.range(3)
 
     circuit = cirq.Circuit(cirq.X(a), cirq.Y(b), cirq.Z(c))
@@ -122,7 +124,7 @@ def test_other_diagram():
     assert_has_qcircuit_diagram(circuit, expected_diagram)
 
 
-def test_qcircuit_qubit_namer():
+def test_qcircuit_qubit_namer() -> None:
     from cirq.contrib.qcircuit import qcircuit_diagram
 
     assert qcircuit_diagram.qcircuit_qubit_namer(cirq.NamedQubit('q')) == r'\lstick{\text{q}}&'
@@ -137,7 +139,7 @@ def test_qcircuit_qubit_namer():
     )
 
 
-def test_two_cx_diagram():
+def test_two_cx_diagram() -> None:
     # test for no moment indication
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     circuit = cirq.Circuit(cirq.CX(q0, q2), cirq.CX(q1, q3), cirq.CX(q0, q2), cirq.CX(q1, q3))
@@ -149,11 +151,11 @@ def test_two_cx_diagram():
  &\lstick{\text{q(2)}}& \qw&\targ    \qw\qwx&         \qw\qwx&\targ    \qw\qwx&         \qw\qwx&\qw\\
  &\lstick{\text{q(3)}}& \qw&         \qw    &\targ    \qw\qwx&         \qw    &\targ    \qw\qwx&\qw\\
  \\
-}""".strip()
+}""".strip()  # noqa: E501
     assert_has_qcircuit_diagram(circuit, expected_diagram)
 
 
-def test_sqrt_iswap_diagram():
+def test_sqrt_iswap_diagram() -> None:
     # test for proper rendering of ISWAP^{0.5}
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.ISWAP(q0, q1) ** 0.5)

cirq/contrib/quantum_volume/quantum_volume.py

@@ -3,16 +3,20 @@
 https://arxiv.org/abs/1811.12926.
 """
 
+from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Optional, Set, Tuple
+from typing import Callable, TYPE_CHECKING
 
-import networkx as nx
 import numpy as np
-import pandas as pd
 
 import cirq
 import cirq.contrib.routing as ccr
 
+if TYPE_CHECKING:
+    import networkx as nx
+    import pandas as pd
+
 
 def generate_model_circuit(
     num_qubits: int, depth: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
@@ -60,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
@@ -92,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(),
@@ -123,7 +127,7 @@ def sample_heavy_set(
     # Add measure gates to the end of (a copy of) the circuit. Ensure that those
     # gates measure those in the given mapping, preserving this order.
     qubits = circuit.all_qubits()
-    key = None
+    key: Callable[[cirq.Qid], cirq.Qid] | None = None
     if mapping:
         # Add any qubits that were not explicitly mapped, so they aren't lost in
         # the sorting.
@@ -154,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
@@ -172,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]]
@@ -200,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
@@ -233,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.
@@ -258,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
@@ -309,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
@@ -328,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:
@@ -354,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
@@ -381,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(
@@ -422,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/quantum_volume/quantum_volume_test.py

@@ -1,6 +1,8 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 """Tests for the Quantum Volume utilities."""
 
+from __future__ import annotations
+
 import io
 from unittest.mock import MagicMock, Mock
 
@@ -16,7 +18,7 @@ class FakeDevice(cirq.Device):
     qubits = cirq.GridQubit.rect(5, 5)
 
 
-def test_generate_model_circuit():
+def test_generate_model_circuit() -> None:
     """Test that a model circuit is randomly generated."""
     model_circuit = cirq.contrib.quantum_volume.generate_model_circuit(
         3, 3, random_state=np.random.RandomState(1)
@@ -27,7 +29,7 @@ def test_generate_model_circuit():
     assert list(model_circuit.findall_operations_with_gate_type(cirq.MeasurementGate)) == []
 
 
-def test_generate_model_circuit_without_seed():
+def test_generate_model_circuit_without_seed() -> None:
     """Test that a model circuit is randomly generated without a seed."""
     model_circuit = cirq.contrib.quantum_volume.generate_model_circuit(3, 3)
 
@@ -36,7 +38,7 @@ def test_generate_model_circuit_without_seed():
     assert list(model_circuit.findall_operations_with_gate_type(cirq.MeasurementGate)) == []
 
 
-def test_generate_model_circuit_seed():
+def test_generate_model_circuit_seed() -> None:
     """Test that a model circuit is determined by its seed ."""
     model_circuit_1 = cirq.contrib.quantum_volume.generate_model_circuit(
         3, 3, random_state=np.random.RandomState(1)
@@ -52,7 +54,7 @@ def test_generate_model_circuit_seed():
     assert model_circuit_2 != model_circuit_3
 
 
-def test_compute_heavy_set():
+def test_compute_heavy_set() -> None:
     """Test that the heavy set can be computed from a given circuit."""
     a, b, c = cirq.LineQubit.range(3)
     model_circuit = cirq.Circuit(
@@ -67,7 +69,7 @@ def test_compute_heavy_set():
     assert cirq.contrib.quantum_volume.compute_heavy_set(model_circuit) == [5, 7]
 
 
-def test_sample_heavy_set():
+def test_sample_heavy_set() -> None:
     """Test that we correctly sample a circuit's heavy set"""
 
     sampler = Mock(spec=cirq.Simulator)
@@ -87,7 +89,7 @@ def test_sample_heavy_set():
     assert probability == 0.75
 
 
-def test_sample_heavy_set_with_parity():
+def test_sample_heavy_set_with_parity() -> None:
     """Test that we correctly sample a circuit's heavy set with a parity map"""
 
     sampler = Mock(spec=cirq.Simulator)
@@ -120,7 +122,7 @@ def test_sample_heavy_set_with_parity():
     assert probability == 0.5
 
 
-def test_compile_circuit_router():
+def test_compile_circuit_router() -> None:
     """Tests that the given router is used."""
     router_mock = MagicMock()
     cirq.contrib.quantum_volume.compile_circuit(
@@ -132,7 +134,7 @@ def test_compile_circuit_router():
     router_mock.assert_called()
 
 
-def test_compile_circuit():
+def test_compile_circuit() -> None:
     """Tests that we are able to compile a model circuit."""
     compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
     a, b, c = cirq.LineQubit.range(3)
@@ -152,7 +154,7 @@ def test_compile_circuit():
     compiler_mock.assert_called_with(compilation_result.circuit)
 
 
-def test_compile_circuit_replaces_swaps():
+def test_compile_circuit_replaces_swaps() -> None:
     """Tests that the compiler never sees the SwapPermutationGates from the
     router."""
     compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
@@ -193,7 +195,7 @@ def test_compile_circuit_replaces_swaps():
     )
 
 
-def test_compile_circuit_with_readout_correction():
+def test_compile_circuit_with_readout_correction() -> None:
     """Tests that we are able to compile a model circuit with readout error
     correction."""
     compiler_mock = MagicMock(side_effect=lambda circuit: circuit)
@@ -220,9 +222,10 @@ def test_compile_circuit_with_readout_correction():
     )
 
 
-def test_compile_circuit_multiple_routing_attempts():
+def test_compile_circuit_multiple_routing_attempts() -> None:
     """Tests that we make multiple attempts at routing and keep the best one."""
     qubits = cirq.LineQubit.range(3)
+    initial_mapping: dict[cirq.Qid, cirq.Qid]
     initial_mapping = dict(zip(qubits, qubits))
     more_operations = cirq.Circuit([cirq.X.on_each(qubits), cirq.Y.on_each(qubits)])
     more_qubits = cirq.Circuit([cirq.X.on_each(cirq.LineQubit.range(4))])
@@ -250,7 +253,7 @@ def test_compile_circuit_multiple_routing_attempts():
     compiler_mock.assert_called_with(well_routed)
 
 
-def test_compile_circuit_no_routing_attempts():
+def test_compile_circuit_no_routing_attempts() -> None:
     """Tests that setting no routing attempts throws an error."""
     a, b, c = cirq.LineQubit.range(3)
     model_circuit = cirq.Circuit([cirq.Moment([cirq.X(a), cirq.Y(b), cirq.Z(c)])])
@@ -264,7 +267,7 @@ def test_compile_circuit_no_routing_attempts():
     assert e.match('Unable to get routing for circuit')
 
 
-def test_calculate_quantum_volume_result():
+def test_calculate_quantum_volume_result() -> None:
     """Test that running the main loop returns the desired result"""
     results = cirq.contrib.quantum_volume.calculate_quantum_volume(
         num_qubits=3,
@@ -285,7 +288,7 @@ def test_calculate_quantum_volume_result():
     cirq.to_json(results, buffer)
 
 
-def test_calculate_quantum_volume_result_with_device_graph():
+def test_calculate_quantum_volume_result_with_device_graph() -> None:
     """Test that running the main loop routes the circuit onto the given device
     graph"""
     device_qubits = [cirq.GridQubit(i, j) for i in range(2) for j in range(3)]
@@ -306,7 +309,7 @@ def test_calculate_quantum_volume_result_with_device_graph():
     )
 
 
-def test_calculate_quantum_volume_loop():
+def test_calculate_quantum_volume_loop() -> None:
     """Test that calculate_quantum_volume is able to run without erring."""
     # Keep test from taking a long time by lowering circuits and routing
     # attempts.
@@ -321,7 +324,7 @@ def test_calculate_quantum_volume_loop():
     )
 
 
-def test_calculate_quantum_volume_loop_with_readout_correction():
+def test_calculate_quantum_volume_loop_with_readout_correction() -> None:
     """Test that calculate_quantum_volume is able to run without erring with
     readout error correction."""
     # Keep test from taking a long time by lowering circuits and routing

cirq/contrib/quimb/density_matrix.py

@@ -1,6 +1,9 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+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
@@ -10,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.
@@ -22,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.
@@ -44,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,
@@ -76,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.
 
@@ -109,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
@@ -196,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: Sequence[cirq.Qid] | None = None
 ) -> np.ndarray:
     """Given a circuit with mixtures or channels, contract a tensor network
     representing the resultant density matrix.