cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py

@@ -16,17 +16,14 @@ from __future__ import annotations
 
 import itertools
 import random
-from typing import Sequence
+from collections.abc import Sequence
 
 import numpy as np
 import pytest
 
 import cirq
 from cirq.contrib.paulistring import measure_pauli_strings
-from cirq.contrib.paulistring.pauli_string_measurement_with_readout_mitigation import (
-    _process_pauli_measurement_results,
-)
-from cirq.experiments.single_qubit_readout_calibration import SingleQubitReadoutCalibrationResult
+from cirq.experiments import SingleQubitReadoutCalibrationResult
 from cirq.experiments.single_qubit_readout_calibration_test import NoisySingleQubitReadoutSampler
 
 
@@ -107,7 +104,8 @@ def _ideal_expectation_based_on_pauli_string(
     )
 
 
-def test_pauli_string_measurement_errors_no_noise() -> None:
+@pytest.mark.parametrize("use_sweep", [True, False])
+def test_pauli_string_measurement_errors_no_noise(use_sweep: bool) -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string"""
 
@@ -119,7 +117,7 @@ def test_pauli_string_measurement_errors_no_noise() -> None:
     circuits_to_pauli[circuit] = [_generate_random_pauli_string(qubits) for _ in range(3)]
 
     circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 1000, 1000, 1000, 1000
+        circuits_to_pauli, sampler, 300, 300, 300, 1234, use_sweep
     )
 
     for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
@@ -141,7 +139,7 @@ def test_pauli_string_measurement_errors_no_noise() -> None:
                 _ideal_expectation_based_on_pauli_string(
                     pauli_string_measurement_results.pauli_string, final_state_vector
                 ),
-                atol=max(4 * pauli_string_measurement_results.mitigated_stddev, 0.1),
+                atol=10 * pauli_string_measurement_results.mitigated_stddev,
             )
             assert isinstance(
                 pauli_string_measurement_results.calibration_result,
@@ -155,55 +153,8 @@ def test_pauli_string_measurement_errors_no_noise() -> None:
             }
 
 
-def test_pauli_string_measurement_errors_with_coefficient_no_noise() -> None:
-    """Test that the mitigated expectation is close to the ideal expectation
-    based on the Pauli string"""
-
-    qubits = cirq.LineQubit.range(5)
-    circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
-    sampler = cirq.Simulator()
-
-    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
-    circuits_to_pauli[circuit] = [_generate_random_pauli_string(qubits, True) for _ in range(3)]
-
-    circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 1000, 1000, 1000, 1000
-    )
-
-    for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
-        assert isinstance(circuit_with_pauli_expectations.circuit, cirq.FrozenCircuit)
-
-        expected_val_simulation = sampler.simulate(
-            circuit_with_pauli_expectations.circuit.unfreeze()
-        )
-        final_state_vector = expected_val_simulation.final_state_vector
-
-        for pauli_string_measurement_results in circuit_with_pauli_expectations.results:
-            # Since there is no noise, the mitigated and unmitigated expectations should be the same
-            assert np.isclose(
-                pauli_string_measurement_results.mitigated_expectation,
-                pauli_string_measurement_results.unmitigated_expectation,
-            )
-            assert np.isclose(
-                pauli_string_measurement_results.mitigated_expectation,
-                _ideal_expectation_based_on_pauli_string(
-                    pauli_string_measurement_results.pauli_string, final_state_vector
-                ),
-                atol=max(4 * pauli_string_measurement_results.mitigated_stddev, 0.1),
-            )
-            assert isinstance(
-                pauli_string_measurement_results.calibration_result,
-                SingleQubitReadoutCalibrationResult,
-            )
-            assert pauli_string_measurement_results.calibration_result.zero_state_errors == {
-                q: 0 for q in pauli_string_measurement_results.pauli_string.qubits
-            }
-            assert pauli_string_measurement_results.calibration_result.one_state_errors == {
-                q: 0 for q in pauli_string_measurement_results.pauli_string.qubits
-            }
-
-
-def test_group_pauli_string_measurement_errors_no_noise_with_coefficient() -> None:
+@pytest.mark.parametrize("use_sweep", [True, False])
+def test_group_pauli_string_measurement_errors_no_noise_with_coefficient(use_sweep: bool) -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the group of Pauli strings"""
 
@@ -214,14 +165,14 @@ def test_group_pauli_string_measurement_errors_no_noise_with_coefficient() -> No
     circuits_to_pauli: dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
     circuits_to_pauli[circuit] = [
         _generate_qwc_paulis(
-            _generate_random_pauli_string(qubits, enable_coeff=True, allow_pauli_i=False), 100, True
+            _generate_random_pauli_string(qubits, enable_coeff=True, allow_pauli_i=False), 10, True
         )
         for _ in range(3)
     ]
     circuits_to_pauli[circuit].append([cirq.PauliString({q: cirq.X for q in qubits})])
 
     circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 1000, 1000, 1000, 1000
+        circuits_to_pauli, sampler, 300, 300, 300, 1234, use_sweep
     )
 
     for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
@@ -243,7 +194,7 @@ def test_group_pauli_string_measurement_errors_no_noise_with_coefficient() -> No
                 _ideal_expectation_based_on_pauli_string(
                     pauli_string_measurement_results.pauli_string, final_state_vector
                 ),
-                atol=max(4 * pauli_string_measurement_results.mitigated_stddev, 0.1),
+                atol=10 * pauli_string_measurement_results.mitigated_stddev,
             )
             assert isinstance(
                 pauli_string_measurement_results.calibration_result,
@@ -257,19 +208,20 @@ def test_group_pauli_string_measurement_errors_no_noise_with_coefficient() -> No
             }
 
 
-def test_pauli_string_measurement_errors_with_noise() -> None:
+@pytest.mark.parametrize("use_sweep", [True, False])
+def test_pauli_string_measurement_errors_with_noise(use_sweep: bool) -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string"""
     qubits = cirq.LineQubit.range(7)
     circuit = cirq.FrozenCircuit(_create_ghz(7, qubits))
-    sampler = NoisySingleQubitReadoutSampler(p0=0.001, p1=0.005, seed=1234)
+    sampler = NoisySingleQubitReadoutSampler(p0=0.01, p1=0.05, seed=1234)
     simulator = cirq.Simulator()
 
     circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [_generate_random_pauli_string(qubits) for _ in range(3)]
 
     circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 1000, 1000, 1000, np.random.default_rng()
+        circuits_to_pauli, sampler, 300, 300, 300, np.random.default_rng(), use_sweep
     )
 
     for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
@@ -286,7 +238,7 @@ def test_pauli_string_measurement_errors_with_noise() -> None:
                 _ideal_expectation_based_on_pauli_string(
                     pauli_string_measurement_results.pauli_string, final_state_vector
                 ),
-                atol=max(4 * pauli_string_measurement_results.mitigated_stddev, 0.1),
+                atol=10 * pauli_string_measurement_results.mitigated_stddev,
             )
 
             assert isinstance(
@@ -297,19 +249,20 @@ def test_pauli_string_measurement_errors_with_noise() -> None:
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.zero_state_errors.values():
-                assert 0.0008 < error < 0.0012
+                assert 0.008 < error < 0.012
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.one_state_errors.values():
-                assert 0.0045 < error < 0.0055
+                assert 0.045 < error < 0.055
 
 
-def test_group_pauli_string_measurement_errors_with_noise() -> None:
+@pytest.mark.parametrize("use_sweep", [True, False])
+def test_group_pauli_string_measurement_errors_with_noise(use_sweep: bool) -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the group Pauli strings"""
     qubits = cirq.LineQubit.range(7)
     circuit = cirq.FrozenCircuit(_create_ghz(7, qubits))
-    sampler = NoisySingleQubitReadoutSampler(p0=0.001, p1=0.005, seed=1234)
+    sampler = NoisySingleQubitReadoutSampler(p0=0.01, p1=0.05, seed=1234)
     simulator = cirq.Simulator()
 
     circuits_to_pauli: dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
@@ -320,7 +273,7 @@ def test_group_pauli_string_measurement_errors_with_noise() -> None:
     ]
 
     circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 800, 1000, 800, np.random.default_rng()
+        circuits_to_pauli, sampler, 300, 300, 300, np.random.default_rng(), use_sweep
     )
 
     for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
@@ -337,7 +290,7 @@ def test_group_pauli_string_measurement_errors_with_noise() -> None:
                 _ideal_expectation_based_on_pauli_string(
                     pauli_string_measurement_results.pauli_string, final_state_vector
                 ),
-                atol=max(4 * pauli_string_measurement_results.mitigated_stddev, 0.1),
+                atol=10 * pauli_string_measurement_results.mitigated_stddev,
             )
 
             assert isinstance(
@@ -348,14 +301,15 @@ def test_group_pauli_string_measurement_errors_with_noise() -> None:
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.zero_state_errors.values():
-                assert 0.0008 < error < 0.0012
+                assert 0.008 < error < 0.012
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.one_state_errors.values():
-                assert 0.0045 < error < 0.0055
+                assert 0.045 < error < 0.055
 
 
-def test_many_circuits_input_measurement_with_noise() -> None:
+@pytest.mark.parametrize("use_sweep", [True, False])
+def test_many_circuits_input_measurement_with_noise(use_sweep: bool) -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string for multiple circuits"""
     qubits_1 = cirq.LineQubit.range(3)
@@ -377,11 +331,11 @@ def test_many_circuits_input_measurement_with_noise() -> None:
     circuits_to_pauli[circuit_2] = [_generate_random_pauli_string(qubits_2) for _ in range(3)]
     circuits_to_pauli[circuit_3] = [_generate_random_pauli_string(qubits_3) for _ in range(3)]
 
-    sampler = NoisySingleQubitReadoutSampler(p0=0.003, p1=0.005, seed=1234)
+    sampler = NoisySingleQubitReadoutSampler(p0=0.03, p1=0.05, seed=1234)
     simulator = cirq.Simulator()
 
     circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 1000, 1000, 1000, np.random.default_rng()
+        circuits_to_pauli, sampler, 300, 300, 300, np.random.default_rng(), use_sweep
     )
 
     for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
@@ -398,7 +352,7 @@ def test_many_circuits_input_measurement_with_noise() -> None:
                 _ideal_expectation_based_on_pauli_string(
                     pauli_string_measurement_results.pauli_string, final_state_vector
                 ),
-                atol=max(4 * pauli_string_measurement_results.mitigated_stddev, 0.1),
+                atol=10 * pauli_string_measurement_results.mitigated_stddev,
             )
             assert isinstance(
                 pauli_string_measurement_results.calibration_result,
@@ -407,48 +361,19 @@ def test_many_circuits_input_measurement_with_noise() -> None:
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.zero_state_errors.values():
-                assert 0.0025 < error < 0.0035
+                assert 0.025 < error < 0.035
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.one_state_errors.values():
-                assert 0.0045 < error < 0.0055
-
-
-def test_allow_measurement_without_readout_mitigation() -> None:
-    """Test that the function allows to measure without error mitigation"""
-    qubits = cirq.LineQubit.range(7)
-    circuit = cirq.FrozenCircuit(_create_ghz(7, qubits))
-    sampler = NoisySingleQubitReadoutSampler(p0=0.001, p1=0.005, seed=1234)
-
-    circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
-    circuits_to_pauli[circuit] = [
-        _generate_random_pauli_string(qubits, True),
-        _generate_random_pauli_string(qubits),
-        _generate_random_pauli_string(qubits),
-    ]
-
-    circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 1000, 1000, 0, np.random.default_rng()
-    )
-
-    for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
-        assert isinstance(circuit_with_pauli_expectations.circuit, cirq.FrozenCircuit)
-
-        for pauli_string_measurement_results in circuit_with_pauli_expectations.results:
-            # Since there's no mitigation, the mitigated and unmitigated expectations
-            # should be the same
-            assert np.isclose(
-                pauli_string_measurement_results.mitigated_expectation,
-                pauli_string_measurement_results.unmitigated_expectation,
-            )
-            assert pauli_string_measurement_results.calibration_result is None
+                assert 0.045 < error < 0.055
 
 
-def test_allow_group_pauli_measurement_without_readout_mitigation() -> None:
+@pytest.mark.parametrize("use_sweep", [True, False])
+def test_allow_group_pauli_measurement_without_readout_mitigation(use_sweep: bool) -> None:
     """Test that the function allows to measure without error mitigation"""
     qubits = cirq.LineQubit.range(7)
     circuit = cirq.FrozenCircuit(_create_ghz(7, qubits))
-    sampler = NoisySingleQubitReadoutSampler(p0=0.001, p1=0.005, seed=1234)
+    sampler = NoisySingleQubitReadoutSampler(p0=0.01, p1=0.005, seed=1234)
 
     circuits_to_pauli: dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
     circuits_to_pauli[circuit] = [
@@ -458,7 +383,7 @@ def test_allow_group_pauli_measurement_without_readout_mitigation() -> None:
     ]
 
     circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 100, 100, 0, np.random.default_rng()
+        circuits_to_pauli, sampler, 300, 300, 0, np.random.default_rng(), use_sweep
     )
 
     for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
@@ -474,7 +399,13 @@ def test_allow_group_pauli_measurement_without_readout_mitigation() -> None:
             assert pauli_string_measurement_results.calibration_result is None
 
 
-def test_many_circuits_with_coefficient() -> None:
+@pytest.mark.parametrize("use_sweep", [True, False])
+@pytest.mark.parametrize(
+    "insert_strategy", [cirq.InsertStrategy.INLINE, cirq.InsertStrategy.EARLIEST]
+)
+def test_many_circuits_with_coefficient(
+    use_sweep: bool, insert_strategy: cirq.InsertStrategy
+) -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string for multiple circuits"""
     qubits_1 = cirq.LineQubit.range(3)
@@ -496,11 +427,18 @@ def test_many_circuits_with_coefficient() -> None:
     circuits_to_pauli[circuit_2] = [_generate_random_pauli_string(qubits_2, True) for _ in range(3)]
     circuits_to_pauli[circuit_3] = [_generate_random_pauli_string(qubits_3, True) for _ in range(3)]
 
-    sampler = NoisySingleQubitReadoutSampler(p0=0.003, p1=0.005, seed=1234)
+    sampler = NoisySingleQubitReadoutSampler(p0=0.03, p1=0.05, seed=1234)
     simulator = cirq.Simulator()
 
     circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 1000, 1000, 1000, np.random.default_rng()
+        circuits_to_pauli,
+        sampler,
+        300,
+        300,
+        300,
+        np.random.default_rng(),
+        use_sweep,
+        insert_strategy,
     )
 
     for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
@@ -517,7 +455,7 @@ def test_many_circuits_with_coefficient() -> None:
                 _ideal_expectation_based_on_pauli_string(
                     pauli_string_measurement_results.pauli_string, final_state_vector
                 ),
-                atol=max(4 * pauli_string_measurement_results.mitigated_stddev, 0.1),
+                atol=10 * pauli_string_measurement_results.mitigated_stddev,
             )
             assert isinstance(
                 pauli_string_measurement_results.calibration_result,
@@ -526,14 +464,15 @@ def test_many_circuits_with_coefficient() -> None:
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.zero_state_errors.values():
-                assert 0.0025 < error < 0.0035
+                assert 0.025 < error < 0.035
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.one_state_errors.values():
-                assert 0.0045 < error < 0.0055
+                assert 0.045 < error < 0.055
 
 
-def test_many_group_pauli_in_circuits_with_coefficient() -> None:
+@pytest.mark.parametrize("use_sweep", [True, False])
+def test_many_group_pauli_in_circuits_with_coefficient(use_sweep: bool) -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string for multiple circuits"""
     qubits_1 = cirq.LineQubit.range(3)
@@ -567,11 +506,11 @@ def test_many_group_pauli_in_circuits_with_coefficient() -> None:
         )
     ]
 
-    sampler = NoisySingleQubitReadoutSampler(p0=0.003, p1=0.005, seed=1234)
+    sampler = NoisySingleQubitReadoutSampler(p0=0.03, p1=0.05, seed=1234)
     simulator = cirq.Simulator()
 
     circuits_with_pauli_expectations = measure_pauli_strings(
-        circuits_to_pauli, sampler, 1000, 1000, 1000, np.random.default_rng()
+        circuits_to_pauli, sampler, 300, 300, 300, np.random.default_rng(), use_sweep
     )
 
     for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
@@ -588,7 +527,7 @@ def test_many_group_pauli_in_circuits_with_coefficient() -> None:
                 _ideal_expectation_based_on_pauli_string(
                     pauli_string_measurement_results.pauli_string, final_state_vector
                 ),
-                atol=max(4 * pauli_string_measurement_results.mitigated_stddev, 0.1),
+                atol=10 * pauli_string_measurement_results.mitigated_stddev,
             )
             assert isinstance(
                 pauli_string_measurement_results.calibration_result,
@@ -597,11 +536,11 @@ def test_many_group_pauli_in_circuits_with_coefficient() -> None:
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.zero_state_errors.values():
-                assert 0.0025 < error < 0.035
+                assert 0.025 < error < 0.035
             for (
                 error
             ) in pauli_string_measurement_results.calibration_result.one_state_errors.values():
-                assert 0.0045 < error < 0.0055
+                assert 0.045 < error < 0.055
 
 
 def test_coefficient_not_real_number() -> None:
@@ -624,7 +563,7 @@ def test_coefficient_not_real_number() -> None:
         "non-Hermitian PauliString. Coefficient must be real.",
     ):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
+            circuits_to_pauli, cirq.Simulator(), 300, 300, 300, np.random.default_rng()
         )
 
 
@@ -633,12 +572,7 @@ def test_empty_input_circuits_to_pauli_mapping() -> None:
 
     with pytest.raises(ValueError, match="Input circuits must not be empty."):
         measure_pauli_strings(
-            [],  # type: ignore[arg-type]
-            cirq.Simulator(),
-            1000,
-            1000,
-            1000,
-            np.random.default_rng(),
+            [], cirq.Simulator(), 300, 300, 300, np.random.default_rng()  # type: ignore[arg-type]
         )
 
 
@@ -654,9 +588,9 @@ def test_invalid_input_circuit_type() -> None:
         measure_pauli_strings(
             qubits_to_pauli,  # type: ignore[arg-type]
             cirq.Simulator(),
-            1000,
-            1000,
-            1000,
+            300,
+            300,
+            300,
             np.random.default_rng(),
         )
 
@@ -687,9 +621,9 @@ def test_invalid_input_pauli_string_type() -> None:
         measure_pauli_strings(
             circuits_to_pauli,  # type: ignore[arg-type]
             cirq.Simulator(),
-            1000,
-            1000,
-            1000,
+            300,
+            300,
+            300,
             np.random.default_rng(),
         )
 
@@ -722,7 +656,7 @@ def test_all_pauli_strings_are_pauli_i() -> None:
         "valid input Pauli strings.",
     ):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
+            circuits_to_pauli, cirq.Simulator(), 300, 300, 300, np.random.default_rng()
         )
 
 
@@ -734,9 +668,9 @@ def test_zero_pauli_repetitions() -> None:
 
     circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [cirq.PauliString({q: cirq.X for q in qubits})]
-    with pytest.raises(ValueError, match="Must provide non-zero pauli_repetitions."):
+    with pytest.raises(ValueError, match="Must provide positive pauli_repetitions."):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 0, 1000, 1000, np.random.default_rng()
+            circuits_to_pauli, cirq.Simulator(), 0, 300, 300, np.random.default_rng()
         )
 
 
@@ -750,7 +684,7 @@ def test_negative_num_random_bitstrings() -> None:
     circuits_to_pauli[circuit] = [cirq.PauliString({q: cirq.X for q in qubits})]
     with pytest.raises(ValueError, match="Must provide zero or more num_random_bitstrings."):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 1000, 1000, -1, np.random.default_rng()
+            circuits_to_pauli, cirq.Simulator(), 300, 300, -1, np.random.default_rng()
         )
 
 
@@ -763,10 +697,10 @@ def test_zero_readout_repetitions() -> None:
     circuits_to_pauli: dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
     circuits_to_pauli[circuit] = [cirq.PauliString({q: cirq.X for q in qubits})]
     with pytest.raises(
-        ValueError, match="Must provide non-zero readout_repetitions for readout" + " calibration."
+        ValueError, match="Must provide positive readout_repetitions for readout" + " calibration."
     ):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 1000, 0, 1000, np.random.default_rng()
+            circuits_to_pauli, cirq.Simulator(), 300, 0, 300, np.random.default_rng()
         )
 
 
@@ -780,7 +714,7 @@ def test_rng_type_mismatch() -> None:
     circuits_to_pauli[circuit] = [cirq.PauliString({q: cirq.X for q in qubits})]
     with pytest.raises(ValueError, match="Must provide a numpy random generator or a seed"):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, "test"  # type: ignore[arg-type]
+            circuits_to_pauli, cirq.Simulator(), 300, 300, 300, "test"  # type: ignore[arg-type]
         )
 
 
@@ -798,7 +732,7 @@ def test_pauli_type_mismatch() -> None:
         " ops.PauliStrings. Got <class 'int'> instead.",
     ):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, "test"  # type: ignore[arg-type]
+            circuits_to_pauli, cirq.Simulator(), 300, 300, 300, 1234  # type: ignore[arg-type]
         )
 
 
@@ -817,7 +751,7 @@ def test_group_paulis_are_not_qwc() -> None:
         ValueError, match="The group of Pauli strings are not Qubit-Wise Commuting with each other."
     ):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
+            circuits_to_pauli, cirq.Simulator(), 300, 300, 300, np.random.default_rng()
         )
 
 
@@ -831,7 +765,7 @@ def test_empty_group_paulis_not_allowed() -> None:
     circuits_to_pauli[circuit] = [[]]  # type: ignore
     with pytest.raises(ValueError, match="Empty group of Pauli strings is not allowed"):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
+            circuits_to_pauli, cirq.Simulator(), 300, 300, 300, np.random.default_rng()
         )
 
 
@@ -867,36 +801,5 @@ def test_group_paulis_type_mismatch() -> None:
         "but found <class 'cirq.ops.pauli_string.PauliString'>.",
     ):
         measure_pauli_strings(
-            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
-        )
-
-
-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: Sequence[cirq.Qid] = cirq.LineQubit.range(5)
-
-    measurement_op = cirq.measure(*qubits, key='m')
-    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)
-
-    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,
-        match="Readout mitigation is enabled, but no calibration result was found for qubits",
-    ):
-        _process_pauli_measurement_results(
-            qubits,
-            [pauli_strings],
-            circuit_results[0],
-            empty_calibration_result_dict,  # type: ignore[arg-type]
-            1000,
-            1.0,
+            circuits_to_pauli, cirq.Simulator(), 300, 300, 300, np.random.default_rng()
         )

cirq/contrib/paulistring/recombine.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, cast, Iterable, Sequence
+from collections.abc import Callable, Iterable, Sequence
+from typing import Any, cast
 
 from cirq import circuits, ops, protocols
 from cirq.contrib import circuitdag
@@ -69,7 +70,9 @@ def move_pauli_strings_into_circuit(
     circuit_left: circuits.Circuit | circuitdag.CircuitDag, circuit_right: circuits.Circuit
 ) -> circuits.Circuit:
     if isinstance(circuit_left, circuitdag.CircuitDag):
-        string_dag = circuitdag.CircuitDag(pauli_string_reorder_pred, circuit_left)
+        string_dag = circuitdag.CircuitDag(
+            incoming_graph_data=circuit_left, can_reorder=pauli_string_reorder_pred
+        )
     else:
         string_dag = pauli_string_dag_from_circuit(cast(circuits.Circuit, circuit_left))
     output_ops = list(circuit_right.all_operations())

cirq/contrib/paulistring/separate.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Iterator
+from collections.abc import Iterator
 
 from cirq import circuits, ops, transformers
 from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGateset

cirq/contrib/qasm_import/_lexer.py

@@ -48,6 +48,7 @@ class QasmLexer:
         'ID',
         'ARROW',
         'EQ',
+        'AND',
     ] + list(reserved.values())
 
     def t_newline(self, t):
@@ -101,8 +102,12 @@ class QasmLexer:
         """=="""
         return t
 
+    def t_AND(self, t):
+        """&&"""
+        return t
+
     def t_ID(self, t):
-        r"""[a-zA-Z][a-zA-Z\d_]*"""
+        r"""[a-zA-Z_][a-zA-Z\d_]*"""
         if t.value in QasmLexer.reserved:
             t.type = QasmLexer.reserved[t.value]
         return t

cirq/contrib/qasm_import/_lexer_test.py

@@ -84,7 +84,7 @@ def test_measurement() -> None:
 
 
 @pytest.mark.parametrize(
-    'identifier', ['b', 'CX', 'abc', 'aXY03', 'a_valid_name_with_02_digits_and_underscores']
+    'identifier', ['b', 'CX', 'abc', '_abc', 'aXY03', 'a_valid_name_with_02_digits_and_underscores']
 )
 def test_valid_ids(identifier: str) -> None:
     lexer = QasmLexer()