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

cirq/ops/qubit_manager.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import dataclasses
-from typing import Iterable, List, Tuple, TYPE_CHECKING
+from typing import Iterable, TYPE_CHECKING
 
 from cirq.ops import raw_types
 
@@ -24,15 +26,15 @@ if TYPE_CHECKING:
 
 class QubitManager(metaclass=abc.ABCMeta):
     @abc.abstractmethod
-    def qalloc(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qalloc(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         """Allocate `n` clean qubits, i.e. qubits guaranteed to be in state |0>."""
 
     @abc.abstractmethod
-    def qborrow(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qborrow(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         """Allocate `n` dirty qubits, i.e. the returned qubits can be in any state."""
 
     @abc.abstractmethod
-    def qfree(self, qubits: Iterable['cirq.Qid']) -> None:
+    def qfree(self, qubits: Iterable[cirq.Qid]) -> None:
         """Free pre-allocated clean or dirty qubits managed by this qubit manager."""
 
 
@@ -42,14 +44,14 @@ class _BaseAncillaQid(raw_types.Qid):
     dim: int = 2
     prefix: str = ''
 
-    def _comparison_key(self) -> Tuple[str, int]:
+    def _comparison_key(self) -> tuple[str, int]:
         return self.prefix, self.id
 
     @property
     def dimension(self) -> int:
         return self.dim
 
-    def with_dimension(self, dimension: int) -> '_BaseAncillaQid':
+    def with_dimension(self, dimension: int) -> _BaseAncillaQid:
         return dataclasses.replace(self, dim=dimension)
 
     def __repr__(self) -> str:
@@ -82,18 +84,18 @@ class SimpleQubitManager(QubitManager):
         self._borrow_id = 0
         self._prefix = prefix
 
-    def qalloc(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qalloc(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         self._clean_id += n
         return [CleanQubit(i, dim, self._prefix) for i in range(self._clean_id - n, self._clean_id)]
 
-    def qborrow(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qborrow(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         self._borrow_id = self._borrow_id + n
         return [
             BorrowableQubit(i, dim, self._prefix)
             for i in range(self._borrow_id - n, self._borrow_id)
         ]
 
-    def qfree(self, qubits: Iterable['cirq.Qid']) -> None:
+    def qfree(self, qubits: Iterable[cirq.Qid]) -> None:
         for q in qubits:
             good = isinstance(q, CleanQubit) and q.id < self._clean_id
             good |= isinstance(q, BorrowableQubit) and q.id < self._borrow_id

cirq/ops/qubit_manager_test.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 from cirq.ops import qubit_manager as cqi
 
 
-def test_clean_qubits():
+def test_clean_qubits() -> None:
     q = cqi.CleanQubit(1)
     assert q.id == 1
     assert q.dimension == 2
@@ -39,7 +41,7 @@ def test_clean_qubits():
     assert cqi.CleanQubit(1) < cqi.CleanQubit(2)
 
 
-def test_ancilla_qubits_prefix():
+def test_ancilla_qubits_prefix() -> None:
     assert cqi.CleanQubit(1, prefix="1") != cqi.CleanQubit(1, prefix="2")
     assert cqi.CleanQubit(1, prefix="1") < cqi.CleanQubit(1, prefix="2")
     assert cqi.CleanQubit(1, prefix="1") < cqi.CleanQubit(2, prefix="1")
@@ -49,7 +51,7 @@ def test_ancilla_qubits_prefix():
     assert cqi.CleanQubit(1, prefix="1") != cqi.BorrowableQubit(1, prefix="1")
 
 
-def test_borrow_qubits():
+def test_borrow_qubits() -> None:
     q = cqi.BorrowableQubit(10)
     assert q.id == 10
     assert q.dimension == 2
@@ -71,7 +73,7 @@ def test_borrow_qubits():
 
 
 @pytest.mark.parametrize('_', range(2))
-def test_simple_qubit_manager(_):
+def test_simple_qubit_manager(_) -> None:
     qm = cirq.ops.SimpleQubitManager()
     assert qm.qalloc(1) == [cqi.CleanQubit(0)]
     assert qm.qalloc(2) == [cqi.CleanQubit(1), cqi.CleanQubit(2)]

cirq/ops/qubit_order.py

@@ -12,13 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
-from typing import Any, Callable, Iterable, Optional, Tuple, TYPE_CHECKING, TypeVar
-
-from cirq.ops import raw_types
+from typing import Any, Callable, Iterable, TYPE_CHECKING, TypeVar
 
 if TYPE_CHECKING:
-    from cirq.ops import qubit_order_or_list
+    import cirq
 
 
 TInternalQubit = TypeVar('TInternalQubit')
@@ -28,12 +27,10 @@ TExternalQubit = TypeVar('TExternalQubit')
 class QubitOrder:
     """Defines the kronecker product order of qubits."""
 
-    def __init__(
-        self, explicit_func: Callable[[Iterable[raw_types.Qid]], Tuple[raw_types.Qid, ...]]
-    ) -> None:
+    def __init__(self, explicit_func: Callable[[Iterable[cirq.Qid]], tuple[cirq.Qid, ...]]) -> None:
         self._explicit_func = explicit_func
 
-    DEFAULT: 'QubitOrder'
+    DEFAULT: QubitOrder
     """A basis that orders qubits in the same way that calling `sorted` does.
 
     Specifically, qubits are ordered first by their type name and then by
@@ -43,8 +40,8 @@ class QubitOrder:
 
     @staticmethod
     def explicit(
-        fixed_qubits: Iterable[raw_types.Qid], fallback: Optional['QubitOrder'] = None
-    ) -> 'QubitOrder':
+        fixed_qubits: Iterable[cirq.Qid], fallback: QubitOrder | None = None
+    ) -> QubitOrder:
         """A basis that contains exactly the given qubits in the given order.
 
         Args:
@@ -77,7 +74,7 @@ class QubitOrder:
         return QubitOrder(func)
 
     @staticmethod
-    def sorted_by(key: Callable[[raw_types.Qid], Any]) -> 'QubitOrder':
+    def sorted_by(key: Callable[[cirq.Qid], Any]) -> QubitOrder:
         """A basis that orders qubits ascending based on a key function.
 
         Args:
@@ -89,7 +86,7 @@ class QubitOrder:
         """
         return QubitOrder(lambda qubits: tuple(sorted(qubits, key=key)))
 
-    def order_for(self, qubits: Iterable[raw_types.Qid]) -> Tuple[raw_types.Qid, ...]:
+    def order_for(self, qubits: Iterable[cirq.Qid]) -> tuple[cirq.Qid, ...]:
         """Returns a qubit tuple ordered corresponding to the basis.
 
         Args:
@@ -104,7 +101,7 @@ class QubitOrder:
         return self._explicit_func(qubits)
 
     @staticmethod
-    def as_qubit_order(val: 'qubit_order_or_list.QubitOrderOrList') -> 'QubitOrder':
+    def as_qubit_order(val: cirq.QubitOrderOrList) -> QubitOrder:
         """Converts a value into a basis.
 
         Args:
@@ -126,7 +123,7 @@ class QubitOrder:
         self,
         internalize: Callable[[TExternalQubit], TInternalQubit],
         externalize: Callable[[TInternalQubit], TExternalQubit],
-    ) -> 'QubitOrder':
+    ) -> QubitOrder:
         """Transforms the Basis so that it applies to wrapped qubits.
 
         Args:

cirq/ops/qubit_order_or_list.py

@@ -18,12 +18,14 @@ This type is defined in its own file to work around an "invalid type" bug in
 mypy.
 """
 
-from typing import Iterable, Union
+from __future__ import annotations
+
+from typing import Iterable
 
 from cirq._doc import document
 from cirq.ops import qubit_order, raw_types
 
-QubitOrderOrList = Union[qubit_order.QubitOrder, Iterable[raw_types.Qid]]
+QubitOrderOrList = qubit_order.QubitOrder | Iterable[raw_types.Qid]
 document(
     QubitOrderOrList,
     """Specifies a qubit ordering.

cirq/ops/qubit_order_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 
 
-def test_default():
+def test_default() -> None:
     a2 = cirq.NamedQubit('a2')
     a10 = cirq.NamedQubit('a10')
     b = cirq.NamedQubit('b')
@@ -30,7 +32,7 @@ def test_default():
     assert sorted([q5, a10, a2, b, q4]) == [q4, q5, a2, a10, b]
 
 
-def test_default_grouping():
+def test_default_grouping() -> None:
     presorted = (
         cirq.GridQubit(0, 1),
         cirq.GridQubit(1, 0),
@@ -48,7 +50,7 @@ def test_default_grouping():
     assert cirq.QubitOrder.DEFAULT.order_for(reversed(presorted)) == presorted
 
 
-def test_explicit():
+def test_explicit() -> None:
     a2 = cirq.NamedQubit('a2')
     a10 = cirq.NamedQubit('a10')
     b = cirq.NamedQubit('b')
@@ -62,7 +64,7 @@ def test_explicit():
         _ = q.order_for([cirq.NamedQubit('c')])
 
 
-def test_explicit_with_fallback():
+def test_explicit_with_fallback() -> None:
     a2 = cirq.NamedQubit('a2')
     a10 = cirq.NamedQubit('a10')
     b = cirq.NamedQubit('b')
@@ -74,7 +76,7 @@ def test_explicit_with_fallback():
     assert q.order_for([a10, a2]) == (b, a2, a10)
 
 
-def test_sorted_by():
+def test_sorted_by() -> None:
     a = cirq.NamedQubit('2')
     b = cirq.NamedQubit('10')
     c = cirq.NamedQubit('-5')
@@ -86,7 +88,7 @@ def test_sorted_by():
     assert q.order_for([a, b, c]) == (b, a, c)
 
 
-def test_map():
+def test_map() -> None:
     b = cirq.NamedQubit('b!')
     q = cirq.QubitOrder.explicit([cirq.NamedQubit('b')]).map(
         internalize=lambda e: cirq.NamedQubit(e.name[:-1]),
@@ -97,7 +99,7 @@ def test_map():
     assert q.order_for([b]) == (b,)
 
 
-def test_qubit_order_or_list():
+def test_qubit_order_or_list() -> None:
     b = cirq.NamedQubit('b')
 
     implied_by_list = cirq.QubitOrder.as_qubit_order([b])
@@ -114,7 +116,7 @@ def test_qubit_order_or_list():
     assert ordered is passed_through
 
 
-def test_qubit_order_iterator():
+def test_qubit_order_iterator() -> None:
     generator = (q for q in cirq.LineQubit.range(5))
     assert cirq.QubitOrder.explicit(generator).order_for((cirq.LineQubit(3),)) == tuple(
         cirq.LineQubit.range(5)
@@ -126,6 +128,6 @@ def test_qubit_order_iterator():
     )
 
 
-def test_qubit_order_invalid():
+def test_qubit_order_invalid() -> None:
     with pytest.raises(ValueError, match="Don't know how to interpret <5> as a Basis."):
-        _ = cirq.QubitOrder.as_qubit_order(5)
+        _ = cirq.QubitOrder.as_qubit_order(5)  # type: ignore[arg-type]

cirq/ops/random_gate_channel.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numbers
-from typing import AbstractSet, Any, cast, Dict, Optional, SupportsFloat, Tuple, TYPE_CHECKING
+from typing import AbstractSet, Any, cast, SupportsFloat, TYPE_CHECKING
 
 import numpy as np
 
@@ -29,7 +31,7 @@ if TYPE_CHECKING:
 class RandomGateChannel(raw_types.Gate):
     """Applies a sub gate with some probability."""
 
-    def __init__(self, *, sub_gate: 'cirq.Gate', probability: 'cirq.TParamVal'):
+    def __init__(self, *, sub_gate: cirq.Gate, probability: cirq.TParamVal):
         if (
             isinstance(probability, numbers.Number)
             and not 0 <= float(cast(SupportsFloat, probability)) <= 1
@@ -45,14 +47,14 @@ class RandomGateChannel(raw_types.Gate):
             self._sub_gate = self.sub_gate.sub_gate
 
     @property
-    def sub_gate(self) -> 'cirq.Gate':
+    def sub_gate(self) -> cirq.Gate:
         return self._sub_gate
 
     @property
-    def probability(self) -> 'cirq.TParamVal':
+    def probability(self) -> cirq.TParamVal:
         return self._probability
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return protocols.qid_shape(self.sub_gate)
 
     def _value_equality_values_(self):
@@ -78,8 +80,8 @@ class RandomGateChannel(raw_types.Gate):
         )
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'RandomGateChannel':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> RandomGateChannel:
         return RandomGateChannel(
             sub_gate=protocols.resolve_parameters(self.sub_gate, resolver, recursive),
             probability=protocols.resolve_parameters(self.probability, resolver, recursive),
@@ -121,7 +123,7 @@ class RandomGateChannel(raw_types.Gate):
             result *= float(self.probability)
         return result
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['sub_gate', 'probability'])
 
     @classmethod
@@ -129,8 +131,8 @@ class RandomGateChannel(raw_types.Gate):
         return cls(sub_gate=sub_gate, probability=probability)
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Optional['cirq.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> cirq.CircuitDiagramInfo | None:
         result = protocols.circuit_diagram_info(self.sub_gate, args, None)
         if result is None:
             return None

cirq/ops/random_gate_channel_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
 import sympy
@@ -18,7 +21,7 @@ import sympy
 import cirq
 
 
-def test_init():
+def test_init() -> None:
     p = cirq.RandomGateChannel(sub_gate=cirq.X, probability=0.5)
     assert p.sub_gate is cirq.X
     assert p.probability == 0.5
@@ -29,7 +32,7 @@ def test_init():
         _ = cirq.RandomGateChannel(sub_gate=cirq.X, probability=-1)
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     q = cirq.LineQubit(0)
 
@@ -67,7 +70,7 @@ def test_eq():
     )
 
 
-def test_consistent_protocols():
+def test_consistent_protocols() -> None:
     cirq.testing.assert_implements_consistent_protocols(
         cirq.RandomGateChannel(sub_gate=cirq.X, probability=1),
         ignore_decompose_to_default_gateset=True,
@@ -86,7 +89,7 @@ def test_consistent_protocols():
     )
 
 
-def test_diagram():
+def test_diagram() -> None:
     class NoDetailsGate(cirq.Gate):
         def num_qubits(self) -> int:
             raise NotImplementedError()
@@ -115,7 +118,7 @@ def test_diagram():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameterized(resolve_fn):
+def test_parameterized(resolve_fn) -> None:
     op = cirq.X.with_probability(sympy.Symbol('x'))
     assert cirq.is_parameterized(op)
     assert not cirq.has_kraus(op)
@@ -128,7 +131,7 @@ def test_parameterized(resolve_fn):
     assert cirq.has_mixture(op2)
 
 
-def test_mixture():
+def test_mixture() -> None:
     class NoDetailsGate(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -150,7 +153,7 @@ def test_mixture():
     assert {p for p, _ in m} == {7 / 8, 1 / 32, 3 / 32}
 
 
-def test_channel():
+def test_channel() -> None:
     class NoDetailsGate(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -192,7 +195,7 @@ def test_channel():
     np.testing.assert_allclose(m[2], cirq.unitary(cirq.I) * np.sqrt(0.75), atol=1e-8)
 
 
-def test_trace_distance():
+def test_trace_distance() -> None:
     t = cirq.trace_distance_bound
     assert 0.999 <= t(cirq.X.with_probability(sympy.Symbol('x')))
     assert t(cirq.X.with_probability(0)) == 0
@@ -201,18 +204,18 @@ def test_trace_distance():
     assert 0.35 <= t(cirq.S.with_probability(0.5)) <= 0.36
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.X.with_probability(0.5)) == 'X[prob=0.5]'
 
 
-def test_stabilizer_supports_probability():
+def test_stabilizer_supports_probability() -> None:
     q = cirq.LineQubit(0)
     c = cirq.Circuit(cirq.X(q).with_probability(0.5), cirq.measure(q, key='m'))
     m = np.sum(cirq.StabilizerSampler().sample(c, repetitions=100)['m'])
     assert 5 < m < 95
 
 
-def test_unsupported_stabilizer_safety():
+def test_unsupported_stabilizer_safety() -> None:
     from cirq.protocols.act_on_protocol_test import ExampleSimulationState
 
     with pytest.raises(TypeError, match="act_on"):