cirq-core 1.6.0.dev20250428201230__py3-none-any.whl → 1.6.0.dev20250429161116__py3-none-any.whl

cirq/sim/mux.py

@@ -17,6 +17,8 @@
 Filename is a reference to multiplexing.
 """
 
+from __future__ import annotations
+
 from typing import List, Optional, Sequence, Type, TYPE_CHECKING, Union
 
 import numpy as np
@@ -39,7 +41,7 @@ document(
 )
 
 
-def _is_clifford_circuit(program: 'cirq.Circuit') -> bool:
+def _is_clifford_circuit(program: cirq.Circuit) -> bool:
     return all(
         clifford_simulator.CliffordSimulator.is_supported_operation(op)
         for op in program.all_operations()
@@ -47,14 +49,14 @@ def _is_clifford_circuit(program: 'cirq.Circuit') -> bool:
 
 
 def sample(
-    program: 'cirq.Circuit',
+    program: cirq.Circuit,
     *,
-    noise: 'cirq.NOISE_MODEL_LIKE' = None,
-    param_resolver: Optional['cirq.ParamResolver'] = None,
+    noise: cirq.NOISE_MODEL_LIKE = None,
+    param_resolver: Optional[cirq.ParamResolver] = None,
     repetitions: int = 1,
     dtype: Type[np.complexfloating] = np.complex64,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> 'cirq.Result':
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> cirq.Result:
     """Simulates sampling from the given circuit.
 
     Args:
@@ -90,7 +92,7 @@ def sample(
     ).run(program=program, param_resolver=param_resolver, repetitions=repetitions)
 
 
-def _to_circuit(program: 'cirq.CIRCUIT_LIKE') -> 'cirq.Circuit':
+def _to_circuit(program: cirq.CIRCUIT_LIKE) -> cirq.Circuit:
     if isinstance(program, circuits.Circuit):
         # No change needed.
         result = program
@@ -103,14 +105,14 @@ def _to_circuit(program: 'cirq.CIRCUIT_LIKE') -> 'cirq.Circuit':
 
 
 def final_state_vector(
-    program: 'cirq.CIRCUIT_LIKE',
+    program: cirq.CIRCUIT_LIKE,
     *,
-    initial_state: 'cirq.STATE_VECTOR_LIKE' = 0,
-    param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
-    qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
+    initial_state: cirq.STATE_VECTOR_LIKE = 0,
+    param_resolver: cirq.ParamResolverOrSimilarType = None,
+    qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
     ignore_terminal_measurements: bool = False,
     dtype: Type[np.complexfloating] = np.complex64,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> np.ndarray:
     """Returns the state vector resulting from acting operations on a state.
 
@@ -174,14 +176,14 @@ def final_state_vector(
 
 
 def sample_sweep(
-    program: 'cirq.Circuit',
-    params: 'cirq.Sweepable',
+    program: cirq.Circuit,
+    params: cirq.Sweepable,
     *,
-    noise: 'cirq.NOISE_MODEL_LIKE' = None,
+    noise: cirq.NOISE_MODEL_LIKE = None,
     repetitions: int = 1,
     dtype: Type[np.complexfloating] = np.complex64,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> Sequence['cirq.Result']:
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> Sequence[cirq.Result]:
     """Runs the supplied Circuit, mimicking quantum hardware.
 
     In contrast to run, this allows for sweeping over different parameter
@@ -219,16 +221,16 @@ def sample_sweep(
 
 
 def final_density_matrix(
-    program: 'cirq.CIRCUIT_LIKE',
+    program: cirq.CIRCUIT_LIKE,
     *,
-    noise: 'cirq.NOISE_MODEL_LIKE' = None,
-    initial_state: 'cirq.STATE_VECTOR_LIKE' = 0,
-    param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
-    qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
+    noise: cirq.NOISE_MODEL_LIKE = None,
+    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,
     ignore_measurement_results: bool = True,
-) -> 'np.ndarray':
+) -> np.ndarray:
     """Returns the density matrix resulting from simulating the circuit.
 
     Note that, unlike `cirq.final_state_vector`, terminal measurements

cirq/sim/simulation_product_state.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from collections import abc
 from typing import Any, Dict, Generic, Iterator, List, Mapping, Optional, Sequence, TYPE_CHECKING
 
@@ -32,10 +34,10 @@ class SimulationProductState(
 
     def __init__(
         self,
-        sim_states: Dict[Optional['cirq.Qid'], TSimulationState],
-        qubits: Sequence['cirq.Qid'],
+        sim_states: Dict[Optional[cirq.Qid], TSimulationState],
+        qubits: Sequence[cirq.Qid],
         split_untangled_states: bool,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Initializes the class.
 
@@ -55,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[Optional[cirq.Qid], TSimulationState]:
         return self._sim_states
 
     @property
@@ -78,7 +80,7 @@ class SimulationProductState(
         return merged_state.transpose_to_qubit_order(self.qubits, inplace=True)
 
     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:
         gate_opt = (
             action
@@ -136,9 +138,7 @@ class SimulationProductState(
                 self._sim_states[q] = op_args
         return True
 
-    def copy(
-        self, deep_copy_buffers: bool = True
-    ) -> 'cirq.SimulationProductState[TSimulationState]':
+    def copy(self, deep_copy_buffers: bool = True) -> cirq.SimulationProductState[TSimulationState]:
         classical_data = self._classical_data.copy()
         copies = {}
         for sim_state in set(self.sim_states.values()):
@@ -152,9 +152,9 @@ class SimulationProductState(
 
     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:
         columns = []
         selected_order: List[ops.Qid] = []
@@ -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: Optional[cirq.Qid]) -> 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[Optional[cirq.Qid]]:
         return iter(self.sim_states)

cirq/sim/simulation_product_state_test.py

@@ -42,7 +42,7 @@ class EmptySimulationState(cirq.SimulationState):
         super().__init__(state=EmptyQuantumState(), 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:
         return True
 
@@ -52,9 +52,9 @@ qs2 = cirq.LineQubit.range(2)
 
 
 def create_container(
-    qubits: Sequence['cirq.Qid'], split_untangled_states=True
+    qubits: Sequence[cirq.Qid], split_untangled_states=True
 ) -> cirq.SimulationProductState[EmptySimulationState]:
-    state_map: Dict[Optional['cirq.Qid'], EmptySimulationState] = {}
+    state_map: Dict[Optional[cirq.Qid], EmptySimulationState] = {}
     log = cirq.ClassicalDataDictionaryStore()
     if split_untangled_states:
         for q in reversed(qubits):

cirq/sim/simulation_state.py

@@ -11,7 +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.
+
 """Objects and methods for acting efficiently on a state tensor."""
+
+from __future__ import annotations
+
 import abc
 import copy
 from typing import (
@@ -49,8 +53,8 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         *,
         state: TState,
         prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        qubits: Optional[Sequence[cirq.Qid]] = None,
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Inits SimulationState.
 
@@ -79,7 +83,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
 
     def measure(
         self,
-        qubits: Sequence['cirq.Qid'],
+        qubits: Sequence[cirq.Qid],
         key: str,
         invert_mask: Sequence[bool],
         confusion_map: Dict[Tuple[int, ...], np.ndarray],
@@ -106,10 +110,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)
@@ -118,7 +122,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
     def _confuse_result(
         self,
         bits: List[int],
-        qubits: Sequence['cirq.Qid'],
+        qubits: Sequence[cirq.Qid],
         confusion_map: Dict[Tuple[int, ...], np.ndarray],
     ):
         """Applies confusion matrices to measured results.
@@ -138,9 +142,9 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
 
     def sample(
         self,
-        qubits: Sequence['cirq.Qid'],
+        qubits: Sequence[cirq.Qid],
         repetitions: int = 1,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> np.ndarray:
         if self._state is not None:
             return self._state.sample(self.get_axes(qubits), repetitions, seed)
@@ -166,7 +170,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         """Creates a final merged state."""
         return self
 
-    def add_qubits(self: Self, qubits: Sequence['cirq.Qid']) -> Self:
+    def add_qubits(self: Self, qubits: Sequence[cirq.Qid]) -> Self:
         """Add `qubits` in the `|0>` state to a new state space and take the kron product.
 
         Args:
@@ -181,7 +185,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
             return self
         return NotImplemented
 
-    def remove_qubits(self: Self, qubits: Sequence['cirq.Qid']) -> Self:
+    def remove_qubits(self: Self, qubits: Sequence[cirq.Qid]) -> Self:
         """Remove `qubits` from the state space.
 
         The qubits to be removed should be untangled from rest of the system and in the |0> state.
@@ -206,7 +210,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         return args
 
     def factor(
-        self, qubits: Sequence['cirq.Qid'], *, validate=True, atol=1e-07, inplace=False
+        self, qubits: Sequence[cirq.Qid], *, validate=True, atol=1e-07, inplace=False
     ) -> Tuple[Self, Self]:
         """Splits two state spaces after a measurement or reset."""
         extracted = copy.copy(self)
@@ -223,7 +227,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         """Subclasses that allow factorization should override this."""
         return self._state.supports_factor if self._state is not None else False
 
-    def transpose_to_qubit_order(self, qubits: Sequence['cirq.Qid'], *, inplace=False) -> Self:
+    def transpose_to_qubit_order(self, qubits: Sequence[cirq.Qid], *, inplace=False) -> Self:
         """Physically reindexes the state by the new basis.
 
         Args:
@@ -245,10 +249,10 @@ 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):
+    def swap(self, q1: cirq.Qid, q2: cirq.Qid, *, inplace=False):
         """Swaps two qubits.
 
         This only affects the index, and does not modify the underlying
@@ -279,7 +283,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         args._set_qubits(qubits)
         return args
 
-    def rename(self, q1: 'cirq.Qid', q2: 'cirq.Qid', *, inplace=False):
+    def rename(self, q1: cirq.Qid, q2: cirq.Qid, *, inplace=False):
         """Renames `q1` to `q2`.
 
         Args:
@@ -306,7 +310,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: Optional[cirq.Qid]) -> Self:
         if item not in self.qubit_map:
             raise IndexError(f'{item} not in {self.qubits}')
         return self
@@ -314,7 +318,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[Optional[cirq.Qid]]:
         return iter(self.qubits)
 
     @property
@@ -323,7 +327,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
 
 
 def strat_act_on_from_apply_decompose(
-    val: Any, args: 'cirq.SimulationState', qubits: Sequence['cirq.Qid']
+    val: Any, args: cirq.SimulationState, qubits: Sequence[cirq.Qid]
 ) -> bool:
     if isinstance(val, ops.Gate):
         decomposed = protocols.decompose_once_with_qubits(val, qubits, flatten=False, default=None)
@@ -331,7 +335,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

@@ -11,7 +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.
+
 """An interface for quantum states as targets for operations."""
+
+from __future__ import annotations
+
 import abc
 from types import NotImplementedType
 from typing import (
@@ -47,8 +51,8 @@ class SimulationStateBase(Generic[TSimulationState], metaclass=abc.ABCMeta):
     def __init__(
         self,
         *,
-        qubits: Sequence['cirq.Qid'],
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        qubits: Sequence[cirq.Qid],
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Initializes the class.
 
@@ -61,19 +65,19 @@ 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
-    def qubit_map(self) -> Mapping['cirq.Qid', int]:
+    def qubit_map(self) -> Mapping[cirq.Qid, int]:
         return self._qubit_map
 
-    def _set_qubits(self, qubits: Sequence['cirq.Qid']):
+    def _set_qubits(self, qubits: Sequence[cirq.Qid]):
         self._qubits = tuple(qubits)
         self._qubit_map = {q: i for i, q in enumerate(self.qubits)}
 
     @property
-    def classical_data(self) -> 'cirq.ClassicalDataStoreReader':
+    def classical_data(self) -> cirq.ClassicalDataStoreReader:
         return self._classical_data
 
     @abc.abstractmethod
@@ -82,7 +86,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
+        self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
     ) -> Union[bool, NotImplementedType]:
         """Handles the act_on protocol fallback implementation.
 
@@ -94,7 +98,7 @@ class SimulationStateBase(Generic[TSimulationState], metaclass=abc.ABCMeta):
         Returns:
             True if the fallback applies, else NotImplemented."""
 
-    def apply_operation(self, op: 'cirq.Operation'):
+    def apply_operation(self, op: cirq.Operation):
         protocols.act_on(op, self)
 
     @abc.abstractmethod
@@ -118,14 +122,14 @@ class SimulationStateBase(Generic[TSimulationState], metaclass=abc.ABCMeta):
     @abc.abstractmethod
     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:
         """Samples the state value."""
 
     @abc.abstractmethod
-    def __getitem__(self, item: Optional['cirq.Qid']) -> TSimulationState:
+    def __getitem__(self, item: Optional[cirq.Qid]) -> TSimulationState:
         """Gets the item associated with the qubit."""
 
     @abc.abstractmethod
@@ -133,5 +137,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[Optional[cirq.Qid]]:
         """Iterates the keys of the mapping."""

cirq/sim/simulation_state_test.py

@@ -38,7 +38,7 @@ class ExampleSimulationState(cirq.SimulationState):
         super().__init__(state=ExampleQuantumState(), qubits=qubits)
 
     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:
         return True