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

cirq/contrib/noise_models/noise_models.py

@@ -23,6 +23,7 @@ if TYPE_CHECKING:
     import cirq
 
 
+@value.value_equality()
 class DepolarizingNoiseModel(devices.NoiseModel):
     """Applies depolarizing noise to each qubit individually at the end of
     every moment.
@@ -39,10 +40,25 @@ class DepolarizingNoiseModel(devices.NoiseModel):
             prepend: If True, put noise before affected gates. Default: False.
         """
         value.validate_probability(depol_prob, 'depol prob')
+        self._depol_prob = depol_prob
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    @property
+    def depol_prob(self):
+        """The depolarizing probability."""
+        return self._depol_prob
+
+    def _value_equality_values_(self):
+        return self.depol_prob, self._prepend
+
+    def __repr__(self) -> str:
+        return (
+            f'cirq.contrib.noise_models.DepolarizingNoiseModel('
+            f'{self.depol_prob!r}, prepend={self._prepend!r})'
+        )
+
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment) or self.is_virtual_moment(moment):  # pragma: no cover
             return moment
 
@@ -54,7 +70,11 @@ class DepolarizingNoiseModel(devices.NoiseModel):
         ]
         return output[::-1] if self._prepend else output
 
+    def _json_dict_(self) -> dict[str, object]:
+        return {'depol_prob': self.depol_prob, 'prepend': self._prepend}
 
+
+@value.value_equality()
 class ReadoutNoiseModel(devices.NoiseModel):
     """NoiseModel with probabilistic bit flips preceding measurement.
 
@@ -75,10 +95,23 @@ class ReadoutNoiseModel(devices.NoiseModel):
             prepend: If True, put noise before affected gates. Default: True.
         """
         value.validate_probability(bitflip_prob, 'bitflip prob')
+        self._bitflip_prob = bitflip_prob
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    @property
+    def bitflip_prob(self):
+        """The probability of a bit-flip during measurement."""
+        return self._bitflip_prob
+
+    def _value_equality_values_(self):
+        return self.bitflip_prob, self._prepend
+
+    def __repr__(self) -> str:
+        p = self.bitflip_prob
+        return f'cirq.contrib.noise_models.ReadoutNoiseModel({p!r}, prepend={self._prepend!r})'
+
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -91,7 +124,11 @@ class ReadoutNoiseModel(devices.NoiseModel):
             return output if self._prepend else output[::-1]
         return moment
 
+    def _json_dict_(self) -> dict[str, object]:
+        return {'bitflip_prob': self.bitflip_prob, 'prepend': self._prepend}
+
 
+@value.value_equality()
 class DampedReadoutNoiseModel(devices.NoiseModel):
     """NoiseModel with T1 decay preceding measurement.
 
@@ -112,10 +149,25 @@ class DampedReadoutNoiseModel(devices.NoiseModel):
             prepend: If True, put noise before affected gates. Default: True.
         """
         value.validate_probability(decay_prob, 'decay_prob')
+        self._decay_prob = decay_prob
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    @property
+    def decay_prob(self):
+        """The probability of T1 decay during measurement."""
+        return self._decay_prob
+
+    def _value_equality_values_(self):
+        return self.decay_prob, self._prepend
+
+    def __repr__(self) -> str:
+        return (
+            f'cirq.contrib.noise_models.DampedReadoutNoiseModel('
+            f'{self.decay_prob!r}, prepend={self._prepend!r})'
+        )
+
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -128,7 +180,11 @@ class DampedReadoutNoiseModel(devices.NoiseModel):
             return output if self._prepend else output[::-1]
         return moment
 
+    def _json_dict_(self) -> dict[str, object]:
+        return {'decay_prob': self.decay_prob, 'prepend': self._prepend}
+
 
+@value.value_equality()
 class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
     """DepolarizingNoiseModel with probabilistic bit flips preceding
     measurement.
@@ -145,15 +201,39 @@ class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
         """
         value.validate_probability(depol_prob, 'depol prob')
         value.validate_probability(bitflip_prob, 'bitflip prob')
+        self._depol_prob = depol_prob
+        self._bitflip_prob = bitflip_prob
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    @property
+    def depol_prob(self):
+        """The depolarizing probability."""
+        return self._depol_prob
+
+    @property
+    def bitflip_prob(self):
+        """The probability of a bit-flip during measurement."""
+        return self._bitflip_prob
+
+    def _value_equality_values_(self):
+        return self.depol_prob, self.bitflip_prob
+
+    def __repr__(self) -> str:
+        p = self.depol_prob
+        b = self.bitflip_prob
+        return f'cirq.contrib.noise_models.DepolarizingWithReadoutNoiseModel({p!r}, {b!r})'
+
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment):
             return [circuits.Moment(self.readout_noise_gate(q) for q in system_qubits), moment]
         return [moment, circuits.Moment(self.qubit_noise_gate(q) for q in system_qubits)]
 
+    def _json_dict_(self) -> dict[str, object]:
+        return {'depol_prob': self.depol_prob, 'bitflip_prob': self.bitflip_prob}
+
 
+@value.value_equality()
 class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
     """DepolarizingWithReadoutNoiseModel with T1 decay preceding
     measurement.
@@ -174,11 +254,38 @@ class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
         value.validate_probability(depol_prob, 'depol prob')
         value.validate_probability(bitflip_prob, 'bitflip prob')
         value.validate_probability(decay_prob, 'decay_prob')
+        self._depol_prob = depol_prob
+        self._bitflip_prob = bitflip_prob
+        self._decay_prob = decay_prob
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    @property
+    def depol_prob(self):
+        """The depolarizing probability."""
+        return self._depol_prob
+
+    @property
+    def bitflip_prob(self):
+        """Probability of a bit-flip during measurement."""
+        return self._bitflip_prob
+
+    @property
+    def decay_prob(self):
+        """The probability of T1 decay during measurement."""
+        return self._decay_prob
+
+    def _value_equality_values_(self):
+        return self.depol_prob, self.bitflip_prob, self.decay_prob
+
+    def __repr__(self) -> str:
+        return (
+            'cirq.contrib.noise_models.DepolarizingWithDampedReadoutNoiseModel('
+            f'{self.depol_prob!r}, {self.bitflip_prob!r}, {self.decay_prob!r})'
+        )
+
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment):
             return [
                 circuits.Moment(self.readout_decay_gate(q) for q in system_qubits),
@@ -187,3 +294,10 @@ class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
             ]
         else:
             return [moment, circuits.Moment(self.qubit_noise_gate(q) for q in system_qubits)]
+
+    def _json_dict_(self) -> dict[str, object]:
+        return {
+            'depol_prob': self.depol_prob,
+            'bitflip_prob': self.bitflip_prob,
+            'decay_prob': self.decay_prob,
+        }

cirq/contrib/noise_models/noise_models_test.py

@@ -12,28 +12,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
+import pytest
+
 import cirq
 import cirq.contrib.noise_models as ccn
 from cirq import ops
-from cirq.testing import assert_equivalent_op_tree
+from cirq.testing import assert_equivalent_op_tree, assert_equivalent_repr
 
 
-def test_depol_noise():
+def test_depol_noise() -> None:
     noise_model = ccn.DepolarizingNoiseModel(depol_prob=0.005)
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.X(qubits[0]), cirq.Y(qubits[1])])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[0] == moment
     for g in noisy_mom[1]:
         assert isinstance(g.gate, cirq.DepolarizingChannel)
 
 
-def test_depol_noise_prepend():
+def test_depol_noise_prepend() -> None:
     noise_model = ccn.DepolarizingNoiseModel(depol_prob=0.005, prepend=True)
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.X(qubits[0]), cirq.Y(qubits[1])])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[1] == moment
     for g in noisy_mom[0]:
@@ -41,7 +47,7 @@ def test_depol_noise_prepend():
 
 
 # Composes depolarization noise with readout noise.
-def test_readout_noise_after_moment():
+def test_readout_noise_after_moment() -> None:
     program = cirq.Circuit()
     qubits = cirq.LineQubit.range(3)
     program.append(
@@ -92,11 +98,32 @@ def test_readout_noise_after_moment():
     assert_equivalent_op_tree(true_noisy_program, noisy_circuit)
 
 
-def test_readout_noise_no_prepend():
+@pytest.mark.parametrize(
+    'model',
+    [
+        ccn.DepolarizingNoiseModel(0.1),
+        ccn.DepolarizingNoiseModel(0.1, prepend=False),
+        ccn.DepolarizingNoiseModel(0.1, prepend=True),
+        ccn.ReadoutNoiseModel(0.2),
+        ccn.ReadoutNoiseModel(0.2, prepend=False),
+        ccn.ReadoutNoiseModel(0.2, prepend=True),
+        ccn.DampedReadoutNoiseModel(0.3),
+        ccn.DampedReadoutNoiseModel(0.3, prepend=False),
+        ccn.DampedReadoutNoiseModel(0.3, prepend=True),
+        ccn.DepolarizingWithReadoutNoiseModel(0.1, 0.2),
+        ccn.DepolarizingWithDampedReadoutNoiseModel(0.1, 0.2, 0.3),
+    ],
+)
+def test_repr(model) -> None:
+    assert_equivalent_repr(model)
+
+
+def test_readout_noise_no_prepend() -> None:
     noise_model = ccn.ReadoutNoiseModel(bitflip_prob=0.005, prepend=False)
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.measure(*qubits, key="meas")])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[0] == moment
     for g in noisy_mom[1]:
@@ -104,7 +131,7 @@ def test_readout_noise_no_prepend():
 
 
 # Composes depolarization, damping, and readout noise (in that order).
-def test_decay_noise_after_moment():
+def test_decay_noise_after_moment() -> None:
     program = cirq.Circuit()
     qubits = cirq.LineQubit.range(3)
     program.append(
@@ -160,11 +187,12 @@ def test_decay_noise_after_moment():
     assert_equivalent_op_tree(true_noisy_program, noisy_circuit)
 
 
-def test_damped_readout_noise_no_prepend():
+def test_damped_readout_noise_no_prepend() -> None:
     noise_model = ccn.DampedReadoutNoiseModel(decay_prob=0.005, prepend=False)
     qubits = cirq.LineQubit.range(2)
     moment = cirq.Moment([cirq.measure(*qubits, key="meas")])
     noisy_mom = noise_model.noisy_moment(moment, system_qubits=qubits)
+    assert isinstance(noisy_mom, list)
     assert len(noisy_mom) == 2
     assert noisy_mom[0] == moment
     for g in noisy_mom[1]:
@@ -172,7 +200,7 @@ def test_damped_readout_noise_no_prepend():
 
 
 # Test the aggregate noise models.
-def test_aggregate_readout_noise_after_moment():
+def test_aggregate_readout_noise_after_moment() -> None:
     program = cirq.Circuit()
     qubits = cirq.LineQubit.range(3)
     program.append(
@@ -219,7 +247,7 @@ def test_aggregate_readout_noise_after_moment():
     assert_equivalent_op_tree(true_noisy_program, noisy_circuit)
 
 
-def test_aggregate_decay_noise_after_moment():
+def test_aggregate_decay_noise_after_moment() -> None:
     program = cirq.Circuit()
     qubits = cirq.LineQubit.range(3)
     program.append(

cirq/contrib/paulistring/clifford_optimize.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import cast, Tuple
+from __future__ import annotations
+
+from typing import cast
 
 from cirq import circuits, ops, protocols, transformers
 from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGateset
@@ -29,7 +31,7 @@ def clifford_optimized_circuit(circuit: circuits.Circuit, atol: float = 1e-8) ->
 
     def find_merge_point(
         start_i: int, string_op: ops.PauliStringPhasor, stop_at_cz: bool
-    ) -> Tuple[int, ops.PauliStringPhasor, int]:
+    ) -> tuple[int, ops.PauliStringPhasor, int]:
         STOP = 0
         CONTINUE = 1
         SKIP = 2
@@ -65,7 +67,7 @@ def clifford_optimized_circuit(circuit: circuits.Circuit, atol: float = 1e-8) ->
                     furthest_i = i
                 break
             if cont_cond == CONTINUE:
-                modified_op = modified_op.pass_operations_over([op], after_to_before=True)
+                modified_op = modified_op.conjugated_by(protocols.inverse(op))
             num_passed_over += 1
             if len(modified_op.pauli_string) == 1:
                 furthest_op = modified_op
@@ -122,7 +124,7 @@ def clifford_optimized_circuit(circuit: circuits.Circuit, atol: float = 1e-8) ->
                 all_ops.insert(merge_i + 1, part_cliff_gate(qubit))
             elif isinstance(other_op, ops.PauliStringPhasor):
                 # Pass over a non-Clifford gate
-                mod_op = other_op.pass_operations_over([part_cliff_gate(qubit)])
+                mod_op = other_op.conjugated_by([part_cliff_gate(qubit)])
                 all_ops[merge_i] = mod_op
                 all_ops.insert(merge_i + 1, part_cliff_gate(qubit))
             elif merge_i > start_i + 1 and num_passed > 0:

cirq/contrib/paulistring/clifford_optimize_test.py

@@ -12,12 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 import cirq
 from cirq.contrib.paulistring import clifford_optimized_circuit, CliffordTargetGateset
 
 
-def test_optimize():
+def test_optimize() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(
         cirq.X(q1) ** 0.5,
@@ -49,7 +50,7 @@ def test_optimize():
     )
 
 
-def test_remove_czs():
+def test_remove_czs() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(cirq.CZ(q0, q1), cirq.Z(q0) ** 0.5, cirq.CZ(q0, q1))
     c_expected = cirq.optimize_for_target_gateset(
@@ -72,7 +73,7 @@ def test_remove_czs():
     )
 
 
-def test_remove_staggered_czs():
+def test_remove_staggered_czs() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     c_orig = cirq.Circuit(cirq.CZ(q0, q1), cirq.CZ(q1, q2), cirq.CZ(q0, q1))
     c_expected = cirq.optimize_for_target_gateset(
@@ -97,7 +98,7 @@ def test_remove_staggered_czs():
     )
 
 
-def test_with_measurements():
+def test_with_measurements() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(cirq.X(q0), cirq.CZ(q0, q1), cirq.measure(q0, q1, key='m'))
     c_expected = cirq.optimize_for_target_gateset(
@@ -121,7 +122,7 @@ def test_with_measurements():
     )
 
 
-def test_optimize_large_circuit():
+def test_optimize_large_circuit() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     c_orig = cirq.testing.nonoptimal_toffoli_circuit(q0, q1, q2)
 

cirq/contrib/paulistring/clifford_target_gateset.py

@@ -16,19 +16,19 @@ from __future__ import annotations
 
 from enum import Enum
 from types import NotImplementedType
-from typing import cast, List, Type, TYPE_CHECKING, Union
-
-import numpy as np
+from typing import cast, TYPE_CHECKING
 
 from cirq import linalg, ops, protocols, transformers
 
 if TYPE_CHECKING:
+    import numpy as np
+
     import cirq
 
 
 def _matrix_to_clifford_op(
     mat: np.ndarray, qubit: cirq.Qid, *, atol: float
-) -> Union[ops.Operation, NotImplementedType]:
+) -> ops.Operation | NotImplementedType:
     rotations = transformers.single_qubit_matrix_to_pauli_rotations(mat, atol)
     clifford_gate = ops.SingleQubitCliffordGate.I
     for pauli, half_turns in rotations:
@@ -48,7 +48,7 @@ def _matrix_to_pauli_string_phasors(
     mat: np.ndarray, qubit: cirq.Qid, *, keep_clifford: bool, atol: float
 ) -> ops.OP_TREE:
     rotations = transformers.single_qubit_matrix_to_pauli_rotations(mat, atol)
-    out_ops: List[ops.GateOperation] = []
+    out_ops: list[ops.GateOperation] = []
     for pauli, half_turns in rotations:
         if keep_clifford and linalg.all_near_zero_mod(half_turns, 0.5):
             cliff_gate = ops.SingleQubitCliffordGate.from_quarter_turns(
@@ -79,7 +79,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
     def __init__(
         self,
         *,
-        single_qubit_target: SingleQubitTarget = SingleQubitTarget.PAULI_STRING_PHASORS_AND_CLIFFORDS,  # pylint: disable=line-too-long
+        single_qubit_target: SingleQubitTarget = SingleQubitTarget.PAULI_STRING_PHASORS_AND_CLIFFORDS,  # noqa: E501
         atol: float = 1e-8,
     ):
         """Initializes CliffordTargetGateset
@@ -97,7 +97,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         """
         self.atol = atol
         self.single_qubit_target = single_qubit_target
-        gates: List[Union[cirq.Gate, Type[cirq.Gate]]] = [ops.CZ, ops.MeasurementGate]
+        gates: list[cirq.Gate | type[cirq.Gate]] = [ops.CZ, ops.MeasurementGate]
         if single_qubit_target in [
             self.SingleQubitTarget.SINGLE_QUBIT_CLIFFORDS,
             self.SingleQubitTarget.PAULI_STRING_PHASORS_AND_CLIFFORDS,
@@ -112,7 +112,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
 
     def _decompose_single_qubit_operation(
         self, op: cirq.Operation, _
-    ) -> Union[NotImplementedType, cirq.OP_TREE]:
+    ) -> NotImplementedType | cirq.OP_TREE:
         if not protocols.has_unitary(op):
             return NotImplemented
         mat = protocols.unitary(op)
@@ -129,7 +129,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
 
     def _decompose_two_qubit_operation(
         self, op: cirq.Operation, _
-    ) -> Union[NotImplementedType, cirq.OP_TREE]:
+    ) -> NotImplementedType | cirq.OP_TREE:
         if not protocols.has_unitary(op):
             return NotImplemented
         return transformers.two_qubit_matrix_to_cz_operations(
@@ -141,7 +141,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         )
 
     @property
-    def postprocess_transformers(self) -> List[cirq.TRANSFORMER]:
+    def postprocess_transformers(self) -> list[cirq.TRANSFORMER]:
         """List of transformers which should be run after decomposing individual operations."""
 
         def rewriter(o: cirq.CircuitOperation):

cirq/contrib/paulistring/clifford_target_gateset_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 pytest
 import sympy
 
@@ -41,7 +43,7 @@ from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGates
         )
     )(cirq.LineQubit(0), cirq.LineQubit(1)),
 )
-def test_converts_various_ops(op, expected_ops):
+def test_converts_various_ops(op, expected_ops) -> None:
     before = cirq.Circuit(op)
     expected = cirq.Circuit(expected_ops, strategy=cirq.InsertStrategy.EARLIEST)
     after = cirq.optimize_for_target_gateset(
@@ -58,7 +60,7 @@ def test_converts_various_ops(op, expected_ops):
     )
 
 
-def test_degenerate_single_qubit_decompose():
+def test_degenerate_single_qubit_decompose() -> None:
     q0 = cirq.LineQubit(0)
 
     before = cirq.Circuit(cirq.Z(q0) ** 0.1, cirq.X(q0) ** 1.0000000001, cirq.Z(q0) ** 0.1)
@@ -72,7 +74,7 @@ def test_degenerate_single_qubit_decompose():
     cirq.testing.assert_allclose_up_to_global_phase(after.unitary(), expected.unitary(), atol=1e-7)
 
 
-def test_converts_single_qubit_series():
+def test_converts_single_qubit_series() -> None:
     q0 = cirq.LineQubit(0)
 
     before = cirq.Circuit(
@@ -96,7 +98,7 @@ def test_converts_single_qubit_series():
     cirq.testing.assert_allclose_up_to_global_phase(before.unitary(), after.unitary(), atol=1e-7)
 
 
-def test_converts_single_qubit_then_two():
+def test_converts_single_qubit_then_two() -> None:
     q0, q1 = cirq.LineQubit.range(2)
 
     before = cirq.Circuit(cirq.X(q0), cirq.Y(q0), cirq.CZ(q0, q1))
@@ -107,7 +109,7 @@ def test_converts_single_qubit_then_two():
     cirq.testing.assert_allclose_up_to_global_phase(before.unitary(), after.unitary(), atol=1e-7)
 
 
-def test_converts_large_circuit():
+def test_converts_large_circuit() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
 
     before = cirq.Circuit(
@@ -147,7 +149,7 @@ def test_converts_large_circuit():
     )
 
 
-def test_convert_to_pauli_string_phasors():
+def test_convert_to_pauli_string_phasors() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(cirq.X(q0), cirq.Y(q1) ** 0.25, cirq.Z(q0) ** 0.125, cirq.H(q1))
     c_new = cirq.optimize_for_target_gateset(
@@ -168,7 +170,7 @@ def test_convert_to_pauli_string_phasors():
     )
 
 
-def test_already_converted():
+def test_already_converted() -> None:
     q0 = cirq.LineQubit(0)
     c_orig = cirq.Circuit(cirq.PauliStringPhasor(cirq.X.on(q0)))
     c_new = cirq.optimize_for_target_gateset(
@@ -181,7 +183,7 @@ def test_already_converted():
     assert c_new == c_orig
 
 
-def test_ignore_unsupported_gate():
+def test_ignore_unsupported_gate() -> None:
     class UnsupportedGate(cirq.testing.TwoQubitGate):
         pass
 
@@ -193,7 +195,7 @@ def test_ignore_unsupported_gate():
     assert c_new == c_orig
 
 
-def test_fail_unsupported_gate():
+def test_fail_unsupported_gate() -> None:
     class UnsupportedGate(cirq.testing.TwoQubitGate):
         pass
 
@@ -205,7 +207,7 @@ def test_fail_unsupported_gate():
         )
 
 
-def test_convert_to_single_qubit_cliffords():
+def test_convert_to_single_qubit_cliffords() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(
         cirq.X(q0), cirq.Y(q1) ** 0.5, cirq.Z(q0) ** -0.5, cirq.Z(q1) ** 0, cirq.H(q0)
@@ -232,7 +234,7 @@ def test_convert_to_single_qubit_cliffords():
     )
 
 
-def test_convert_to_single_qubit_cliffords_ignores_non_clifford():
+def test_convert_to_single_qubit_cliffords_ignores_non_clifford() -> None:
     q0 = cirq.LineQubit(0)
     c_orig = cirq.Circuit(cirq.Z(q0) ** 0.25)
     c_new = cirq.optimize_for_target_gateset(

cirq/contrib/paulistring/optimize.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Callable
 
 from cirq import circuits, ops, transformers

cirq/contrib/paulistring/optimize_test.py

@@ -12,12 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 import cirq
 from cirq.contrib.paulistring import optimized_circuit
 
 
-def test_optimize():
+def test_optimize() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     c_orig = cirq.Circuit(
         cirq.X(q0) ** 0.5,
@@ -61,7 +62,7 @@ def test_optimize():
     )
 
 
-def test_optimize_large_circuit():
+def test_optimize_large_circuit() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     c_orig = cirq.testing.nonoptimal_toffoli_circuit(q0, q1, q2)
 
@@ -79,7 +80,7 @@ def test_optimize_large_circuit():
     )
 
 
-def test_repeat_limit():
+def test_repeat_limit() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     c_orig = cirq.testing.nonoptimal_toffoli_circuit(q0, q1, q2)
 

cirq/contrib/paulistring/pauli_string_dag.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import cast
 
 from cirq import circuits, ops, protocols

cirq/contrib/paulistring/pauli_string_dag_test.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 from cirq.contrib.paulistring import convert_and_separate_circuit, pauli_string_dag_from_circuit
 
 
-def test_pauli_string_dag_from_circuit():
+def test_pauli_string_dag_from_circuit() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     c_orig = cirq.testing.nonoptimal_toffoli_circuit(q0, q1, q2)
     c_left, _ = convert_and_separate_circuit(c_orig)