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

cirq/experiments/single_qubit_readout_calibration_test.py

@@ -22,7 +22,7 @@ import pytest
 import cirq
 
 
-def test_single_qubit_readout_result_repr():
+def test_single_qubit_readout_result_repr() -> None:
     result = cirq.experiments.SingleQubitReadoutCalibrationResult(
         zero_state_errors={cirq.LineQubit(0): 0.1},
         one_state_errors={cirq.LineQubit(0): 0.2},
@@ -61,7 +61,7 @@ class NoisySingleQubitReadoutSampler(cirq.Sampler):
         return results
 
 
-def test_estimate_single_qubit_readout_errors_no_noise():
+def test_estimate_single_qubit_readout_errors_no_noise() -> None:
     qubits = cirq.LineQubit.range(10)
     sampler = cirq.Simulator()
     repetitions = 1000
@@ -74,7 +74,7 @@ def test_estimate_single_qubit_readout_errors_no_noise():
     assert isinstance(result.timestamp, float)
 
 
-def test_estimate_single_qubit_readout_errors_with_noise():
+def test_estimate_single_qubit_readout_errors_with_noise() -> None:
     qubits = cirq.LineQubit.range(5)
     sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.2, seed=1234)
     repetitions = 1000
@@ -89,7 +89,7 @@ def test_estimate_single_qubit_readout_errors_with_noise():
     assert isinstance(result.timestamp, float)
 
 
-def test_estimate_parallel_readout_errors_no_noise():
+def test_estimate_parallel_readout_errors_no_noise() -> None:
     qubits = [cirq.GridQubit(i, 0) for i in range(10)]
     sampler = cirq.Simulator()
     repetitions = 1000
@@ -104,7 +104,7 @@ def test_estimate_parallel_readout_errors_no_noise():
     _, _ = result.plot_heatmap()
 
 
-def test_estimate_parallel_readout_errors_all_zeros():
+def test_estimate_parallel_readout_errors_all_zeros() -> None:
     qubits = cirq.LineQubit.range(10)
     sampler = cirq.ZerosSampler()
     repetitions = 1000
@@ -117,7 +117,7 @@ def test_estimate_parallel_readout_errors_all_zeros():
     assert isinstance(result.timestamp, float)
 
 
-def test_estimate_parallel_readout_errors_bad_bit_string():
+def test_estimate_parallel_readout_errors_bad_bit_string() -> None:
     qubits = cirq.LineQubit.range(4)
     with pytest.raises(ValueError, match='but was None'):
         _ = cirq.estimate_parallel_single_qubit_readout_errors(
@@ -126,7 +126,7 @@ def test_estimate_parallel_readout_errors_bad_bit_string():
             repetitions=1000,
             trials=35,
             trials_per_batch=10,
-            bit_strings=[[1] * 4],
+            bit_strings=[[1] * 4],  # type: ignore[arg-type]
         )
     with pytest.raises(ValueError, match='0 or 1'):
         _ = cirq.estimate_parallel_single_qubit_readout_errors(
@@ -138,7 +138,7 @@ def test_estimate_parallel_readout_errors_bad_bit_string():
         )
 
 
-def test_estimate_parallel_readout_errors_zero_reps():
+def test_estimate_parallel_readout_errors_zero_reps() -> None:
     qubits = cirq.LineQubit.range(10)
     with pytest.raises(ValueError, match='non-zero repetition'):
         _ = cirq.estimate_parallel_single_qubit_readout_errors(
@@ -146,7 +146,7 @@ def test_estimate_parallel_readout_errors_zero_reps():
         )
 
 
-def test_estimate_parallel_readout_errors_zero_trials():
+def test_estimate_parallel_readout_errors_zero_trials() -> None:
     qubits = cirq.LineQubit.range(10)
     with pytest.raises(ValueError, match='non-zero trials'):
         _ = cirq.estimate_parallel_single_qubit_readout_errors(
@@ -154,7 +154,7 @@ def test_estimate_parallel_readout_errors_zero_trials():
         )
 
 
-def test_estimate_parallel_readout_errors_zero_batch():
+def test_estimate_parallel_readout_errors_zero_batch() -> None:
     qubits = cirq.LineQubit.range(10)
     with pytest.raises(ValueError, match='non-zero trials_per_batch'):
         _ = cirq.estimate_parallel_single_qubit_readout_errors(
@@ -162,7 +162,7 @@ def test_estimate_parallel_readout_errors_zero_batch():
         )
 
 
-def test_estimate_parallel_readout_errors_batching():
+def test_estimate_parallel_readout_errors_batching() -> None:
     qubits = cirq.LineQubit.range(5)
     sampler = cirq.ZerosSampler()
     repetitions = 1000
@@ -175,7 +175,7 @@ def test_estimate_parallel_readout_errors_batching():
     assert isinstance(result.timestamp, float)
 
 
-def test_estimate_parallel_readout_errors_with_noise():
+def test_estimate_parallel_readout_errors_with_noise() -> None:
     qubits = cirq.LineQubit.range(5)
     sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.2, seed=1234)
     repetitions = 1000
@@ -190,7 +190,7 @@ def test_estimate_parallel_readout_errors_with_noise():
     assert isinstance(result.timestamp, float)
 
 
-def test_estimate_parallel_readout_errors_missing_qubits():
+def test_estimate_parallel_readout_errors_missing_qubits() -> None:
     qubits = cirq.LineQubit.range(4)
 
     result = cirq.estimate_parallel_single_qubit_readout_errors(

cirq/experiments/t2_decay_experiment.py

@@ -48,7 +48,7 @@ def t2_decay(
     repetitions: int = 1000,
     delay_sweep: study.Sweep | None = None,
     num_pulses: list[int] | None = None,
-) -> cirq.experiments.T2DecayResult | list[cirq.experiments.T2DecayResult]:
+) -> cirq.experiments.T2DecayResult:
     """Runs a t2 transverse relaxation experiment.
 
     Initializes a qubit into a superposition state, evolves the system using

cirq/experiments/t2_decay_experiment_test.py

@@ -22,7 +22,7 @@ import cirq
 import cirq.experiments.t2_decay_experiment as t2
 
 
-def test_init_t2_decay_result():
+def test_init_t2_decay_result() -> None:
     x_data = pd.DataFrame(
         columns=['delay_ns', 0, 1], index=range(2), data=[[100.0, 0, 10], [1000.0, 10, 0]]
     )
@@ -42,7 +42,7 @@ def test_init_t2_decay_result():
 
 
 @pytest.mark.usefixtures('closefigures')
-def test_plot_does_not_raise_error():
+def test_plot_does_not_raise_error() -> None:
     class _TimeDependentDecay(cirq.NoiseModel):
         def noisy_moment(self, moment, system_qubits):
             duration = max(
@@ -67,7 +67,7 @@ def test_plot_does_not_raise_error():
     results.plot_bloch_vector()
 
 
-def test_result_eq():
+def test_result_eq() -> None:
     example_data = pd.DataFrame(
         columns=['delay_ns', 0, 1],
         index=range(5),
@@ -85,7 +85,7 @@ def test_result_eq():
     eq.add_equality_group(cirq.experiments.T2DecayResult(example_data, other_data))
 
 
-def test_sudden_decay_results():
+def test_sudden_decay_results() -> None:
     class _SuddenDecay(cirq.NoiseModel):
         def noisy_moment(self, moment, system_qubits):
             duration = max(
@@ -117,7 +117,7 @@ def test_sudden_decay_results():
 
 
 @pytest.mark.parametrize('experiment_type', [t2.ExperimentType.HAHN_ECHO, t2.ExperimentType.CPMG])
-def test_spin_echo_cancels_out_constant_rate_phase(experiment_type):
+def test_spin_echo_cancels_out_constant_rate_phase(experiment_type) -> None:
     class _TimeDependentPhase(cirq.NoiseModel):
         def noisy_moment(self, moment, system_qubits):
             duration = max(
@@ -151,7 +151,7 @@ def test_spin_echo_cancels_out_constant_rate_phase(experiment_type):
     'experiment_type',
     [t2.ExperimentType.RAMSEY, t2.ExperimentType.HAHN_ECHO, t2.ExperimentType.CPMG],
 )
-def test_all_on_results(experiment_type):
+def test_all_on_results(experiment_type) -> None:
     pulses = [1] if experiment_type == t2.ExperimentType.CPMG else None
     results = t2.t2_decay(
         sampler=cirq.Simulator(),
@@ -174,7 +174,7 @@ def test_all_on_results(experiment_type):
     'experiment_type',
     [t2.ExperimentType.RAMSEY, t2.ExperimentType.HAHN_ECHO, t2.ExperimentType.CPMG],
 )
-def test_all_off_results(experiment_type):
+def test_all_off_results(experiment_type) -> None:
     pulses = [1] if experiment_type == t2.ExperimentType.CPMG else None
     results = t2.t2_decay(
         sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
@@ -204,7 +204,7 @@ def test_all_off_results(experiment_type):
     'experiment_type',
     [t2.ExperimentType.RAMSEY, t2.ExperimentType.HAHN_ECHO, t2.ExperimentType.CPMG],
 )
-def test_custom_delay_sweep(experiment_type):
+def test_custom_delay_sweep(experiment_type) -> None:
     pulses = [1] if experiment_type == t2.ExperimentType.CPMG else None
     results = t2.t2_decay(
         sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
@@ -231,7 +231,7 @@ def test_custom_delay_sweep(experiment_type):
     )
 
 
-def test_multiple_pulses():
+def test_multiple_pulses() -> None:
     results = t2.t2_decay(
         sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
         qubit=cirq.GridQubit(0, 0),
@@ -302,7 +302,7 @@ def test_multiple_pulses():
     assert results.expectation_pauli_x.equals(expected)
 
 
-def test_bad_args():
+def test_bad_args() -> None:
     with pytest.raises(ValueError, match='repetitions <= 0'):
         _ = cirq.experiments.t2_decay(
             sampler=cirq.Simulator(),
@@ -388,7 +388,7 @@ def test_bad_args():
         )
 
 
-def test_cpmg_circuit():
+def test_cpmg_circuit() -> None:
     """Tests sub-component to make sure CPMG circuit is generated correctly."""
     q = cirq.GridQubit(1, 1)
     t = sympy.Symbol('t')
@@ -406,7 +406,7 @@ def test_cpmg_circuit():
     assert circuit == expected
 
 
-def test_cpmg_sweep():
+def test_cpmg_sweep() -> None:
     sweep = t2._cpmg_sweep([1, 3, 5])
     expected = cirq.Zip(
         cirq.Points('pulse_0', [1, 1, 1]),
@@ -418,7 +418,7 @@ def test_cpmg_sweep():
     assert sweep == expected
 
 
-def test_str():
+def test_str() -> None:
     x_data = pd.DataFrame(
         columns=['delay_ns', 0, 1], index=range(2), data=[[100.0, 0, 10], [1000.0, 10, 0]]
     )

cirq/experiments/two_qubit_xeb_test.py

@@ -36,7 +36,7 @@ def _manhattan_distance(qubit1: cirq.GridQubit, qubit2: cirq.GridQubit) -> int:
 
 class MockDevice(cirq.Device):
     @property
-    def metadata(self):
+    def metadata(self) -> cirq.DeviceMetadata:
         qubits = cirq.GridQubit.rect(3, 2, 4, 3)
         graph = nx.Graph(
             pair for pair in itertools.combinations(qubits, 2) if _manhattan_distance(*pair) == 1
@@ -45,21 +45,19 @@ class MockDevice(cirq.Device):
 
 
 class MockProcessor:
-    def get_device(self):
+    def get_device(self) -> MockDevice:
         return MockDevice()
 
 
 class DensityMatrixSimulatorWithProcessor(cirq.DensityMatrixSimulator):
     @property
-    def processor(self):
+    def processor(self) -> MockProcessor:
         return MockProcessor()
 
 
-def test_parallel_two_qubit_xeb_simulator_without_processor_fails():
-    sampler = (
-        cirq.DensityMatrixSimulator(
-            seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
-        ),
+def test_parallel_two_qubit_xeb_simulator_without_processor_fails() -> None:
+    sampler = cirq.DensityMatrixSimulator(
+        seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
     )
 
     with pytest.raises(ValueError):
@@ -90,7 +88,9 @@ def test_parallel_two_qubit_xeb_simulator_without_processor_fails():
         ),
     ],
 )
-def test_parallel_two_qubit_xeb(sampler: cirq.Sampler, qubits: Sequence[cirq.GridQubit] | None):
+def test_parallel_two_qubit_xeb(
+    sampler: cirq.Sampler, qubits: Sequence[cirq.GridQubit] | None
+) -> None:
     res = cirq.experiments.parallel_two_qubit_xeb(
         sampler=sampler,
         qubits=qubits,
@@ -114,7 +114,7 @@ def test_parallel_two_qubit_xeb(sampler: cirq.Sampler, qubits: Sequence[cirq.Gri
     ],
 )
 @pytest.mark.parametrize('ax', [None, plt.subplots(1, 1, figsize=(8, 8))[1]])
-def test_plotting(sampler, qubits, ax):
+def test_plotting(sampler, qubits, ax) -> None:
     res = cirq.experiments.parallel_two_qubit_xeb(
         sampler=sampler,
         qubits=qubits,
@@ -157,7 +157,7 @@ _TEST_RESULT = cirq.experiments.TwoQubitXEBResult(
         (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.46875),
     ],
 )
-def test_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):
+def test_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float) -> None:
     assert _TEST_RESULT.pauli_error()[(q0, q1)] == pytest.approx(pauli)
 
 
@@ -183,7 +183,7 @@ class MockParallelRandomizedBenchmarkingResult(ParallelRandomizedBenchmarkingRes
         (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.46875 - 0.13),
     ],
 )
-def test_inferred_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):
+def test_inferred_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float) -> None:
     combined_results = cirq.experiments.InferredXEBResult(
         rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
     )
@@ -200,7 +200,7 @@ def test_inferred_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: flo
         (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.2709999999999999),
     ],
 )
-def test_inferred_xeb_error(q0: cirq.GridQubit, q1: cirq.GridQubit, xeb: float):
+def test_inferred_xeb_error(q0: cirq.GridQubit, q1: cirq.GridQubit, xeb: float) -> None:
     combined_results = cirq.experiments.InferredXEBResult(
         rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
     )
@@ -208,7 +208,7 @@ def test_inferred_xeb_error(q0: cirq.GridQubit, q1: cirq.GridQubit, xeb: float):
     assert combined_results.inferred_xeb_error()[(q0, q1)] == pytest.approx(xeb)
 
 
-def test_inferred_single_qubit_pauli():
+def test_inferred_single_qubit_pauli() -> None:
     combined_results = cirq.experiments.InferredXEBResult(
         rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
     )
@@ -233,7 +233,7 @@ def test_inferred_single_qubit_pauli():
         (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.46875),
     ],
 )
-def test_inferred_two_qubit_pauli(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):
+def test_inferred_two_qubit_pauli(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float) -> None:
     combined_results = cirq.experiments.InferredXEBResult(
         rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
     )
@@ -243,7 +243,7 @@ def test_inferred_two_qubit_pauli(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli:
 @pytest.mark.parametrize('ax', [None, plt.subplots(1, 1, figsize=(8, 8))[1]])
 @pytest.mark.parametrize('target_error', ['pauli', 'xeb', 'decay_constant'])
 @pytest.mark.parametrize('kind', ['single_qubit', 'two_qubit', 'both', ''])
-def test_inferred_plots(ax, target_error, kind):
+def test_inferred_plots(ax, target_error, kind) -> None:
     combined_results = cirq.experiments.InferredXEBResult(
         rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
     )
@@ -296,7 +296,7 @@ def test_run_rb_and_xeb(
     sampler: cirq.Sampler,
     qubits: Sequence[cirq.GridQubit] | None,
     pairs: Sequence[tuple[cirq.GridQubit, cirq.GridQubit]] | None,
-):
+) -> None:
     res = cirq.experiments.run_rb_and_xeb(
         sampler=sampler,
         qubits=qubits,
@@ -313,11 +313,9 @@ def test_run_rb_and_xeb(
     )
 
 
-def test_run_rb_and_xeb_without_processor_fails():
-    sampler = (
-        cirq.DensityMatrixSimulator(
-            seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
-        ),
+def test_run_rb_and_xeb_without_processor_fails() -> None:
+    sampler = cirq.DensityMatrixSimulator(
+        seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
     )
 
     with pytest.raises(ValueError):

cirq/experiments/xeb_fitting.py

@@ -342,7 +342,7 @@ class XEBPhasedFSimCharacterizationOptions(XEBCharacterizationOptions):
 
         return np.asarray(initial_simplex), names
 
-    def get_parameterized_gate(self):
+    def get_parameterized_gate(self) -> cirq.Gate:
         theta = THETA_SYMBOL if self.characterize_theta else self.theta_default
         zeta = ZETA_SYMBOL if self.characterize_zeta else self.zeta_default
         chi = CHI_SYMBOL if self.characterize_chi else self.chi_default
@@ -374,7 +374,7 @@ class XEBPhasedFSimCharacterizationOptions(XEBCharacterizationOptions):
 
     def with_defaults_from_gate(
         self, gate: cirq.Gate, gate_to_angles_func=phased_fsim_angles_from_gate
-    ):
+    ) -> XEBPhasedFSimCharacterizationOptions:
         """A new Options class with {angle}_defaults inferred from `gate`.
 
         This keeps the same settings for the characterize_{angle} booleans, but will disregard
@@ -393,7 +393,7 @@ class XEBPhasedFSimCharacterizationOptions(XEBCharacterizationOptions):
         return protocols.dataclass_json_dict(self)
 
 
-def SqrtISwapXEBOptions(*args, **kwargs):
+def SqrtISwapXEBOptions(*args, **kwargs) -> XEBPhasedFSimCharacterizationOptions:
     """Options for calibrating a sqrt(ISWAP) gate using XEB."""
     return XEBPhasedFSimCharacterizationOptions(*args, **kwargs).with_defaults_from_gate(
         ops.SQRT_ISWAP

cirq/experiments/xeb_fitting_test.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import itertools
 import multiprocessing
-from typing import Iterable, Iterator
+from typing import Iterable, Iterator, Sequence
 
 import networkx as nx
 import numpy as np
@@ -50,7 +50,7 @@ def pool() -> Iterator[multiprocessing.pool.Pool]:
 
 
 @pytest.fixture(scope='module')
-def circuits_cycle_depths_sampled_df():
+def circuits_cycle_depths_sampled_df() -> tuple[list[cirq.Circuit], Sequence[int], pd.DataFrame]:
     q0, q1 = cirq.LineQubit.range(2)
     circuits = [
         rqcg.random_rotations_between_two_qubit_circuit(
@@ -58,7 +58,7 @@ def circuits_cycle_depths_sampled_df():
         )
         for _ in range(2)
     ]
-    cycle_depths = np.arange(10, 40 + 1, 10)
+    cycle_depths = list(range(10, 40 + 1, 10))
 
     sampled_df = sample_2q_xeb_circuits(
         sampler=cirq.Simulator(seed=53), circuits=circuits, cycle_depths=cycle_depths
@@ -67,7 +67,7 @@ def circuits_cycle_depths_sampled_df():
 
 
 @pytest.mark.parametrize('pass_cycle_depths', (True, False))
-def test_benchmark_2q_xeb_fidelities(circuits_cycle_depths_sampled_df, pass_cycle_depths):
+def test_benchmark_2q_xeb_fidelities(circuits_cycle_depths_sampled_df, pass_cycle_depths) -> None:
     circuits, cycle_depths, sampled_df = circuits_cycle_depths_sampled_df
 
     if pass_cycle_depths:
@@ -75,7 +75,7 @@ def test_benchmark_2q_xeb_fidelities(circuits_cycle_depths_sampled_df, pass_cycl
     else:
         fid_df = benchmark_2q_xeb_fidelities(sampled_df, circuits)
     assert len(fid_df) == len(cycle_depths)
-    assert sorted(fid_df['cycle_depth'].unique()) == cycle_depths.tolist()
+    assert sorted(fid_df['cycle_depth'].unique()) == cycle_depths
     assert np.all(fid_df['fidelity'] > 0.98)
 
     fit_df = fit_exponential_decays(fid_df)
@@ -84,7 +84,7 @@ def test_benchmark_2q_xeb_fidelities(circuits_cycle_depths_sampled_df, pass_cycl
         assert len(row['fidelities']) == len(cycle_depths)
 
 
-def test_benchmark_2q_xeb_subsample_depths(circuits_cycle_depths_sampled_df):
+def test_benchmark_2q_xeb_subsample_depths(circuits_cycle_depths_sampled_df) -> None:
     circuits, _, sampled_df = circuits_cycle_depths_sampled_df
     cycle_depths = [10, 20]
     fid_df = benchmark_2q_xeb_fidelities(sampled_df, circuits, cycle_depths)
@@ -114,7 +114,7 @@ def _gridqubits_to_graph_device(qubits: Iterable[cirq.GridQubit]):
     )
 
 
-def test_benchmark_2q_xeb_fidelities_parallel():
+def test_benchmark_2q_xeb_fidelities_parallel() -> None:
     circuits = rqcg.generate_library_of_2q_circuits(
         n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, max_cycle_depth=4
     )
@@ -140,7 +140,7 @@ def test_benchmark_2q_xeb_fidelities_parallel():
         assert len(row['fidelities']) == len(cycle_depths)
 
 
-def test_benchmark_2q_xeb_fidelities_vectorized():
+def test_benchmark_2q_xeb_fidelities_vectorized() -> None:
     rs = np.random.RandomState(52)
     mock_records = [{'pure_probs': rs.rand(4), 'sampled_probs': rs.rand(4)} for _ in range(100)]
     df = pd.DataFrame(mock_records)
@@ -177,7 +177,7 @@ def test_benchmark_2q_xeb_fidelities_vectorized():
 
 
 @pytest.mark.parametrize('gate', [cirq.SQRT_ISWAP, cirq.FSimGate(np.pi / 4, 0)])
-def test_parameterize_phased_fsim_circuit(gate):
+def test_parameterize_phased_fsim_circuit(gate) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = rqcg.random_rotations_between_two_qubit_circuit(
         q0, q1, depth=3, two_qubit_op_factory=lambda a, b, _: gate(a, b), seed=52
@@ -208,7 +208,7 @@ X^0.5                                PhX(0.25)^0.5
     )
 
 
-def test_get_initial_simplex():
+def test_get_initial_simplex() -> None:
     options = SqrtISwapXEBOptions()
     simplex, names = options.get_initial_simplex_and_names()
     assert names == ['theta', 'zeta', 'chi', 'gamma', 'phi']
@@ -216,7 +216,7 @@ def test_get_initial_simplex():
     assert simplex.shape[1] == len(names)
 
 
-def test_characterize_phased_fsim_parameters_with_xeb(pool):
+def test_characterize_phased_fsim_parameters_with_xeb(pool) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     rs = np.random.RandomState(52)
     circuits = [
@@ -225,7 +225,7 @@ def test_characterize_phased_fsim_parameters_with_xeb(pool):
         )
         for _ in range(2)
     ]
-    cycle_depths = np.arange(3, 20, 6)
+    cycle_depths = list(range(3, 20, 6))
     sampled_df = sample_2q_xeb_circuits(
         sampler=cirq.Simulator(seed=rs),
         circuits=circuits,
@@ -260,7 +260,7 @@ def test_characterize_phased_fsim_parameters_with_xeb(pool):
 
 
 @pytest.mark.parametrize('use_pool', (True, False))
-def test_parallel_full_workflow(request, use_pool):
+def test_parallel_full_workflow(request, use_pool) -> None:
     circuits = rqcg.generate_library_of_2q_circuits(
         n_library_circuits=5,
         two_qubit_gate=cirq.ISWAP**0.5,
@@ -320,7 +320,7 @@ def test_parallel_full_workflow(request, use_pool):
         assert 0 <= row['layer_fid_c'] <= 1
 
 
-def test_fit_exponential_decays():
+def test_fit_exponential_decays() -> None:
     rs = np.random.RandomState(999)
     cycle_depths = np.arange(3, 100, 11)
     fidelities = 0.95 * 0.98**cycle_depths + rs.normal(0, 0.2)
@@ -330,7 +330,7 @@ def test_fit_exponential_decays():
     assert 0 < layer_fid_std < 1e-3
 
 
-def test_fit_exponential_decays_negative_fids():
+def test_fit_exponential_decays_negative_fids() -> None:
     rs = np.random.RandomState(999)
     cycle_depths = np.arange(3, 100, 11)
     fidelities = 0.5 * 0.5**cycle_depths + rs.normal(0, 0.2) - 0.5
@@ -342,10 +342,12 @@ def test_fit_exponential_decays_negative_fids():
     assert layer_fid_std == np.inf
 
 
-def test_options_with_defaults_from_gate():
+def test_options_with_defaults_from_gate() -> None:
     options = XEBPhasedFSimCharacterizationOptions().with_defaults_from_gate(cirq.ISWAP**0.5)
+    assert options.theta_default is not None
     np.testing.assert_allclose(options.theta_default, -np.pi / 4)
     options = XEBPhasedFSimCharacterizationOptions().with_defaults_from_gate(cirq.ISWAP**-0.5)
+    assert options.theta_default is not None
     np.testing.assert_allclose(options.theta_default, np.pi / 4)
 
     options = XEBPhasedFSimCharacterizationOptions().with_defaults_from_gate(
@@ -365,7 +367,7 @@ def test_options_with_defaults_from_gate():
         _ = XEBPhasedFSimCharacterizationOptions().with_defaults_from_gate(cirq.XX)
 
 
-def test_options_defaults_set():
+def test_options_defaults_set() -> None:
     o1 = XEBPhasedFSimCharacterizationOptions(
         characterize_zeta=True,
         characterize_chi=True,
@@ -424,13 +426,13 @@ def _random_angles(n, seed):
     ]
     + [cirq.PhasedFSimGate(*r) for r in _random_angles(10, 0)],
 )
-def test_phased_fsim_angles_from_gate(gate):
+def test_phased_fsim_angles_from_gate(gate) -> None:
     angles = phased_fsim_angles_from_gate(gate)
     angles = {k.removesuffix('_default'): v for k, v in angles.items()}
     phasedfsim = cirq.PhasedFSimGate(**angles)
     np.testing.assert_allclose(cirq.unitary(phasedfsim), cirq.unitary(gate), atol=1e-9)
 
 
-def test_phased_fsim_angles_from_gate_unsupporet_gate():
+def test_phased_fsim_angles_from_gate_unsupporet_gate() -> None:
     with pytest.raises(ValueError, match='Unknown default angles'):
         _ = phased_fsim_angles_from_gate(cirq.testing.TwoQubitGate())

cirq/experiments/xeb_sampling.py

@@ -159,7 +159,7 @@ class _ZippedCircuit:
     """
 
     wide_circuit: cirq.Circuit
-    pairs: list[tuple[cirq.Qid, cirq.Qid]]
+    pairs: Sequence[tuple[cirq.Qid, cirq.Qid]]
     combination: list[int]
     layer_i: int
     combination_i: int
@@ -291,7 +291,7 @@ def sample_2q_xeb_circuits(
     combinations_by_layer: list[CircuitLibraryCombination] | None = None,
     shuffle: cirq.RANDOM_STATE_OR_SEED_LIKE | None = None,
     dataset_directory: str | None = None,
-):
+) -> pd.DataFrame:
     """Sample two-qubit XEB circuits given a sampler.
 
     Args:

cirq/experiments/xeb_sampling_test.py

@@ -28,7 +28,7 @@ import cirq.experiments.random_quantum_circuit_generation as rqcg
 from cirq.experiments.xeb_sampling import sample_2q_xeb_circuits
 
 
-def test_sample_2q_xeb_circuits():
+def test_sample_2q_xeb_circuits() -> None:
     q0 = cirq.NamedQubit('a')
     q1 = cirq.NamedQubit('b')
     circuits = [
@@ -37,7 +37,7 @@ def test_sample_2q_xeb_circuits():
         )
         for _ in range(2)
     ]
-    cycle_depths = np.arange(3, 20, 6)
+    cycle_depths = list(range(3, 20, 6))
 
     df = sample_2q_xeb_circuits(
         sampler=cirq.Simulator(),
@@ -53,20 +53,20 @@ def test_sample_2q_xeb_circuits():
         assert np.isclose(np.sum(row['sampled_probs']), 1)
 
 
-def test_sample_2q_xeb_circuits_error():
+def test_sample_2q_xeb_circuits_error() -> None:
     qubits = cirq.LineQubit.range(3)
     circuits = [cirq.testing.random_circuit(qubits, n_moments=5, op_density=0.8, random_state=52)]
-    cycle_depths = np.arange(3, 50, 9)
+    cycle_depths = list(range(3, 50, 9))
     with pytest.raises(ValueError):  # three qubit circuits
         _ = sample_2q_xeb_circuits(
             sampler=cirq.Simulator(), circuits=circuits, cycle_depths=cycle_depths
         )
 
 
-def test_sample_2q_xeb_circuits_no_progress(capsys):
+def test_sample_2q_xeb_circuits_no_progress(capsys) -> None:
     qubits = cirq.LineQubit.range(2)
     circuits = [cirq.testing.random_circuit(qubits, n_moments=7, op_density=0.8, random_state=52)]
-    cycle_depths = np.arange(3, 4)
+    cycle_depths = [3]
     _ = sample_2q_xeb_circuits(
         sampler=cirq.Simulator(), circuits=circuits, cycle_depths=cycle_depths, progress_bar=None
     )
@@ -98,7 +98,7 @@ def _assert_frame_approx_equal(df, df2, *, atol):
                 assert v1 == v2, k
 
 
-def test_sample_2q_parallel_xeb_circuits(tmpdir):
+def test_sample_2q_parallel_xeb_circuits(tmpdir) -> None:
     circuits = rqcg.generate_library_of_2q_circuits(
         n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, max_cycle_depth=10
     )
@@ -139,7 +139,7 @@ def test_sample_2q_parallel_xeb_circuits(tmpdir):
     )
 
 
-def test_sample_2q_parallel_xeb_circuits_bad_circuit_library():
+def test_sample_2q_parallel_xeb_circuits_bad_circuit_library() -> None:
     circuits = rqcg.generate_library_of_2q_circuits(
         n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, max_cycle_depth=10
     )
@@ -161,7 +161,7 @@ def test_sample_2q_parallel_xeb_circuits_bad_circuit_library():
         )
 
 
-def test_sample_2q_parallel_xeb_circuits_error_bad_qubits():
+def test_sample_2q_parallel_xeb_circuits_error_bad_qubits() -> None:
     circuits = rqcg.generate_library_of_2q_circuits(
         n_library_circuits=5,
         two_qubit_gate=cirq.ISWAP**0.5,

cirq/experiments/xeb_simulation.py

@@ -86,7 +86,7 @@ def simulate_2q_xeb_circuits(
     param_resolver: cirq.ParamResolverOrSimilarType = None,
     pool: multiprocessing.pool.Pool | None = None,
     simulator: cirq.SimulatesIntermediateState | None = None,
-):
+) -> pd.DataFrame:
     """Simulate two-qubit XEB circuits.
 
     These ideal probabilities can be benchmarked against potentially noisy