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

cirq/ops/gateset.py

@@ -14,20 +14,9 @@
 
 """Functionality for grouping and validating Cirq gates."""
 
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    FrozenSet,
-    Hashable,
-    List,
-    Optional,
-    Sequence,
-    Type,
-    TYPE_CHECKING,
-    Union,
-)
+from __future__ import annotations
+
+from typing import Any, Callable, cast, Hashable, Sequence, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq.ops import global_phase_op, op_tree, raw_types
@@ -37,8 +26,7 @@ if TYPE_CHECKING:
 
 
 def _gate_str(
-    gate: Union[raw_types.Gate, Type[raw_types.Gate], 'cirq.GateFamily'],
-    gettr: Callable[[Any], str] = str,
+    gate: raw_types.Gate | type[raw_types.Gate] | cirq.GateFamily, gettr: Callable[[Any], str] = str
 ) -> str:
     return gettr(gate) if not isinstance(gate, type) else f'{gate.__module__}.{gate.__name__}'
 
@@ -112,10 +100,10 @@ class GateFamily:
 
     def __init__(
         self,
-        gate: Union[Type[raw_types.Gate], raw_types.Gate],
+        gate: type[raw_types.Gate] | raw_types.Gate,
         *,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
+        name: str | None = None,
+        description: str | None = None,
         ignore_global_phase: bool = True,
         tags_to_accept: Sequence[Hashable] = (),
         tags_to_ignore: Sequence[Hashable] = (),
@@ -164,7 +152,7 @@ class GateFamily:
     def _gate_str(self, gettr: Callable[[Any], str] = str) -> str:
         return _gate_str(self.gate, gettr)
 
-    def _gate_json(self) -> Union[raw_types.Gate, str]:
+    def _gate_json(self) -> raw_types.Gate | str:
         return self.gate if not isinstance(self.gate, type) else protocols.json_cirq_type(self.gate)
 
     def _default_name(self) -> str:
@@ -186,7 +174,7 @@ class GateFamily:
         )
 
     @property
-    def gate(self) -> Union[Type[raw_types.Gate], raw_types.Gate]:
+    def gate(self) -> type[raw_types.Gate] | raw_types.Gate:
         return self._gate
 
     @property
@@ -198,11 +186,11 @@ class GateFamily:
         return self._description
 
     @property
-    def tags_to_accept(self) -> FrozenSet[Hashable]:
+    def tags_to_accept(self) -> frozenset[Hashable]:
         return self._tags_to_accept
 
     @property
-    def tags_to_ignore(self) -> FrozenSet[Hashable]:
+    def tags_to_ignore(self) -> frozenset[Hashable]:
         return self._tags_to_ignore
 
     def _predicate(self, gate: raw_types.Gate) -> bool:
@@ -225,7 +213,7 @@ class GateFamily:
             )
         return isinstance(gate, self.gate)
 
-    def __contains__(self, item: Union[raw_types.Gate, raw_types.Operation]) -> bool:
+    def __contains__(self, item: raw_types.Gate | raw_types.Operation) -> bool:
         if self._tags_to_accept and (
             not isinstance(item, raw_types.Operation) or self._tags_to_accept.isdisjoint(item.tags)
         ):
@@ -268,8 +256,8 @@ class GateFamily:
             self._tags_to_ignore,
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
-        d: Dict[str, Any] = {
+    def _json_dict_(self) -> dict[str, Any]:
+        d: dict[str, Any] = {
             'gate': self._gate_json(),
             'name': self.name,
             'description': self.description,
@@ -291,7 +279,7 @@ class GateFamily:
         tags_to_accept=(),
         tags_to_ignore=(),
         **kwargs,
-    ) -> 'GateFamily':
+    ) -> GateFamily:
         if isinstance(gate, str):
             gate = protocols.cirq_type_from_json(gate)
         return cls(
@@ -319,8 +307,8 @@ class Gateset:
 
     def __init__(
         self,
-        *gates: Union[Type[raw_types.Gate], raw_types.Gate, GateFamily],
-        name: Optional[str] = None,
+        *gates: type[raw_types.Gate] | raw_types.Gate | GateFamily,
+        name: str | None = None,
         unroll_circuit_op: bool = True,
     ) -> None:
         """Init Gateset.
@@ -344,10 +332,10 @@ class Gateset:
         """
         self._name = name
         self._unroll_circuit_op = unroll_circuit_op
-        self._instance_gate_families: Dict[raw_types.Gate, GateFamily] = {}
-        self._type_gate_families: Dict[Type[raw_types.Gate], GateFamily] = {}
+        self._instance_gate_families: dict[raw_types.Gate, GateFamily] = {}
+        self._type_gate_families: dict[type[raw_types.Gate], GateFamily] = {}
         self._gates_repr_str = ", ".join([_gate_str(g, repr) for g in gates])
-        unique_gate_list: List[GateFamily] = list(
+        unique_gate_list: list[GateFamily] = list(
             dict.fromkeys(g if isinstance(g, GateFamily) else GateFamily(gate=g) for g in gates)
         )
 
@@ -361,16 +349,16 @@ class Gateset:
         self._gates = frozenset(unique_gate_list)
 
     @property
-    def name(self) -> Optional[str]:
+    def name(self) -> str | None:
         return self._name
 
     @property
-    def gates(self) -> FrozenSet[GateFamily]:
+    def gates(self) -> frozenset[GateFamily]:
         return self._gates
 
     def with_params(
-        self, *, name: Optional[str] = None, unroll_circuit_op: Optional[bool] = None
-    ) -> 'Gateset':
+        self, *, name: str | None = None, unroll_circuit_op: bool | None = None
+    ) -> Gateset:
         """Returns a copy of this Gateset with identical gates and new values for named arguments.
 
         If a named argument is None then corresponding value of this Gateset is used instead.
@@ -395,7 +383,7 @@ class Gateset:
         gates = self.gates
         return Gateset(*gates, name=name, unroll_circuit_op=cast(bool, unroll_circuit_op))
 
-    def __contains__(self, item: Union[raw_types.Gate, raw_types.Operation]) -> bool:
+    def __contains__(self, item: raw_types.Gate | raw_types.Operation) -> bool:
         r"""Check for containment of a given Gate/Operation in this Gateset.
 
         Containment checks are handled as follows:
@@ -445,7 +433,7 @@ class Gateset:
 
         return any(item in gate_family for gate_family in self._gates)
 
-    def validate(self, circuit_or_optree: Union['cirq.AbstractCircuit', op_tree.OP_TREE]) -> bool:
+    def validate(self, circuit_or_optree: cirq.AbstractCircuit | op_tree.OP_TREE) -> bool:
         """Validates gates forming `circuit_or_optree` should be contained in Gateset.
 
         Args:
@@ -510,7 +498,7 @@ class Gateset:
             header += self.name
         return f'{header}\n' + "\n\n".join([str(g) for g in self._unique_gate_list])
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'gates': self._unique_gate_list,
             'name': self.name,
@@ -518,7 +506,7 @@ class Gateset:
         }
 
     @classmethod
-    def _from_json_dict_(cls, gates, name, unroll_circuit_op, **kwargs) -> 'Gateset':
+    def _from_json_dict_(cls, gates, name, unroll_circuit_op, **kwargs) -> Gateset:
         # This parameter was deprecated in 0.16, but we keep this logic here for backwards
         # compatibility.
         if 'accept_global_phase_op' in kwargs:

cirq/ops/gateset_test.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import re
-from typing import cast, List, Tuple
+from typing import cast
 
 import numpy as np
 import pytest
@@ -24,7 +26,7 @@ from cirq._compat import proper_repr
 
 
 class CustomXPowGate(cirq.EigenGate):
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.array([[0.5, 0.5], [0.5, 0.5]])), (1, np.array([[0.5, -0.5], [-0.5, 0.5]]))]
 
     def __str__(self) -> str:

cirq/ops/global_phase_op.py

@@ -13,8 +13,10 @@
 # limitations under the License.
 """A no-qubit global phase operation."""
 
+from __future__ import annotations
+
 from types import NotImplementedType
-from typing import AbstractSet, Any, cast, Collection, Dict, Optional, Sequence, Tuple, Union
+from typing import AbstractSet, Any, cast, Collection, Sequence
 
 import numpy as np
 import sympy
@@ -27,14 +29,14 @@ from cirq.ops import control_values as cv, controlled_gate, raw_types
 
 @value.value_equality(approximate=True)
 class GlobalPhaseGate(raw_types.Gate):
-    def __init__(self, coefficient: 'cirq.TParamValComplex', atol: float = 1e-8) -> None:
+    def __init__(self, coefficient: cirq.TParamValComplex, atol: float = 1e-8) -> None:
         if not isinstance(coefficient, sympy.Basic):
             if abs(1 - abs(coefficient)) > atol:
                 raise ValueError(f'Coefficient is not unitary: {coefficient!r}')
         self._coefficient = coefficient
 
     @property
-    def coefficient(self) -> 'cirq.TParamValComplex':
+    def coefficient(self) -> cirq.TParamValComplex:
         return self._coefficient
 
     def _value_equality_values_(self) -> Any:
@@ -43,19 +45,17 @@ class GlobalPhaseGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def __pow__(self, power) -> 'cirq.GlobalPhaseGate':
+    def __pow__(self, power) -> cirq.GlobalPhaseGate:
         if isinstance(power, (int, float)):
             return GlobalPhaseGate(self.coefficient**power)
         return NotImplemented
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         if not self._has_unitary_():
             return NotImplemented
         return np.array([[self.coefficient]])
 
-    def _apply_unitary_(
-        self, args: 'cirq.ApplyUnitaryArgs'
-    ) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         if not self._has_unitary_():
             return NotImplemented
         assert not cirq.is_parameterized(self)
@@ -71,13 +71,13 @@ class GlobalPhaseGate(raw_types.Gate):
     def __repr__(self) -> str:
         return f'cirq.GlobalPhaseGate({proper_repr(self.coefficient)})'
 
-    def _op_repr_(self, qubits: Sequence['cirq.Qid']) -> str:
+    def _op_repr_(self, qubits: Sequence[cirq.Qid]) -> str:
         return f'cirq.global_phase_operation({proper_repr(self.coefficient)})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['coefficient'])
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return tuple()
 
     def _is_parameterized_(self) -> bool:
@@ -87,18 +87,23 @@ class GlobalPhaseGate(raw_types.Gate):
         return protocols.parameter_names(self.coefficient)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.GlobalPhaseGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> cirq.GlobalPhaseGate:
         coefficient = protocols.resolve_parameters(self.coefficient, resolver, recursive)
         return GlobalPhaseGate(coefficient=coefficient)
 
+    def is_identity(self) -> bool:
+        """Checks if gate is equivalent to an identity.
+
+        Returns: True if the coefficient is within rounding error of 1.
+        """
+        return not protocols.is_parameterized(self._coefficient) and np.isclose(self.coefficient, 1)
+
     def controlled(
         self,
-        num_controls: Optional[int] = None,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-        control_qid_shape: Optional[Tuple[int, ...]] = None,
+        num_controls: int | None = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+        control_qid_shape: tuple[int, ...] | None = None,
     ) -> raw_types.Gate:
         result = super().controlled(num_controls, control_values, control_qid_shape)
         if (
@@ -120,7 +125,27 @@ class GlobalPhaseGate(raw_types.Gate):
 
 
 def global_phase_operation(
-    coefficient: 'cirq.TParamValComplex', atol: float = 1e-8
-) -> 'cirq.GateOperation':
+    coefficient: cirq.TParamValComplex, atol: float = 1e-8
+) -> cirq.GateOperation:
     """Creates an operation that represents a global phase on the state."""
     return GlobalPhaseGate(coefficient, atol)()
+
+
+def from_phase_and_exponent(
+    half_turns: cirq.TParamVal, exponent: cirq.TParamVal
+) -> cirq.GlobalPhaseGate:
+    """Creates a GlobalPhaseGate from the global phase and exponent.
+
+    Args:
+        half_turns: The number of half turns to rotate by.
+        exponent: The power to raise the phase to.
+
+    Returns: A `GlobalPhaseGate` with the corresponding coefficient.
+    """
+    coefficient = 1j ** (2 * half_turns * exponent)
+    coefficient = (
+        complex(coefficient)
+        if isinstance(coefficient, sympy.Expr) and coefficient.is_complex
+        else coefficient
+    )
+    return GlobalPhaseGate(coefficient)

cirq/ops/global_phase_op_test.py

@@ -12,16 +12,21 @@
 # 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
 
 import cirq
+from cirq.ops import global_phase_op
 
 
-def test_init():
+def test_init() -> None:
     op = cirq.global_phase_operation(1j)
-    assert op.gate.coefficient == 1j
+    gate = op.gate
+    assert isinstance(gate, cirq.GlobalPhaseGate)
+    assert gate.coefficient == 1j
     assert op.qubits == ()
     assert op.with_qubits() == op
     assert cirq.has_stabilizer_effect(op)
@@ -32,7 +37,7 @@ def test_init():
         _ = cirq.global_phase_operation(1j).with_qubits(cirq.LineQubit(0))
 
 
-def test_protocols():
+def test_protocols() -> None:
     for p in [1, 1j, -1, sympy.Symbol('s')]:
         cirq.testing.assert_implements_consistent_protocols(cirq.global_phase_operation(p))
 
@@ -42,7 +47,7 @@ def test_protocols():
 
 
 @pytest.mark.parametrize('phase', [1, 1j, -1])
-def test_act_on_tableau(phase):
+def test_act_on_tableau(phase) -> None:
     original_tableau = cirq.CliffordTableau(0)
     args = cirq.CliffordTableauSimulationState(original_tableau.copy(), np.random.RandomState())
     cirq.act_on(cirq.global_phase_operation(phase), args, allow_decompose=False)
@@ -50,7 +55,7 @@ def test_act_on_tableau(phase):
 
 
 @pytest.mark.parametrize('phase', [1, 1j, -1])
-def test_act_on_ch_form(phase):
+def test_act_on_ch_form(phase) -> None:
     state = cirq.StabilizerStateChForm(0)
     args = cirq.StabilizerChFormSimulationState(
         qubits=[], prng=np.random.RandomState(), initial_state=state
@@ -59,16 +64,16 @@ def test_act_on_ch_form(phase):
     assert state.state_vector() == [[phase]]
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.global_phase_operation(1j)) == '1j'
 
 
-def test_repr():
+def test_repr() -> None:
     op = cirq.global_phase_operation(1j)
     cirq.testing.assert_equivalent_repr(op)
 
 
-def test_diagram():
+def test_diagram() -> None:
     a, b = cirq.LineQubit.range(2)
     x, y = cirq.LineQubit.range(10, 12)
 
@@ -200,7 +205,7 @@ global phase:   -0.5π
     )
 
 
-def test_gate_init():
+def test_gate_init() -> None:
     gate = cirq.GlobalPhaseGate(1j)
     assert gate.coefficient == 1j
     assert isinstance(gate.on(), cirq.GateOperation)
@@ -213,7 +218,7 @@ def test_gate_init():
         _ = gate.on(cirq.LineQubit(0))
 
 
-def test_gate_protocols():
+def test_gate_protocols() -> None:
     for p in [1, 1j, -1]:
         cirq.testing.assert_implements_consistent_protocols(cirq.GlobalPhaseGate(p))
 
@@ -221,7 +226,7 @@ def test_gate_protocols():
 
 
 @pytest.mark.parametrize('phase', [1, 1j, -1])
-def test_gate_act_on_tableau(phase):
+def test_gate_act_on_tableau(phase) -> None:
     original_tableau = cirq.CliffordTableau(0)
     args = cirq.CliffordTableauSimulationState(original_tableau.copy(), np.random.RandomState())
     cirq.act_on(cirq.GlobalPhaseGate(phase), args, qubits=(), allow_decompose=False)
@@ -229,7 +234,7 @@ def test_gate_act_on_tableau(phase):
 
 
 @pytest.mark.parametrize('phase', [1, 1j, -1])
-def test_gate_act_on_ch_form(phase):
+def test_gate_act_on_ch_form(phase) -> None:
     state = cirq.StabilizerStateChForm(0)
     args = cirq.StabilizerChFormSimulationState(
         qubits=[], prng=np.random.RandomState(), initial_state=state
@@ -238,25 +243,25 @@ def test_gate_act_on_ch_form(phase):
     assert state.state_vector() == [[phase]]
 
 
-def test_gate_str():
+def test_gate_str() -> None:
     assert str(cirq.GlobalPhaseGate(1j)) == '1j'
 
 
-def test_gate_repr():
+def test_gate_repr() -> None:
     gate = cirq.GlobalPhaseGate(1j)
     cirq.testing.assert_equivalent_repr(gate)
 
 
-def test_gate_op_repr():
+def test_gate_op_repr() -> None:
     gate = cirq.GlobalPhaseGate(1j)
     cirq.testing.assert_equivalent_repr(gate.on())
 
 
-def test_gate_global_phase_op_json_dict():
+def test_gate_global_phase_op_json_dict() -> None:
     assert cirq.GlobalPhaseGate(-1j)._json_dict_() == {'coefficient': -1j}
 
 
-def test_parameterization():
+def test_parameterization() -> None:
     t = sympy.Symbol('t')
     gpt = cirq.GlobalPhaseGate(coefficient=t)
     assert cirq.is_parameterized(gpt)
@@ -267,14 +272,14 @@ def test_parameterization():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve(resolve_fn):
+def test_resolve(resolve_fn) -> None:
     t = sympy.Symbol('t')
     gpt = cirq.GlobalPhaseGate(coefficient=t)
     assert resolve_fn(gpt, {'t': -1}) == cirq.GlobalPhaseGate(coefficient=-1)
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve_error(resolve_fn):
+def test_resolve_error(resolve_fn) -> None:
     t = sympy.Symbol('t')
     gpt = cirq.GlobalPhaseGate(coefficient=t)
     with pytest.raises(ValueError, match='Coefficient is not unitary'):
@@ -284,7 +289,7 @@ def test_resolve_error(resolve_fn):
 @pytest.mark.parametrize(
     'coeff, exp', [(-1, 1), (1j, 0.5), (-1j, -0.5), (1 / np.sqrt(2) * (1 + 1j), 0.25)]
 )
-def test_global_phase_gate_controlled(coeff, exp):
+def test_global_phase_gate_controlled(coeff, exp) -> None:
     g = cirq.GlobalPhaseGate(coeff)
     op = cirq.global_phase_operation(coeff)
     q = cirq.LineQubit.range(3)
@@ -300,3 +305,22 @@ def test_global_phase_gate_controlled(coeff, exp):
     assert g.controlled(control_values=xor_control_values) == cirq.ControlledGate(
         g, control_values=xor_control_values
     )
+
+
+def test_is_identity() -> None:
+    g = cirq.GlobalPhaseGate(1)
+    assert g.is_identity()
+    g = cirq.GlobalPhaseGate(1j)
+    assert not g.is_identity()
+    g = cirq.GlobalPhaseGate(-1)
+    assert not g.is_identity()
+
+
+def test_from_phase_and_exponent() -> None:
+    g = global_phase_op.from_phase_and_exponent(2.5, 0.5)
+    assert g.coefficient == np.exp(1.25j * np.pi)
+    a, b = sympy.symbols('a, b')
+    g = global_phase_op.from_phase_and_exponent(a, b)
+    assert g.coefficient == 1j ** (2 * a * b)
+    g = global_phase_op.from_phase_and_exponent(1 / a, a)
+    assert g.coefficient == -1

cirq/ops/greedy_qubit_manager.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Iterable, List, Set, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Iterable, TYPE_CHECKING
 
 from cirq.ops import named_qubit, qid_util, qubit_manager
 
@@ -49,25 +51,25 @@ class GreedyQubitManager(qubit_manager.QubitManager):
             maximize_reuse: Flag to control a FIFO vs LIFO strategy, defaults to False (FIFO).
         """
         self._prefix = prefix
-        self._used_qubits: Set['cirq.Qid'] = set()
-        self._free_qubits: List['cirq.Qid'] = []
+        self._used_qubits: set[cirq.Qid] = set()
+        self._free_qubits: list[cirq.Qid] = []
         self._size = 0
         self.maximize_reuse = maximize_reuse
         self.resize(size)
 
-    def _allocate_qid(self, name: str, dim: int) -> 'cirq.Qid':
+    def _allocate_qid(self, name: str, dim: int) -> cirq.Qid:
         return qid_util.q(name) if dim == 2 else named_qubit.NamedQid(name, dimension=dim)
 
     def resize(self, new_size: int, dim: int = 2) -> None:
         if new_size <= self._size:
             return
-        new_qubits: List['cirq.Qid'] = [
+        new_qubits: list[cirq.Qid] = [
             self._allocate_qid(f'{self._prefix}_{s}', dim) for s in range(self._size, new_size)
         ]
         self._free_qubits = new_qubits + self._free_qubits
         self._size = new_size
 
-    def qalloc(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qalloc(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         if not n:
             return []
         self.resize(self._size + n - len(self._free_qubits), dim=dim)
@@ -76,11 +78,11 @@ class GreedyQubitManager(qubit_manager.QubitManager):
         self._used_qubits.update(ret_qubits)
         return ret_qubits
 
-    def qfree(self, qubits: Iterable['cirq.Qid']) -> None:
+    def qfree(self, qubits: Iterable[cirq.Qid]) -> None:
         qs = list(dict(zip(qubits, qubits)).keys())
         assert self._used_qubits.issuperset(qs), "Only managed qubits currently in-use can be freed"
         self._used_qubits = self._used_qubits.difference(qs)
         self._free_qubits.extend(qs)
 
-    def qborrow(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qborrow(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         return self.qalloc(n, dim)

cirq/ops/greedy_qubit_manager_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 cirq
 
 
@@ -30,7 +32,7 @@ class GateAllocInDecompose(cirq.Gate):
             qm.qfree([q])
 
 
-def test_greedy_qubit_manager():
+def test_greedy_qubit_manager() -> None:
     def make_circuit(qm: cirq.QubitManager):
         q = cirq.LineQubit.range(2)
         g = GateAllocInDecompose(1)
@@ -90,12 +92,12 @@ ancilla_1: ───X───X───
     )
 
 
-def test_empty_qubits():
+def test_empty_qubits() -> None:
     qm = cirq.GreedyQubitManager(prefix="anc")
     assert qm.qalloc(0) == []
 
 
-def test_greedy_qubit_manager_preserves_order():
+def test_greedy_qubit_manager_preserves_order() -> None:
     qm = cirq.GreedyQubitManager(prefix="anc")
     ancillae = [cirq.q(f"anc_{i}") for i in range(100)]
     assert qm.qalloc(100) == ancillae