cirq-core 1.6.0.dev20250520054601__py3-none-any.whl → 1.6.0.dev20250520181654__py3-none-any.whl

cirq/sim/density_matrix_simulator.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Sequence, Type, TYPE_CHECKING, Union
+from typing import Any, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -119,7 +119,7 @@ class DensityMatrixSimulator(
     def __init__(
         self,
         *,
-        dtype: Type[np.complexfloating] = np.complex64,
+        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,
@@ -151,7 +151,7 @@ class DensityMatrixSimulator(
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union[np.ndarray, cirq.STATE_VECTOR_LIKE, cirq.DensityMatrixSimulationState],
+        initial_state: np.ndarray | cirq.STATE_VECTOR_LIKE | cirq.DensityMatrixSimulationState,
         qubits: Sequence[cirq.Qid],
         classical_data: cirq.ClassicalDataStore,
     ) -> cirq.DensityMatrixSimulationState:
@@ -192,7 +192,7 @@ class DensityMatrixSimulator(
     def _create_simulator_trial_result(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[cirq.DensityMatrixSimulationState],
     ) -> cirq.DensityMatrixTrialResult:
         return DensityMatrixTrialResult(
@@ -203,12 +203,12 @@ class DensityMatrixSimulator(
     def simulate_expectation_values_sweep(
         self,
         program: cirq.AbstractCircuit,
-        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+        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,
-    ) -> List[List[float]]:
+    ) -> list[list[float]]:
         if not permit_terminal_measurements and program.are_any_measurements_terminal():
             raise ValueError(
                 'Provided circuit has terminal measurements, which may '
@@ -218,7 +218,7 @@ class DensityMatrixSimulator(
         swept_evs = []
         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]
         for param_resolver in study.to_resolvers(params):
@@ -245,7 +245,7 @@ class DensityMatrixStepResult(simulator_base.StepResultBase['cirq.DensityMatrixS
     def __init__(
         self,
         sim_state: cirq.SimulationStateBase[cirq.DensityMatrixSimulationState],
-        dtype: Type[np.complexfloating] = np.complex64,
+        dtype: type[np.complexfloating] = np.complex64,
     ):
         """DensityMatrixStepResult.
 
@@ -256,7 +256,7 @@ class DensityMatrixStepResult(simulator_base.StepResultBase['cirq.DensityMatrixS
         """
         super().__init__(sim_state)
         self._dtype = dtype
-        self._density_matrix: Optional[np.ndarray] = None
+        self._density_matrix: np.ndarray | None = None
 
     def density_matrix(self, copy=True):
         """Returns the density matrix at this step in the simulation.
@@ -356,13 +356,13 @@ class DensityMatrixTrialResult(
     def __init__(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[cirq.DensityMatrixSimulationState],
     ) -> None:
         super().__init__(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
         )
-        self._final_density_matrix: Optional[np.ndarray] = None
+        self._final_density_matrix: np.ndarray | None = None
 
     @property
     def final_density_matrix(self) -> np.ndarray:

cirq/sim/density_matrix_utils.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import List, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -31,7 +31,7 @@ def sample_density_matrix(
     density_matrix: np.ndarray,
     indices: Sequence[int],
     *,  # Force keyword arguments
-    qid_shape: Optional[Tuple[int, ...]] = None,
+    qid_shape: tuple[int, ...] | None = None,
     repetitions: int = 1,
     seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> np.ndarray:
@@ -96,10 +96,10 @@ def sample_density_matrix(
 def measure_density_matrix(
     density_matrix: np.ndarray,
     indices: Sequence[int],
-    qid_shape: Optional[Tuple[int, ...]] = None,
-    out: Optional[np.ndarray] = None,
+    qid_shape: tuple[int, ...] | None = None,
+    out: np.ndarray | None = None,
     seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-) -> Tuple[List[int], np.ndarray]:
+) -> tuple[list[int], np.ndarray]:
     """Performs a measurement of the density matrix in the computational basis.
 
     This does not modify `density_matrix` unless the optional `out` is
@@ -187,7 +187,7 @@ def measure_density_matrix(
 
 
 def _probs(
-    density_matrix: np.ndarray, indices: Sequence[int], qid_shape: Tuple[int, ...]
+    density_matrix: np.ndarray, indices: Sequence[int], qid_shape: tuple[int, ...]
 ) -> np.ndarray:
     """Returns the probabilities for a measurement on the given indices."""
     # Only diagonal elements matter.
@@ -197,8 +197,8 @@ def _probs(
 
 
 def _validate_density_matrix_qid_shape(
-    density_matrix: np.ndarray, qid_shape: Tuple[int, ...]
-) -> Tuple[int, ...]:
+    density_matrix: np.ndarray, qid_shape: tuple[int, ...]
+) -> tuple[int, ...]:
     """Validates that a tensor's shape is a valid shape for qids and returns the
     qid shape.
     """
@@ -244,7 +244,7 @@ def _validate_num_qubits(density_matrix: np.ndarray) -> int:
     return int(row_size).bit_length() - 1
 
 
-def _indices_shape(qid_shape: Tuple[int, ...], indices: Sequence[int]) -> Tuple[int, ...]:
+def _indices_shape(qid_shape: tuple[int, ...], indices: Sequence[int]) -> tuple[int, ...]:
     """Validates that the indices have values within range of `len(qid_shape)`."""
     if any(index < 0 for index in indices):
         raise IndexError(f'Negative index in indices: {indices}')

cirq/sim/mux.py

@@ -19,7 +19,7 @@ Filename is a reference to multiplexing.
 
 from __future__ import annotations
 
-from typing import List, Optional, Sequence, Type, TYPE_CHECKING, Union
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -32,7 +32,7 @@ from cirq.transformers import measurement_transformers
 if TYPE_CHECKING:
     import cirq
 
-CIRCUIT_LIKE = Union[circuits.Circuit, ops.Gate, ops.OP_TREE]
+CIRCUIT_LIKE = circuits.Circuit | ops.Gate | ops.OP_TREE
 document(
     CIRCUIT_LIKE,
     """A `circuits.Circuit` or a value that can be trivially converted into it:
@@ -52,9 +52,9 @@ def sample(
     program: cirq.Circuit,
     *,
     noise: cirq.NOISE_MODEL_LIKE = None,
-    param_resolver: Optional[cirq.ParamResolver] = None,
+    param_resolver: cirq.ParamResolver | None = None,
     repetitions: int = 1,
-    dtype: Type[np.complexfloating] = np.complex64,
+    dtype: type[np.complexfloating] = np.complex64,
     seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> cirq.Result:
     """Simulates sampling from the given circuit.
@@ -111,7 +111,7 @@ def final_state_vector(
     param_resolver: cirq.ParamResolverOrSimilarType = None,
     qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
     ignore_terminal_measurements: bool = False,
-    dtype: Type[np.complexfloating] = np.complex64,
+    dtype: type[np.complexfloating] = np.complex64,
     seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> np.ndarray:
     """Returns the state vector resulting from acting operations on a state.
@@ -181,7 +181,7 @@ def sample_sweep(
     *,
     noise: cirq.NOISE_MODEL_LIKE = None,
     repetitions: int = 1,
-    dtype: Type[np.complexfloating] = np.complex64,
+    dtype: type[np.complexfloating] = np.complex64,
     seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> Sequence[cirq.Result]:
     """Runs the supplied Circuit, mimicking quantum hardware.
@@ -206,7 +206,7 @@ def sample_sweep(
     """
     prng = value.parse_random_state(seed)
 
-    trial_results: List[study.Result] = []
+    trial_results: list[study.Result] = []
     for param_resolver in study.to_resolvers(params):
         measurements = sample(
             program,
@@ -227,8 +227,8 @@ def final_density_matrix(
     initial_state: cirq.STATE_VECTOR_LIKE = 0,
     param_resolver: cirq.ParamResolverOrSimilarType = None,
     qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
-    dtype: Type[np.complexfloating] = np.complex64,
-    seed: Optional[Union[int, np.random.RandomState]] = None,
+    dtype: type[np.complexfloating] = np.complex64,
+    seed: int | np.random.RandomState | None = None,
     ignore_measurement_results: bool = True,
 ) -> np.ndarray:
     """Returns the density matrix resulting from simulating the circuit.

cirq/sim/simulation_product_state.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from collections import abc
-from typing import Any, Dict, Generic, Iterator, List, Mapping, Optional, Sequence, TYPE_CHECKING
+from typing import Any, Generic, Iterator, Mapping, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -34,10 +34,10 @@ class SimulationProductState(
 
     def __init__(
         self,
-        sim_states: Dict[Optional[cirq.Qid], TSimulationState],
+        sim_states: dict[cirq.Qid | None, TSimulationState],
         qubits: Sequence[cirq.Qid],
         split_untangled_states: bool,
-        classical_data: Optional[cirq.ClassicalDataStore] = None,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Initializes the class.
 
@@ -57,7 +57,7 @@ class SimulationProductState(
         self._split_untangled_states = split_untangled_states
 
     @property
-    def sim_states(self) -> Mapping[Optional[cirq.Qid], TSimulationState]:
+    def sim_states(self) -> Mapping[cirq.Qid | None, TSimulationState]:
         return self._sim_states
 
     @property
@@ -108,7 +108,7 @@ class SimulationProductState(
 
         # Go through the op's qubits and join any disparate SimulationState states
         # into a new combined state.
-        op_args_opt: Optional[TSimulationState] = None
+        op_args_opt: TSimulationState | None = None
         for q in qubits:
             if op_args_opt is None:
                 op_args_opt = self.sim_states[q]
@@ -152,12 +152,12 @@ class SimulationProductState(
 
     def sample(
         self,
-        qubits: List[cirq.Qid],
+        qubits: list[cirq.Qid],
         repetitions: int = 1,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> np.ndarray:
         columns = []
-        selected_order: List[ops.Qid] = []
+        selected_order: list[ops.Qid] = []
         q_set = set(qubits)
         for v in dict.fromkeys(self.sim_states.values()):
             qs = [q for q in v.qubits if q in q_set]
@@ -170,11 +170,11 @@ class SimulationProductState(
         index_order = [qubit_map[q] for q in qubits]
         return stacked[:, index_order]
 
-    def __getitem__(self, item: Optional[cirq.Qid]) -> TSimulationState:
+    def __getitem__(self, item: cirq.Qid | None) -> TSimulationState:
         return self.sim_states[item]
 
     def __len__(self) -> int:
         return len(self.sim_states)
 
-    def __iter__(self) -> Iterator[Optional[cirq.Qid]]:
+    def __iter__(self) -> Iterator[cirq.Qid | None]:
         return iter(self.sim_states)

cirq/sim/simulation_product_state_test.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Optional, Sequence
+from typing import Any, Sequence
 
 import cirq
 
@@ -57,7 +57,7 @@ qs2 = cirq.LineQubit.range(2)
 def create_container(
     qubits: Sequence[cirq.Qid], split_untangled_states=True
 ) -> cirq.SimulationProductState[EmptySimulationState]:
-    state_map: Dict[Optional[cirq.Qid], EmptySimulationState] = {}
+    state_map: dict[cirq.Qid | None, EmptySimulationState] = {}
     log = cirq.ClassicalDataDictionaryStore()
     if split_untangled_states:
         for q in reversed(qubits):

cirq/sim/simulation_state.py

@@ -18,20 +18,7 @@ from __future__ import annotations
 
 import abc
 import copy
-from typing import (
-    Any,
-    cast,
-    Dict,
-    Generic,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-)
+from typing import Any, cast, Generic, Iterator, Sequence, TYPE_CHECKING, TypeVar
 
 import numpy as np
 from typing_extensions import Self
@@ -52,9 +39,9 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         self,
         *,
         state: TState,
-        prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence[cirq.Qid]] = None,
-        classical_data: Optional[cirq.ClassicalDataStore] = None,
+        prng: np.random.RandomState | None = None,
+        qubits: Sequence[cirq.Qid] | None = None,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Inits SimulationState.
 
@@ -86,7 +73,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         qubits: Sequence[cirq.Qid],
         key: str,
         invert_mask: Sequence[bool],
-        confusion_map: Dict[Tuple[int, ...], np.ndarray],
+        confusion_map: dict[tuple[int, ...], np.ndarray],
     ):
         """Measures the qubits and records to `log_of_measurement_results`.
 
@@ -110,10 +97,10 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
             value.MeasurementKey.parse_serialized(key), corrected, qubits
         )
 
-    def get_axes(self, qubits: Sequence[cirq.Qid]) -> List[int]:
+    def get_axes(self, qubits: Sequence[cirq.Qid]) -> list[int]:
         return [self.qubit_map[q] for q in qubits]
 
-    def _perform_measurement(self, qubits: Sequence[cirq.Qid]) -> List[int]:
+    def _perform_measurement(self, qubits: Sequence[cirq.Qid]) -> list[int]:
         """Delegates the call to measure the `QuantumStateRepresentation`."""
         if self._state is not None:
             return self._state.measure(self.get_axes(qubits), self.prng)
@@ -121,9 +108,9 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
 
     def _confuse_result(
         self,
-        bits: List[int],
+        bits: list[int],
         qubits: Sequence[cirq.Qid],
-        confusion_map: Dict[Tuple[int, ...], np.ndarray],
+        confusion_map: dict[tuple[int, ...], np.ndarray],
     ):
         """Applies confusion matrices to measured results.
 
@@ -211,7 +198,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
 
     def factor(
         self, qubits: Sequence[cirq.Qid], *, validate=True, atol=1e-07, inplace=False
-    ) -> Tuple[Self, Self]:
+    ) -> tuple[Self, Self]:
         """Splits two state spaces after a measurement or reset."""
         extracted = copy.copy(self)
         remainder = self if inplace else copy.copy(self)
@@ -249,7 +236,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         return args
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return self._qubits
 
     def swap(self, q1: cirq.Qid, q2: cirq.Qid, *, inplace=False):
@@ -310,7 +297,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         args._set_qubits(qubits)
         return args
 
-    def __getitem__(self, item: Optional[cirq.Qid]) -> Self:
+    def __getitem__(self, item: cirq.Qid | None) -> Self:
         if item not in self.qubit_map:
             raise IndexError(f'{item} not in {self.qubits}')
         return self
@@ -318,7 +305,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
     def __len__(self) -> int:
         return len(self.qubits)
 
-    def __iter__(self) -> Iterator[Optional[cirq.Qid]]:
+    def __iter__(self) -> Iterator[cirq.Qid | None]:
         return iter(self.qubits)
 
     @property
@@ -335,7 +322,7 @@ def strat_act_on_from_apply_decompose(
         decomposed = protocols.decompose_once(val, flatten=False, default=None)
     if decomposed is None:
         return NotImplemented
-    all_ancilla: Set[cirq.Qid] = set()
+    all_ancilla: set[cirq.Qid] = set()
     for operation in ops.flatten_to_ops(decomposed):
         curr_ancilla = tuple(q for q in operation.qubits if q not in args.qubits)
         args = args.add_qubits(curr_ancilla)

cirq/sim/simulation_state_base.py

@@ -18,20 +18,7 @@ from __future__ import annotations
 
 import abc
 from types import NotImplementedType
-from typing import (
-    Any,
-    Dict,
-    Generic,
-    Iterator,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import Any, Generic, Iterator, Mapping, Sequence, TYPE_CHECKING, TypeVar
 
 from typing_extensions import Self
 
@@ -50,10 +37,7 @@ class SimulationStateBase(Generic[TSimulationState], metaclass=abc.ABCMeta):
     """An interface for quantum states as targets for operations."""
 
     def __init__(
-        self,
-        *,
-        qubits: Sequence[cirq.Qid],
-        classical_data: Optional[cirq.ClassicalDataStore] = None,
+        self, *, qubits: Sequence[cirq.Qid], classical_data: cirq.ClassicalDataStore | None = None
     ):
         """Initializes the class.
 
@@ -66,7 +50,7 @@ class SimulationStateBase(Generic[TSimulationState], metaclass=abc.ABCMeta):
         self._classical_data = classical_data or value.ClassicalDataDictionaryStore()
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return self._qubits
 
     @property
@@ -88,7 +72,7 @@ class SimulationStateBase(Generic[TSimulationState], metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def _act_on_fallback_(
         self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
-    ) -> Union[bool, NotImplementedType]:
+    ) -> bool | NotImplementedType:
         """Handles the act_on protocol fallback implementation.
 
         Args:
@@ -116,21 +100,21 @@ class SimulationStateBase(Generic[TSimulationState], metaclass=abc.ABCMeta):
         """
 
     @property
-    def log_of_measurement_results(self) -> Dict[str, List[int]]:
+    def log_of_measurement_results(self) -> dict[str, list[int]]:
         """Gets the log of measurement results."""
         return {str(k): list(self.classical_data.get_digits(k)) for k in self.classical_data.keys()}
 
     @abc.abstractmethod
     def sample(
         self,
-        qubits: List[cirq.Qid],
+        qubits: list[cirq.Qid],
         repetitions: int = 1,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> np.ndarray:
         """Samples the state value."""
 
     @abc.abstractmethod
-    def __getitem__(self, item: Optional[cirq.Qid]) -> TSimulationState:
+    def __getitem__(self, item: cirq.Qid | None) -> TSimulationState:
         """Gets the item associated with the qubit."""
 
     @abc.abstractmethod
@@ -138,5 +122,5 @@ class SimulationStateBase(Generic[TSimulationState], metaclass=abc.ABCMeta):
         """Gets the number of items in the mapping."""
 
     @abc.abstractmethod
-    def __iter__(self) -> Iterator[Optional[cirq.Qid]]:
+    def __iter__(self) -> Iterator[cirq.Qid | None]:
         """Iterates the keys of the mapping."""

cirq/sim/simulation_utils.py

@@ -11,10 +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
 
-from typing import Any, Sequence, Tuple
+from typing import Any, Sequence
 
 import numpy as np
 
@@ -22,7 +21,7 @@ from cirq import linalg
 
 
 def state_probabilities_by_indices(
-    state_probability: np.ndarray, indices: Sequence[int], qid_shape: Tuple[int, ...]
+    state_probability: np.ndarray, indices: Sequence[int], qid_shape: tuple[int, ...]
 ) -> np.ndarray:
     """Returns the probabilities for a state/measurement on the given indices.
 
@@ -40,7 +39,7 @@ def state_probabilities_by_indices(
     Returns:
         State probabilities.
     """
-    probs: np.ndarray[Tuple[int, ...], Any]
+    probs: np.ndarray[tuple[int, ...], Any]
     probs = state_probability.reshape((-1,))
     not_measured = [i for i in range(len(qid_shape)) if i not in indices]
     if linalg.can_numpy_support_shape(qid_shape):