cirq-core 1.5.0.dev20250409225226__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/contrib/acquaintance/strategies/quartic_paired_test.py

@@ -12,8 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 import random
+from typing import Iterable
 
 import pytest
 
@@ -21,27 +24,28 @@ import cirq
 import cirq.contrib.acquaintance as cca
 
 
-def test_bad_qubit_pairs():
+def test_bad_qubit_pairs() -> None:
     a, b, c, d, e = cirq.LineQubit.range(5)
     bad_qubit_pairs = [(a, b), (c, d), (e,)]
     with pytest.raises(ValueError):
         cca.strategies.quartic_paired.qubit_pairs_to_qubit_order(bad_qubit_pairs)
 
 
-def random_index_pairs(n_pairs: int):
+def random_index_pairs(n_pairs: int) -> tuple[tuple[int, int], ...]:
     indices = list(range(2 * n_pairs))
     random.shuffle(indices)
-    return tuple(indices[2 * i : 2 * (i + 1)] for i in range(n_pairs))
+    return tuple(zip(indices[0::2], indices[1::2]))
 
 
 @pytest.mark.parametrize(
     'index_pairs', [random_index_pairs(n_pairs) for n_pairs in range(2, 7) for _ in range(2)]
 )
-def test_quartic_paired_acquaintances(index_pairs):
+def test_quartic_paired_acquaintances(index_pairs) -> None:
     n_pairs = len(index_pairs)
-    qubit_pairs = tuple(tuple(cirq.LineQubit(x) for x in index_pair) for index_pair in index_pairs)
+    qubit_pairs: Iterable[tuple[cirq.Qid, cirq.Qid]]
+    qubit_pairs = tuple((cirq.LineQubit(x), cirq.LineQubit(y)) for x, y in index_pairs)
     strategy, qubits = cca.quartic_paired_acquaintance_strategy(qubit_pairs)
-    initial_mapping = {q: q.x for q in qubits}
+    initial_mapping = {q: q.x for q in qubits}  # type: ignore[attr-defined]
     opps = cca.get_logical_acquaintance_opportunities(strategy, initial_mapping)
     assert set(len(opp) for opp in opps) == set([2, 4])
     quadratic_opps = set(opp for opp in opps if len(opp) == 2)

cirq/contrib/acquaintance/testing.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import cast, Sequence, TYPE_CHECKING
 
 from cirq import devices, ops, protocols

cirq/contrib/acquaintance/topological_sort.py

@@ -18,11 +18,11 @@ import operator
 import random
 from typing import Any, Callable, cast, Iterable, TYPE_CHECKING
 
-import networkx
-
 from cirq import ops
 
 if TYPE_CHECKING:
+    import networkx
+
     import cirq
 
 

cirq/contrib/acquaintance/topological_sort_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 pytest
 
 import cirq
@@ -29,7 +31,7 @@ import cirq.contrib.acquaintance as cca
         for _ in range(5)
     ],
 )
-def test_topological_sort(circuit_dag, sorted_nodes):
+def test_topological_sort(circuit_dag, sorted_nodes) -> None:
     sorted_nodes = list(sorted_nodes)
     assert cca.is_topologically_sorted(circuit_dag, (node.val for node in sorted_nodes))
 

cirq/contrib/bayesian_network/bayesian_network_gate.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import math
-from typing import Any, cast, Dict, Iterator, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, Iterator, Sequence, TYPE_CHECKING
 
 from sympy.combinatorics import GrayCode
 
@@ -96,8 +96,8 @@ class BayesianNetworkGate(raw_types.Gate):
 
     def __init__(
         self,
-        init_probs: List[Tuple[str, Optional[float]]],
-        arc_probs: List[Tuple[str, Tuple[str], List[float]]],
+        init_probs: list[tuple[str, float | None]],
+        arc_probs: list[tuple[str, tuple[str, ...], list[float]]],
     ):
         """Builds a BayesianNetworkGate.
 
@@ -175,28 +175,27 @@ class BayesianNetworkGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return True
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return (2,) * len(self._init_probs)
 
     def _value_equality_values_(self):
         return self._init_probs, self._arc_probs
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'init_probs': self._init_probs, 'arc_probs': self._arc_probs}
 
     @classmethod
     def _from_json_dict_(
         cls,
-        init_probs: List[List[Union[str, Optional[float]]]],
-        arc_probs: List[List[Union[str, List[str], List[float]]]],
+        init_probs: list[list[str | float | None]],
+        arc_probs: list[list[str | list[str] | list[float]]],
         **kwargs,
     ) -> BayesianNetworkGate:
         converted_init_probs = cast(
-            List[Tuple[str, Optional[float]]],
-            [(param, init_prob) for param, init_prob in init_probs],
+            list[tuple[str, float | None]], [(param, init_prob) for param, init_prob in init_probs]
         )
         converted_cond_probs = cast(
-            List[Tuple[str, Tuple[str], List[float]]],
+            list[tuple[str, tuple[str, ...], list[float]]],
             [(target, tuple(params), cond_probs) for target, params, cond_probs in arc_probs],
         )
         return cls(converted_init_probs, converted_cond_probs)

cirq/contrib/bayesian_network/bayesian_network_gate_test.py

@@ -11,6 +11,9 @@
 # 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.
+
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
@@ -18,14 +21,14 @@ import cirq
 import cirq.contrib.bayesian_network as ccb
 
 
-def test_basic_properties():
+def test_basic_properties() -> None:
     gate = ccb.BayesianNetworkGate([('q0', None), ('q1', None), ('q2', None)], [])
 
     assert gate._has_unitary_()
     assert gate._qid_shape_() == (2, 2, 2)
 
 
-def test_incorrect_constructor():
+def test_incorrect_constructor() -> None:
     # Success building.
     ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0',), [0.0, 0.0])])
 
@@ -34,7 +37,9 @@ def test_incorrect_constructor():
 
     # This is an easy mistake where the tuple for q0 doesn't have the comma at the end.
     with pytest.raises(ValueError, match='Conditional prob params must be a tuple.'):
-        ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0'), [0.0, 0.0])])
+        ccb.BayesianNetworkGate(
+            [('q0', 0.0), ('q1', None)], [('q1', ('q0'), [0.0, 0.0])]  # type: ignore
+        )
 
     with pytest.raises(ValueError, match='Incorrect number of conditional probs.'):
         ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0',), [0.0])])
@@ -43,17 +48,17 @@ def test_incorrect_constructor():
         ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0',), [2016.0913, 0.0])])
 
 
-def test_repr():
+def test_repr() -> None:
     gate = ccb.BayesianNetworkGate([('q0', 0.0), ('q1', None)], [('q1', ('q0',), [0.0, 0.0])])
 
     assert repr(gate) == (
         "cirq.BayesianNetworkGate(init_probs=[('q0', 0.0), ('q1', None)],"
-        + " arc_probs=[('q1', ('q0',), [0.0, 0.0])])"
+        " arc_probs=[('q1', ('q0',), [0.0, 0.0])])"
     )
 
 
 @pytest.mark.parametrize('input_prob', [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
-def test_prob_encoding(input_prob):
+def test_prob_encoding(input_prob) -> None:
     q = cirq.NamedQubit('q')
     gate = ccb.BayesianNetworkGate([('q', input_prob)], [])
     circuit = cirq.Circuit(gate.on(q))
@@ -79,7 +84,7 @@ def test_prob_encoding(input_prob):
     ],
 )
 @pytest.mark.parametrize('decompose', [True, False])
-def test_initial_probs(p0, p1, p2, expected_probs, decompose):
+def test_initial_probs(p0, p1, p2, expected_probs, decompose) -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     gate = ccb.BayesianNetworkGate([('q0', p0), ('q1', p1), ('q2', p2)], [])
     if decompose:
@@ -99,7 +104,7 @@ def test_initial_probs(p0, p1, p2, expected_probs, decompose):
     [(0.0, 0.0, 0.1), (0.0, 1.0, 0.2), (1.0, 0.0, 0.3), (1.0, 1.0, 0.4)],
 )
 @pytest.mark.parametrize('decompose', [True, False])
-def test_arc_probs(input_prob_q0, input_prob_q1, expected_prob_q2, decompose):
+def test_arc_probs(input_prob_q0, input_prob_q1, expected_prob_q2, decompose) -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     gate = ccb.BayesianNetworkGate(
         [('q0', input_prob_q0), ('q1', input_prob_q1), ('q2', None)],
@@ -119,7 +124,7 @@ def test_arc_probs(input_prob_q0, input_prob_q1, expected_prob_q2, decompose):
     np.testing.assert_almost_equal(actual_prob_q2_is_one, expected_prob_q2, decimal=4)
 
 
-def test_repro_figure_10_of_paper():
+def test_repro_figure_10_of_paper() -> None:
     # We try to create the network of figure 10 and check that the probabilities are the same as
     # the ones in table 10 of https://arxiv.org/abs/2004.14803.
     ir = cirq.NamedQubit('q4_IR')

cirq/contrib/circuitdag/circuit_dag.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import functools
-from typing import Any, Callable, cast, Dict, Generic, Iterator, TypeVar
+from typing import Any, Callable, cast, Generic, Iterator, TypeVar
 
 import networkx
 
@@ -44,7 +44,7 @@ class Unique(Generic[T]):
     def __repr__(self) -> str:
         return f'cirq.contrib.Unique({id(self)}, {self.val!r})'
 
-    def __lt__(self, other):
+    def __lt__(self, other) -> bool:
         if not isinstance(other, type(self)):
             return NotImplemented
         return id(self) < id(other)
@@ -132,7 +132,7 @@ class CircuitDag(networkx.DiGraph):
         for node, attr in g2.nodes(data=True):
             attr['val'] = node.val
 
-        def node_match(attr1: Dict[Any, Any], attr2: Dict[Any, Any]) -> bool:
+        def node_match(attr1: dict[Any, Any], attr2: dict[Any, Any]) -> bool:
             return attr1['val'] == attr2['val']
 
         return networkx.is_isomorphic(g1, g2, node_match=node_match)
@@ -176,7 +176,7 @@ class CircuitDag(networkx.DiGraph):
     def all_operations(self) -> Iterator[cirq.Operation]:
         return (node.val for node in self.ordered_nodes())
 
-    def all_qubits(self):
+    def all_qubits(self) -> frozenset[cirq.Qid]:
         return frozenset(q for node in self.nodes for q in node.val.qubits)
 
     def to_circuit(self) -> cirq.Circuit:

cirq/contrib/circuitdag/circuit_dag_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 itertools
 import random
 
@@ -25,7 +27,7 @@ class FakeDevice(cirq.Device):
     pass
 
 
-def test_wrapper_eq():
+def test_wrapper_eq() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.contrib.CircuitDag.make_node(cirq.X(q0)))
@@ -34,7 +36,7 @@ def test_wrapper_eq():
     eq.add_equality_group(cirq.contrib.CircuitDag.make_node(cirq.X(q1)))
 
 
-def test_wrapper_cmp():
+def test_wrapper_cmp() -> None:
     u0 = cirq.contrib.Unique(0)
     u1 = cirq.contrib.Unique(1)
     # The ordering of Unique instances is unpredictable
@@ -49,14 +51,14 @@ def test_wrapper_cmp():
     assert u1 >= u0
 
 
-def test_wrapper_cmp_failure():
+def test_wrapper_cmp_failure() -> None:
     with pytest.raises(TypeError):
         _ = object() < cirq.contrib.Unique(1)
     with pytest.raises(TypeError):
         _ = cirq.contrib.Unique(1) < object()
 
 
-def test_wrapper_repr():
+def test_wrapper_repr() -> None:
     q0 = cirq.LineQubit(0)
 
     node = cirq.contrib.CircuitDag.make_node(cirq.X(q0))
@@ -64,14 +66,14 @@ def test_wrapper_repr():
     assert repr(node) == expected
 
 
-def test_init():
+def test_init() -> None:
     dag = cirq.contrib.CircuitDag()
     assert networkx.dag.is_directed_acyclic_graph(dag)
     assert list(dag.nodes()) == []
     assert list(dag.edges()) == []
 
 
-def test_append():
+def test_append() -> None:
     q0 = cirq.LineQubit(0)
     dag = cirq.contrib.CircuitDag()
     dag.append(cirq.X(q0))
@@ -81,7 +83,7 @@ def test_append():
     assert [(n1.val, n2.val) for n1, n2 in dag.edges()] == [(cirq.X(q0), cirq.Y(q0))]
 
 
-def test_two_identical_ops():
+def test_two_identical_ops() -> None:
     q0 = cirq.LineQubit(0)
     dag = cirq.contrib.CircuitDag()
     dag.append(cirq.X(q0))
@@ -96,7 +98,7 @@ def test_two_identical_ops():
     }
 
 
-def test_from_ops():
+def test_from_ops() -> None:
     q0 = cirq.LineQubit(0)
     dag = cirq.contrib.CircuitDag.from_ops(cirq.X(q0), cirq.Y(q0))
     assert networkx.dag.is_directed_acyclic_graph(dag)
@@ -104,7 +106,7 @@ def test_from_ops():
     assert [(n1.val, n2.val) for n1, n2 in dag.edges()] == [(cirq.X(q0), cirq.Y(q0))]
 
 
-def test_from_circuit():
+def test_from_circuit() -> None:
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.X(q0), cirq.Y(q0))
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
@@ -114,14 +116,14 @@ def test_from_circuit():
     assert sorted(circuit.all_qubits()) == sorted(dag.all_qubits())
 
 
-def test_to_empty_circuit():
+def test_to_empty_circuit() -> None:
     circuit = cirq.Circuit()
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
     assert networkx.dag.is_directed_acyclic_graph(dag)
     assert circuit == dag.to_circuit()
 
 
-def test_to_circuit():
+def test_to_circuit() -> None:
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.X(q0), cirq.Y(q0))
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
@@ -135,7 +137,7 @@ def test_to_circuit():
     )
 
 
-def test_equality():
+def test_equality() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit1 = cirq.Circuit(
         cirq.X(q0), cirq.Y(q0), cirq.Z(q1), cirq.CZ(q0, q1), cirq.X(q1), cirq.Y(q1), cirq.Z(q0)
@@ -165,7 +167,7 @@ def test_equality():
     eq.add_equality_group(cirq.contrib.CircuitDag.from_circuit(circuit4))
 
 
-def test_larger_circuit():
+def test_larger_circuit() -> None:
     q0, q1, q2, q3 = [
         cirq.GridQubit(0, 5),
         cirq.GridQubit(1, 5),
@@ -211,7 +213,7 @@ def test_larger_circuit():
 
 
 @pytest.mark.parametrize('circuit', [cirq.testing.random_circuit(10, 10, 0.5) for _ in range(3)])
-def test_is_maximalist(circuit):
+def test_is_maximalist(circuit) -> None:
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
     transitive_closure = networkx.dag.transitive_closure(dag)
     assert cirq.contrib.CircuitDag(incoming_graph_data=transitive_closure) == dag
@@ -230,7 +232,7 @@ def _get_circuits_and_is_blockers():
 
 
 @pytest.mark.parametrize('circuit, is_blocker', _get_circuits_and_is_blockers())
-def test_findall_nodes_until_blocked(circuit, is_blocker):
+def test_findall_nodes_until_blocked(circuit, is_blocker) -> None:
     dag = cirq.contrib.CircuitDag.from_circuit(circuit)
     all_nodes = list(dag.ordered_nodes())
     found_nodes = list(dag.findall_nodes_until_blocked(is_blocker))

cirq/contrib/custom_simulators/custom_state_simulator.py

@@ -14,14 +14,14 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Generic, Sequence, Type, TYPE_CHECKING
-
-import numpy as np
+from typing import Any, Generic, Sequence, TYPE_CHECKING
 
 from cirq import sim
 from cirq.sim.simulation_state import TSimulationState
 
 if TYPE_CHECKING:
+    import numpy as np
+
     import cirq
 
 
@@ -47,7 +47,7 @@ class CustomStateSimulator(
 
     def __init__(
         self,
-        state_type: Type[TSimulationState],
+        state_type: type[TSimulationState],
         *,
         noise: cirq.NOISE_MODEL_LIKE = None,
         split_untangled_states: bool = False,
@@ -66,7 +66,7 @@ class CustomStateSimulator(
     def _create_simulator_trial_result(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[TSimulationState],
     ) -> CustomStateTrialResult[TSimulationState]:
         return CustomStateTrialResult(

cirq/contrib/custom_simulators/custom_state_simulator_test.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import List, Sequence, Tuple
+from typing import Sequence
 
 import numpy as np
 import sympy
@@ -24,13 +24,15 @@ from cirq.contrib.custom_simulators.custom_state_simulator import CustomStateSim
 
 
 class ComputationalBasisState(cirq.qis.QuantumStateRepresentation):
-    def __init__(self, initial_state: List[int]):
+    def __init__(self, initial_state: list[int]):
         self.basis = initial_state
 
     def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisState:
         return ComputationalBasisState(self.basis)  # pragma: no cover
 
-    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
+    def measure(
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         return [self.basis[i] for i in axes]
 
 
@@ -49,7 +51,7 @@ class ComputationalBasisSimState(cirq.SimulationState[ComputationalBasisState]):
             return True
 
 
-def create_test_circuit():
+def create_test_circuit() -> cirq.Circuit:
     q0, q1 = cirq.LineQid.range(2, dimension=3)
     x = cirq.XPowGate(dimension=3)
     return cirq.Circuit(
@@ -64,26 +66,27 @@ def create_test_circuit():
     )
 
 
-def test_basis_state_simulator():
+def test_basis_state_simulator() -> None:
     sim = CustomStateSimulator(ComputationalBasisSimState)
     circuit = create_test_circuit()
     r = sim.simulate(circuit)
     assert r.measurements == {'a': np.array([1]), 'b': np.array([2])}
-    assert r._final_simulator_state._state.basis == [2, 2]
+    assert r._final_simulator_state._state.basis == [2, 2]  # type: ignore[attr-defined]
 
 
-def test_built_in_states():
+def test_built_in_states() -> None:
     # Verify this works for the built-in states too, you just lose the custom step/trial results.
     sim = CustomStateSimulator(cirq.StateVectorSimulationState)
     circuit = create_test_circuit()
     r = sim.simulate(circuit)
     assert r.measurements == {'a': np.array([1]), 'b': np.array([2])}
     assert np.allclose(
-        r._final_simulator_state._state._state_vector, [[0, 0, 0], [0, 0, 0], [0, 0, 1]]
+        r._final_simulator_state._state._state_vector,  # type: ignore[attr-defined]
+        [[0, 0, 0], [0, 0, 0], [0, 0, 1]],
     )
 
 
-def test_product_state_mode_built_in_state():
+def test_product_state_mode_built_in_state() -> None:
     sim = CustomStateSimulator(cirq.StateVectorSimulationState, split_untangled_states=True)
     circuit = create_test_circuit()
     r = sim.simulate(circuit)
@@ -99,16 +102,16 @@ def test_product_state_mode_built_in_state():
     )
 
 
-def test_noise():
+def test_noise() -> None:
     x = cirq.XPowGate(dimension=3)
     sim = CustomStateSimulator(ComputationalBasisSimState, noise=x**2)
     circuit = create_test_circuit()
     r = sim.simulate(circuit)
     assert r.measurements == {'a': np.array([2]), 'b': np.array([2])}
-    assert r._final_simulator_state._state.basis == [1, 2]
+    assert r._final_simulator_state._state.basis == [1, 2]  # type: ignore[attr-defined]
 
 
-def test_run():
+def test_run() -> None:
     sim = CustomStateSimulator(ComputationalBasisSimState)
     circuit = create_test_circuit()
     r = sim.run(circuit)
@@ -116,7 +119,7 @@ def test_run():
     assert np.allclose(r.records['b'], np.array([[1], [2]]))
 
 
-def test_parameterized_repetitions():
+def test_parameterized_repetitions() -> None:
     q = cirq.LineQid(0, dimension=5)
     x = cirq.XPowGate(dimension=5)
     circuit = cirq.Circuit(
@@ -136,13 +139,15 @@ def test_parameterized_repetitions():
 
 
 class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
-    def __init__(self, initial_state: List[int]):
+    def __init__(self, initial_state: list[int]):
         self.basis = initial_state
 
     def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisProductState:
         return ComputationalBasisProductState(self.basis)
 
-    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
+    def measure(
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         return [self.basis[i] for i in axes]
 
     def kron(self, other: ComputationalBasisProductState) -> ComputationalBasisProductState:
@@ -150,7 +155,7 @@ class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple[ComputationalBasisProductState, ComputationalBasisProductState]:
+    ) -> tuple[ComputationalBasisProductState, ComputationalBasisProductState]:
         extracted = ComputationalBasisProductState(
             [self.basis[i] for i in axes]
         )  # pragma: no cover
@@ -182,7 +187,7 @@ class ComputationalBasisSimProductState(cirq.SimulationState[ComputationalBasisP
             return True
 
 
-def test_product_state_mode():
+def test_product_state_mode() -> None:
     sim = CustomStateSimulator(ComputationalBasisSimProductState, split_untangled_states=True)
     circuit = create_test_circuit()
     r = sim.simulate(circuit)

cirq/contrib/graph_device/graph_device.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import abc
 import itertools
-from typing import cast, Iterable, Optional, Tuple, TYPE_CHECKING
+from typing import Any, cast, Hashable, Iterable, NoReturn, TYPE_CHECKING
 
 from cirq import devices, ops, value
 from cirq.contrib.graph_device.hypergraph import UndirectedHypergraph
@@ -98,7 +98,7 @@ def is_crosstalk_graph(graph: UndirectedHypergraph) -> bool:
     return True
 
 
-def raise_crosstalk_error(*ops: ops.Operation):
+def raise_crosstalk_error(*ops: ops.Operation) -> NoReturn:
     raise ValueError(f'crosstalk on {ops}')
 
 
@@ -122,8 +122,8 @@ class UndirectedGraphDevice(devices.Device):
 
     def __init__(
         self,
-        device_graph: Optional[UndirectedHypergraph] = None,
-        crosstalk_graph: Optional[UndirectedHypergraph] = None,
+        device_graph: UndirectedHypergraph | None = None,
+        crosstalk_graph: UndirectedHypergraph | None = None,
     ) -> None:
         """Inits UndirectedGraphDevice.
 
@@ -152,15 +152,15 @@ class UndirectedGraphDevice(devices.Device):
         self.crosstalk_graph = crosstalk_graph
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
-        return cast(Tuple['cirq.Qid', ...], tuple(sorted(self.device_graph.vertices)))
+    def qubits(self) -> tuple[cirq.Qid, ...]:
+        return cast(tuple['cirq.Qid', ...], tuple(sorted(self.device_graph.vertices)))
 
     @property
-    def edges(self):
+    def edges(self) -> tuple[frozenset[Hashable], ...]:
         return tuple(sorted(self.device_graph.edges))
 
     @property
-    def labelled_edges(self):
+    def labelled_edges(self) -> dict[frozenset, Any]:
         return self.device_graph.labelled_edges
 
     def get_device_edge_from_op(self, operation: ops.Operation) -> UndirectedGraphDeviceEdge:
@@ -174,8 +174,8 @@ class UndirectedGraphDevice(devices.Device):
             device_edge = self.get_device_edge_from_op(operation)
         except Exception as error:
             if frozenset(operation.qubits) not in self.device_graph.edges:
-                error = ValueError(f'{operation.qubits} not in device graph edges')
-            raise error
+                raise ValueError(f'{operation.qubits} not in device graph edges') from error
+            raise  # pragma: no cover
         device_edge.validate_operation(operation)
 
     def validate_crosstalk(
@@ -185,6 +185,7 @@ class UndirectedGraphDevice(devices.Device):
             self.crosstalk_graph._adjacency_lists.get(frozenset(operation.qubits), ())
         )
         for crosstalk_edge in adjacent_crosstalk_edges:
+            # pylint: disable=unreachable
             label = self.crosstalk_graph.labelled_edges[crosstalk_edge]
             validator = (
                 raise_crosstalk_error(operation, *other_operations) if (label is None) else label
@@ -194,7 +195,7 @@ class UndirectedGraphDevice(devices.Device):
             ):
                 validator(operation, *crosstalk_operations)
 
-    def validate_moment(self, moment: cirq.Moment):
+    def validate_moment(self, moment: cirq.Moment) -> None:
         super().validate_moment(moment)
         ops = moment.operations
         for i, op in enumerate(ops):