cirq-core 1.7.0.dev20250806162852__py3-none-any.whl → 1.7.0.dev20250812001555__py3-none-any.whl

cirq/devices/superconducting_qubits_noise_properties_test.py

@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+from typing import Any, Sequence
+
 import numpy as np
 import pytest
 
@@ -37,7 +39,9 @@ DEFAULT_GATE_NS: dict[type, float] = {
 }
 
 
-def default_props(system_qubits: list[cirq.Qid], qubit_pairs: list[tuple[cirq.Qid, cirq.Qid]]):
+def default_props(
+    system_qubits: Sequence[cirq.Qid], qubit_pairs: Sequence[tuple[cirq.Qid, cirq.Qid]]
+) -> dict[str, Any]:
     return {
         'gate_times_ns': DEFAULT_GATE_NS,
         't1_ns': {q: 1e5 for q in system_qubits},
@@ -75,7 +79,7 @@ class ExampleNoiseProperties(SuperconductingQubitsNoiseProperties):
         return set()
 
 
-def test_init_validation():
+def test_init_validation() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     with pytest.raises(ValueError, match='Keys specified for T1 and Tphi are not identical.'):
         _ = ExampleNoiseProperties(
@@ -92,7 +96,7 @@ def test_init_validation():
             t1_ns={q0: 1},
             tphi_ns={q0: 1},
             readout_errors={q0: [0.1, 0.2]},
-            gate_pauli_errors={OpIdentifier(cirq.CCNOT, q0, q1, q2): 0.1},
+            gate_pauli_errors={OpIdentifier(type(cirq.CCNOT), q0, q1, q2): 0.1},
         )
 
     with pytest.raises(ValueError, match='does not appear in the symmetric or asymmetric'):
@@ -102,8 +106,8 @@ def test_init_validation():
             tphi_ns={q0: 1},
             readout_errors={q0: [0.1, 0.2]},
             gate_pauli_errors={
-                OpIdentifier(cirq.CNOT, q0, q1): 0.1,
-                OpIdentifier(cirq.CNOT, q1, q0): 0.1,
+                OpIdentifier(cirq.CNotPowGate, q0, q1): 0.1,
+                OpIdentifier(cirq.CNotPowGate, q1, q0): 0.1,
             },
         )
 
@@ -136,18 +140,19 @@ def test_init_validation():
     # All errors are ignored if validation is disabled.
     _ = ExampleNoiseProperties(
         gate_times_ns=DEFAULT_GATE_NS,
-        t1_ns={},
+        # t1_ns={},
+        t1_ns={q0: 1},
         tphi_ns={q0: 1},
         readout_errors={q0: [0.1, 0.2]},
         gate_pauli_errors={
-            OpIdentifier(cirq.CCNOT, q0, q1, q2): 0.1,
-            OpIdentifier(cirq.CNOT, q0, q1): 0.1,
+            OpIdentifier(type(cirq.CCNOT), q0, q1, q2): 0.1,
+            OpIdentifier(type(cirq.CNOT), q0, q1): 0.1,
         },
         validate=False,
     )
 
 
-def test_qubits():
+def test_qubits() -> None:
     q0 = cirq.LineQubit(0)
     props = ExampleNoiseProperties(**default_props([q0], []))
     assert props.qubits == [q0]
@@ -155,7 +160,7 @@ def test_qubits():
     assert props.qubits == [q0]
 
 
-def test_depol_memoization():
+def test_depol_memoization() -> None:
     # Verify that depolarizing error is memoized.
     q0 = cirq.LineQubit(0)
     props = ExampleNoiseProperties(**default_props([q0], []))
@@ -165,7 +170,7 @@ def test_depol_memoization():
     assert depol_error_a is depol_error_b
 
 
-def test_depol_validation():
+def test_depol_validation() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     # Create unvalidated properties with too many qubits on a Z gate.
     z_2q_props = ExampleNoiseProperties(
@@ -213,7 +218,7 @@ def test_depol_validation():
         ),
     ],
 )
-def test_single_qubit_gates(op):
+def test_single_qubit_gates(op) -> None:
     q0 = cirq.LineQubit(0)
     props = ExampleNoiseProperties(**default_props([q0], []))
     model = NoiseModelFromNoiseProperties(props)
@@ -237,10 +242,10 @@ def test_single_qubit_gates(op):
     assert np.allclose(
         thermal_choi,
         [
-            [1, 0, 0, 9.99750031e-01],
-            [0, 2.49968753e-04, 0, 0],
-            [0, 0, 0, 0],
-            [9.99750031e-01, 0, 0, 9.99750031e-01],
+            [1.0, 0.0, 0.0, 9.99750031e-01],
+            [0.0, 2.49968753e-04, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.0],
+            [9.99750031e-01, 0.0, 0.0, 9.99750031e-01],
         ],
     )
 
@@ -248,7 +253,7 @@ def test_single_qubit_gates(op):
 @pytest.mark.parametrize(
     'op', [cirq.ISWAP(*cirq.LineQubit.range(2)) ** 0.6, cirq.CZ(*cirq.LineQubit.range(2)) ** 0.3]
 )
-def test_two_qubit_gates(op):
+def test_two_qubit_gates(op) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     props = ExampleNoiseProperties(**default_props([q0, q1], [(q0, q1), (q1, q0)]))
     model = NoiseModelFromNoiseProperties(props)
@@ -268,6 +273,8 @@ def test_two_qubit_gates(op):
     assert len(noisy_circuit.moments[2].operations) == 2
     thermal_op_0 = noisy_circuit.moments[2].operation_at(q0)
     thermal_op_1 = noisy_circuit.moments[2].operation_at(q1)
+    assert thermal_op_0 is not None
+    assert thermal_op_1 is not None
     assert isinstance(thermal_op_0.gate, cirq.KrausChannel)
     assert isinstance(thermal_op_1.gate, cirq.KrausChannel)
     thermal_choi_0 = cirq.kraus_to_choi(cirq.kraus(thermal_op_0))
@@ -284,7 +291,7 @@ def test_two_qubit_gates(op):
     assert np.allclose(thermal_choi_1, expected_thermal_choi)
 
 
-def test_measure_gates():
+def test_measure_gates() -> None:
     q00, q01, q10, q11 = cirq.GridQubit.rect(2, 2)
     qubits = [q00, q01, q10, q11]
     props = ExampleNoiseProperties(
@@ -311,7 +318,7 @@ def test_measure_gates():
     # Amplitude damping before measurement
     assert len(noisy_circuit.moments[0].operations) == 4
     for q in qubits:
-        op = noisy_circuit.moments[0].operation_at(q)
+        op = noisy_circuit.moments[0].operation_at(q)  # type: ignore[assignment]
         assert isinstance(op.gate, cirq.GeneralizedAmplitudeDampingChannel), q
         assert np.isclose(op.gate.p, 0.90909090), q
         assert np.isclose(op.gate.gamma, 0.011), q
@@ -322,7 +329,7 @@ def test_measure_gates():
     assert noisy_circuit.moments[1] == circuit.moments[0]
 
 
-def test_wait_gates():
+def test_wait_gates() -> None:
     q0 = cirq.LineQubit(0)
     props = ExampleNoiseProperties(**default_props([q0], []))
     model = NoiseModelFromNoiseProperties(props)
@@ -341,9 +348,9 @@ def test_wait_gates():
     assert np.allclose(
         thermal_choi,
         [
-            [1, 0, 0, 9.990005e-01],
-            [0, 9.99500167e-04, 0, 0],
-            [0, 0, 0, 0],
-            [9.990005e-01, 0, 0, 9.990005e-01],
+            [1.0, 0.0, 0.0, 9.990005e-01],
+            [0.0, 9.99500167e-04, 0.0, 0.0],
+            [0.0, 0.0, 0.0, 0.0],
+            [9.990005e-01, 0.0, 0.0, 9.990005e-01],
         ],
     )

cirq/devices/thermal_noise_model_test.py

@@ -28,7 +28,7 @@ from cirq.devices.thermal_noise_model import (
 )
 
 
-def test_helper_method_errors():
+def test_helper_method_errors() -> None:
     with pytest.raises(ValueError, match='_left_mul only accepts square matrices'):
         _ = _left_mul(np.array([[1, 2, 3], [4, 5, 6]]))
 
@@ -49,12 +49,12 @@ def test_helper_method_errors():
         _validate_rates({q0}, {q0: np.array([[0.001, 0.01, 0.1], [0.002, 0.02, 0.2]])})
 
 
-def test_create_thermal_noise_per_qubit():
+def test_create_thermal_noise_per_qubit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
-    gate_durations = {cirq.PhasedXZGate: 25.0}
-    heat_rate_GHz = {q0: 1e-5, q1: 2e-5}
-    cool_rate_GHz = {q0: 1e-4, q1: 2e-4}
-    dephase_rate_GHz = {q0: 3e-4, q1: 4e-4}
+    gate_durations: dict[type, float] = {cirq.PhasedXZGate: 25.0}
+    heat_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-5, q1: 2e-5}
+    cool_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-4, q1: 2e-4}
+    dephase_rate_GHz: dict[cirq.Qid, float] = {q0: 3e-4, q1: 4e-4}
     model = ThermalNoiseModel(
         qubits={q0, q1},
         gate_durations_ns=gate_durations,
@@ -69,11 +69,11 @@ def test_create_thermal_noise_per_qubit():
     assert np.allclose(model.rate_matrix_GHz[q1], np.array([[0, 2e-4], [2e-5, 4e-4]]))
 
 
-def test_create_thermal_noise_mixed_type():
+def test_create_thermal_noise_mixed_type() -> None:
     q0, q1 = cirq.LineQubit.range(2)
-    gate_durations = {cirq.PhasedXZGate: 25.0}
+    gate_durations: dict[type, float] = {cirq.PhasedXZGate: 25.0}
     heat_rate_GHz = None
-    cool_rate_GHz = {q0: 1e-4, q1: 2e-4}
+    cool_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-4, q1: 2e-4}
     dephase_rate_GHz = 3e-4
     model = ThermalNoiseModel(
         qubits={q0, q1},
@@ -89,11 +89,11 @@ def test_create_thermal_noise_mixed_type():
     assert np.allclose(model.rate_matrix_GHz[q1], np.array([[0, 2e-4], [0, 3e-4]]))
 
 
-def test_incomplete_rates():
+def test_incomplete_rates() -> None:
     q0, q1 = cirq.LineQubit.range(2)
-    gate_durations = {cirq.PhasedXZGate: 25.0}
-    heat_rate_GHz = {q1: 1e-5}
-    cool_rate_GHz = {q0: 1e-4}
+    gate_durations: dict[type, float] = {cirq.PhasedXZGate: 25.0}
+    heat_rate_GHz: dict[cirq.Qid, float] = {q1: 1e-5}
+    cool_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-4}
     model = ThermalNoiseModel(
         qubits={q0, q1},
         gate_durations_ns=gate_durations,
@@ -108,12 +108,12 @@ def test_incomplete_rates():
     assert np.allclose(model.rate_matrix_GHz[q1], np.array([[0, 0], [1e-5, 0]]))
 
 
-def test_noise_from_empty_moment():
+def test_noise_from_empty_moment() -> None:
     # Verify that a moment with no duration has no noise.
     q0, q1 = cirq.LineQubit.range(2)
-    gate_durations = {}
-    heat_rate_GHz = {q1: 1e-5}
-    cool_rate_GHz = {q0: 1e-4}
+    gate_durations: dict[type, float] = {}
+    heat_rate_GHz: dict[cirq.Qid, float] = {q1: 1e-5}
+    cool_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-4}
     model = ThermalNoiseModel(
         qubits={q0, q1},
         gate_durations_ns=gate_durations,
@@ -127,12 +127,12 @@ def test_noise_from_empty_moment():
     assert model.noisy_moment(moment, system_qubits=[q0, q1]) == [moment]
 
 
-def test_noise_from_zero_duration():
+def test_noise_from_zero_duration() -> None:
     # Verify that a moment with no duration has no noise.
     q0, q1 = cirq.LineQubit.range(2)
-    gate_durations = {}
-    heat_rate_GHz = {q1: 1e-5}
-    cool_rate_GHz = {q0: 1e-4}
+    gate_durations: dict[type, float] = {}
+    heat_rate_GHz: dict[cirq.Qid, float] = {q1: 1e-5}
+    cool_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-4}
     model = ThermalNoiseModel(
         qubits={q0, q1},
         gate_durations_ns=gate_durations,
@@ -146,13 +146,13 @@ def test_noise_from_zero_duration():
     assert model.noisy_moment(moment, system_qubits=[q0, q1]) == [moment]
 
 
-def test_noise_from_virtual_gates():
+def test_noise_from_virtual_gates() -> None:
     # Verify that a moment with only virtual gates has no noise if
     # require_physical_tag is True.
     q0, q1 = cirq.LineQubit.range(2)
-    gate_durations = {cirq.ZPowGate: 25.0}
-    heat_rate_GHz = {q1: 1e-5}
-    cool_rate_GHz = {q0: 1e-4}
+    gate_durations: dict[type, float] = {cirq.ZPowGate: 25.0}
+    heat_rate_GHz: dict[cirq.Qid, float] = {q1: 1e-5}
+    cool_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-4}
     model = ThermalNoiseModel(
         qubits={q0, q1},
         gate_durations_ns=gate_durations,
@@ -170,16 +170,16 @@ def test_noise_from_virtual_gates():
         _ = model.noisy_moment(part_virtual_moment, system_qubits=[q0, q1])
 
     model.require_physical_tag = False
-    assert len(model.noisy_moment(moment, system_qubits=[q0, q1])) == 2
+    assert len(model.noisy_moment(moment, system_qubits=[q0, q1])) == 2  # type: ignore[arg-type]
 
 
-def test_noise_from_measurement():
+def test_noise_from_measurement() -> None:
     # Verify that a moment with only measurement gates has no noise if
     # skip_measurements is True.
     q0, q1 = cirq.LineQubit.range(2)
-    gate_durations = {cirq.ZPowGate: 25.0, cirq.MeasurementGate: 4000.0}
-    heat_rate_GHz = {q1: 1e-5}
-    cool_rate_GHz = {q0: 1e-4}
+    gate_durations: dict[type, float] = {cirq.ZPowGate: 25.0, cirq.MeasurementGate: 4000.0}
+    heat_rate_GHz: dict[cirq.Qid, float] = {q1: 1e-5}
+    cool_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-4}
     model = ThermalNoiseModel(
         qubits={q0, q1},
         gate_durations_ns=gate_durations,
@@ -193,13 +193,13 @@ def test_noise_from_measurement():
     assert model.noisy_moment(moment, system_qubits=[q0, q1]) == [moment]
 
     part_measure_moment = cirq.Moment(cirq.measure(q0, key='m'), cirq.Z(q1))
-    assert len(model.noisy_moment(part_measure_moment, system_qubits=[q0, q1])) == 2
+    assert len(model.noisy_moment(part_measure_moment, system_qubits=[q0, q1])) == 2  # type: ignore[arg-type]
 
     model.skip_measurements = False
-    assert len(model.noisy_moment(moment, system_qubits=[q0, q1])) == 2
+    assert len(model.noisy_moment(moment, system_qubits=[q0, q1])) == 2  # type: ignore[arg-type]
 
 
-def test_noisy_moment_one_qubit():
+def test_noisy_moment_one_qubit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     model = ThermalNoiseModel(
         qubits={q0, q1},
@@ -212,6 +212,7 @@ def test_noisy_moment_one_qubit():
     gate = cirq.PhasedXZGate(x_exponent=1, z_exponent=0.5, axis_phase_exponent=0.25)
     moment = cirq.Moment(gate.on(q0))
     noisy_moment = model.noisy_moment(moment, system_qubits=[q0, q1])
+    assert isinstance(noisy_moment, list)
     assert noisy_moment[0] == moment
     # Noise applies to both qubits, even if only one is acted upon.
     assert len(noisy_moment[1]) == 2
@@ -227,7 +228,7 @@ def test_noisy_moment_one_qubit():
     )
 
 
-def test_noisy_moment_one_qubit_prepend():
+def test_noisy_moment_one_qubit_prepend() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     model = ThermalNoiseModel(
         qubits={q0, q1},
@@ -241,6 +242,7 @@ def test_noisy_moment_one_qubit_prepend():
     gate = cirq.PhasedXZGate(x_exponent=1, z_exponent=0.5, axis_phase_exponent=0.25)
     moment = cirq.Moment(gate.on(q0))
     noisy_moment = model.noisy_moment(moment, system_qubits=[q0, q1])
+    assert isinstance(noisy_moment, list)
     # Noise applies to both qubits, even if only one is acted upon.
     assert len(noisy_moment[0]) == 2
     noisy_choi = cirq.kraus_to_choi(cirq.kraus(noisy_moment[0].operations[0]))
@@ -257,12 +259,12 @@ def test_noisy_moment_one_qubit_prepend():
     assert noisy_moment[1] == moment
 
 
-def test_noise_from_wait():
+def test_noise_from_wait() -> None:
     # Verify that wait-gate noise is duration-dependent.
     q0 = cirq.LineQubit(0)
-    gate_durations = {cirq.ZPowGate: 25.0}
-    heat_rate_GHz = {q0: 1e-5}
-    cool_rate_GHz = {q0: 1e-4}
+    gate_durations: dict[type, float] = {cirq.ZPowGate: 25.0}
+    heat_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-5}
+    cool_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-4}
     model = ThermalNoiseModel(
         qubits={q0},
         gate_durations_ns=gate_durations,
@@ -274,6 +276,7 @@ def test_noise_from_wait():
     )
     moment = cirq.Moment(cirq.wait(q0, nanos=100))
     noisy_moment = model.noisy_moment(moment, system_qubits=[q0])
+    assert isinstance(noisy_moment, list)
     assert noisy_moment[0] == moment
     assert len(noisy_moment[1]) == 1
     noisy_choi = cirq.kraus_to_choi(cirq.kraus(noisy_moment[1].operations[0]))
@@ -288,11 +291,11 @@ def test_noise_from_wait():
     )
 
 
-def test_symbolic_times_for_wait_gate():
+def test_symbolic_times_for_wait_gate() -> None:
     q0 = cirq.LineQubit(0)
-    gate_durations = {cirq.ZPowGate: 25.0}
-    heat_rate_GHz = {q0: 1e-5}
-    cool_rate_GHz = {q0: 1e-4}
+    gate_durations: dict[type, float] = {cirq.ZPowGate: 25.0}
+    heat_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-5}
+    cool_rate_GHz: dict[cirq.Qid, float] = {q0: 1e-4}
     model = ThermalNoiseModel(
         qubits={q0},
         gate_durations_ns=gate_durations,
@@ -307,7 +310,7 @@ def test_symbolic_times_for_wait_gate():
         _ = model.noisy_moment(moment, system_qubits=[q0])
 
 
-def test_noisy_moment_two_qubit():
+def test_noisy_moment_two_qubit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     model = ThermalNoiseModel(
         qubits={q0, q1},
@@ -320,6 +323,7 @@ def test_noisy_moment_two_qubit():
     gate = cirq.CZ**0.5
     moment = cirq.Moment(gate.on(q0, q1))
     noisy_moment = model.noisy_moment(moment, system_qubits=[q0, q1])
+    assert isinstance(noisy_moment, list)
     assert noisy_moment[0] == moment
     assert len(noisy_moment[1]) == 2
     noisy_choi_0 = cirq.kraus_to_choi(cirq.kraus(noisy_moment[1].operations[0]))
@@ -344,7 +348,7 @@ def test_noisy_moment_two_qubit():
     )
 
 
-def test_repr():
+def test_repr() -> None:
     q0 = cirq.LineQubit(0)
     model = ThermalNoiseModel(
         qubits={q0},

cirq/devices/unconstrained_device.py

@@ -47,5 +47,5 @@ class _UnconstrainedDevice(device.Device):
         return protocols.obj_to_dict_helper(self, [])
 
 
-UNCONSTRAINED_DEVICE: device.Device = _UnconstrainedDevice()
+UNCONSTRAINED_DEVICE = _UnconstrainedDevice()
 document(UNCONSTRAINED_DEVICE, """A device with no constraints on operations or qubits.""")

cirq/devices/unconstrained_device_test.py

@@ -17,17 +17,17 @@ from __future__ import annotations
 import cirq
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.UNCONSTRAINED_DEVICE)
 
 
-def test_infinitely_fast():
+def test_infinitely_fast() -> None:
     assert cirq.UNCONSTRAINED_DEVICE.duration_of(cirq.X(cirq.NamedQubit('a'))) == cirq.Duration(
         picos=0
     )
 
 
-def test_any_qubit_works():
+def test_any_qubit_works() -> None:
     moment = cirq.Moment([cirq.X(cirq.LineQubit(987654321))])
     cirq.UNCONSTRAINED_DEVICE.validate_moment(moment)
     cirq.UNCONSTRAINED_DEVICE.validate_circuit(cirq.Circuit(moment))

cirq/experiments/benchmarking/parallel_xeb.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 from concurrent import futures
-from typing import overload, Sequence, TYPE_CHECKING, Union
+from typing import Iterable, Mapping, overload, Sequence, TYPE_CHECKING, Union
 
 import attrs
 import networkx as nx
@@ -34,14 +34,18 @@ if TYPE_CHECKING:
 
 _TARGET_T = Union['cirq.Gate', 'cirq.Operation', 'cirq.AbstractCircuit']
 _QUBIT_PAIR_T = tuple['cirq.GridQubit', 'cirq.GridQubit']
-_CANONICAL_TARGET_T = Union['cirq.Operation', dict[_QUBIT_PAIR_T, 'cirq.Operation']]
-_PROBABILITIES_DICT_T = dict[_QUBIT_PAIR_T, list[list[np.ndarray]]]
+_CANONICAL_TARGET_T = Union['cirq.Operation', Mapping[_QUBIT_PAIR_T, 'cirq.Operation']]
+_PROBABILITIES_DICT_T = Mapping[_QUBIT_PAIR_T, list[list[np.ndarray]]]
 
 
 def _canonize_pair(pair: _QUBIT_PAIR_T) -> _QUBIT_PAIR_T:
     return min(pair), max(pair)
 
 
+def _tuple_from_ints(seq: Iterable[int]) -> tuple[int, ...]:
+    return tuple(seq)
+
+
 @attrs.frozen
 class XEBParameters:
     """A frozen dataclass that holds the parameter of an XEB experiment.
@@ -56,7 +60,9 @@ class XEBParameters:
     n_repetitions: int = 10**4
     n_combinations: int = 10
     n_circuits: int = 20
-    cycle_depths: tuple[int, ...] = attrs.field(default=(5, 25, 50, 100, 200, 300), converter=tuple)
+    cycle_depths: tuple[int, ...] = attrs.field(
+        default=(5, 25, 50, 100, 200, 300), converter=_tuple_from_ints
+    )
 
 
 @attrs.frozen
@@ -75,7 +81,7 @@ class XEBWideCircuitInfo:
     pairs: Sequence[_QUBIT_PAIR_T] = attrs.field(
         converter=lambda seq: [_canonize_pair(pair) for pair in seq]
     )
-    narrow_template_indices: tuple[int, ...] = attrs.field(converter=tuple)
+    narrow_template_indices: tuple[int, ...] = attrs.field(converter=_tuple_from_ints)
     cycle_depth: int | None = None
 
     @staticmethod
@@ -166,7 +172,7 @@ def _target_to_operation(target: _TARGET_T) -> cirq.Operation:
     return target
 
 
-def _canonize_target(target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T]) -> _CANONICAL_TARGET_T:
+def _canonize_target(target: _TARGET_T | Mapping[_QUBIT_PAIR_T, _TARGET_T]) -> _CANONICAL_TARGET_T:
     if isinstance(target, (ops.Gate, ops.Operation, circuits.AbstractCircuit)):
         return _target_to_operation(target)
     return {k: _target_to_operation(v) for k, v in target.items()}
@@ -272,10 +278,10 @@ def simulate_circuit_library(
 @overload
 def simulate_circuit_library(
     circuit_templates: Sequence[cirq.Circuit],
-    target_or_dict: dict[_QUBIT_PAIR_T, ops.Operation],
+    target_or_dict: Mapping[_QUBIT_PAIR_T, ops.Operation],
     cycle_depths: Sequence[int],
     pool: futures.Executor | None = None,
-) -> dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]: ...
+) -> Mapping[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]: ...
 
 
 def simulate_circuit_library(
@@ -283,7 +289,7 @@ def simulate_circuit_library(
     target_or_dict: _CANONICAL_TARGET_T,
     cycle_depths: Sequence[int],
     pool: futures.Executor | None = None,
-) -> Sequence[Sequence[np.ndarray]] | dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]:
+) -> Sequence[Sequence[np.ndarray]] | Mapping[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]:
     """Simulate the given sequence of circuits.
 
     Args:
@@ -407,15 +413,16 @@ def _reshape_sampling_results(
 
 def _reshape_simulation_results(
     simulation_results: (
-        Sequence[Sequence[np.ndarray]] | dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]
+        Sequence[Sequence[np.ndarray]] | Mapping[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]
     ),
     cycle_depths: Sequence[int],
     pairs: Sequence[_QUBIT_PAIR_T],
     num_templates: int,
 ) -> _PROBABILITIES_DICT_T:
+    cycle_depth_to_index: dict[int, int]
     cycle_depth_to_index = {d: i for i, d in enumerate(cycle_depths)}
 
-    if isinstance(simulation_results, dict):
+    if isinstance(simulation_results, Mapping):
         pure_probabilities = {
             pair: [[np.empty(0)] * num_templates for _ in range(len(cycle_depths))]
             for pair in pairs
@@ -463,7 +470,7 @@ def _cross_entropy(p: np.ndarray, q: np.ndarray, eps: float = 1e-60) -> float:
 def estimate_fidelities(
     sampling_results: Sequence[dict[str, np.ndarray]],
     simulation_results: (
-        Sequence[Sequence[np.ndarray]] | dict[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]
+        Sequence[Sequence[np.ndarray]] | Mapping[_QUBIT_PAIR_T, Sequence[Sequence[np.ndarray]]]
     ),
     cycle_depths: Sequence[int],
     wide_circuits_info: Sequence[XEBWideCircuitInfo],
@@ -525,7 +532,7 @@ def estimate_fidelities(
 
 def _extract_pairs(
     sampler: cirq.Sampler,
-    target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T],
+    target: _TARGET_T | Mapping[_QUBIT_PAIR_T, _TARGET_T],
     qubits: Sequence[cirq.GridQubit] | None,
     pairs: Sequence[_QUBIT_PAIR_T] | None,
 ) -> Sequence[_QUBIT_PAIR_T]:
@@ -545,8 +552,8 @@ def _extract_pairs(
 
 def parallel_xeb_workflow(
     sampler: cirq.Sampler,
-    target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T],
-    ideal_target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T] | None = None,
+    target: _TARGET_T | Mapping[_QUBIT_PAIR_T, _TARGET_T],
+    ideal_target: _TARGET_T | Mapping[_QUBIT_PAIR_T, _TARGET_T] | None = None,
     qubits: Sequence[cirq.GridQubit] | None = None,
     pairs: Sequence[_QUBIT_PAIR_T] | None = None,
     parameters: XEBParameters = XEBParameters(),
@@ -644,8 +651,8 @@ def parallel_xeb_workflow(
 
 def parallel_two_qubit_xeb(
     sampler: cirq.Sampler,
-    target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T],
-    ideal_target: _TARGET_T | dict[_QUBIT_PAIR_T, _TARGET_T] | None = None,
+    target: _TARGET_T | Mapping[_QUBIT_PAIR_T, _TARGET_T],
+    ideal_target: _TARGET_T | Mapping[_QUBIT_PAIR_T, _TARGET_T] | None = None,
     qubits: Sequence[cirq.GridQubit] | None = None,
     pairs: Sequence[_QUBIT_PAIR_T] | None = None,
     parameters: XEBParameters = XEBParameters(),