cirq-core 1.6.0.dev20250501173104__py3-none-any.whl → 1.6.0.dev20250501231232__py3-none-any.whl

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import itertools
 import random
 from typing import Dict, Sequence
 
@@ -32,9 +33,14 @@ def _create_ghz(number_of_qubits: int, qubits: Sequence[cirq.Qid]) -> cirq.Circu
     return ghz_circuit
 
 
-def _generate_random_pauli_string(qubits: Sequence[cirq.Qid], enable_coeff: bool = False):
+def _generate_random_pauli_string(
+    qubits: Sequence[cirq.Qid], enable_coeff: bool = False, allow_pauli_i: bool = True
+):
     pauli_ops = [cirq.I, cirq.X, cirq.Y, cirq.Z]
 
+    if not allow_pauli_i:
+        pauli_ops = [cirq.X, cirq.Y, cirq.Z]
+
     operators = {q: random.choice(pauli_ops) for q in qubits}
     # Ensure at least one non-identity.
     operators[random.choice(qubits)] = random.choice(pauli_ops[1:])
@@ -45,6 +51,49 @@ def _generate_random_pauli_string(qubits: Sequence[cirq.Qid], enable_coeff: bool
     return cirq.PauliString(operators)
 
 
+def _generate_qwc_paulis(
+    input_pauli: cirq.PauliString, num_output: int, exclude_input_pauli: bool = False
+) -> list[cirq.PauliString]:
+    """Generates PauliStrings that are Qubit-Wise Commuting (QWC)
+    with the input_pauli.
+
+    All operations in input_pauli must not be pauli I.
+    """
+    allowed_paulis_per_qubit = []
+    qubits = input_pauli.qubits
+
+    for qubit in qubits:
+        pauli_op = input_pauli.get(qubit, cirq.I)
+
+        allowed_pauli_op = []
+        if pauli_op == cirq.I:
+            allowed_pauli_op = [cirq.I, cirq.X, cirq.Y, cirq.Z]  # pragma: no cover
+        elif pauli_op == cirq.X:
+            allowed_pauli_op = [cirq.I, cirq.X]
+        elif pauli_op == cirq.Y:
+            allowed_pauli_op = [cirq.I, cirq.Y]
+        elif pauli_op == cirq.Z:
+            allowed_pauli_op = [cirq.I, cirq.Z]
+
+        allowed_paulis_per_qubit.append(allowed_pauli_op)
+
+    qwc_paulis: list[cirq.PauliString] = []
+
+    for pauli_combination in itertools.product(*allowed_paulis_per_qubit):
+        pauli_dict = {}
+        for i, qid in enumerate(qubits):
+            pauli_dict[qid] = pauli_combination[i]
+
+        qwc_pauli: cirq.PauliString = cirq.PauliString(pauli_dict)
+        if exclude_input_pauli and qwc_pauli == input_pauli:
+            continue  # pragma: no cover
+        if all(q == cirq.I for q in qwc_pauli):
+            continue
+        qwc_paulis.append(qwc_pauli)
+
+    return qwc_paulis if num_output > len(qwc_paulis) else random.sample(qwc_paulis, num_output)
+
+
 def _ideal_expectation_based_on_pauli_string(
     pauli_string: cirq.PauliString, final_state_vector: np.ndarray
 ) -> float:
@@ -149,6 +198,60 @@ def test_pauli_string_measurement_errors_with_coefficient_no_noise() -> None:
             }
 
 
+def test_group_pauli_string_measurement_errors_no_noise_with_coefficient() -> None:
+    """Test that the mitigated expectation is close to the ideal expectation
+    based on the group of Pauli strings"""
+
+    qubits = cirq.LineQubit.range(5)
+    circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
+    sampler = cirq.Simulator()
+
+    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
+        )
+        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, 100, 100, 100, 100
+    )
+
+    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=4 * 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_noise() -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string"""
@@ -196,6 +299,57 @@ def test_pauli_string_measurement_errors_with_noise() -> None:
                 assert 0.0045 < error < 0.0055
 
 
+def test_group_pauli_string_measurement_errors_with_noise() -> 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.1, p1=0.005, seed=1234)
+    simulator = cirq.Simulator()
+
+    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), 5
+        )
+    ]
+
+    circuits_with_pauli_expectations = measure_pauli_strings(
+        circuits_to_pauli, sampler, 800, 1000, 800, np.random.default_rng()
+    )
+
+    for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
+        assert isinstance(circuit_with_pauli_expectations.circuit, cirq.FrozenCircuit)
+
+        expected_val_simulation = simulator.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:
+            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=4 * pauli_string_measurement_results.mitigated_stddev,
+            )
+
+            assert isinstance(
+                pauli_string_measurement_results.calibration_result,
+                SingleQubitReadoutCalibrationResult,
+            )
+
+            for (
+                error
+            ) in pauli_string_measurement_results.calibration_result.zero_state_errors.values():
+                assert 0.08 < error < 0.12
+            for (
+                error
+            ) in pauli_string_measurement_results.calibration_result.one_state_errors.values():
+                assert 0.0045 < error < 0.0055
+
+
 def test_many_circuits_input_measurement_with_noise() -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string for multiple circuits"""
@@ -285,6 +439,36 @@ def test_allow_measurement_without_readout_mitigation() -> None:
             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.1, p1=0.005, seed=1234)
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli[circuit] = [
+        _generate_qwc_paulis(_generate_random_pauli_string(qubits, True), 2, True),
+        _generate_qwc_paulis(_generate_random_pauli_string(qubits), 4),
+        _generate_qwc_paulis(_generate_random_pauli_string(qubits), 6),
+    ]
+
+    circuits_with_pauli_expectations = measure_pauli_strings(
+        circuits_to_pauli, sampler, 100, 100, 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_many_circuits_with_coefficient() -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string for multiple circuits"""
@@ -344,6 +528,77 @@ def test_many_circuits_with_coefficient() -> None:
                 assert 0.0045 < error < 0.0055
 
 
+def test_many_group_pauli_in_circuits_with_coefficient() -> 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)
+    qubits_2 = [
+        cirq.GridQubit(0, 1),
+        cirq.GridQubit(1, 1),
+        cirq.GridQubit(1, 0),
+        cirq.GridQubit(1, 2),
+        cirq.GridQubit(2, 1),
+    ]
+    qubits_3 = cirq.LineQubit.range(8)
+
+    circuit_1 = cirq.FrozenCircuit(_create_ghz(3, qubits_1))
+    circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
+    circuit_3 = cirq.FrozenCircuit(_create_ghz(8, qubits_3))
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli[circuit_1] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits_1, enable_coeff=True, allow_pauli_i=False), 4
+        )
+    ]
+    circuits_to_pauli[circuit_2] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits_2, enable_coeff=True, allow_pauli_i=False), 5
+        )
+    ]
+    circuits_to_pauli[circuit_3] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits_3, enable_coeff=True, allow_pauli_i=False), 6
+        )
+    ]
+
+    sampler = NoisySingleQubitReadoutSampler(p0=0.03, p1=0.005, seed=1234)
+    simulator = cirq.Simulator()
+
+    circuits_with_pauli_expectations = measure_pauli_strings(
+        circuits_to_pauli, sampler, 1000, 1000, 1000, np.random.default_rng()
+    )
+
+    for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
+        assert isinstance(circuit_with_pauli_expectations.circuit, cirq.FrozenCircuit)
+
+        expected_val_simulation = simulator.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:
+            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=4 * pauli_string_measurement_results.mitigated_stddev,
+            )
+            assert isinstance(
+                pauli_string_measurement_results.calibration_result,
+                SingleQubitReadoutCalibrationResult,
+            )
+            for (
+                error
+            ) in pauli_string_measurement_results.calibration_result.zero_state_errors.values():
+                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_coefficient_not_real_number() -> None:
     """Test that the coefficient of input pauli string is not real.
     Should return error in this case"""
@@ -416,12 +671,13 @@ def test_invalid_input_pauli_string_type() -> None:
     circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
 
     circuits_to_pauli: Dict[cirq.FrozenCircuit, cirq.FrozenCircuit] = {}
-    circuits_to_pauli[circuit_1] = circuit_2
+    circuits_to_pauli[circuit_1] = [_generate_random_pauli_string(qubits_1)]  # type: ignore
+    circuits_to_pauli[circuit_2] = [circuit_1, circuit_2]  # type: ignore
 
     with pytest.raises(
         TypeError,
         match="All elements in the Pauli string lists must be cirq.PauliString "
-        "instances, got <class 'cirq.circuits.moment.Moment'>.",
+        "instances, got <class 'cirq.circuits.frozen_circuit.FrozenCircuit'>.",
     ):
         measure_pauli_strings(
             circuits_to_pauli,  # type: ignore[arg-type]
@@ -521,3 +777,91 @@ def test_rng_type_mismatch() -> None:
         measure_pauli_strings(
             circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, "test"  # type: ignore[arg-type]
         )
+
+
+def test_pauli_type_mismatch() -> None:
+    """Test that the input paulis are not a sequence of PauliStrings."""
+    qubits = cirq.LineQubit.range(5)
+
+    circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, int] = {}
+    circuits_to_pauli[circuit] = 1
+    with pytest.raises(
+        TypeError,
+        match="Expected all elements to be either a sequence of PauliStrings or sequences of"
+        " ops.PauliStrings. Got <class 'int'> instead.",
+    ):
+        measure_pauli_strings(
+            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, "test"  # type: ignore[arg-type]
+        )
+
+
+def test_group_paulis_are_not_qwc() -> None:
+    """Test that the group paulis are not qwc."""
+    qubits = cirq.LineQubit.range(5)
+
+    circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
+
+    pauli_str1: cirq.PauliString = cirq.PauliString({qubits[0]: cirq.X, qubits[1]: cirq.Y})
+    pauli_str2: cirq.PauliString = cirq.PauliString({qubits[0]: cirq.Y})
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli[circuit] = [[pauli_str1, pauli_str2]]  # type: ignore
+    with pytest.raises(
+        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()
+        )
+
+
+def test_empty_group_paulis_not_allowed() -> None:
+    """Test that the group paulis are empty"""
+    qubits = cirq.LineQubit.range(5)
+
+    circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    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()
+        )
+
+
+def test_group_paulis_type_mismatch() -> None:
+    """Test that the group paulis type is not correct"""
+    qubits_1 = cirq.LineQubit.range(3)
+    qubits_2 = [
+        cirq.GridQubit(0, 1),
+        cirq.GridQubit(1, 1),
+        cirq.GridQubit(1, 0),
+        cirq.GridQubit(1, 2),
+        cirq.GridQubit(2, 1),
+    ]
+    qubits_3 = cirq.LineQubit.range(8)
+
+    circuit_1 = cirq.FrozenCircuit(_create_ghz(3, qubits_1))
+    circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
+    circuit_3 = cirq.FrozenCircuit(_create_ghz(8, qubits_3))
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli[circuit_1] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits_1, enable_coeff=True, allow_pauli_i=False), 6
+        )
+        for _ in range(3)
+    ]
+    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)]
+
+    with pytest.raises(
+        TypeError,
+        match="Expected all elements to be sequences of ops.PauliString, "
+        "but found <class 'cirq.ops.pauli_string.PauliString'>.",
+    ):
+        measure_pauli_strings(
+            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
+        )

cirq/transformers/analytical_decompositions/two_qubit_to_cz.py

@@ -14,6 +14,8 @@
 
 """Utility methods for decomposing two-qubit unitaries into CZ gates."""
 
+from __future__ import annotations
+
 from typing import cast, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -31,8 +33,8 @@ if TYPE_CHECKING:
 
 
 def _remove_partial_czs_or_fail(
-    operations: Iterable['cirq.Operation'], atol: float
-) -> List['cirq.Operation']:
+    operations: Iterable[cirq.Operation], atol: float
+) -> List[cirq.Operation]:
     result = []
     for op in operations:
         if isinstance(op.gate, ops.CZPowGate):
@@ -49,8 +51,8 @@ def _remove_partial_czs_or_fail(
 
 
 def two_qubit_matrix_to_cz_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     mat: np.ndarray,
     allow_partial_czs: bool,
     atol: float = 1e-8,
@@ -85,13 +87,13 @@ def two_qubit_matrix_to_cz_operations(
 
 
 def two_qubit_matrix_to_diagonal_and_cz_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     mat: np.ndarray,
     allow_partial_czs: bool = False,
     atol: float = 1e-8,
     clean_operations: bool = True,
-) -> Tuple[np.ndarray, List['cirq.Operation']]:
+) -> Tuple[np.ndarray, List[cirq.Operation]]:
     """Decomposes a 2-qubit unitary to a diagonal and the remaining operations.
 
     For a 2-qubit unitary V, return ops, a list of operations and
@@ -136,7 +138,7 @@ def two_qubit_matrix_to_diagonal_and_cz_operations(
     )
 
 
-def _xx_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float):
+def _xx_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float):
     a = x * -2 / np.pi
     yield ops.H(q1)
     yield ops.CZ(q0, q1)
@@ -145,7 +147,7 @@ def _xx_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float):
     yield ops.H(q1)
 
 
-def _xx_yy_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float, y: float):
+def _xx_yy_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float, y: float):
     a = x * -2 / np.pi
     b = y * -2 / np.pi
     yield ops.X(q0) ** 0.5
@@ -160,9 +162,7 @@ def _xx_yy_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float, y:
     yield ops.X(q0) ** -0.5
 
 
-def _xx_yy_zz_interaction_via_full_czs(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', x: float, y: float, z: float
-):
+def _xx_yy_zz_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float, y: float, z: float):
     a = x * -2 / np.pi + 0.5
     b = y * -2 / np.pi + 0.5
     c = z * -2 / np.pi + 0.5
@@ -192,8 +192,8 @@ def cleanup_operations(operations: Sequence[ops.Operation]):
 
 
 def _kak_decomposition_to_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     kak: linalg.KakDecomposition,
     allow_partial_czs: bool,
     atol: float = 1e-8,
@@ -232,7 +232,7 @@ def _is_trivial_angle(rad: float, atol: float) -> bool:
 
 
 def _parity_interaction(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', rads: float, atol: float, gate: Optional[ops.Gate] = None
+    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: Optional[ops.Gate] = None
 ):
     """Yields a ZZ interaction framed by the given operation."""
     if abs(rads) < atol:
@@ -255,14 +255,14 @@ def _parity_interaction(
         yield g.on(q0), g.on(q1)
 
 
-def _do_single_on(u: np.ndarray, q: 'cirq.Qid', atol: float = 1e-8):
+def _do_single_on(u: np.ndarray, q: cirq.Qid, atol: float = 1e-8):
     for gate in single_qubit_decompositions.single_qubit_matrix_to_gates(u, atol):
         yield gate(q)
 
 
 def _non_local_part(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     interaction_coefficients: Tuple[float, float, float],
     allow_partial_czs: bool,
     atol: float = 1e-8,

cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py

@@ -14,6 +14,8 @@
 
 """Utility methods for decomposing two-qubit unitaries into FSim gates."""
 
+from __future__ import annotations
+
 from typing import Iterable, Iterator, List, Optional, Sequence, TYPE_CHECKING, Union
 
 import numpy as np
@@ -25,11 +27,11 @@ if TYPE_CHECKING:
 
 
 def decompose_two_qubit_interaction_into_four_fsim_gates(
-    interaction: Union['cirq.SupportsUnitary', np.ndarray],
+    interaction: Union[cirq.SupportsUnitary, np.ndarray],
     *,
-    fsim_gate: Union['cirq.FSimGate', 'cirq.ISwapPowGate'],
-    qubits: Optional[Sequence['cirq.Qid']] = None,
-) -> 'cirq.Circuit':
+    fsim_gate: Union[cirq.FSimGate, cirq.ISwapPowGate],
+    qubits: Optional[Sequence[cirq.Qid]] = None,
+) -> cirq.Circuit:
     """Decomposes operations into an FSimGate near theta=pi/2, phi=0.
 
     This decomposition is guaranteed to use exactly four of the given FSim
@@ -110,12 +112,12 @@ def _sticky_0_to_1(v: float, *, atol: float) -> Optional[float]:
 
 def _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
     *,
-    qubits: Sequence['cirq.Qid'],
-    fsim_gate: 'cirq.FSimGate',
+    qubits: Sequence[cirq.Qid],
+    fsim_gate: cirq.FSimGate,
     canonical_x_kak_coefficient: float,
     canonical_y_kak_coefficient: float,
     atol: float = 1e-8,
-) -> List['cirq.Operation']:
+) -> List[cirq.Operation]:
     x = canonical_x_kak_coefficient
     y = canonical_y_kak_coefficient
     assert 0 <= y <= x <= np.pi / 4
@@ -174,10 +176,10 @@ _B = _BGate()
 
 
 def _decompose_two_qubit_interaction_into_two_b_gates(
-    interaction: Union['cirq.SupportsUnitary', np.ndarray, 'cirq.KakDecomposition'],
+    interaction: Union[cirq.SupportsUnitary, np.ndarray, cirq.KakDecomposition],
     *,
-    qubits: Sequence['cirq.Qid'],
-) -> List['cirq.Operation']:
+    qubits: Sequence[cirq.Qid],
+) -> List[cirq.Operation]:
     kak = linalg.kak_decomposition(interaction)
 
     result = _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
@@ -192,8 +194,8 @@ def _decompose_two_qubit_interaction_into_two_b_gates(
 
 
 def _decompose_b_gate_into_two_fsims(
-    *, fsim_gate: 'cirq.FSimGate', qubits: Sequence['cirq.Qid']
-) -> List['cirq.Operation']:
+    *, fsim_gate: cirq.FSimGate, qubits: Sequence[cirq.Qid]
+) -> List[cirq.Operation]:
     kak = linalg.kak_decomposition(_B)
 
     result = _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
@@ -211,8 +213,8 @@ def _decompose_b_gate_into_two_fsims(
 
 
 def _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
-    qubits: Sequence['cirq.Qid'], kak_interaction_coefficients: Iterable[float]
-) -> List['cirq.Operation']:
+    qubits: Sequence[cirq.Qid], kak_interaction_coefficients: Iterable[float]
+) -> List[cirq.Operation]:
     """Decompose using a minimal construction of two-qubit operations.
 
     References:
@@ -236,11 +238,8 @@ def _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
 
 
 def _fix_single_qubit_gates_around_kak_interaction(
-    *,
-    desired: 'cirq.KakDecomposition',
-    operations: List['cirq.Operation'],
-    qubits: Sequence['cirq.Qid'],
-) -> Iterator['cirq.Operation']:
+    *, desired: cirq.KakDecomposition, operations: List[cirq.Operation], qubits: Sequence[cirq.Qid]
+) -> Iterator[cirq.Operation]:
     """Adds single qubit operations to complete a desired interaction.
 
     Args:

cirq/transformers/analytical_decompositions/two_qubit_to_ms.py

@@ -19,6 +19,8 @@ Gate compilation methods implemented here are following the paper below:
     arXiv:1603.07678
 """
 
+from __future__ import annotations
+
 from typing import cast, Iterable, List, Optional, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -31,11 +33,7 @@ if TYPE_CHECKING:
 
 
 def two_qubit_matrix_to_ion_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
-    mat: np.ndarray,
-    atol: float = 1e-8,
-    clean_operations: bool = True,
+    q0: cirq.Qid, q1: cirq.Qid, mat: np.ndarray, atol: float = 1e-8, clean_operations: bool = True
 ) -> List[ops.Operation]:
     """Decomposes a two-qubit operation into MS/single-qubit rotation gates.
 
@@ -56,7 +54,7 @@ def two_qubit_matrix_to_ion_operations(
 
 
 def _kak_decomposition_to_operations(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', kak: linalg.KakDecomposition, atol: float = 1e-8
+    q0: cirq.Qid, q1: cirq.Qid, kak: linalg.KakDecomposition, atol: float = 1e-8
 ) -> List[ops.Operation]:
     """Assumes that the decomposition is canonical."""
     b0, b1 = kak.single_qubit_operations_before
@@ -74,13 +72,13 @@ def _kak_decomposition_to_operations(
     )
 
 
-def _do_single_on(u: np.ndarray, q: 'cirq.Qid', atol: float = 1e-8):
+def _do_single_on(u: np.ndarray, q: cirq.Qid, atol: float = 1e-8):
     for gate in single_qubit_decompositions.single_qubit_matrix_to_gates(u, atol):
         yield gate(q)
 
 
 def _parity_interaction(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', rads: float, atol: float, gate: Optional[ops.Gate] = None
+    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: Optional[ops.Gate] = None
 ):
     """Yields an XX interaction framed by the given operation."""
 
@@ -98,8 +96,8 @@ def _parity_interaction(
 
 
 def _non_local_part(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     interaction_coefficients: Tuple[float, float, float],
     atol: float = 1e-8,
 ):