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

cirq/sim/simulator_base.py

@@ -14,22 +14,11 @@
 
 """Batteries-included class for Cirq's built-in simulators."""
 
+from __future__ import annotations
+
 import abc
 import collections
-from typing import (
-    Any,
-    cast,
-    Dict,
-    Generic,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TYPE_CHECKING,
-    TypeVar,
-)
+from typing import Any, cast, Generic, Iterator, Sequence, TYPE_CHECKING, TypeVar
 
 import numpy as np
 
@@ -91,9 +80,9 @@ class SimulatorBase(
     def __init__(
         self,
         *,
-        dtype: Type[np.complexfloating] = np.complex64,
-        noise: 'cirq.NOISE_MODEL_LIKE' = None,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        dtype: type[np.complexfloating] = np.complex64,
+        noise: cirq.NOISE_MODEL_LIKE = None,
+        seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         split_untangled_states: bool = False,
     ):
         """Initializes the simulator.
@@ -112,15 +101,15 @@ class SimulatorBase(
         self._split_untangled_states = split_untangled_states
 
     @property
-    def noise(self) -> 'cirq.NoiseModel':
+    def noise(self) -> cirq.NoiseModel:
         return self._noise
 
     @abc.abstractmethod
     def _create_partial_simulation_state(
         self,
         initial_state: Any,
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
     ) -> TSimulationState:
         """Creates an instance of the TSimulationState class for the simulator.
 
@@ -171,14 +160,14 @@ class SimulatorBase(
         return protocols.has_unitary(val)
 
     def _base_iterator(
-        self, circuit: 'cirq.AbstractCircuit', qubits: Tuple['cirq.Qid', ...], initial_state: Any
+        self, circuit: cirq.AbstractCircuit, qubits: tuple[cirq.Qid, ...], initial_state: Any
     ) -> Iterator[TStepResultBase]:
         sim_state = self._create_simulation_state(initial_state, qubits)
         return self._core_iterator(circuit, sim_state)
 
     def _core_iterator(
         self,
-        circuit: 'cirq.AbstractCircuit',
+        circuit: cirq.AbstractCircuit,
         sim_state: SimulationStateBase[TSimulationState],
         all_measurements_are_terminal: bool = False,
     ) -> Iterator[TStepResultBase]:
@@ -204,7 +193,7 @@ class SimulatorBase(
             return
 
         noisy_moments = self.noise.noisy_moments(circuit, sorted(circuit.all_qubits()))
-        measured: Dict[Tuple['cirq.Qid', ...], bool] = collections.defaultdict(bool)
+        measured: dict[tuple[cirq.Qid, ...], bool] = collections.defaultdict(bool)
         for moment in noisy_moments:
             for op in ops.flatten_to_ops(moment):
                 try:
@@ -224,11 +213,8 @@ class SimulatorBase(
             yield self._create_step_result(sim_state)
 
     def _run(
-        self,
-        circuit: 'cirq.AbstractCircuit',
-        param_resolver: 'cirq.ParamResolver',
-        repetitions: int,
-    ) -> Dict[str, np.ndarray]:
+        self, circuit: cirq.AbstractCircuit, param_resolver: cirq.ParamResolver, repetitions: int
+    ) -> dict[str, np.ndarray]:
         """See definition in `cirq.SimulatesSamples`."""
         param_resolver = param_resolver or study.ParamResolver({})
         resolved_circuit = protocols.resolve_parameters(circuit, param_resolver)
@@ -241,9 +227,10 @@ class SimulatorBase(
             if self._can_be_in_run_prefix(self.noise)
             else (resolved_circuit[0:0], resolved_circuit)
         )
-        step_result = None
+        step_result: TStepResultBase | None = None
         for step_result in self._core_iterator(circuit=prefix, sim_state=sim_state):
             pass
+        assert step_result is not None
 
         general_ops = list(general_suffix.all_operations())
         if all(isinstance(op.gate, ops.MeasurementGate) for op in general_ops):
@@ -257,7 +244,7 @@ class SimulatorBase(
                 measurement_ops, repetitions, seed=self._prng, _allow_repeated=True
             )
 
-        records: Dict['cirq.MeasurementKey', List[Sequence[Sequence[int]]]] = {}
+        records: dict[cirq.MeasurementKey, list[Sequence[Sequence[int]]]] = {}
         for i in range(repetitions):
             for step_result in self._core_iterator(
                 general_suffix,
@@ -286,9 +273,9 @@ class SimulatorBase(
 
     def simulate_sweep_iter(
         self,
-        program: 'cirq.AbstractCircuit',
-        params: 'cirq.Sweepable',
-        qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
+        program: cirq.AbstractCircuit,
+        params: cirq.Sweepable,
+        qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
     ) -> Iterator[TSimulationTrialResult]:
         """Simulates the supplied Circuit.
@@ -313,7 +300,7 @@ class SimulatorBase(
             possible parameter resolver.
         """
 
-        def sweep_prefixable(op: 'cirq.Operation'):
+        def sweep_prefixable(op: cirq.Operation):
             return self._can_be_in_run_prefix(op) and not protocols.is_parameterized(op)
 
         qubits = ops.QubitOrder.as_qubit_order(qubit_order).order_for(program.all_qubits())
@@ -324,21 +311,22 @@ class SimulatorBase(
             if self._can_be_in_run_prefix(self.noise)
             else (program[0:0], program)
         )
-        step_result = None
+        step_result: TStepResultBase | None = None
         for step_result in self._core_iterator(circuit=prefix, sim_state=sim_state):
             pass
+        assert step_result is not None
         sim_state = step_result._sim_state
         yield from super().simulate_sweep_iter(suffix, params, qubit_order, sim_state)
 
     def _create_simulation_state(
-        self, initial_state: Any, qubits: Sequence['cirq.Qid']
+        self, initial_state: Any, qubits: Sequence[cirq.Qid]
     ) -> SimulationStateBase[TSimulationState]:
         if isinstance(initial_state, SimulationStateBase):
             return initial_state
 
         classical_data = value.ClassicalDataDictionaryStore()
         if self._split_untangled_states:
-            args_map: Dict[Optional['cirq.Qid'], TSimulationState] = {}
+            args_map: dict[cirq.Qid | None, TSimulationState] = {}
             if isinstance(initial_state, int):
                 for q in reversed(qubits):
                     args_map[q] = self._create_partial_simulation_state(
@@ -375,7 +363,7 @@ class StepResultBase(
             sim_state: The `SimulationStateBase` for this step.
         """
         super().__init__(sim_state)
-        self._merged_sim_state_cache: Optional[TSimulationState] = None
+        self._merged_sim_state_cache: TSimulationState | None = None
         qubits = sim_state.qubits
         self._qubits = qubits
         self._qubit_mapping = {q: i for i, q in enumerate(qubits)}
@@ -393,9 +381,9 @@ class StepResultBase(
 
     def sample(
         self,
-        qubits: List['cirq.Qid'],
+        qubits: list[cirq.Qid],
         repetitions: int = 1,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> np.ndarray:
         return self._sim_state.sample(qubits, repetitions, seed)
 
@@ -408,8 +396,8 @@ class SimulationTrialResultBase(
     def __init__(
         self,
         params: study.ParamResolver,
-        measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[TSimulationState]',
+        measurements: dict[str, np.ndarray],
+        final_simulator_state: cirq.SimulationStateBase[TSimulationState],
     ) -> None:
         """Initializes the `SimulationTrialResultBase` class.
 
@@ -423,9 +411,9 @@ class SimulationTrialResultBase(
                 trial finishes.
         """
         super().__init__(params, measurements, final_simulator_state=final_simulator_state)
-        self._merged_sim_state_cache: Optional[TSimulationState] = None
+        self._merged_sim_state_cache: TSimulationState | None = None
 
-    def get_state_containing_qubit(self, qubit: 'cirq.Qid') -> TSimulationState:
+    def get_state_containing_qubit(self, qubit: cirq.Qid) -> TSimulationState:
         """Returns the independent state space containing the qubit.
 
         Args:
@@ -438,7 +426,7 @@ class SimulationTrialResultBase(
     def _get_substates(self) -> Sequence[TSimulationState]:
         state = self._final_simulator_state
         if isinstance(state, SimulationProductState):
-            substates: Dict[TSimulationState, int] = {}
+            substates: dict[TSimulationState, int] = {}
             for q in state.qubits:
                 substates[self.get_state_containing_qubit(q)] = 0
             substates[state[None]] = 0

cirq/sim/simulator_base_test.py

@@ -11,8 +11,11 @@
 # 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 math
-from typing import Any, Dict, List, Sequence, Tuple
+from typing import Any, Sequence
 
 import numpy as np
 import pytest
@@ -29,12 +32,12 @@ class CountingState(cirq.qis.QuantumStateRepresentation):
         self.copy_count = copy_count
 
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
-    ) -> List[int]:
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         self.measurement_count += 1
         return [self.gate_count]
 
-    def kron(self, other: 'CountingState') -> 'CountingState':
+    def kron(self, other: CountingState) -> CountingState:
         return CountingState(
             self.data,
             self.gate_count + other.gate_count,
@@ -44,15 +47,15 @@ class CountingState(cirq.qis.QuantumStateRepresentation):
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple['CountingState', 'CountingState']:
+    ) -> tuple[CountingState, CountingState]:
         return CountingState(
             self.data, self.gate_count, self.measurement_count, self.copy_count
         ), CountingState(self.data)
 
-    def reindex(self, axes: Sequence[int]) -> 'CountingState':
+    def reindex(self, axes: Sequence[int]) -> CountingState:
         return CountingState(self.data, self.gate_count, self.measurement_count, self.copy_count)
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'CountingState':
+    def copy(self, deep_copy_buffers: bool = True) -> CountingState:
         return CountingState(
             self.data, self.gate_count, self.measurement_count, self.copy_count + 1
         )
@@ -64,7 +67,7 @@ class CountingSimulationState(cirq.SimulationState[CountingState]):
         super().__init__(state=state_obj, qubits=qubits, classical_data=classical_data)
 
     def _act_on_fallback_(
-        self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
+        self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
     ) -> bool:
         self._state.gate_count += 1
         return True
@@ -95,11 +98,11 @@ class SplittableCountingSimulationState(CountingSimulationState):
 class CountingStepResult(cirq.StepResultBase[CountingSimulationState]):
     def sample(
         self,
-        qubits: List[cirq.Qid],
+        qubits: list[cirq.Qid],
         repetitions: int = 1,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> np.ndarray:
-        measurements: List[List[int]] = []
+        measurements: list[list[int]] = []
         for _ in range(repetitions):
             measurements.append(self._merged_sim_state._perform_measurement(qubits))
         return np.array(measurements, dtype=int)
@@ -121,7 +124,7 @@ class CountingSimulator(
     def _create_partial_simulation_state(
         self,
         initial_state: Any,
-        qubits: Sequence['cirq.Qid'],
+        qubits: Sequence[cirq.Qid],
         classical_data: cirq.ClassicalDataStore,
     ) -> CountingSimulationState:
         return CountingSimulationState(
@@ -131,8 +134,8 @@ class CountingSimulator(
     def _create_simulator_trial_result(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[CountingSimulationState]',
+        measurements: dict[str, np.ndarray],
+        final_simulator_state: cirq.SimulationStateBase[CountingSimulationState],
     ) -> CountingTrialResult:
         return CountingTrialResult(
             params, measurements, final_simulator_state=final_simulator_state
@@ -151,7 +154,7 @@ class SplittableCountingSimulator(CountingSimulator):
     def _create_partial_simulation_state(
         self,
         initial_state: Any,
-        qubits: Sequence['cirq.Qid'],
+        qubits: Sequence[cirq.Qid],
         classical_data: cirq.ClassicalDataStore,
     ) -> CountingSimulationState:
         return SplittableCountingSimulationState(
@@ -219,7 +222,9 @@ def test_noise_applied_measurement_gate():
 def test_parameterized_copies_all_but_last():
     sim = CountingSimulator()
     n = 4
-    rs = sim.simulate_sweep(cirq.Circuit(cirq.X(q0) ** 'a'), [{'a': i} for i in range(n)])
+    rs = sim.simulate_sweep(
+        cirq.Circuit(cirq.X(q0) ** sympy.Symbol('a')), [{'a': i} for i in range(n)]
+    )
     for i in range(n):
         r = rs[i]
         assert r._final_simulator_state.gate_count == 1

cirq/sim/simulator_test.py

@@ -11,9 +11,13 @@
 # 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.
+
 """Tests for simulator.py"""
+
+from __future__ import annotations
+
 import abc
-from typing import Any, Dict, Generic, List, Sequence, Union
+from typing import Any, Generic, Iterator, Sequence
 from unittest import mock
 
 import duet
@@ -37,10 +41,10 @@ from cirq.sim.simulator import (
 class FakeSimulatesSamples(SimulatesSamples):
     """A SimulatesSamples that returns specified values from _run."""
 
-    def __init__(self, run_output: Dict[str, np.ndarray]):
+    def __init__(self, run_output: dict[str, np.ndarray]):
         self._run_output = run_output
 
-    def _run(self, *args, **kwargs) -> Dict[str, np.ndarray]:
+    def _run(self, *args, **kwargs) -> dict[str, np.ndarray]:
         return self._run_output
 
 
@@ -64,17 +68,22 @@ class FakeStepResult(cirq.StepResult):
 
 class SimulatesIntermediateStateImpl(
     Generic[TStepResult, TSimulationState],
-    SimulatesIntermediateState[TStepResult, 'SimulationTrialResult', TSimulationState],
+    SimulatesIntermediateState[TStepResult, SimulationTrialResult, TSimulationState],
     metaclass=abc.ABCMeta,
 ):
     """A SimulatesIntermediateState that uses the default SimulationTrialResult type."""
 
+    def _base_iterator(
+        self, circuit: cirq.AbstractCircuit, qubits: tuple[cirq.Qid, ...], initial_state: Any
+    ) -> Iterator[TStepResult]:
+        raise NotImplementedError
+
     def _create_simulator_trial_result(
         self,
         params: study.ParamResolver,
-        measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[TSimulationState]',
-    ) -> 'SimulationTrialResult':
+        measurements: dict[str, np.ndarray],
+        final_simulator_state: cirq.SimulationStateBase[TSimulationState],
+    ) -> SimulationTrialResult:
         """This method creates a default trial result.
 
         Args:
@@ -455,7 +464,7 @@ def test_iter_definitions():
 
         def compute_amplitudes_sweep(
             self,
-            program: 'cirq.AbstractCircuit',
+            program: cirq.AbstractCircuit,
             bitstrings: Sequence[int],
             params: study.Sweepable,
             qubit_order: cirq.QubitOrderOrList = cirq.QubitOrder.DEFAULT,
@@ -464,22 +473,22 @@ def test_iter_definitions():
 
         def simulate_expectation_values_sweep(
             self,
-            program: 'cirq.AbstractCircuit',
-            observables: Union['cirq.PauliSumLike', List['cirq.PauliSumLike']],
-            params: 'study.Sweepable',
+            program: cirq.AbstractCircuit,
+            observables: cirq.PauliSumLike | list[cirq.PauliSumLike],
+            params: study.Sweepable,
             qubit_order: cirq.QubitOrderOrList = cirq.QubitOrder.DEFAULT,
             initial_state: Any = None,
             permit_terminal_measurements: bool = False,
-        ) -> List[List[float]]:
+        ) -> list[list[float]]:
             return [[1.0]]
 
         def simulate_sweep(
             self,
-            program: 'cirq.AbstractCircuit',
+            program: cirq.AbstractCircuit,
             params: study.Sweepable,
             qubit_order: cirq.QubitOrderOrList = cirq.QubitOrder.DEFAULT,
             initial_state: Any = None,
-        ) -> List[SimulationTrialResult]:
+        ) -> list[SimulationTrialResult]:
             return [mock_trial_result]
 
     non_iter_sim = FakeNonIterSimulatorImpl()

cirq/sim/sparse_simulator.py

@@ -14,7 +14,9 @@
 
 """A simulator that uses numpy's einsum for sparse matrix operations."""
 
-from typing import Any, Iterator, List, Optional, Sequence, Type, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -125,9 +127,9 @@ class Simulator(
     def __init__(
         self,
         *,
-        dtype: Type[np.complexfloating] = np.complex64,
-        noise: 'cirq.NOISE_MODEL_LIKE' = None,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        dtype: type[np.complexfloating] = np.complex64,
+        noise: cirq.NOISE_MODEL_LIKE = None,
+        seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         split_untangled_states: bool = True,
     ):
         """A sparse matrix simulator.
@@ -152,9 +154,9 @@ class Simulator(
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union['cirq.STATE_VECTOR_LIKE', 'cirq.StateVectorSimulationState'],
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
+        initial_state: cirq.STATE_VECTOR_LIKE | cirq.StateVectorSimulationState,
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
     ):
         """Creates the StateVectorSimulationState for a circuit.
 
@@ -183,19 +185,19 @@ class Simulator(
         )
 
     def _create_step_result(
-        self, sim_state: 'cirq.SimulationStateBase[cirq.StateVectorSimulationState]'
+        self, sim_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState]
     ):
         return SparseSimulatorStep(sim_state=sim_state, dtype=self._dtype)
 
     def simulate_expectation_values_sweep_iter(
         self,
-        program: 'cirq.AbstractCircuit',
-        observables: Union['cirq.PauliSumLike', List['cirq.PauliSumLike']],
-        params: 'cirq.Sweepable',
-        qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
+        program: cirq.AbstractCircuit,
+        observables: cirq.PauliSumLike | list[cirq.PauliSumLike],
+        params: cirq.Sweepable,
+        qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
         permit_terminal_measurements: bool = False,
-    ) -> Iterator[List[float]]:
+    ) -> Iterator[list[float]]:
         if not permit_terminal_measurements and program.are_any_measurements_terminal():
             raise ValueError(
                 'Provided circuit has terminal measurements, which may '
@@ -204,7 +206,7 @@ class Simulator(
             )
         qubit_order = ops.QubitOrder.as_qubit_order(qubit_order)
         qmap = {q: i for i, q in enumerate(qubit_order.order_for(program.all_qubits()))}
-        if not isinstance(observables, List):
+        if not isinstance(observables, list):
             observables = [observables]
         pslist = [ops.PauliSum.wrap(pslike) for pslike in observables]
         yield from (
@@ -222,8 +224,8 @@ class SparseSimulatorStep(
 
     def __init__(
         self,
-        sim_state: 'cirq.SimulationStateBase[cirq.StateVectorSimulationState]',
-        dtype: Type[np.complexfloating] = np.complex64,
+        sim_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState],
+        dtype: type[np.complexfloating] = np.complex64,
     ):
         """Results of a step of the simulator.
 
@@ -235,7 +237,7 @@ class SparseSimulatorStep(
         qubit_map = {q: i for i, q in enumerate(sim_state.qubits)}
         super().__init__(sim_state=sim_state, qubit_map=qubit_map)
         self._dtype = dtype
-        self._state_vector: Optional[np.ndarray] = None
+        self._state_vector: np.ndarray | None = None
 
     def state_vector(self, copy: bool = False):
         """Return the state vector at this point in the computation.