cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/study/sweeps_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 import pytest
 import sympy
+
 import cirq
 
 
@@ -110,7 +111,9 @@ def test_zip_longest_compatibility():
 
 
 def test_empty_zip():
+    assert len(cirq.Zip()) == 0
     assert len(cirq.ZipLongest()) == 0
+    assert str(cirq.Zip()) == 'Zip()'
     with pytest.raises(ValueError, match='non-empty'):
         _ = cirq.ZipLongest(cirq.Points('e', []), cirq.Points('a', [1, 2, 3]))
 
@@ -141,10 +144,26 @@ def test_product():
     assert _values(sweep, 'a') == [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3]
     assert _values(sweep, 'b') == [4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7]
 
+    sweep = cirq.Points('a', [1, 2]) * (cirq.Points('b', [3, 4]) * cirq.Points('c', [5, 6]))
+    assert len(sweep) == 8
+    assert _values(sweep, 'a') == [1, 1, 1, 1, 2, 2, 2, 2]
+    assert _values(sweep, 'b') == [3, 3, 4, 4, 3, 3, 4, 4]
+    assert _values(sweep, 'c') == [5, 6, 5, 6, 5, 6, 5, 6]
+
+
+def test_zip_addition():
+    zip_sweep = cirq.Zip(cirq.Points('a', [1, 2]), cirq.Points('b', [3, 4]))
+    zip_sweep2 = cirq.Points('c', [5, 6]) + zip_sweep
+    assert len(zip_sweep2) == 2
+    assert _values(zip_sweep2, 'a') == [1, 2]
+    assert _values(zip_sweep2, 'b') == [3, 4]
+    assert _values(zip_sweep2, 'c') == [5, 6]
+
 
 def test_empty_product():
     sweep = cirq.Product()
     assert len(sweep) == len(list(sweep)) == 1
+    assert str(sweep) == 'Product()'
 
 
 def test_slice_access_error():
@@ -246,6 +265,8 @@ def test_equality():
     et.make_equality_group(lambda: cirq.Linspace('b', 0, 10, 11))
     et.make_equality_group(lambda: cirq.Points('a', list(range(11))))
     et.make_equality_group(lambda: cirq.Points('b', list(range(11))))
+    et.make_equality_group(lambda: cirq.Concat(cirq.Linspace('a', 0, 10, 11)))
+    et.make_equality_group(lambda: cirq.Concat(cirq.Linspace('b', 0, 10, 11)))
 
     # Product and Zip sweeps can also be equated.
     et.make_equality_group(lambda: cirq.Linspace('a', 0, 5, 6) * cirq.Linspace('b', 10, 15, 6))
@@ -373,3 +394,105 @@ def test_dict_to_zip_sweep():
     assert cirq.dict_to_zip_sweep({'t': [0, 1], 's': [2, 3], 'r': 4}) == (
         cirq.Zip(cirq.Points('t', [0, 1]), cirq.Points('s', [2, 3]), cirq.Points('r', [4]))
     )
+
+
+def test_concat_linspace():
+    sweep1 = cirq.Linspace('a', 0.34, 9.16, 4)
+    sweep2 = cirq.Linspace('a', 10, 20, 4)
+    concat_sweep = cirq.Concat(sweep1, sweep2)
+
+    assert len(concat_sweep) == 8
+    assert concat_sweep.keys == ['a']
+    params = list(concat_sweep.param_tuples())
+    assert len(params) == 8
+    assert params[0] == (('a', 0.34),)
+    assert params[3] == (('a', 9.16),)
+    assert params[4] == (('a', 10.0),)
+    assert params[7] == (('a', 20.0),)
+
+
+def test_concat_points():
+    sweep1 = cirq.Points('a', [1, 2])
+    sweep2 = cirq.Points('a', [3, 4, 5])
+    concat_sweep = cirq.Concat(sweep1, sweep2)
+
+    assert concat_sweep.keys == ['a']
+    assert len(concat_sweep) == 5
+    params = list(concat_sweep)
+    assert len(params) == 5
+    assert _values(concat_sweep, 'a') == [1, 2, 3, 4, 5]
+
+
+def test_concat_many_points():
+    sweep1 = cirq.Points('a', [1, 2])
+    sweep2 = cirq.Points('a', [3, 4, 5])
+    sweep3 = cirq.Points('a', [6, 7, 8])
+    concat_sweep = cirq.Concat(sweep1, sweep2, sweep3)
+
+    assert len(concat_sweep) == 8
+    params = list(concat_sweep)
+    assert len(params) == 8
+    assert _values(concat_sweep, 'a') == [1, 2, 3, 4, 5, 6, 7, 8]
+
+
+def test_concat_mixed():
+    sweep1 = cirq.Linspace('a', 0, 1, 3)
+    sweep2 = cirq.Points('a', [2, 3])
+    concat_sweep = cirq.Concat(sweep1, sweep2)
+
+    assert len(concat_sweep) == 5
+    assert _values(concat_sweep, 'a') == [0.0, 0.5, 1.0, 2, 3]
+
+
+def test_concat_inconsistent_keys():
+    sweep1 = cirq.Linspace('a', 0, 1, 3)
+    sweep2 = cirq.Points('b', [2, 3])
+
+    with pytest.raises(ValueError, match="All sweeps must have the same descriptors"):
+        cirq.Concat(sweep1, sweep2)
+
+
+def test_concat_sympy_symbol():
+    a = sympy.Symbol('a')
+    sweep1 = cirq.Linspace(a, 0, 1, 3)
+    sweep2 = cirq.Points(a, [2, 3])
+    concat_sweep = cirq.Concat(sweep1, sweep2)
+
+    assert len(concat_sweep) == 5
+    assert _values(concat_sweep, 'a') == [0.0, 0.5, 1.0, 2, 3]
+
+
+def test_concat_repr_and_str():
+    sweep1 = cirq.Linspace('a', 0, 1, 3)
+    sweep2 = cirq.Points('a', [2, 3])
+    concat_sweep = cirq.Concat(sweep1, sweep2)
+
+    expected_repr = (
+        "cirq.Concat(cirq.Linspace('a', start=0, stop=1, length=3), cirq.Points('a', [2, 3]))"
+    )
+    expected_str = "Concat(cirq.Linspace('a', start=0, stop=1, length=3), cirq.Points('a', [2, 3]))"
+
+    assert repr(concat_sweep) == expected_repr
+    assert str(concat_sweep) == expected_str
+
+
+def test_concat_large_sweep():
+    sweep1 = cirq.Points('a', list(range(101)))
+    sweep2 = cirq.Points('a', list(range(101, 202)))
+    concat_sweep = cirq.Concat(sweep1, sweep2)
+
+    assert len(concat_sweep) == 202
+    assert _values(concat_sweep, 'a') == list(range(101)) + list(range(101, 202))
+
+
+def test_concat_different_keys_raises():
+    sweep1 = cirq.Linspace('a', 0, 1, 3)
+    sweep2 = cirq.Points('b', [2, 3])
+
+    with pytest.raises(ValueError, match="All sweeps must have the same descriptors."):
+        _ = cirq.Concat(sweep1, sweep2)
+
+
+def test_concat_empty_sweep_raises():
+    with pytest.raises(ValueError, match="Concat requires at least one sweep."):
+        _ = cirq.Concat()

cirq/testing/__init__.py

@@ -15,107 +15,136 @@
 """Utilities for testing code."""
 
 from cirq.testing.circuit_compare import (
-    assert_circuits_with_terminal_measurements_are_equivalent,
-    assert_circuits_have_same_unitary_given_final_permutation,
-    assert_has_consistent_apply_channel,
-    assert_has_consistent_apply_unitary,
-    assert_has_consistent_apply_unitary_for_various_exponents,
-    assert_has_diagram,
-    assert_same_circuits,
-    highlight_text_differences,
-    assert_has_consistent_qid_shape,
+    # pylint: disable=line-too-long
+    assert_circuits_with_terminal_measurements_are_equivalent as assert_circuits_with_terminal_measurements_are_equivalent,
+    assert_circuits_have_same_unitary_given_final_permutation as assert_circuits_have_same_unitary_given_final_permutation,
+    assert_has_consistent_apply_channel as assert_has_consistent_apply_channel,
+    assert_has_consistent_apply_unitary as assert_has_consistent_apply_unitary,
+    assert_has_consistent_apply_unitary_for_various_exponents as assert_has_consistent_apply_unitary_for_various_exponents,
+    assert_has_diagram as assert_has_diagram,
+    assert_same_circuits as assert_same_circuits,
+    highlight_text_differences as highlight_text_differences,
+    assert_has_consistent_qid_shape as assert_has_consistent_qid_shape,
 )
 
-from cirq.testing.consistent_act_on import assert_all_implemented_act_on_effects_match_unitary
+from cirq.testing.consistent_act_on import (
+    # pylint: disable=line-too-long
+    assert_all_implemented_act_on_effects_match_unitary as assert_all_implemented_act_on_effects_match_unitary,
+)
 
-from cirq.testing.consistent_channels import assert_consistent_channel, assert_consistent_mixture
+from cirq.testing.consistent_channels import (
+    assert_consistent_channel as assert_consistent_channel,
+    assert_consistent_mixture as assert_consistent_mixture,
+)
 
 from cirq.testing.consistent_controlled_gate_op import (
-    assert_controlled_and_controlled_by_identical,
-    assert_controlled_unitary_consistent,
+    assert_controlled_and_controlled_by_identical as assert_controlled_and_controlled_by_identical,
+    assert_controlled_unitary_consistent as assert_controlled_unitary_consistent,
 )
 
 from cirq.testing.consistent_decomposition import (
-    assert_decompose_ends_at_default_gateset,
-    assert_decompose_is_consistent_with_unitary,
+    assert_decompose_ends_at_default_gateset as assert_decompose_ends_at_default_gateset,
+    assert_decompose_is_consistent_with_unitary as assert_decompose_is_consistent_with_unitary,
 )
 
 from cirq.testing.consistent_pauli_expansion import (
-    assert_pauli_expansion_is_consistent_with_unitary,
+    # pylint: disable=line-too-long
+    assert_pauli_expansion_is_consistent_with_unitary as assert_pauli_expansion_is_consistent_with_unitary,
 )
 
-from cirq.testing.consistent_phase_by import assert_phase_by_is_consistent_with_unitary
+from cirq.testing.consistent_phase_by import (
+    assert_phase_by_is_consistent_with_unitary as assert_phase_by_is_consistent_with_unitary,
+)
 
 from cirq.testing.consistent_protocols import (
-    assert_eigengate_implements_consistent_protocols,
-    assert_has_consistent_trace_distance_bound,
-    assert_implements_consistent_protocols,
-    assert_commutes_magic_method_consistent_with_unitaries,
+    # pylint: disable=line-too-long
+    assert_eigengate_implements_consistent_protocols as assert_eigengate_implements_consistent_protocols,
+    assert_has_consistent_trace_distance_bound as assert_has_consistent_trace_distance_bound,
+    assert_implements_consistent_protocols as assert_implements_consistent_protocols,
+    assert_commutes_magic_method_consistent_with_unitaries as assert_commutes_magic_method_consistent_with_unitaries,
 )
 
-from cirq.testing.consistent_qasm import assert_qasm_is_consistent_with_unitary
+from cirq.testing.consistent_qasm import (
+    assert_qasm_is_consistent_with_unitary as assert_qasm_is_consistent_with_unitary,
+)
 
-from cirq.testing.consistent_resolve_parameters import assert_consistent_resolve_parameters
+from cirq.testing.consistent_resolve_parameters import (
+    assert_consistent_resolve_parameters as assert_consistent_resolve_parameters,
+)
 
-from cirq.testing.consistent_specified_has_unitary import assert_specifies_has_unitary_if_unitary
+from cirq.testing.consistent_specified_has_unitary import (
+    assert_specifies_has_unitary_if_unitary as assert_specifies_has_unitary_if_unitary,
+)
 
-from cirq.testing.deprecation import assert_deprecated
+from cirq.testing.deprecation import assert_deprecated as assert_deprecated
 
-from cirq.testing.devices import ValidatingTestDevice
+from cirq.testing.devices import ValidatingTestDevice as ValidatingTestDevice
 
-from cirq.testing.equals_tester import EqualsTester
+from cirq.testing.equals_tester import EqualsTester as EqualsTester
 
-from cirq.testing.equivalent_basis_map import assert_equivalent_computational_basis_map
+from cirq.testing.equivalent_basis_map import (
+    assert_equivalent_computational_basis_map as assert_equivalent_computational_basis_map,
+)
 
-from cirq.testing.equivalent_repr_eval import assert_equivalent_repr
+from cirq.testing.equivalent_repr_eval import assert_equivalent_repr as assert_equivalent_repr
 
 from cirq.testing.gate_features import (
-    SingleQubitGate,
-    TwoQubitGate,
-    ThreeQubitGate,
-    DoesNotSupportSerializationGate,
+    SingleQubitGate as SingleQubitGate,
+    TwoQubitGate as TwoQubitGate,
+    ThreeQubitGate as ThreeQubitGate,
+    DoesNotSupportSerializationGate as DoesNotSupportSerializationGate,
 )
 
-from cirq.testing.json import assert_json_roundtrip_works
+from cirq.testing.json import assert_json_roundtrip_works as assert_json_roundtrip_works
 
 from cirq.testing.lin_alg_utils import (
-    assert_allclose_up_to_global_phase,
-    random_density_matrix,
-    random_orthogonal,
-    random_special_orthogonal,
-    random_special_unitary,
-    random_superposition,
-    random_unitary,
+    assert_allclose_up_to_global_phase as assert_allclose_up_to_global_phase,
+    random_density_matrix as random_density_matrix,
+    random_orthogonal as random_orthogonal,
+    random_special_orthogonal as random_special_orthogonal,
+    random_special_unitary as random_special_unitary,
+    random_superposition as random_superposition,
+    random_unitary as random_unitary,
 )
 
-from cirq.testing.logs import assert_logs
+from cirq.testing.logs import assert_logs as assert_logs
+
+from cirq.testing.no_identifier_qubit import NoIdentifierQubit as NoIdentifierQubit
 
-from cirq.testing.no_identifier_qubit import NoIdentifierQubit
+from cirq.testing.op_tree import assert_equivalent_op_tree as assert_equivalent_op_tree
 
-from cirq.testing.op_tree import assert_equivalent_op_tree
+from cirq.testing.order_tester import OrderTester as OrderTester
 
-from cirq.testing.order_tester import OrderTester
+from cirq.testing.pytest_utils import (
+    retry_once_after_timeout as retry_once_after_timeout,
+    retry_once_with_later_random_values as retry_once_with_later_random_values,
+)
 
 from cirq.testing.random_circuit import (
-    DEFAULT_GATE_DOMAIN,
-    random_circuit,
-    random_two_qubit_circuit_with_czs,
+    DEFAULT_GATE_DOMAIN as DEFAULT_GATE_DOMAIN,
+    random_circuit as random_circuit,
+    random_two_qubit_circuit_with_czs as random_two_qubit_circuit_with_czs,
 )
 
 from cirq.testing.repr_pretty_tester import (
-    assert_repr_pretty,
-    assert_repr_pretty_contains,
-    FakePrinter,
+    assert_repr_pretty as assert_repr_pretty,
+    assert_repr_pretty_contains as assert_repr_pretty_contains,
+    FakePrinter as FakePrinter,
 )
 
 from cirq.testing.routing_devices import (
-    construct_grid_device,
-    construct_ring_device,
-    RoutingTestingDevice,
+    construct_grid_device as construct_grid_device,
+    construct_ring_device as construct_ring_device,
+    RoutingTestingDevice as RoutingTestingDevice,
 )
 
-from cirq.testing.sample_circuits import nonoptimal_toffoli_circuit
+from cirq.testing.sample_circuits import nonoptimal_toffoli_circuit as nonoptimal_toffoli_circuit
 
-from cirq.testing.sample_gates import PhaseUsingCleanAncilla, PhaseUsingDirtyAncilla
+from cirq.testing.sample_gates import (
+    PhaseUsingCleanAncilla as PhaseUsingCleanAncilla,
+    PhaseUsingDirtyAncilla as PhaseUsingDirtyAncilla,
+)
 
-from cirq.testing.consistent_unitary import assert_unitary_is_consistent
+from cirq.testing.consistent_unitary import (
+    assert_unitary_is_consistent as assert_unitary_is_consistent,
+)

cirq/testing/_compat_test_data/module_a/__init__.py

@@ -5,9 +5,9 @@ import logging
 
 from cirq.testing._compat_test_data.module_a import module_b
 
-from cirq.testing._compat_test_data.module_a.dupe import DUPE_CONSTANT
+from cirq.testing._compat_test_data.module_a.dupe import DUPE_CONSTANT as DUPE_CONSTANT
 
-from cirq.testing._compat_test_data.module_a.types import SampleType
+from cirq.testing._compat_test_data.module_a.types import SampleType as SampleType
 
 MODULE_A_ATTRIBUTE = "module_a"
 

cirq/testing/_compat_test_data/module_a/sub/subsub/__init__.py

@@ -1,2 +1,2 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
-from cirq.testing._compat_test_data.module_a.sub.subsub.dupe import DUPE_CONSTANT
+from cirq.testing._compat_test_data.module_a.sub.subsub.dupe import DUPE_CONSTANT as DUPE_CONSTANT

cirq/testing/circuit_compare.py

@@ -12,16 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Union
-
-from collections import defaultdict
 import itertools
 import random
+from collections import defaultdict
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Union
 
 import numpy as np
 import sympy
 
-from cirq import circuits, ops, linalg, protocols, qis
+from cirq import circuits, linalg, ops, protocols, qis
 from cirq.testing import lin_alg_utils
 
 

cirq/testing/circuit_compare_test.py

@@ -12,9 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
-
 import numpy as np
+import pytest
 
 import cirq
 from cirq.testing.circuit_compare import _assert_apply_unitary_works_when_axes_transposed
@@ -334,7 +333,7 @@ def test_assert_has_consistent_apply_unitary():
             return args.available_buffer
 
         def _unitary_(self):
-            return np.eye(2)
+            return np.eye(2)  # pragma: no cover
 
         def _num_qubits_(self):
             return 1
@@ -367,7 +366,7 @@ def test_assert_has_consistent_apply_unitary():
             return args.available_buffer
 
         def _unitary_(self):
-            return np.array([[0, 1], [1, 0]])
+            return np.array([[0, 1], [1, 0]])  # pragma: no cover
 
         def _num_qubits_(self):
             return 1
@@ -484,7 +483,7 @@ def test_assert_has_consistent_qid_shape():
 
     class ConsistentOp(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
         @property
         def qubits(self):
@@ -501,7 +500,7 @@ def test_assert_has_consistent_qid_shape():
     # the three methods before finding an inconsistency and throwing an error.
     class InconsistentOp1(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
         @property
         def qubits(self):
@@ -515,7 +514,7 @@ def test_assert_has_consistent_qid_shape():
 
     class InconsistentOp2(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
         @property
         def qubits(self):
@@ -529,7 +528,7 @@ def test_assert_has_consistent_qid_shape():
 
     class InconsistentOp3(cirq.Operation):
         def with_qubits(self, *qubits):
-            raise NotImplementedError  # pragma: no cover
+            raise NotImplementedError
 
         @property
         def qubits(self):

cirq/testing/consistent_act_on.py

@@ -16,17 +16,17 @@ from typing import Any, cast, Optional, Type
 
 import numpy as np
 
+from cirq import protocols
 from cirq.circuits.circuit import Circuit
 from cirq.devices import LineQubit
 from cirq.ops import common_gates
 from cirq.ops.dense_pauli_string import DensePauliString
-from cirq import protocols
 from cirq.qis import clifford_tableau
-from cirq.sim import state_vector_simulation_state, final_state_vector
+from cirq.sim import final_state_vector, state_vector_simulation_state
 from cirq.sim.clifford import (
     clifford_tableau_simulation_state,
-    stabilizer_state_ch_form,
     stabilizer_ch_form_simulation_state,
+    stabilizer_state_ch_form,
 )
 
 

cirq/testing/consistent_channels_test.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
 import numpy as np
+import pytest
+
 import cirq
 
 

cirq/testing/consistent_controlled_gate_op.py

@@ -12,11 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Sequence, Optional, Union, Collection
+from typing import Collection, Optional, Sequence, Union
 
-from cirq import devices, ops, protocols
 import numpy as np
 
+from cirq import devices, ops, protocols
+
 
 def assert_controlled_and_controlled_by_identical(
     gate: ops.Gate,

cirq/testing/consistent_controlled_gate_op_test.py

@@ -12,11 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, Sequence, Union, Collection, Tuple, List
-
-import pytest
+from typing import Collection, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
+import pytest
 
 import cirq
 from cirq.ops import control_values as cv

cirq/testing/consistent_decomposition.py

@@ -16,7 +16,7 @@ from typing import Any
 
 import numpy as np
 
-from cirq import devices, protocols, ops, circuits
+from cirq import circuits, devices, ops, protocols
 from cirq.testing import lin_alg_utils
 
 

cirq/testing/consistent_decomposition_test.py

@@ -12,9 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
-
 import numpy as np
+import pytest
 import sympy
 
 import cirq

cirq/testing/consistent_pauli_expansion_test.py

@@ -32,7 +32,7 @@ class GoodGateExplicitPauliExpansion(cirq.testing.SingleQubitGate):
 
 class GoodGateNoPauliExpansion(cirq.Gate):
     def num_qubits(self) -> int:
-        return 4
+        return 4  # pragma: no cover
 
 
 class GoodGateNoUnitary(cirq.testing.SingleQubitGate):

cirq/testing/consistent_phase_by.py

@@ -17,7 +17,7 @@ from typing import Any
 import numpy as np
 import sympy
 
-from cirq import protocols, linalg
+from cirq import linalg, protocols
 from cirq.testing import lin_alg_utils
 
 

cirq/testing/consistent_phase_by_test.py

@@ -12,9 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
-
 import numpy as np
+import pytest
 
 import cirq
 

cirq/testing/consistent_protocols.py

@@ -13,34 +13,34 @@
 # limitations under the License.
 
 import itertools
-from typing import Any, Dict, Optional, Sequence, Type, Union
+from typing import Any, Dict, Optional, Sequence, Type
 
 import numpy as np
 import sympy
 
 from cirq import ops, protocols, value
-from cirq.testing.consistent_act_on import assert_all_implemented_act_on_effects_match_unitary
 from cirq.testing.circuit_compare import (
     assert_has_consistent_apply_unitary,
     assert_has_consistent_qid_shape,
 )
+from cirq.testing.consistent_act_on import assert_all_implemented_act_on_effects_match_unitary
+from cirq.testing.consistent_controlled_gate_op import (
+    assert_controlled_and_controlled_by_identical,
+    assert_controlled_unitary_consistent,
+)
 from cirq.testing.consistent_decomposition import (
-    assert_decompose_is_consistent_with_unitary,
     assert_decompose_ends_at_default_gateset,
+    assert_decompose_is_consistent_with_unitary,
 )
-from cirq.testing.consistent_phase_by import assert_phase_by_is_consistent_with_unitary
-from cirq.testing.consistent_qasm import assert_qasm_is_consistent_with_unitary
 from cirq.testing.consistent_pauli_expansion import (
     assert_pauli_expansion_is_consistent_with_unitary,
 )
+from cirq.testing.consistent_phase_by import assert_phase_by_is_consistent_with_unitary
+from cirq.testing.consistent_qasm import assert_qasm_is_consistent_with_unitary
 from cirq.testing.consistent_resolve_parameters import assert_consistent_resolve_parameters
 from cirq.testing.consistent_specified_has_unitary import assert_specifies_has_unitary_if_unitary
-from cirq.testing.equivalent_repr_eval import assert_equivalent_repr
-from cirq.testing.consistent_controlled_gate_op import (
-    assert_controlled_and_controlled_by_identical,
-    assert_controlled_unitary_consistent,
-)
 from cirq.testing.consistent_unitary import assert_unitary_is_consistent
+from cirq.testing.equivalent_repr_eval import assert_equivalent_repr
 
 
 def assert_implements_consistent_protocols(
@@ -175,7 +175,7 @@ def _assert_meets_standards_helper(
 
 
 def assert_commutes_magic_method_consistent_with_unitaries(
-    *vals: Sequence[Any], atol: Union[int, float] = 1e-8
+    *vals: Sequence[Any], atol: float = 1e-8
 ) -> None:
     if any(isinstance(val, ops.Operation) for val in vals):
         raise TypeError('`_commutes_` need not be consistent with unitaries for `Operation`.')

cirq/testing/consistent_protocols_test.py

@@ -12,17 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import AbstractSet, Sequence, Union, List, Tuple
-
-import pytest
+from types import NotImplementedType
+from typing import AbstractSet, List, Sequence, Tuple, Union
 
 import numpy as np
+import pytest
 import sympy
 
 import cirq
-from cirq._compat import proper_repr
-from cirq.type_workarounds import NotImplementedType
 import cirq.testing.consistent_controlled_gate_op_test as controlled_gate_op_test
+from cirq._compat import proper_repr
 
 
 class GoodGate(cirq.testing.SingleQubitGate):