cirq-core 1.6.0.dev20250702012506__py3-none-any.whl → 1.6.0.dev20250702211226__py3-none-any.whl

cirq/contrib/custom_simulators/custom_state_simulator_test.py

@@ -30,7 +30,9 @@ class ComputationalBasisState(cirq.qis.QuantumStateRepresentation):
     def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisState:
         return ComputationalBasisState(self.basis)  # pragma: no cover
 
-    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
+    def measure(
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         return [self.basis[i] for i in axes]
 
 
@@ -49,7 +51,7 @@ class ComputationalBasisSimState(cirq.SimulationState[ComputationalBasisState]):
             return True
 
 
-def create_test_circuit():
+def create_test_circuit() -> cirq.Circuit:
     q0, q1 = cirq.LineQid.range(2, dimension=3)
     x = cirq.XPowGate(dimension=3)
     return cirq.Circuit(
@@ -143,7 +145,9 @@ class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
     def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisProductState:
         return ComputationalBasisProductState(self.basis)
 
-    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
+    def measure(
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         return [self.basis[i] for i in axes]
 
     def kron(self, other: ComputationalBasisProductState) -> ComputationalBasisProductState:

cirq/contrib/graph_device/graph_device.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import abc
 import itertools
-from typing import cast, Iterable, TYPE_CHECKING
+from typing import Any, cast, Hashable, Iterable, NoReturn, TYPE_CHECKING
 
 from cirq import devices, ops, value
 from cirq.contrib.graph_device.hypergraph import UndirectedHypergraph
@@ -98,7 +98,7 @@ def is_crosstalk_graph(graph: UndirectedHypergraph) -> bool:
     return True
 
 
-def raise_crosstalk_error(*ops: ops.Operation):
+def raise_crosstalk_error(*ops: ops.Operation) -> NoReturn:
     raise ValueError(f'crosstalk on {ops}')
 
 
@@ -156,11 +156,11 @@ class UndirectedGraphDevice(devices.Device):
         return cast(tuple['cirq.Qid', ...], tuple(sorted(self.device_graph.vertices)))
 
     @property
-    def edges(self):
+    def edges(self) -> tuple[frozenset[Hashable], ...]:
         return tuple(sorted(self.device_graph.edges))
 
     @property
-    def labelled_edges(self):
+    def labelled_edges(self) -> dict[frozenset, Any]:
         return self.device_graph.labelled_edges
 
     def get_device_edge_from_op(self, operation: ops.Operation) -> UndirectedGraphDeviceEdge:
@@ -185,6 +185,7 @@ class UndirectedGraphDevice(devices.Device):
             self.crosstalk_graph._adjacency_lists.get(frozenset(operation.qubits), ())
         )
         for crosstalk_edge in adjacent_crosstalk_edges:
+            # pylint: disable=unreachable
             label = self.crosstalk_graph.labelled_edges[crosstalk_edge]
             validator = (
                 raise_crosstalk_error(operation, *other_operations) if (label is None) else label
@@ -194,7 +195,7 @@ class UndirectedGraphDevice(devices.Device):
             ):
                 validator(operation, *crosstalk_operations)
 
-    def validate_moment(self, moment: cirq.Moment):
+    def validate_moment(self, moment: cirq.Moment) -> None:
         super().validate_moment(moment)
         ops = moment.operations
         for i, op in enumerate(ops):

cirq/contrib/graph_device/graph_device_test.py

@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+from typing import Any, Hashable, Iterable
+
 import pytest
 
 import cirq
@@ -21,7 +23,7 @@ import cirq.contrib.graph_device as ccgd
 import cirq.contrib.graph_device.graph_device as ccgdgd
 
 
-def test_fixed_duration_undirected_graph_device_edge_eq():
+def test_fixed_duration_undirected_graph_device_edge_eq() -> None:
     e = ccgd.FixedDurationUndirectedGraphDeviceEdge(cirq.Duration(picos=4))
     f = ccgd.FixedDurationUndirectedGraphDeviceEdge(cirq.Duration(picos=4))
     g = ccgd.FixedDurationUndirectedGraphDeviceEdge(cirq.Duration(picos=5))
@@ -30,15 +32,15 @@ def test_fixed_duration_undirected_graph_device_edge_eq():
     assert e != 4
 
 
-def test_unconstrained_undirected_graph_device_edge_eq():
+def test_unconstrained_undirected_graph_device_edge_eq() -> None:
     e = ccgdgd._UnconstrainedUndirectedGraphDeviceEdge()
     f = ccgd.UnconstrainedUndirectedGraphDeviceEdge
     assert e == f
     assert e != 3
 
 
-def test_is_undirected_device_graph():
-    assert not ccgd.is_undirected_device_graph('abc')
+def test_is_undirected_device_graph() -> None:
+    assert not ccgd.is_undirected_device_graph('abc')  # type: ignore[arg-type]
     graph = ccgd.UndirectedHypergraph()
     assert ccgd.is_undirected_device_graph(graph)
     a, b, c, d, e = cirq.LineQubit.range(5)
@@ -52,9 +54,9 @@ def test_is_undirected_device_graph():
     assert not ccgd.is_undirected_device_graph(graph)
 
 
-def test_is_crosstalk_graph():
+def test_is_crosstalk_graph() -> None:
     a, b, c, d, e, f = cirq.LineQubit.range(6)
-    assert not ccgd.is_crosstalk_graph('abc')
+    assert not ccgd.is_crosstalk_graph('abc')  # type: ignore[arg-type]
     graph = ccgd.UndirectedHypergraph()
     graph.add_vertex('abc')
     assert not ccgd.is_crosstalk_graph(graph)
@@ -76,14 +78,14 @@ def test_is_crosstalk_graph():
     assert not ccgd.is_crosstalk_graph(graph)
 
 
-def test_unconstrained_undirected_graph_device_edge():
+def test_unconstrained_undirected_graph_device_edge() -> None:
     edge = ccgd.UnconstrainedUndirectedGraphDeviceEdge
     qubits = cirq.LineQubit.range(2)
     assert edge.duration_of(cirq.X(qubits[0])) == cirq.Duration(picos=0)
     assert edge.duration_of(cirq.CZ(*qubits[:2])) == cirq.Duration(picos=0)
 
 
-def test_graph_device():
+def test_graph_device() -> None:
     one_qubit_duration = cirq.Duration(picos=10)
     two_qubit_duration = cirq.Duration(picos=1)
     one_qubit_edge = ccgd.FixedDurationUndirectedGraphDeviceEdge(one_qubit_duration)
@@ -95,7 +97,7 @@ def test_graph_device():
 
     n_qubits = 4
     qubits = cirq.LineQubit.range(n_qubits)
-    edges = {
+    edges: dict[Iterable[Hashable], Any] = {
         (cirq.LineQubit(i), cirq.LineQubit((i + 1) % n_qubits)): two_qubit_edge
         for i in range(n_qubits)
     }
@@ -111,8 +113,8 @@ def test_graph_device():
 
     assert ccgd.is_undirected_device_graph(device_graph)
     with pytest.raises(TypeError):
-        ccgd.UndirectedGraphDevice('abc')
-    constraint_edges = {
+        ccgd.UndirectedGraphDevice('abc')  # type: ignore[arg-type]
+    constraint_edges: dict[Iterable[Hashable], Any] = {
         (frozenset(cirq.LineQubit.range(2)), frozenset(cirq.LineQubit.range(2, 4))): None,
         (
             frozenset(cirq.LineQubit.range(1, 3)),
@@ -123,7 +125,7 @@ def test_graph_device():
     assert ccgd.is_crosstalk_graph(crosstalk_graph)
 
     with pytest.raises(TypeError):
-        ccgd.UndirectedGraphDevice(device_graph, crosstalk_graph='abc')
+        ccgd.UndirectedGraphDevice(device_graph, crosstalk_graph='abc')  # type: ignore[arg-type]
 
     graph_device = ccgd.UndirectedGraphDevice(device_graph)
     assert graph_device.crosstalk_graph == ccgd.UndirectedHypergraph()
@@ -141,7 +143,7 @@ def test_graph_device():
     with pytest.raises(ValueError):
         graph_device.validate_operation(cirq.CNOT(qubits[0], qubits[2]))
     with pytest.raises(AttributeError):
-        graph_device.validate_operation(list((2, 3)))
+        graph_device.validate_operation(list((2, 3)))  # type: ignore[arg-type]
 
     moment = cirq.Moment([cirq.CNOT(*qubits[:2]), cirq.CNOT(*qubits[2:])])
     with pytest.raises(ValueError):
@@ -155,7 +157,7 @@ def test_graph_device():
         graph_device.validate_moment(moment)
 
 
-def test_graph_device_copy_and_add():
+def test_graph_device_copy_and_add() -> None:
     a, b, c, d, e, f = cirq.LineQubit.range(6)
     device_graph = ccgd.UndirectedHypergraph(labelled_edges={(a, b): None, (c, d): None})
     crosstalk_graph = ccgd.UndirectedHypergraph(

cirq/contrib/graph_device/hypergraph.py

@@ -71,7 +71,7 @@ class UndirectedHypergraph:
                 self._adjacency_lists[neighbor].difference_update((edge,))
         del self._adjacency_lists[vertex]
 
-    def remove_vertices(self, vertices):
+    def remove_vertices(self, vertices) -> None:
         for vertex in vertices:
             self.remove_vertex(vertex)
 
@@ -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]) -> None:
         for vertices, label in edges.items():
             self.add_edge(vertices, label)
 

cirq/contrib/graph_device/hypergraph_test.py

@@ -21,7 +21,7 @@ import pytest
 import cirq.contrib.graph_device as ccgd
 
 
-def test_update_edge_label():
+def test_update_edge_label() -> None:
     edge = frozenset(range(3))
     graph = ccgd.UndirectedHypergraph(labelled_edges={edge: 'a'})
     assert graph.labelled_edges[edge] == 'a'
@@ -29,7 +29,7 @@ def test_update_edge_label():
     assert graph.labelled_edges[edge] == 'b'
 
 
-def test_hypergraph():
+def test_hypergraph() -> None:
     vertices = range(4)
     graph = ccgd.UndirectedHypergraph(vertices=vertices)
     assert graph.vertices == tuple(vertices)
@@ -55,7 +55,7 @@ def test_hypergraph():
         for _ in range(10)
     ],
 )
-def test_eq(vertices, edges):
+def test_eq(vertices, edges) -> None:
     vertices = set(vertices).union(*edges)
     graph_initialized = ccgd.UndirectedHypergraph(vertices=vertices, labelled_edges=edges)
     graph_added_parallel = ccgd.UndirectedHypergraph()
@@ -69,15 +69,15 @@ def test_eq(vertices, edges):
     assert graph_initialized == graph_added_parallel == graph_added_sequential
 
 
-def test_random_hypergraph():
+def test_random_hypergraph() -> None:
     n_vertices = 4
     graph = ccgd.UndirectedHypergraph.random(n_vertices, {1: 1.0})
-    assert sorted(graph.vertices) == sorted(range(n_vertices))
+    assert sorted(graph.vertices) == sorted(range(n_vertices))  # type: ignore[type-var]
     assert set(graph.labelled_edges.values()) == set((None,))
     assert tuple(len(edge) for edge in graph.edges) == (1,) * n_vertices
 
 
-def test_copy():
+def test_copy() -> None:
     graph_original = ccgd.UndirectedHypergraph(labelled_edges={(0, 1): None})
     graph_copy = graph_original.__copy__()
     assert graph_copy == graph_original
@@ -85,20 +85,20 @@ def test_copy():
     assert graph_copy != graph_original
 
 
-def test_iadd():
+def test_iadd() -> None:
     graph = ccgd.UndirectedHypergraph(labelled_edges={(0, 1): None})
     addend = ccgd.UndirectedHypergraph(labelled_edges={(1, 2): None})
     graph += addend
     assert set(graph.edges) == set(frozenset(e) for e in ((0, 1), (1, 2)))
-    assert sorted(graph.vertices) == [0, 1, 2]
+    assert sorted(graph.vertices) == [0, 1, 2]  # type: ignore[type-var]
 
 
-def test_add():
+def test_add() -> None:
     first_addend = ccgd.UndirectedHypergraph(labelled_edges={('a', 'b'): None})
     second_addend = ccgd.UndirectedHypergraph(labelled_edges={('c', 'b'): None})
     graph_sum = first_addend + second_addend
-    assert sorted(first_addend.vertices) == list('ab')
-    assert sorted(second_addend.vertices) == list('bc')
+    assert sorted(first_addend.vertices) == list('ab')  # type: ignore[type-var]
+    assert sorted(second_addend.vertices) == list('bc')  # type: ignore[type-var]
     assert sorted(graph_sum.vertices) == list('abc')
     assert sorted(first_addend.edges) == [frozenset('ab')]
     assert sorted(second_addend.edges) == [frozenset('bc')]

cirq/contrib/graph_device/uniform_graph_device_test.py

@@ -14,21 +14,27 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 import pytest
 
 import cirq
 import cirq.contrib.graph_device as ccgd
 
+if TYPE_CHECKING:
+    from cirq.contrib.graph_device.graph_device import UndirectedGraphDeviceEdge
+
 
-def test_empty_uniform_undirected_linear_device():
+def test_empty_uniform_undirected_linear_device() -> None:
     n_qubits = 4
+    edge_labels: dict[int, UndirectedGraphDeviceEdge | None]
     edge_labels = {}
     device = ccgd.uniform_undirected_linear_device(n_qubits, edge_labels)
     assert device.qubits == tuple()
     assert device.edges == tuple()
 
 
-def test_negative_arity_arg_uniform_undirected_linear_device():
+def test_negative_arity_arg_uniform_undirected_linear_device() -> None:
     with pytest.raises(ValueError):
         ccgd.uniform_undirected_linear_device(5, {-1: None})
     with pytest.raises(ValueError):
@@ -36,7 +42,7 @@ def test_negative_arity_arg_uniform_undirected_linear_device():
 
 
 @pytest.mark.parametrize('arity', range(1, 5))
-def test_regular_uniform_undirected_linear_device(arity):
+def test_regular_uniform_undirected_linear_device(arity) -> None:
     n_qubits = 10
     edge_labels = {arity: None}
     device = ccgd.uniform_undirected_linear_device(n_qubits, edge_labels)

cirq/contrib/hacks/disable_validation.py

@@ -17,10 +17,13 @@
 from __future__ import annotations
 
 import contextlib
+from collections.abc import Generator
 
 
 @contextlib.contextmanager
-def disable_op_validation(*, accept_debug_responsibility: bool = False):
+def disable_op_validation(
+    *, accept_debug_responsibility: bool = False
+) -> Generator[None, None, None]:
     if not accept_debug_responsibility:
         raise ValueError(
             "WARNING! Using disable_op_validation with invalid ops can cause "

cirq/contrib/json.py

@@ -3,10 +3,10 @@
 
 from __future__ import annotations
 
-from cirq.protocols.json_serialization import DEFAULT_RESOLVERS
+from cirq.protocols.json_serialization import DEFAULT_RESOLVERS, ObjectFactory
 
 
-def contrib_class_resolver(cirq_type: str):
+def contrib_class_resolver(cirq_type: str) -> ObjectFactory | None:
     """Extend cirq's JSON API with resolvers for cirq contrib classes."""
     from cirq.contrib.acquaintance import SwapPermutationGate
     from cirq.contrib.bayesian_network import BayesianNetworkGate

cirq/contrib/noise_models/noise_models.py

@@ -42,7 +42,7 @@ class DepolarizingNoiseModel(devices.NoiseModel):
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment) or self.is_virtual_moment(moment):  # pragma: no cover
             return moment
 
@@ -78,7 +78,7 @@ class ReadoutNoiseModel(devices.NoiseModel):
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -115,7 +115,7 @@ class DampedReadoutNoiseModel(devices.NoiseModel):
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -148,7 +148,7 @@ class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment):
             return [circuits.Moment(self.readout_noise_gate(q) for q in system_qubits), moment]
         return [moment, circuits.Moment(self.qubit_noise_gate(q) for q in system_qubits)]
@@ -178,7 +178,7 @@ class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment):
             return [
                 circuits.Moment(self.readout_decay_gate(q) for q in system_qubits),

cirq/contrib/noise_models/noise_models_test.py

@@ -25,6 +25,7 @@ def test_depol_noise() -> None:
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.X(qubits[0]), cirq.Y(qubits[1])])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[0] == moment
     for g in noisy_mom[1]:
@@ -36,6 +37,7 @@ def test_depol_noise_prepend() -> None:
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.X(qubits[0]), cirq.Y(qubits[1])])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[1] == moment
     for g in noisy_mom[0]:
@@ -99,6 +101,7 @@ def test_readout_noise_no_prepend() -> None:
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.measure(*qubits, key="meas")])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[0] == moment
     for g in noisy_mom[1]:
@@ -167,6 +170,7 @@ def test_damped_readout_noise_no_prepend() -> None:
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.measure(*qubits, key="meas")])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[0] == moment
     for g in noisy_mom[1]:

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py

@@ -286,7 +286,7 @@ def _build_many_one_qubits_empty_confusion_matrix(qubits_length: int) -> list[np
 
 
 def _process_pauli_measurement_results(
-    qubits: list[ops.Qid],
+    qubits: Sequence[ops.Qid],
     pauli_string_groups: list[list[ops.PauliString]],
     circuit_results: list[ResultDict],
     calibration_results: dict[tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult],
@@ -304,10 +304,11 @@ def _process_pauli_measurement_results(
 
     Args:
         qubits: Qubits to build confusion matrices for. In a sorted order.
-        pauli_strings: The lists of QWC Pauli string groups that are measured.
+        pauli_string_groups: The lists of QWC Pauli string groups that are measured.
         circuit_results: A list of ResultDict obtained
             from running the Pauli measurement circuits.
-        confusion_matrices: A list of confusion matrices from calibration results.
+        calibration_results: A dictionary of SingleQubitReadoutCalibrationResult
+            for tuples of qubits present in `pauli_string_groups`.
         pauli_repetitions: The number of repetitions used for Pauli string measurements.
         timestamp: The timestamp of the calibration results.
         disable_readout_mitigation: If set to True, returns no error-mitigated error
@@ -326,7 +327,7 @@ def _process_pauli_measurement_results(
 
         calibration_result = (
             calibration_results[tuple(pauli_readout_qubits)]
-            if disable_readout_mitigation is False
+            if not disable_readout_mitigation
             else None
         )
 
@@ -458,9 +459,9 @@ def measure_pauli_strings(
     qubits_list = sorted(unique_qubit_tuples)
 
     # Build the basis-change circuits for each Pauli string group
-    pauli_measurement_circuits = list[circuits.Circuit]()
+    pauli_measurement_circuits: list[circuits.Circuit] = []
     for input_circuit, pauli_string_groups in normalized_circuits_to_pauli.items():
-        qid_list = list(sorted(input_circuit.all_qubits()))
+        qid_list = sorted(input_circuit.all_qubits())
         basis_change_circuits = []
         input_circuit_unfrozen = input_circuit.unfreeze()
         for pauli_strings in pauli_string_groups:

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py

@@ -874,23 +874,20 @@ def test_group_paulis_type_mismatch() -> None:
 
 def test_process_pauli_measurement_results_raises_error_on_missing_calibration() -> None:
     """Test that the function raises an error if the calibration result is missing."""
-    qubits: list[cirq.Qid] = [q for q in cirq.LineQubit.range(5)]
+    qubits: Sequence[cirq.Qid] = cirq.LineQubit.range(5)
 
     measurement_op = cirq.measure(*qubits, key='m')
-    test_circuits = list[cirq.Circuit]()
-    for _ in range(3):
-        circuit_list = []
-
-        circuit = _create_ghz(5, qubits) + measurement_op
-        circuit_list.append(circuit)
-    test_circuits.extend(circuit_list)
+    test_circuits: list[cirq.Circuit] = [_create_ghz(5, qubits) + measurement_op for _ in range(3)]
 
     pauli_strings = [_generate_random_pauli_string(qubits, True) for _ in range(3)]
     sampler = cirq.Simulator()
 
     circuit_results = sampler.run_batch(test_circuits, repetitions=1000)
 
-    empty_calibration_result_dict = {tuple(qubits): None}
+    pauli_strings_qubits = sorted(
+        set(itertools.chain.from_iterable(ps.qubits for ps in pauli_strings))
+    )
+    empty_calibration_result_dict = {tuple(pauli_strings_qubits): None}
 
     with pytest.raises(
         ValueError,

cirq/contrib/qcircuit/qcircuit_diagram_info.py

@@ -17,7 +17,7 @@ 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'\{')

cirq/contrib/qcircuit/qcircuit_diagram_info_test.py

@@ -18,7 +18,8 @@ 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

@@ -33,7 +33,7 @@ def circuit_to_pdf_using_qcircuit_via_tex(
     qcircuit_kwargs=None,
     clean_ext=('dvi', 'ps'),
     documentclass='article',
-):
+) -> None:
     """Compiles the QCircuit-based latex diagram of the given circuit.
 
     Args: