cirq-core 1.6.0.dev20250505203257__py3-none-any.whl → 1.6.0.dev20250507172716__py3-none-any.whl

cirq/experiments/benchmarking/parallel_xeb_test.py

@@ -0,0 +1,445 @@
+# 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.
+
+import itertools
+from concurrent import futures
+from typing import Iterator
+
+import networkx as nx
+import numpy as np
+import pytest
+
+import cirq
+import cirq.experiments.random_quantum_circuit_generation as rqcg
+from cirq.experiments.benchmarking import parallel_xeb as xeb
+
+_QUBITS = cirq.LineQubit.range(2)
+_CIRCUIT_TEMPLATES = [
+    cirq.Circuit(cirq.X.on_each(_QUBITS), cirq.CZ(*_QUBITS), cirq.Y.on_each(_QUBITS)),
+    cirq.Circuit(cirq.Y.on_each(_QUBITS), cirq.CX(*_QUBITS), cirq.Z.on_each(_QUBITS)),
+    cirq.Circuit(cirq.Z.on_each(_QUBITS), cirq.CZ(*_QUBITS), cirq.X.on_each(_QUBITS)),
+]
+_PAIRS = ((cirq.q(0, 0), cirq.q(0, 1)), (cirq.q(0, 2), cirq.q(0, 3)), (cirq.q(0, 4), cirq.q(0, 5)))
+
+
+class TestXEBWideCircuitInfo:
+
+    def test_from_circuit(self):
+        permutation = [1, 2, 0]
+        target = cirq.CircuitOperation(cirq.FrozenCircuit(cirq.CNOT(*_QUBITS)))
+        wide_circuit = xeb.XEBWideCircuitInfo.from_narrow_circuits(
+            _CIRCUIT_TEMPLATES, permutation=permutation, pairs=_PAIRS, target=target
+        )
+        assert wide_circuit == xeb.XEBWideCircuitInfo(
+            wide_circuit=cirq.Circuit.from_moments(
+                [
+                    cirq.Y.on_each(*_PAIRS[0]),
+                    cirq.Z.on_each(*_PAIRS[1]),
+                    cirq.X.on_each(*_PAIRS[2]),
+                ],
+                cirq.CircuitOperation(
+                    cirq.FrozenCircuit(
+                        cirq.CNOT(*_PAIRS[0]), cirq.CNOT(*_PAIRS[1]), cirq.CNOT(*_PAIRS[2])
+                    )
+                ),
+                [
+                    cirq.Z.on_each(*_PAIRS[0]),
+                    cirq.X.on_each(*_PAIRS[1]),
+                    cirq.Y.on_each(*_PAIRS[2]),
+                ],
+            ),
+            pairs=_PAIRS,
+            narrow_template_indices=permutation,
+        )
+
+    def test_sliced_circuit(self):
+        wid_circuit = xeb.XEBWideCircuitInfo(
+            wide_circuit=cirq.Circuit.from_moments(
+                [
+                    cirq.Y.on_each(*_PAIRS[0]),
+                    cirq.Z.on_each(*_PAIRS[1]),
+                    cirq.X.on_each(*_PAIRS[2]),
+                ],
+                cirq.CircuitOperation(
+                    cirq.FrozenCircuit(
+                        cirq.CNOT(*_PAIRS[0]), cirq.CNOT(*_PAIRS[1]), cirq.CNOT(*_PAIRS[2])
+                    )
+                ),
+                [
+                    cirq.Z.on_each(*_PAIRS[0]),
+                    cirq.X.on_each(*_PAIRS[1]),
+                    cirq.Y.on_each(*_PAIRS[2]),
+                ],
+            ),
+            pairs=_PAIRS,
+            narrow_template_indices=[1, 2, 0],
+        )
+        sliced_circuit = xeb.XEBWideCircuitInfo(
+            wide_circuit=cirq.Circuit.from_moments(
+                [
+                    cirq.Y.on_each(*_PAIRS[0]),
+                    cirq.Z.on_each(*_PAIRS[1]),
+                    cirq.X.on_each(*_PAIRS[2]),
+                ],
+                cirq.CircuitOperation(
+                    cirq.FrozenCircuit(
+                        cirq.CNOT(*_PAIRS[0]), cirq.CNOT(*_PAIRS[1]), cirq.CNOT(*_PAIRS[2])
+                    )
+                ),
+                [
+                    cirq.Z.on_each(*_PAIRS[0]),
+                    cirq.X.on_each(*_PAIRS[1]),
+                    cirq.Y.on_each(*_PAIRS[2]),
+                ],
+                [cirq.measure(p, key=str(p)) for p in _PAIRS],
+            ),
+            pairs=_PAIRS,
+            narrow_template_indices=[1, 2, 0],
+            cycle_depth=1,
+        )
+
+        assert wid_circuit.sliced_circuits([1]) == [sliced_circuit]
+
+
+def test_create_combination_circuits():
+    wide_circuits_info = xeb.create_combination_circuits(
+        _CIRCUIT_TEMPLATES,
+        [rqcg.CircuitLibraryCombination(layer=None, combinations=[[1, 2, 0]], pairs=_PAIRS)],
+        target=cirq.CNOT(*_QUBITS),
+    )
+
+    assert wide_circuits_info == [
+        xeb.XEBWideCircuitInfo(
+            wide_circuit=cirq.Circuit.from_moments(
+                [
+                    cirq.Y.on_each(*_PAIRS[0]),
+                    cirq.Z.on_each(*_PAIRS[1]),
+                    cirq.X.on_each(*_PAIRS[2]),
+                ],
+                [cirq.CNOT(*_PAIRS[0]), cirq.CNOT(*_PAIRS[1]), cirq.CNOT(*_PAIRS[2])],
+                [
+                    cirq.Z.on_each(*_PAIRS[0]),
+                    cirq.X.on_each(*_PAIRS[1]),
+                    cirq.Y.on_each(*_PAIRS[2]),
+                ],
+            ),
+            pairs=_PAIRS,
+            narrow_template_indices=[1, 2, 0],
+        )
+    ]
+
+
+def test_create_combination_circuits_with_target_dict():
+    wide_circuits_info = xeb.create_combination_circuits(
+        _CIRCUIT_TEMPLATES,
+        [rqcg.CircuitLibraryCombination(layer=None, combinations=[[1, 2, 0]], pairs=_PAIRS)],
+        target={_PAIRS[0]: cirq.CNOT(*_QUBITS), _PAIRS[1]: cirq.CZ(*_QUBITS)},
+    )
+
+    # Wide circuit is created for the qubit pairs in the intersection between target.keys()
+    # and combination.pairs
+    assert wide_circuits_info == [
+        xeb.XEBWideCircuitInfo(
+            wide_circuit=cirq.Circuit.from_moments(
+                [cirq.Y.on_each(*_PAIRS[0]), cirq.Z.on_each(*_PAIRS[1])],
+                [cirq.CNOT(*_PAIRS[0]), cirq.CZ(*_PAIRS[1])],
+                [cirq.Z.on_each(*_PAIRS[0]), cirq.X.on_each(*_PAIRS[1])],
+            ),
+            pairs=_PAIRS,
+            narrow_template_indices=[1, 2, 0],
+        )
+    ]
+
+
+def test_simulate_circuit():
+    sim = cirq.Simulator(seed=0)
+    circuit = cirq.Circuit.from_moments(
+        cirq.X.on_each(_QUBITS),
+        cirq.CNOT(*_QUBITS),
+        cirq.X.on_each(_QUBITS),
+        cirq.CNOT(*_QUBITS),
+        cirq.X.on_each(_QUBITS),
+        cirq.CNOT(*_QUBITS),
+        cirq.X.on_each(_QUBITS),
+    )
+
+    result = xeb.simulate_circuit(sim, circuit, [1, 3])
+    np.testing.assert_allclose(result, [[0, 1, 0, 0], [1, 0, 0, 0]])  # |01>  # |00>
+
+
+def test_simulate_circuit_library():
+    circuit_templates = [
+        cirq.Circuit.from_moments(
+            cirq.X.on_each(_QUBITS),
+            cirq.CNOT(*_QUBITS),
+            cirq.X.on_each(_QUBITS),
+            cirq.CNOT(*_QUBITS),
+            cirq.X.on_each(_QUBITS),
+            cirq.CNOT(*_QUBITS),
+            cirq.X.on_each(_QUBITS),
+        )
+    ]
+
+    result = xeb.simulate_circuit_library(
+        circuit_templates=circuit_templates, target_or_dict=cirq.CNOT(*_QUBITS), cycle_depths=(1, 3)
+    )
+    np.testing.assert_allclose(result, [[[0, 1, 0, 0], [1, 0, 0, 0]]])  # |01>  # |00>
+
+
+def test_simulate_circuit_library_with_target_dict():
+    circuit_templates = [
+        cirq.Circuit.from_moments(
+            [cirq.H(_QUBITS[0]), cirq.X(_QUBITS[1])],
+            cirq.CNOT(*_QUBITS),
+            [cirq.H(_QUBITS[0]), cirq.X(_QUBITS[1])],
+            cirq.CNOT(*_QUBITS),
+            [cirq.H(_QUBITS[0]), cirq.X(_QUBITS[1])],
+            cirq.CNOT(*_QUBITS),
+            [cirq.H(_QUBITS[0]), cirq.X(_QUBITS[1])],
+        )
+    ]
+
+    result = xeb.simulate_circuit_library(
+        circuit_templates=circuit_templates,
+        target_or_dict={_PAIRS[0]: cirq.CNOT(*_QUBITS), _PAIRS[1]: cirq.CZ(*_QUBITS)},
+        cycle_depths=(1, 3),
+    )
+
+    # First pair result.
+    np.testing.assert_allclose(result[_PAIRS[0]], [[[0.25, 0.25, 0.25, 0.25], [0, 1, 0, 0]]])
+
+    # Second pair result.
+    np.testing.assert_allclose(result[_PAIRS[1]], [[[0, 0, 1, 0], [1, 0, 0, 0]]])  # |10>  # |00>
+
+
+def test_sample_all_circuits():
+    wide_circuits = [
+        cirq.Circuit.from_moments(
+            [cirq.Y.on_each(*_PAIRS[0]), cirq.Z.on_each(*_PAIRS[1]), cirq.X.on_each(*_PAIRS[2])],
+            cirq.CircuitOperation(
+                cirq.FrozenCircuit(
+                    cirq.CNOT(*_PAIRS[0]), cirq.CNOT(*_PAIRS[1]), cirq.CNOT(*_PAIRS[2])
+                )
+            ),
+            [cirq.Z.on_each(*_PAIRS[0]), cirq.X.on_each(*_PAIRS[1]), cirq.Y.on_each(*_PAIRS[2])],
+            [cirq.measure(p, key=str(p)) for p in _PAIRS],
+        )
+    ]
+    result = xeb.sample_all_circuits(cirq.Simulator(seed=0), circuits=wide_circuits, repetitions=10)
+    assert len(result) == len(wide_circuits)
+    assert result[0].keys() == {str(p) for p in _PAIRS}
+    np.testing.assert_allclose(
+        result[0]['(cirq.GridQubit(0, 0), cirq.GridQubit(0, 1))'], [0, 0, 1, 0]
+    )  # |10>
+    np.testing.assert_allclose(
+        result[0]['(cirq.GridQubit(0, 2), cirq.GridQubit(0, 3))'], [0, 0, 0, 1]
+    )  # |11>
+    np.testing.assert_allclose(
+        result[0]['(cirq.GridQubit(0, 4), cirq.GridQubit(0, 5))'], [0, 1, 0, 0]
+    )  # |01>
+
+
+def test_estimate_fidelities():
+    sampling_result = [{str(_PAIRS[0]): np.array([0.15, 0.15, 0.35, 0.35])}]
+
+    simulation_results = [[np.array([0.1, 0.2, 0.3, 0.4])]]
+
+    result = xeb.estimate_fidelities(
+        sampling_results=sampling_result,
+        simulation_results=simulation_results,
+        cycle_depths=(1,),
+        num_templates=1,
+        pairs=_PAIRS[:1],
+        wide_circuits_info=[
+            xeb.XEBWideCircuitInfo(
+                wide_circuit=cirq.Circuit.from_moments(
+                    [cirq.Y.on_each(*_PAIRS[0])],
+                    cirq.CNOT(*_PAIRS[0]),
+                    [cirq.Z.on_each(*_PAIRS[0])],
+                    cirq.measure(_PAIRS[0], key=str(_PAIRS[0])),
+                ),
+                cycle_depth=1,
+                narrow_template_indices=(0,),
+                pairs=_PAIRS[:1],
+            )
+        ],
+    )
+
+    assert result == [
+        xeb.XEBFidelity(pair=_PAIRS[0], cycle_depth=1, fidelity=pytest.approx(0.785, abs=2e-4))
+    ]
+
+
+def test_estimate_fidelities_with_dict_target():
+    sampling_result = [{str(_PAIRS[0]): np.array([0.15, 0.15, 0.35, 0.35])}]
+
+    simulation_results = {_PAIRS[0]: [[np.array([0.1, 0.2, 0.3, 0.4])]]}
+
+    result = xeb.estimate_fidelities(
+        sampling_results=sampling_result,
+        simulation_results=simulation_results,
+        cycle_depths=(1,),
+        num_templates=1,
+        pairs=_PAIRS[:1],
+        wide_circuits_info=[
+            xeb.XEBWideCircuitInfo(
+                wide_circuit=cirq.Circuit.from_moments(
+                    [cirq.Y.on_each(*_PAIRS[0])],
+                    cirq.CNOT(*_PAIRS[0]),
+                    [cirq.Z.on_each(*_PAIRS[0])],
+                    cirq.measure(_PAIRS[0], key=str(_PAIRS[0])),
+                ),
+                cycle_depth=1,
+                narrow_template_indices=(0,),
+                pairs=_PAIRS[:1],
+            )
+        ],
+    )
+
+    assert result == [
+        xeb.XEBFidelity(pair=_PAIRS[0], cycle_depth=1, fidelity=pytest.approx(0.785, abs=2e-4))
+    ]
+
+
+def _assert_fidelities_approx_equal(fids, expected: float, atol: float):
+    fids = np.asarray(fids).tolist()
+    fids.sort(reverse=True)
+    fids.pop()  # discard smallest to make the test robust to randomness
+    np.testing.assert_allclose(fids, expected, atol=atol)
+
+
+@pytest.mark.parametrize('target', [cirq.CZ, cirq.Circuit(cirq.CZ(*_QUBITS)), cirq.CZ(*_QUBITS)])
+@pytest.mark.parametrize('pairs', [_PAIRS[:1], _PAIRS[:2]])
+def test_parallel_two_qubit_xeb(target, pairs):
+    sampler = cirq.DensityMatrixSimulator(noise=cirq.depolarize(0.03), seed=0)
+    result = xeb.parallel_two_qubit_xeb(
+        sampler=sampler,
+        target=target,
+        pairs=pairs,
+        parameters=xeb.XEBParameters(
+            n_circuits=10, n_combinations=10, n_repetitions=10, cycle_depths=range(1, 10, 2)
+        ),
+    )
+    _assert_fidelities_approx_equal(result.fidelities.layer_fid, 0.9, atol=0.3)
+
+
+class ExampleDevice(cirq.Device):
+    @property
+    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 abs(pair[0].row - pair[1].row) + abs(pair[0].col - pair[1].col) == 1
+        )
+        return cirq.DeviceMetadata(qubits, graph)
+
+
+class ExampleProcessor:
+    def get_device(self):
+        return ExampleDevice()
+
+
+class DensityMatrixSimulatorWithProcessor(cirq.DensityMatrixSimulator):
+    @property
+    def processor(self):
+        return ExampleProcessor()
+
+
+def test_parallel_two_qubit_xeb_with_device():
+    target = cirq.CZ
+    sampler = DensityMatrixSimulatorWithProcessor(noise=cirq.depolarize(0.03), seed=0)
+    result = xeb.parallel_two_qubit_xeb(
+        sampler=sampler,
+        target=target,
+        parameters=xeb.XEBParameters(
+            n_circuits=10, n_combinations=10, n_repetitions=10, cycle_depths=range(1, 10, 2)
+        ),
+    )
+    _assert_fidelities_approx_equal(result.fidelities.layer_fid, 0.9, atol=0.3)
+    qubits = cirq.GridQubit.rect(3, 2, 4, 3)
+    pairs = tuple(
+        pair
+        for pair in itertools.combinations(qubits, 2)
+        if abs(pair[0].row - pair[1].row) + abs(pair[0].col - pair[1].col) == 1
+        and pair[0] < pair[1]
+    )
+    assert result.all_qubit_pairs == pairs
+
+
+def test_parallel_two_qubit_xeb_with_dict_target():
+    target = {p: cirq.Circuit(cirq.CZ(*_QUBITS)) for p in _PAIRS[:2]}
+    target[_PAIRS[2]] = cirq.CZ(*_QUBITS)
+    sampler = cirq.DensityMatrixSimulator(noise=cirq.depolarize(0.03), seed=0)
+    result = xeb.parallel_two_qubit_xeb(
+        sampler=sampler,
+        target=target,
+        parameters=xeb.XEBParameters(
+            n_circuits=10, n_combinations=10, n_repetitions=10, cycle_depths=range(1, 10, 2)
+        ),
+    )
+    _assert_fidelities_approx_equal(result.fidelities.layer_fid, 0.9, atol=0.3)
+    assert result.all_qubit_pairs == _PAIRS
+
+
+def test_parallel_two_qubit_xeb_with_ideal_target():
+    target = {p: cirq.Circuit(cirq.CZ(*_QUBITS)) for p in _PAIRS[:2]}
+    target[_PAIRS[2]] = cirq.CZ(*_QUBITS)
+    sampler = cirq.DensityMatrixSimulator(noise=cirq.depolarize(0.03), seed=0)
+    result = xeb.parallel_two_qubit_xeb(
+        sampler=sampler,
+        target=target,
+        ideal_target=cirq.CZ,
+        parameters=xeb.XEBParameters(
+            n_circuits=10, n_combinations=10, n_repetitions=10, cycle_depths=range(1, 10, 2)
+        ),
+    )
+    _assert_fidelities_approx_equal(result.fidelities.layer_fid, 0.9, atol=0.3)
+    assert result.all_qubit_pairs == _PAIRS
+
+
+@pytest.fixture
+def threading_pool() -> Iterator[futures.Executor]:
+    with futures.ThreadPoolExecutor(1) as pool:
+        yield pool
+
+
+def test_parallel_two_qubit_xeb_with_dict_target_and_pool(threading_pool):
+    target = {p: cirq.Circuit(cirq.CZ(*_QUBITS)) for p in _PAIRS}
+    sampler = cirq.DensityMatrixSimulator(noise=cirq.depolarize(0.03), seed=0)
+    result = xeb.parallel_two_qubit_xeb(
+        sampler=sampler,
+        target=target,
+        parameters=xeb.XEBParameters(
+            n_circuits=10, n_combinations=10, n_repetitions=10, cycle_depths=range(1, 10, 2)
+        ),
+        pool=threading_pool,
+    )
+    _assert_fidelities_approx_equal(result.fidelities.layer_fid, 0.9, atol=0.3)
+    assert result.all_qubit_pairs == _PAIRS
+
+
+def test_parallel_two_qubit_xeb_with_invalid_input_raises():
+    with pytest.raises(AssertionError):
+        _ = xeb.parallel_two_qubit_xeb(
+            sampler=cirq.Simulator(seed=0), target={_PAIRS[0]: cirq.CZ}, pairs=_PAIRS
+        )
+
+    with pytest.raises(AssertionError):
+        _ = xeb.parallel_two_qubit_xeb(
+            sampler=cirq.Simulator(seed=0),
+            target=cirq.CZ,
+            ideal_target={_PAIRS[0]: cirq.CZ},
+            pairs=_PAIRS,
+        )

cirq/experiments/fidelity_estimation.py

@@ -11,16 +11,22 @@
 # 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.
+
 """Estimation of fidelity associated with experimental circuit executions."""
-from typing import Callable, Mapping, Optional, Sequence
+
+from __future__ import annotations
+
+from typing import Callable, Mapping, Optional, Sequence, TYPE_CHECKING
 
 import numpy as np
 
-from cirq.circuits import Circuit
 from cirq.ops import QubitOrder, QubitOrderOrList
 from cirq.sim import final_state_vector
 from cirq.value import state_vector_to_probabilities
 
+if TYPE_CHECKING:
+    import cirq
+
 
 def linear_xeb_fidelity_from_probabilities(
     hilbert_space_dimension: int, probabilities: Sequence[float]
@@ -132,7 +138,7 @@ def hog_score_xeb_fidelity_from_probabilities(
 
 
 def xeb_fidelity(
-    circuit: Circuit,
+    circuit: cirq.Circuit,
     bitstrings: Sequence[int],
     qubit_order: QubitOrderOrList = QubitOrder.DEFAULT,
     amplitudes: Optional[Mapping[int, complex]] = None,
@@ -197,7 +203,7 @@ def xeb_fidelity(
 
 
 def linear_xeb_fidelity(
-    circuit: Circuit,
+    circuit: cirq.Circuit,
     bitstrings: Sequence[int],
     qubit_order: QubitOrderOrList = QubitOrder.DEFAULT,
     amplitudes: Optional[Mapping[int, complex]] = None,
@@ -213,7 +219,7 @@ def linear_xeb_fidelity(
 
 
 def log_xeb_fidelity(
-    circuit: Circuit,
+    circuit: cirq.Circuit,
     bitstrings: Sequence[int],
     qubit_order: QubitOrderOrList = QubitOrder.DEFAULT,
     amplitudes: Optional[Mapping[int, complex]] = None,

cirq/experiments/two_qubit_xeb.py

@@ -107,6 +107,10 @@ class TwoQubitXEBResult:
 
     @functools.cached_property
     def _qubit_pair_map(self) -> Dict[Tuple[cirq.GridQubit, cirq.GridQubit], int]:
+        if isinstance(self.fidelities.index[0][0], ops.Qid):
+            return {
+                (min(q0, q1), max(q0, q1)): i for i, (q0, q1) in enumerate(self.fidelities.index)
+            }
         return {
             (min(q0, q1), max(q0, q1)): i
             for i, (_, _, (q0, q1)) in enumerate(self.fidelities.index)

cirq/linalg/combinators.py

@@ -14,6 +14,8 @@
 
 """Utility methods for combining matrices."""
 
+from __future__ import annotations
+
 import functools
 from typing import TYPE_CHECKING, Union
 
@@ -107,7 +109,7 @@ def kron_with_controls(*factors: Union[np.ndarray, complex]) -> np.ndarray:
     return product
 
 
-def dot(*values: 'ArrayLike') -> np.ndarray:
+def dot(*values: ArrayLike) -> np.ndarray:
     """Computes the dot/matrix product of a sequence of values.
 
     Performs the computation in serial order without regard to the matrix
@@ -136,7 +138,7 @@ def dot(*values: 'ArrayLike') -> np.ndarray:
     return result
 
 
-def _merge_dtypes(dtype1: 'DTypeLike', dtype2: 'DTypeLike') -> np.dtype:
+def _merge_dtypes(dtype1: DTypeLike, dtype2: DTypeLike) -> np.dtype:
     return (np.zeros(0, dtype1) + np.zeros(0, dtype2)).dtype
 
 

cirq/linalg/predicates.py

@@ -11,7 +11,12 @@
 # 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.
+
 """Utility methods for checking properties of matrices."""
+
+from __future__ import annotations
+
+from types import EllipsisType
 from typing import cast, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
@@ -228,7 +233,7 @@ def slice_for_qubits_equal_to(
     big_endian_qureg_value: int = 0,
     num_qubits: Optional[int] = None,
     qid_shape: Optional[Tuple[int, ...]] = None,
-) -> Tuple[Union[slice, int, 'ellipsis'], ...]:
+) -> Tuple[Union[slice, int, EllipsisType], ...]:
     """Returns an index corresponding to a desired subset of an np.ndarray.
 
     It is assumed that the np.ndarray's shape is of the form (2, 2, 2, ..., 2).

cirq/linalg/tolerance.py

@@ -14,6 +14,9 @@
 
 """Utility for testing approximate equality of matrices and scalars within
 tolerances."""
+
+from __future__ import annotations
+
 from typing import Iterable, TYPE_CHECKING, Union
 
 import numpy as np
@@ -22,7 +25,7 @@ if TYPE_CHECKING:
     from numpy.typing import ArrayLike
 
 
-def all_near_zero(a: 'ArrayLike', *, atol: float = 1e-8) -> bool:
+def all_near_zero(a: ArrayLike, *, atol: float = 1e-8) -> bool:
     """Checks if the tensor's elements are all near zero.
 
     Args:

cirq/neutral_atoms/convert_to_neutral_atom_gates.py

@@ -12,15 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cirq import ops
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from cirq.neutral_atoms import neutral_atom_devices
 
+if TYPE_CHECKING:
+    import cirq
+
 
-def is_native_neutral_atom_op(operation: ops.Operation) -> bool:
+def is_native_neutral_atom_op(operation: cirq.Operation) -> bool:
     """Returns true if the operation is in the default neutral atom gateset."""
     return operation in neutral_atom_devices.neutral_atom_gateset()
 
 
-def is_native_neutral_atom_gate(gate: ops.Gate) -> bool:
+def is_native_neutral_atom_gate(gate: cirq.Gate) -> bool:
     """Returns true if the gate is in the default neutral atom gateset."""
     return gate in neutral_atom_devices.neutral_atom_gateset()

cirq/ops/clifford_gate_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import functools
 import itertools
 from typing import Tuple, Type
@@ -59,7 +61,7 @@ def _all_rotation_pairs():
 
 
 @functools.lru_cache()
-def _all_clifford_gates() -> Tuple['cirq.SingleQubitCliffordGate', ...]:
+def _all_clifford_gates() -> Tuple[cirq.SingleQubitCliffordGate, ...]:
     return tuple(
         cirq.SingleQubitCliffordGate.from_xz_map(trans_x, trans_z)
         for trans_x, trans_z in _all_rotation_pairs()

cirq/ops/projector.py

@@ -1,13 +1,18 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import itertools
 import math
-from typing import Any, Dict, Iterable, List, Mapping, Optional
+from typing import Any, Dict, Iterable, List, Mapping, Optional, TYPE_CHECKING
 
 import numpy as np
 from scipy.sparse import csr_matrix
 
 from cirq import value
-from cirq.ops import raw_types
+
+if TYPE_CHECKING:
+    import cirq
 
 
 def _check_qids_dimension(qids):
@@ -21,7 +26,7 @@ def _check_qids_dimension(qids):
 class ProjectorString:
     """Mapping of `cirq.Qid` to measurement values (with a coefficient) representing a projector."""
 
-    def __init__(self, projector_dict: Dict[raw_types.Qid, int], coefficient: complex = 1):
+    def __init__(self, projector_dict: Dict[cirq.Qid, int], coefficient: complex = 1):
         """Constructor for ProjectorString
 
         Args:
@@ -34,14 +39,14 @@ class ProjectorString:
         self._coefficient = complex(coefficient)
 
     @property
-    def projector_dict(self) -> Dict[raw_types.Qid, int]:
+    def projector_dict(self) -> Dict[cirq.Qid, int]:
         return self._projector_dict
 
     @property
     def coefficient(self) -> complex:
         return self._coefficient
 
-    def matrix(self, projector_qids: Optional[Iterable[raw_types.Qid]] = None) -> csr_matrix:
+    def matrix(self, projector_qids: Optional[Iterable[cirq.Qid]] = None) -> csr_matrix:
         """Returns the matrix of self in computational basis of qubits.
 
         Args:
@@ -75,7 +80,7 @@ class ProjectorString:
             ([self._coefficient] * len(ones_idx), (ones_idx, ones_idx)), shape=(total_d, total_d)
         )
 
-    def _get_idx_to_keep(self, qid_map: Mapping[raw_types.Qid, int]):
+    def _get_idx_to_keep(self, qid_map: Mapping[cirq.Qid, int]):
         num_qubits = len(qid_map)
         idx_to_keep: List[Any] = [slice(0, 2)] * num_qubits
         for q in self.projector_dict.keys():
@@ -83,7 +88,7 @@ class ProjectorString:
         return tuple(idx_to_keep)
 
     def expectation_from_state_vector(
-        self, state_vector: np.ndarray, qid_map: Mapping[raw_types.Qid, int]
+        self, state_vector: np.ndarray, qid_map: Mapping[cirq.Qid, int]
     ) -> complex:
         """Expectation of the projection from a state vector.
 
@@ -105,7 +110,7 @@ class ProjectorString:
         )
 
     def expectation_from_density_matrix(
-        self, state: np.ndarray, qid_map: Mapping[raw_types.Qid, int]
+        self, state: np.ndarray, qid_map: Mapping[cirq.Qid, int]
     ) -> complex:
         """Expectation of the projection from a density matrix.