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

cirq/sim/state_vector_simulation_state_test.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import cast, Type
+from __future__ import annotations
+
+from typing import cast
 from unittest import mock
 
 import numpy as np
@@ -21,7 +23,7 @@ import pytest
 import cirq
 
 
-def test_default_parameter():
+def test_default_parameter() -> None:
     dtype = np.complex64
     tensor = cirq.one_hot(shape=(2, 2, 2), dtype=np.complex64)
     qubits = cirq.LineQubit.range(3)
@@ -33,7 +35,7 @@ def test_default_parameter():
     assert args.available_buffer.dtype == tensor.dtype
 
 
-def test_infer_target_tensor():
+def test_infer_target_tensor() -> None:
     dtype = np.complex64
     args = cirq.StateVectorSimulationState(
         qubits=cirq.LineQubit.range(2),
@@ -54,13 +56,13 @@ def test_infer_target_tensor():
     )
 
 
-def test_shallow_copy_buffers():
+def test_shallow_copy_buffers() -> None:
     args = cirq.StateVectorSimulationState(qubits=cirq.LineQubit.range(1), initial_state=0)
     copy = args.copy(deep_copy_buffers=False)
     assert copy.available_buffer is args.available_buffer
 
 
-def test_decomposed_fallback():
+def test_decomposed_fallback() -> None:
     class Composite(cirq.Gate):
         def num_qubits(self) -> int:
             return 1  # pragma: no cover
@@ -82,7 +84,7 @@ def test_decomposed_fallback():
     )
 
 
-def test_cannot_act():
+def test_cannot_act() -> None:
     class NoDetails:
         pass
 
@@ -98,7 +100,7 @@ def test_cannot_act():
         cirq.act_on(NoDetails(), args, qubits=())
 
 
-def test_act_using_probabilistic_single_qubit_channel():
+def test_act_using_probabilistic_single_qubit_channel() -> None:
     class ProbabilisticSorX(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -148,7 +150,7 @@ def test_act_using_probabilistic_single_qubit_channel():
     )
 
 
-def test_act_using_adaptive_two_qubit_channel():
+def test_act_using_adaptive_two_qubit_channel() -> None:
     class Decay11(cirq.Gate):
         def num_qubits(self) -> int:
             return 2
@@ -171,7 +173,7 @@ def test_act_using_adaptive_two_qubit_channel():
             qubits=cirq.LineQubit.range(4),
             prng=mock_prng,
             initial_state=np.copy(state),
-            dtype=cast(Type[np.complexfloating], state.dtype),
+            dtype=cast(type[np.complexfloating], state.dtype),
         )
         cirq.act_on(Decay11(), args, [cirq.LineQubit(1), cirq.LineQubit(3)])
         return args.target_tensor
@@ -210,7 +212,7 @@ def test_act_using_adaptive_two_qubit_channel():
         assert_not_affected(projected_state, sample=3 / 4 + 1e-8)
 
 
-def test_probability_comes_up_short_results_in_fallback():
+def test_probability_comes_up_short_results_in_fallback() -> None:
     class Short(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -234,7 +236,7 @@ def test_probability_comes_up_short_results_in_fallback():
     np.testing.assert_allclose(args.target_tensor, np.array([0, 1]))
 
 
-def test_random_channel_has_random_behavior():
+def test_random_channel_has_random_behavior() -> None:
     q = cirq.LineQubit(0)
     s = cirq.Simulator().sample(
         cirq.Circuit(cirq.X(q), cirq.amplitude_damp(0.4).on(q), cirq.measure(q, key='out')),
@@ -245,7 +247,7 @@ def test_random_channel_has_random_behavior():
     assert v[1] > 1
 
 
-def test_measured_channel():
+def test_measured_channel() -> None:
     # This behaves like an X-basis measurement.
     kc = cirq.KrausChannel(
         kraus_ops=(np.array([[1, 1], [1, 1]]) * 0.5, np.array([[1, -1], [-1, 1]]) * 0.5), key='m'
@@ -257,7 +259,7 @@ def test_measured_channel():
     assert results.histogram(key='m') == {0: 100}
 
 
-def test_measured_mixture():
+def test_measured_mixture() -> None:
     # This behaves like an X-basis measurement.
     mm = cirq.MixedUnitaryChannel(
         mixture=((0.5, np.array([[1, 0], [0, 1]])), (0.5, np.array([[0, 1], [1, 0]]))), key='flip'
@@ -269,6 +271,6 @@ def test_measured_mixture():
     assert results.histogram(key='flip') == results.histogram(key='m')
 
 
-def test_qid_shape_error():
+def test_qid_shape_error() -> None:
     with pytest.raises(ValueError, match="qid_shape must be provided"):
         cirq.sim.state_vector_simulation_state._BufferedStateVector.create(initial_state=0)

cirq/sim/state_vector_simulator.py

@@ -11,12 +11,15 @@
 # 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.
+
 """Abstract classes for simulations which keep track of state vector."""
 
+from __future__ import annotations
+
 import abc
 import warnings
 from functools import cached_property
-from typing import Any, Dict, Generic, Iterator, Sequence, Type, TYPE_CHECKING, TypeVar
+from typing import Any, Generic, Iterator, Sequence, TYPE_CHECKING, TypeVar
 
 import numpy as np
 
@@ -47,9 +50,9 @@ class SimulatesIntermediateStateVector(
     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,
     ):
         super().__init__(
@@ -58,20 +61,20 @@ class SimulatesIntermediateStateVector(
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
-        measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.StateVectorSimulationState]',
-    ) -> 'cirq.StateVectorTrialResult':
+        params: cirq.ParamResolver,
+        measurements: dict[str, np.ndarray],
+        final_simulator_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState],
+    ) -> cirq.StateVectorTrialResult:
         return StateVectorTrialResult(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
         )
 
     def compute_amplitudes_sweep_iter(
         self,
-        program: 'cirq.AbstractCircuit',
+        program: cirq.AbstractCircuit,
         bitstrings: Sequence[int],
-        params: 'cirq.Sweepable',
-        qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
+        params: cirq.Sweepable,
+        qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
     ) -> Iterator[Sequence[complex]]:
         if isinstance(bitstrings, np.ndarray) and len(bitstrings.shape) > 1:
             raise ValueError(
@@ -112,9 +115,9 @@ class StateVectorTrialResult(
 
     def __init__(
         self,
-        params: 'cirq.ParamResolver',
-        measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.StateVectorSimulationState]',
+        params: cirq.ParamResolver,
+        measurements: dict[str, np.ndarray],
+        final_simulator_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState],
     ) -> None:
         super().__init__(
             params=params,

cirq/sim/state_vector_simulator_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 numpy as np
 
 import cirq

cirq/sim/state_vector_test.py

@@ -11,10 +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 state_vector.py"""
 
+from __future__ import annotations
+
 import itertools
-from typing import Iterator, Optional
+from typing import Iterator
 from unittest import mock
 
 import numpy as np
@@ -34,7 +37,7 @@ def use_np_transpose(request) -> Iterator[bool]:
 
 def test_state_mixin():
     class TestClass(cirq.StateVectorMixin):
-        def state_vector(self, copy: Optional[bool] = None) -> np.ndarray:
+        def state_vector(self, copy: bool | None = None) -> np.ndarray:
             return np.array([0, 0, 1, 0])
 
     qubits = cirq.LineQubit.range(2)
@@ -357,7 +360,7 @@ def test_measure_state_empty_state(use_np_transpose: bool):
 
 
 class BasicStateVector(cirq.StateVectorMixin):
-    def state_vector(self, copy: Optional[bool] = None) -> np.ndarray:
+    def state_vector(self, copy: bool | None = None) -> np.ndarray:
         return np.array([0, 1, 0, 0])
 
 

cirq/study/flatten_expressions.py

@@ -11,10 +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.
+
 """Resolves symbolic expressions to unique symbols."""
 
+from __future__ import annotations
+
 import numbers
-from typing import Any, Callable, List, Optional, Tuple, TYPE_CHECKING, Union
+from typing import Any, Callable, TYPE_CHECKING
 
 import sympy
 
@@ -25,7 +28,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def flatten(val: Any) -> Tuple[Any, 'ExpressionMap']:
+def flatten(val: Any) -> tuple[Any, ExpressionMap]:
     """Creates a copy of `val` with any symbols or expressions replaced with
     new symbols.  `val` can be a `Circuit`, `Gate`, `Operation`, or other
     type.
@@ -111,8 +114,8 @@ def flatten(val: Any) -> Tuple[Any, 'ExpressionMap']:
 
 
 def flatten_with_sweep(
-    val: Any, sweep: Union[sweeps.Sweep, List[resolver.ParamResolver]]
-) -> Tuple[Any, sweeps.Sweep]:
+    val: Any, sweep: sweeps.Sweep | list[resolver.ParamResolver]
+) -> tuple[Any, sweeps.Sweep]:
     """Creates a copy of `val` with any symbols or expressions replaced with
     new symbols.  `val` can be a `Circuit`, `Gate`, `Operation`, or other
     type.  Also transforms a sweep over the symbols in `val` to a sweep over the
@@ -146,7 +149,7 @@ def flatten_with_sweep(
 
 def flatten_with_params(
     val: Any, params: resolver.ParamResolverOrSimilarType
-) -> Tuple[Any, resolver.ParamDictType]:
+) -> tuple[Any, resolver.ParamDictType]:
     """Creates a copy of `val` with any symbols or expressions replaced with
     new symbols.  `val` can be a `Circuit`, `Gate`, `Operation`, or other
     type.  Also transforms a dictionary of symbol values for `val` to an
@@ -198,9 +201,9 @@ class _ParamFlattener(resolver.ParamResolver):
 
     def __init__(
         self,
-        param_dict: Optional[resolver.ParamResolverOrSimilarType] = None,
+        param_dict: resolver.ParamResolverOrSimilarType | None = None,
         *,  # Force keyword args
-        get_param_name: Optional[Callable[[sympy.Expr], str]] = None,
+        get_param_name: Callable[[sympy.Expr], str] | None = None,
     ):
         """Initializes a new _ParamFlattener.
 
@@ -250,8 +253,8 @@ class _ParamFlattener(resolver.ParamResolver):
         return symbol
 
     def value_of(
-        self, value: Union['cirq.TParamKey', 'cirq.TParamValComplex'], recursive: bool = False
-    ) -> 'cirq.TParamValComplex':
+        self, value: cirq.TParamKey | cirq.TParamValComplex, recursive: bool = False
+    ) -> cirq.TParamValComplex:
         """Resolves a symbol or expression to a new symbol unique to that value.
 
         - If value is a float, returns it.
@@ -326,9 +329,7 @@ class ExpressionMap(dict):
         """
         super().__init__(*args, **kwargs)
 
-    def transform_sweep(
-        self, sweep: Union[sweeps.Sweep, List[resolver.ParamResolver]]
-    ) -> sweeps.Sweep:
+    def transform_sweep(self, sweep: sweeps.Sweep | list[resolver.ParamResolver]) -> sweeps.Sweep:
         """Returns a sweep to use with a circuit flattened earlier with
         `cirq.flatten`.
 
@@ -343,7 +344,7 @@ class ExpressionMap(dict):
             sweep: The sweep to transform.
         """
         sweep = sweepable.to_sweep(sweep)
-        param_list: List[resolver.ParamDictType] = []
+        param_list: list[resolver.ParamDictType] = []
         for r in sweep:
             param_dict: resolver.ParamDictType = {}
             for formula, sym in self.items():
@@ -380,8 +381,8 @@ class ExpressionMap(dict):
 
 
 def _ensure_not_str(
-    param: Union[sympy.Expr, 'cirq.TParamValComplex', str],
-) -> Union[sympy.Expr, 'cirq.TParamValComplex']:
+    param: sympy.Expr | cirq.TParamValComplex | str,
+) -> sympy.Expr | cirq.TParamValComplex:
     if isinstance(param, str):
         return sympy.Symbol(param)
     return param

cirq/study/flatten_expressions_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 sympy
 
 import cirq
@@ -23,14 +25,14 @@ from cirq.study import flatten_expressions
 # factor, is not consistent between sympy versions <1.4 and >=1.4.
 
 
-def test_expr_map_names():
+def test_expr_map_names() -> None:
     flattener = flatten_expressions._ParamFlattener({'collision': '<x + 2>'})
     expressions = [sympy.Symbol('x') + i for i in range(3)]
     syms = flattener.flatten(expressions)
     assert syms == [sympy.Symbol(name) for name in ('x', '<x + 1>', '<x + 2>_1')]
 
 
-def test_flattener_value_of():
+def test_flattener_value_of() -> None:
     flattener = flatten_expressions._ParamFlattener({'c': 5, 'x1': 'x1'})
     assert flattener.value_of(9) == 9
     assert flattener.value_of('c') == 5
@@ -54,18 +56,18 @@ def test_flattener_value_of():
     ]
 
 
-def test_flattener_repr():
+def test_flattener_repr() -> None:
     assert repr(flatten_expressions._ParamFlattener({'a': 1})) == ("_ParamFlattener({a: 1})")
     assert repr(
         flatten_expressions._ParamFlattener({'a': 1}, get_param_name=lambda expr: 'x')
     ).startswith("_ParamFlattener({a: 1}, get_param_name=<function ")
 
 
-def test_expression_map_repr():
+def test_expression_map_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.ExpressionMap({'a': 'b'}))
 
 
-def test_flatten_circuit():
+def test_flatten_circuit() -> None:
     qubit = cirq.LineQubit(0)
     a = sympy.Symbol('a')
     circuit = cirq.Circuit(cirq.X(qubit) ** a, cirq.X(qubit) ** (1 + a / 2))
@@ -78,7 +80,7 @@ def test_flatten_circuit():
     assert expr_map == {a: a, 1 + a / 2: sympy.Symbol('<a/2 + 1>')}
 
 
-def test_transform_params():
+def test_transform_params() -> None:
     qubit = cirq.LineQubit(0)
     a = sympy.Symbol('a')
     circuit = cirq.Circuit(cirq.X(qubit) ** (a / 4), cirq.X(qubit) ** (1 + a / 2))
@@ -90,7 +92,7 @@ def test_transform_params():
     assert new_params == expected_params
 
 
-def test_transform_sweep():
+def test_transform_sweep() -> None:
     qubit = cirq.LineQubit(0)
     a = sympy.Symbol('a')
     circuit = cirq.Circuit(cirq.X(qubit) ** (a / 4), cirq.X(qubit) ** (1 + a / 2))
@@ -109,20 +111,20 @@ def test_transform_sweep():
     assert resolvers == expected_resolvers
 
 
-def test_flattener_new():
+def test_flattener_new() -> None:
     flattener = flatten_expressions._ParamFlattener({'a': 'b'})
     flattener2 = flatten_expressions._ParamFlattener(flattener)
     assert isinstance(flattener2, flatten_expressions._ParamFlattener)
     assert flattener2.param_dict == flattener.param_dict
 
 
-def test_resolver_new():
+def test_resolver_new() -> None:
     flattener = flatten_expressions._ParamFlattener({'a': 'b'})
     flattener2 = cirq.ParamResolver(flattener)
     assert flattener2 is flattener
 
 
-def test_transformed_sweep():
+def test_transformed_sweep() -> None:
     a = sympy.Symbol('a')
     sweep = cirq.Linspace('a', start=0, stop=3, length=4)
     expr_map = cirq.ExpressionMap({a / 4: 'x0', 1 - a / 2: 'x1'})
@@ -134,7 +136,7 @@ def test_transformed_sweep():
     assert params[1] == (('x0', 1 / 4), ('x1', 1 - 1 / 2))
 
 
-def test_transformed_sweep_equality():
+def test_transformed_sweep_equality() -> None:
     a = sympy.Symbol('a')
     sweep = cirq.Linspace('a', start=0, stop=3, length=4)
     expr_map = cirq.ExpressionMap({a / 4: 'x0', 1 - a / 4: 'x1'})

cirq/study/resolver.py

@@ -13,8 +13,11 @@
 # limitations under the License.
 
 """Resolves ParameterValues to assigned values."""
+
+from __future__ import annotations
+
 import numbers
-from typing import Any, cast, Dict, Iterator, Mapping, Optional, TYPE_CHECKING, Union
+from typing import Any, cast, Iterator, Mapping, TYPE_CHECKING, Union
 
 import numpy as np
 import sympy
@@ -27,7 +30,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-ParamDictType = Dict['cirq.TParamKey', 'cirq.TParamValComplex']
+ParamDictType = dict['cirq.TParamKey', 'cirq.TParamValComplex']
 ParamMappingType = Mapping['cirq.TParamKey', 'cirq.TParamValComplex']
 document(ParamDictType, """Dictionary from symbols to values.""")
 document(ParamMappingType, """Immutable map from symbols to values.""")
@@ -61,16 +64,16 @@ class ParamResolver:
         TypeError if formulas are passed as keys.
     """
 
-    def __new__(cls, param_dict: 'cirq.ParamResolverOrSimilarType' = None):
+    def __new__(cls, param_dict: cirq.ParamResolverOrSimilarType = None):
         if isinstance(param_dict, ParamResolver):
             return param_dict
         return super().__new__(cls)
 
-    def __init__(self, param_dict: 'cirq.ParamResolverOrSimilarType' = None) -> None:
+    def __init__(self, param_dict: cirq.ParamResolverOrSimilarType = None) -> None:
         if hasattr(self, 'param_dict'):
             return  # Already initialized. Got wrapped as part of the __new__.
 
-        self._param_hash: Optional[int] = None
+        self._param_hash: int | None = None
         self._param_dict = cast(ParamDictType, {} if param_dict is None else param_dict)
         for key in self._param_dict:
             if isinstance(key, sympy.Expr) and not isinstance(key, sympy.Symbol):
@@ -82,8 +85,8 @@ class ParamResolver:
         return self._param_dict
 
     def value_of(
-        self, value: Union['cirq.TParamKey', 'cirq.TParamValComplex'], recursive: bool = True
-    ) -> 'cirq.TParamValComplex':
+        self, value: cirq.TParamKey | cirq.TParamValComplex, recursive: bool = True
+    ) -> cirq.TParamValComplex:
         """Attempt to resolve a parameter to its assigned value.
 
         Scalars are returned without modification.  Strings are resolved via
@@ -193,7 +196,7 @@ class ParamResolver:
 
         return self._value_of_recursive(value)
 
-    def _value_of_recursive(self, value: 'cirq.TParamKey') -> 'cirq.TParamValComplex':
+    def _value_of_recursive(self, value: cirq.TParamKey) -> cirq.TParamValComplex:
         # Recursive parameter resolution. We can safely assume that value is a
         # single symbol, since combinations are handled earlier in the method.
         if value in self._deep_eval_map:
@@ -213,8 +216,8 @@ class ParamResolver:
             self._deep_eval_map[value] = self.value_of(v, recursive=True)
         return self._deep_eval_map[value]
 
-    def _resolve_parameters_(self, resolver: 'ParamResolver', recursive: bool) -> 'ParamResolver':
-        new_dict: Dict['cirq.TParamKey', Union[float, str, sympy.Symbol, sympy.Expr]] = {
+    def _resolve_parameters_(self, resolver: ParamResolver, recursive: bool) -> ParamResolver:
+        new_dict: dict[cirq.TParamKey, float | str | sympy.Symbol | sympy.Expr] = {
             k: k for k in resolver
         }
         new_dict.update({k: self.value_of(k, recursive) for k in self})
@@ -225,15 +228,13 @@ class ParamResolver:
             return ParamResolver()._resolve_parameters_(new_resolver, recursive=True)
         return ParamResolver(cast(ParamDictType, new_dict))
 
-    def __iter__(self) -> Iterator[Union[str, sympy.Expr]]:
+    def __iter__(self) -> Iterator[str | sympy.Expr]:
         return iter(self._param_dict)
 
     def __bool__(self) -> bool:
         return bool(self._param_dict)
 
-    def __getitem__(
-        self, key: Union['cirq.TParamKey', 'cirq.TParamValComplex']
-    ) -> 'cirq.TParamValComplex':
+    def __getitem__(self, key: cirq.TParamKey | cirq.TParamValComplex) -> cirq.TParamValComplex:
         return self.value_of(key)
 
     def __hash__(self) -> int:
@@ -241,7 +242,7 @@ class ParamResolver:
             self._param_hash = hash(frozenset(self._param_dict.items()))
         return self._param_hash
 
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         # clear cached hash value when pickling, see #6674
         state = self.__dict__
         if state["_param_hash"] is not None:
@@ -265,7 +266,7 @@ class ParamResolver:
         )
         return f'cirq.ParamResolver({param_dict_repr})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             # JSON requires mappings to have keys of basic types.
             'param_dict': list(self._param_dict.items())
@@ -285,7 +286,7 @@ def _resolve_value(val: Any) -> Any:
         return val.p
     if isinstance(val, sympy_numbers.RationalConstant):
         return val.p / val.q
-    if val == sympy.pi:
+    if val is sympy.pi:
         return np.pi
 
     getter = getattr(val, '_resolved_value_', None)