cirq-core 1.7.0.dev20250924231107__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,55 +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
-    )
-
-    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=10 * pauli_string_measurement_results.mitigated_stddev,
-            )
-            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_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
+        circuits_to_pauli, sampler, 300, 300, 300, 1234, use_sweep
     )
 
     for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
@@ -203,7 +153,8 @@ def test_pauli_string_measurement_errors_with_coefficient_no_noise() -> None:
             }
 
 
-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:
@@ -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:
@@ -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:
@@ -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:
@@ -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
+                assert 0.045 < error < 0.055
 
 
-def test_allow_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)
-
-    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
-
-
-def test_allow_group_pauli_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)
+    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:
@@ -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:
@@ -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/_parser.py

@@ -17,7 +17,8 @@ from __future__ import annotations
 import dataclasses
 import functools
 import operator
-from typing import Any, Callable, cast, Iterable, TYPE_CHECKING
+from collections.abc import Callable, Iterable
+from typing import Any, cast, TYPE_CHECKING
 
 import numpy as np
 import sympy

cirq/contrib/qasm_import/_parser_test.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import re
 import textwrap
-from typing import Callable
+from collections.abc import Callable
 
 import numpy as np
 import pytest
@@ -1089,8 +1089,8 @@ two_qubit_gates = [
 # Mapping of two-qubit gates and `num_params`
 two_qubit_param_gates = {
     # TODO: fix and enable commented gates below
-    # ('cu1', cirq.ControlledGate(QasmUGate(0, 0, 0.1 / np.pi))): 1,
-    # ('cu3', cirq.ControlledGate(QasmUGate(0.1 / np.pi, 0.2 / np.pi, 0.3 / np.pi))): 3,
+    ('cu1', cirq.ControlledGate(QasmUGate(0, 0, 0.1 / np.pi))): 1,
+    ('cu3', cirq.ControlledGate(QasmUGate(0.1 / np.pi, 0.2 / np.pi, 0.3 / np.pi))): 3,
     # ('cu', cirq.ControlledGate(QasmUGate(0.1 / np.pi, 0.2 / np.pi, 0.3 / np.pi))): 3,
     ('crx', cirq.ControlledGate(cirq.rx(0.1))): 1,
     ('cry', cirq.ControlledGate(cirq.ry(0.1))): 1,

cirq/contrib/quantikz/__init__.py

@@ -0,0 +1,21 @@
+# Copyright 2025 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Converts Cirq circuits to LaTeX diagrams using the Quantikz package."""
+
+from cirq.contrib.quantikz.circuit_to_latex_quantikz import (
+    CircuitToQuantikz as CircuitToQuantikz,
+    GATE_STYLES_COLORFUL as GATE_STYLES_COLORFUL,
+)
+from cirq.contrib.quantikz.circuit_to_latex_render import render_circuit as render_circuit