cirq-core 1.1.0.dev20221219200817__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/study/sweeps_test.py

@@ -77,6 +77,64 @@ def test_zip():
     assert _values(sweep, 'b') == [4, 5, 6]
 
 
+def test_zip_longest():
+    sweep = cirq.ZipLongest(cirq.Points('a', [1, 2, 3]), cirq.Points('b', [4, 5, 6, 7]))
+    assert tuple(sweep.param_tuples()) == (
+        (('a', 1), ('b', 4)),
+        (('a', 2), ('b', 5)),
+        (('a', 3), ('b', 6)),
+        (('a', 3), ('b', 7)),
+    )
+    assert sweep.keys == ['a', 'b']
+    assert (
+        str(sweep) == 'ZipLongest(cirq.Points(\'a\', [1, 2, 3]), cirq.Points(\'b\', [4, 5, 6, 7]))'
+    )
+    assert (
+        repr(sweep)
+        == 'cirq_google.ZipLongest(cirq.Points(\'a\', [1, 2, 3]), cirq.Points(\'b\', [4, 5, 6, 7]))'
+    )
+
+
+def test_zip_longest_compatibility():
+    sweep = cirq.Zip(cirq.Points('a', [1, 2, 3]), cirq.Points('b', [4, 5, 6]))
+    sweep_longest = cirq.ZipLongest(cirq.Points('a', [1, 2, 3]), cirq.Points('b', [4, 5, 6]))
+    assert tuple(sweep.param_tuples()) == tuple(sweep_longest.param_tuples())
+
+    sweep = cirq.Zip(
+        (cirq.Points('a', [1, 3]) * cirq.Points('b', [2, 4])), cirq.Points('c', [4, 5, 6, 7])
+    )
+    sweep_longest = cirq.ZipLongest(
+        (cirq.Points('a', [1, 3]) * cirq.Points('b', [2, 4])), cirq.Points('c', [4, 5, 6, 7])
+    )
+    assert tuple(sweep.param_tuples()) == tuple(sweep_longest.param_tuples())
+
+
+def test_empty_zip():
+    assert len(cirq.ZipLongest()) == 0
+    with pytest.raises(ValueError, match='non-empty'):
+        _ = cirq.ZipLongest(cirq.Points('e', []), cirq.Points('a', [1, 2, 3]))
+
+
+def test_zip_eq():
+    et = cirq.testing.EqualsTester()
+    point_sweep1 = cirq.Points('a', [1, 2, 3])
+    point_sweep2 = cirq.Points('b', [4, 5, 6, 7])
+    point_sweep3 = cirq.Points('c', [1, 2])
+
+    et.add_equality_group(cirq.ZipLongest(), cirq.ZipLongest())
+
+    et.add_equality_group(
+        cirq.ZipLongest(point_sweep1, point_sweep2), cirq.ZipLongest(point_sweep1, point_sweep2)
+    )
+
+    et.add_equality_group(cirq.ZipLongest(point_sweep3, point_sweep2))
+    et.add_equality_group(cirq.ZipLongest(point_sweep2, point_sweep1))
+    et.add_equality_group(cirq.ZipLongest(point_sweep1, point_sweep2, point_sweep3))
+
+    et.add_equality_group(cirq.Zip(point_sweep1, point_sweep2, point_sweep3))
+    et.add_equality_group(cirq.Zip(point_sweep1, point_sweep2))
+
+
 def test_product():
     sweep = cirq.Points('a', [1, 2, 3]) * cirq.Points('b', [4, 5, 6, 7])
     assert len(sweep) == 12
@@ -215,6 +273,12 @@ def test_repr():
     )
     cirq.testing.assert_equivalent_repr(cirq.Points('zero&pi', [0, 3.14159]))
     cirq.testing.assert_equivalent_repr(cirq.Linspace('I/10', 0, 1, 10))
+    cirq.testing.assert_equivalent_repr(
+        cirq.Points('zero&pi', [0, 3.14159], metadata='example str')
+    )
+    cirq.testing.assert_equivalent_repr(
+        cirq.Linspace('for_q0', 0, 1, 10, metadata=cirq.LineQubit(0))
+    )
 
 
 def test_zip_product_str():

cirq/testing/__init__.py

@@ -107,3 +107,7 @@ from cirq.testing.routing_devices import (
 )
 
 from cirq.testing.sample_circuits import nonoptimal_toffoli_circuit
+
+from cirq.testing.sample_gates import PhaseUsingCleanAncilla, PhaseUsingDirtyAncilla
+
+from cirq.testing.consistent_unitary import assert_unitary_is_consistent

cirq/testing/circuit_compare.py

@@ -11,6 +11,7 @@
 # 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 typing import Any, Dict, Iterable, List, Optional, Sequence, Union
 
 from collections import defaultdict
@@ -175,10 +176,10 @@ def assert_circuits_with_terminal_measurements_are_equivalent(
             "Circuit's effect differs from the reference circuit.\n"
             '\n'
             'Diagram of actual circuit:\n'
-            '{}\n'
+            f'{actual}\n'
             '\n'
             'Diagram of reference circuit with desired function:\n'
-            '{}\n'.format(actual, reference)
+            f'{reference}\n'
         )
 
 
@@ -195,20 +196,20 @@ def assert_same_circuits(
         "Actual circuit differs from expected circuit.\n"
         "\n"
         "Diagram of actual circuit:\n"
-        "{}\n"
+        f"{actual}\n"
         "\n"
         "Diagram of expected circuit:\n"
-        "{}\n"
+        f"{expected}\n"
         "\n"
         "Index of first differing moment:\n"
-        "{}\n"
+        f"{_first_differing_moment_index(actual, expected)}\n"
         "\n"
         "Full repr of actual circuit:\n"
-        "{!r}\n"
+        f"{actual!r}\n"
         "\n"
         "Full repr of expected circuit:\n"
-        "{!r}\n"
-    ).format(actual, expected, _first_differing_moment_index(actual, expected), actual, expected)
+        f"{expected!r}\n"
+    )
 
 
 def _first_differing_moment_index(
@@ -237,7 +238,7 @@ def assert_circuits_have_same_unitary_given_final_permutation(
         ValueError: if 'qubit_map' does not have the same set of keys and values.
     """
     if set(qubit_map.keys()) != set(qubit_map.values()):
-        raise ValueError("'qubit_map' must have the same set of of keys and values.")
+        raise ValueError("'qubit_map' must have the same set of keys and values.")
 
     if not set(qubit_map.keys()).issubset(actual.all_qubits()):
         raise ValueError(
@@ -275,17 +276,13 @@ def assert_has_diagram(
         "Circuit's text diagram differs from the desired diagram.\n"
         '\n'
         'Diagram of actual circuit:\n'
-        '{}\n'
+        f'{actual_diagram}\n'
         '\n'
         'Desired text diagram:\n'
-        '{}\n'
+        f'{desired_diagram}\n'
         '\n'
         'Highlighted differences:\n'
-        '{}\n'.format(
-            actual_diagram,
-            desired_diagram,
-            highlight_text_differences(actual_diagram, desired_diagram),
-        )
+        f'{highlight_text_differences(actual_diagram, desired_diagram)}\n'
     )
 
 
@@ -329,7 +326,7 @@ def assert_has_consistent_apply_unitary(val: Any, *, atol: float = 1e-8) -> None
     # If you applied a unitary, it should match the one you say you have.
     if actual is not None:
         assert expected is not None
-        n = np.product([2, *qid_shape])
+        n = np.prod([2, *qid_shape])
         np.testing.assert_allclose(actual.reshape(n, n), expected, atol=atol)
 
 
@@ -373,7 +370,7 @@ def assert_has_consistent_apply_channel(val: Any, *, atol: float = 1e-8) -> None
     # If you applied a channel, it should match the superoperator you say you have.
     if actual is not None:
         assert expected is not None
-        n = np.product(qid_shape) ** 2
+        n = np.prod(qid_shape) ** 2
         np.testing.assert_allclose(actual.reshape((n, n)), expected, atol=atol)
 
 

cirq/testing/consistent_act_on.py

@@ -68,7 +68,7 @@ def assert_all_implemented_act_on_effects_match_unitary(
     Checks that act_on with CliffordTableau or StabilizerStateCHForm behaves
     consistently with act_on through final state vector. Does not work with
     Operations or Gates expecting non-qubit Qids. If either of the
-    assert_*_implmented args is true, fails if the corresponding method is not
+    assert_*_implemented args is true, fails if the corresponding method is not
     implemented for the test circuit.
 
     Args:
@@ -95,7 +95,7 @@ def assert_all_implemented_act_on_effects_match_unitary(
                 "Could not assert if any act_on methods were "
                 "implemented. Operating on qudits or with a "
                 "non-unitary or parameterized operation is "
-                "unsupported.\n\nval: {!r}".format(val)
+                f"unsupported.\n\nval: {val!r}"
             )
         return None
 
@@ -124,7 +124,7 @@ def assert_all_implemented_act_on_effects_match_unitary(
             state_vector_has_stabilizer(state_vector, stab) for stab in tableau.stabilizers()
         ), (
             "act_on clifford tableau is not consistent with "
-            "final_state_vector simulation.\n\nval: {!r}".format(val)
+            f"final_state_vector simulation.\n\nval: {val!r}"
         )
 
     stabilizer_ch_form = _final_stabilizer_state_ch_form(circuit, qubit_map)
@@ -133,7 +133,7 @@ def assert_all_implemented_act_on_effects_match_unitary(
             "Failed to generate final "
             "stabilizer state CH form "
             "for the test circuit."
-            "\n\nval: {!r}".format(val)
+            f"\n\nval: {val!r}"
         )
     else:
         np.testing.assert_allclose(

cirq/testing/consistent_controlled_gate_op_test.py

@@ -49,7 +49,7 @@ class BadGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
 
     def controlled(
         self,
-        num_controls: int = None,
+        num_controls: Optional[int] = None,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,

cirq/testing/consistent_decomposition.py

@@ -40,8 +40,17 @@ def assert_decompose_is_consistent_with_unitary(val: Any, ignoring_global_phase:
         # If there's no decomposition, it's vacuously consistent.
         return
 
-    actual = circuits.Circuit(dec).unitary(qubit_order=qubits)
-
+    c = circuits.Circuit(dec)
+    if len(c.all_qubits().difference(qubits)):
+        # The decomposition contains ancilla qubits.
+        ancilla = tuple(c.all_qubits().difference(qubits))
+        qubit_order = ancilla + qubits
+        actual = c.unitary(qubit_order=qubit_order)
+        qid_shape = protocols.qid_shape(qubits)
+        vol = np.prod(qid_shape, dtype=np.int64)
+        actual = actual[:vol, :vol]
+    else:
+        actual = c.unitary(qubit_order=qubits)
     if ignoring_global_phase:
         lin_alg_utils.assert_allclose_up_to_global_phase(actual, expected, atol=1e-8)
     else:

cirq/testing/consistent_decomposition_test.py

@@ -43,6 +43,14 @@ def test_assert_decompose_is_consistent_with_unitary():
         GoodGateDecompose().on(cirq.NamedQubit('q'))
     )
 
+    cirq.testing.assert_decompose_is_consistent_with_unitary(
+        cirq.testing.PhaseUsingCleanAncilla(theta=0.1, ancilla_bitsize=3)
+    )
+
+    cirq.testing.assert_decompose_is_consistent_with_unitary(
+        cirq.testing.PhaseUsingDirtyAncilla(phase_state=1, ancilla_bitsize=4)
+    )
+
     with pytest.raises(AssertionError):
         cirq.testing.assert_decompose_is_consistent_with_unitary(BadGateDecompose())
 
@@ -83,7 +91,6 @@ class ParameterizedGate(cirq.Gate):
 
 
 def test_assert_decompose_ends_at_default_gateset():
-
     cirq.testing.assert_decompose_ends_at_default_gateset(GateDecomposesToDefaultGateset())
     cirq.testing.assert_decompose_ends_at_default_gateset(
         GateDecomposesToDefaultGateset().on(*cirq.LineQubit.range(2))

cirq/testing/consistent_protocols.py

@@ -37,6 +37,7 @@ from cirq.testing.consistent_resolve_parameters import assert_consistent_resolve
 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
+from cirq.testing.consistent_unitary import assert_unitary_is_consistent
 
 
 def assert_implements_consistent_protocols(
@@ -153,6 +154,7 @@ def _assert_meets_standards_helper(
     assert_qasm_is_consistent_with_unitary(val)
     assert_has_consistent_trace_distance_bound(val)
     assert_decompose_is_consistent_with_unitary(val, ignoring_global_phase=ignoring_global_phase)
+    assert_unitary_is_consistent(val, ignoring_global_phase=ignoring_global_phase)
     if not ignore_decompose_to_default_gateset:
         assert_decompose_ends_at_default_gateset(val)
     assert_phase_by_is_consistent_with_unitary(val)

cirq/testing/consistent_protocols_test.py

@@ -186,8 +186,10 @@ class GoodEigenGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
     def __repr__(self):
-        return 'GoodEigenGate(exponent={}, global_shift={!r})'.format(
-            proper_repr(self._exponent), self._global_shift
+        return (
+            'GoodEigenGate('
+            f'exponent={proper_repr(self._exponent)}, '
+            f'global_shift={self._global_shift!r})'
         )
 
 
@@ -196,8 +198,10 @@ class BadEigenGate(GoodEigenGate):
         return [0, 0]
 
     def __repr__(self):
-        return 'BadEigenGate(exponent={}, global_shift={!r})'.format(
-            proper_repr(self._exponent), self._global_shift
+        return (
+            'BadEigenGate('
+            f'exponent={proper_repr(self._exponent)}, '
+            f'global_shift={self._global_shift!r})'
         )
 
 

cirq/testing/consistent_qasm.py

@@ -11,6 +11,7 @@
 # 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.
+
 import warnings
 from typing import Any, List, Sequence, Optional
 
@@ -90,21 +91,13 @@ qreg q[{num_qubits}];
             p_qasm_unitary = None
         raise AssertionError(
             'QASM not consistent with cirq.unitary(op) up to global phase.\n\n'
-            'op:\n{}\n\n'
-            'cirq.unitary(op):\n{}\n\n'
-            'Generated QASM:\n\n{}\n\n'
-            'Unitary of generated QASM:\n{}\n\n'
-            'Phased matched cirq.unitary(op):\n{}\n\n'
-            'Phased matched unitary of generated QASM:\n{}\n\n'
-            'Underlying error:\n{}'.format(
-                _indent(repr(op)),
-                _indent(repr(unitary)),
-                _indent(qasm),
-                _indent(repr(qasm_unitary)),
-                _indent(repr(p_unitary)),
-                _indent(repr(p_qasm_unitary)),
-                _indent(str(ex)),
-            )
+            f'op:\n{_indent(repr(op))}\n\n'
+            f'cirq.unitary(op):\n{_indent(repr(unitary))}\n\n'
+            f'Generated QASM:\n\n{_indent(qasm)}\n\n'
+            f'Unitary of generated QASM:\n{_indent(repr(qasm_unitary))}\n\n'
+            f'Phased matched cirq.unitary(op):\n{_indent(repr(p_unitary))}\n\n'
+            f'Phased matched unitary of generated QASM:\n{_indent(repr(p_qasm_unitary))}\n\n'
+            f'Underlying error:\n{_indent(str(ex))}'
         )
 
 

cirq/testing/consistent_specified_has_unitary.py

@@ -28,5 +28,5 @@ def assert_specifies_has_unitary_if_unitary(val: Any) -> None:
         "Value is unitary but doesn't specify a _has_unitary_ method that "
         "can be used to cheaply verify this fact.\n"
         "\n"
-        "val: {!r}".format(val)
+        f"val: {val!r}"
     )

cirq/testing/consistent_unitary.py

@@ -0,0 +1,85 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 typing import Any
+import cirq
+import numpy as np
+
+
+def assert_unitary_is_consistent(val: Any, ignoring_global_phase: bool = False):
+    if not isinstance(val, (cirq.Operation, cirq.Gate)):
+        return
+
+    if not cirq.has_unitary(val):
+        return
+
+    # Ensure that `u` is a unitary.
+    u = cirq.unitary(val)
+    assert not (u is None or u is NotImplemented)
+    assert cirq.is_unitary(u)
+
+    if isinstance(val, cirq.Operation):
+        qubits = val.qubits
+        decomposition = cirq.decompose_once(val, default=None)
+    else:
+        qubits = tuple(cirq.LineQid.for_gate(val))
+        decomposition = cirq.decompose_once_with_qubits(val, qubits, default=None)
+
+    if decomposition is None or decomposition is NotImplemented:
+        return
+
+    c = cirq.Circuit(decomposition)
+    if len(c.all_qubits().difference(qubits)) == 0:
+        return
+
+    clean_qubits = tuple(q for q in c.all_qubits() if isinstance(q, cirq.ops.CleanQubit))
+    borrowable_qubits = tuple(q for q in c.all_qubits() if isinstance(q, cirq.ops.BorrowableQubit))
+    qubit_order = clean_qubits + borrowable_qubits + qubits
+
+    # Check that the decomposition uses all data qubits in addition to
+    # clean and/or borrowable qubits.
+    assert set(qubit_order) == c.all_qubits()
+
+    qid_shape = cirq.qid_shape(qubit_order)
+    full_unitary = cirq.apply_unitaries(
+        decomposition,
+        qubits=qubit_order,
+        args=cirq.ApplyUnitaryArgs.for_unitary(qid_shape=qid_shape),
+        default=None,
+    )
+    if full_unitary is None:
+        raise ValueError(f'apply_unitaries failed on the decomposition of {val}')
+    vol = np.prod(qid_shape, dtype=np.int64)
+    full_unitary = full_unitary.reshape((vol, vol))
+
+    vol = np.prod(cirq.qid_shape(borrowable_qubits + qubits), dtype=np.int64)
+
+    # Extract the submatrix acting on the |0..0> subspace of clean qubits.
+    # This submatirx must be a unitary.
+    clean_qubits_zero_subspace = full_unitary[:vol, :vol]
+
+    # If the borrowable qubits are restored to their initial state, then
+    # the decomposition's effect on it is the identity matrix.
+    # This means that the `clean_qubits_zero_subspace` must be I \otimes u.
+    # So checking that `clean_qubits_zero_subspace` is I \otimes u checks correctness
+    # for both clean and borrowable qubits at the same time.
+    expected = np.kron(np.eye(2 ** len(borrowable_qubits), dtype=np.complex128), u)
+
+    if ignoring_global_phase:
+        cirq.testing.assert_allclose_up_to_global_phase(
+            clean_qubits_zero_subspace, expected, atol=1e-8
+        )
+    else:
+        np.testing.assert_allclose(clean_qubits_zero_subspace, expected, atol=1e-8)

cirq/testing/consistent_unitary_test.py

@@ -0,0 +1,96 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+import cirq
+
+import pytest
+import numpy as np
+
+
+class InconsistentGate(cirq.Gate):
+    def _num_qubits_(self) -> int:
+        return 1
+
+    def _unitary_(self) -> np.ndarray:
+        return np.eye(2, dtype=np.complex128)
+
+    def _decompose_with_context_(self, qubits, *, context):
+        (q,) = context.qubit_manager.qalloc(1)
+        yield cirq.X(q)
+        yield cirq.CNOT(q, qubits[0])
+
+
+class FailsOnDecompostion(cirq.Gate):
+    def _num_qubits_(self) -> int:
+        return 1
+
+    def _unitary_(self) -> np.ndarray:
+        return np.eye(2, dtype=np.complex128)
+
+    def _has_unitary_(self) -> bool:
+        return True
+
+    def _decompose_with_context_(self, qubits, *, context):
+        (q,) = context.qubit_manager.qalloc(1)
+        yield cirq.X(q)
+        yield cirq.measure(qubits[0])
+
+
+class CleanCorrectButBorrowableIncorrectGate(cirq.Gate):
+    """Ancilla type determines if the decomposition is correct or not."""
+
+    def __init__(self, use_clean_ancilla: bool) -> None:
+        self.ancillas_are_clean = use_clean_ancilla
+
+    def _num_qubits_(self):
+        return 2
+
+    def _decompose_with_context_(self, qubits, *, context):
+        if self.ancillas_are_clean:
+            anc = context.qubit_manager.qalloc(1)
+        else:
+            anc = context.qubit_manager.qborrow(1)
+        yield cirq.CCNOT(*qubits, *anc)
+        yield cirq.Z(*anc)
+        yield cirq.CCNOT(*qubits, *anc)
+        context.qubit_manager.qfree(anc)
+
+
+@pytest.mark.parametrize('ignore_phase', [False, True])
+@pytest.mark.parametrize(
+    'g,is_consistent',
+    [
+        (cirq.testing.PhaseUsingCleanAncilla(theta=0.1, ancilla_bitsize=3), True),
+        (cirq.testing.PhaseUsingDirtyAncilla(phase_state=1, ancilla_bitsize=4), True),
+        (InconsistentGate(), False),
+        (CleanCorrectButBorrowableIncorrectGate(use_clean_ancilla=True), True),
+        (CleanCorrectButBorrowableIncorrectGate(use_clean_ancilla=False), False),
+    ],
+)
+def test_assert_unitary_is_consistent(g, ignore_phase, is_consistent):
+    if is_consistent:
+        cirq.testing.assert_unitary_is_consistent(g, ignore_phase)
+        cirq.testing.assert_unitary_is_consistent(g.on(*cirq.LineQid.for_gate(g)), ignore_phase)
+    else:
+        with pytest.raises(AssertionError):
+            cirq.testing.assert_unitary_is_consistent(g, ignore_phase)
+        with pytest.raises(AssertionError):
+            cirq.testing.assert_unitary_is_consistent(g.on(*cirq.LineQid.for_gate(g)), ignore_phase)
+
+
+def test_failed_decomposition():
+    with pytest.raises(ValueError):
+        cirq.testing.assert_unitary_is_consistent(FailsOnDecompostion())
+
+    _ = cirq.testing.assert_unitary_is_consistent(cirq.Circuit())

cirq/testing/equivalent_repr_eval.py

@@ -52,10 +52,10 @@ def assert_equivalent_repr(
         raise AssertionError(
             'eval(repr(value)) raised an exception.\n'
             '\n'
-            'setup_code={}\n'
-            'type(value): {}\n'
-            'value={!r}\n'
-            'error={!r}'.format(setup_code, type(value), value, ex)
+            f'setup_code={setup_code}\n'
+            f'type(value): {type(value)}\n'
+            f'value={value!r}\n'
+            f'error={ex!r}'
         )
 
     assert eval_repr_value == value, (
@@ -87,14 +87,14 @@ def assert_equivalent_repr(
         a = eval(f'{value!r}.__class__', global_vals, local_vals)
     except Exception:
         raise AssertionError(
-            "The repr of a value of type {} wasn't 'dottable'.\n"
-            "{!r}.XXX must be equivalent to ({!r}).XXX, "
-            "but it raised an error instead.".format(type(value), value, value)
+            f"The repr of a value of type {type(value)} wasn't 'dottable'.\n"
+            f"{value!r}.XXX must be equivalent to ({value!r}).XXX, "
+            "but it raised an error instead."
         )
 
     b = eval(f'({value!r}).__class__', global_vals, local_vals)
     assert a == b, (
-        "The repr of a value of type {} wasn't 'dottable'.\n"
-        "{!r}.XXX must be equivalent to ({!r}).XXX, "
-        "but it wasn't.".format(type(value), value, value)
+        f"The repr of a value of type {type(value)} wasn't 'dottable'.\n"
+        f"{value!r}.XXX must be equivalent to ({value!r}).XXX, "
+        "but it wasn't."
     )

cirq/testing/json.py

@@ -95,11 +95,11 @@ class ModuleJsonTestSpec:
 
         return result
 
-    def get_resolver_cache_types(self):
+    def get_resolver_cache_types(self) -> Set[Tuple[str, Type]]:
         result: Set[Tuple[str, Type]] = set()
         for k, v in self.resolver_cache.items():
-            t = v if isinstance(v, type) else None
-            result.add((k, t))
+            if isinstance(v, type):
+                result.add((k, v))
         return result
 
     def get_all_names(self) -> Iterator[str]:

cirq/testing/logs.py

@@ -48,7 +48,7 @@ def assert_logs(
             module for valid levels. By default this captures at the
             `logging.WARNING` level and above, so this does not capture `logging.INFO`
             or `logging.DEBUG` logs by default.
-        max_level: The maxium level at which to capture the logs. See the python logging
+        max_level: The maximum level at which to capture the logs. See the python logging
             module for valid levels. By default this captures to the `logging.CRITICAL` level
             thus, all the errors and critical messages will be captured as well.
         capture_warnings: Whether warnings from the python's `warnings` module

cirq/testing/order_tester.py

@@ -50,10 +50,9 @@ class OrderTester:
             expected = cmp_func(0, sign)
             actual = cmp_func(a, b)
             assert expected == actual, (
-                "Ordering constraint violated. Expected X={} to {} Y={}, "
-                "but X {} Y returned {}".format(
-                    a, ['be more than', 'equal', 'be less than'][sign + 1], b, cmp_name, actual
-                )
+                f"Ordering constraint violated. Expected X={a} "
+                f"to {['be more than', 'equal', 'be less than'][sign + 1]} Y={b}, "
+                f"but X {cmp_name} Y returned {actual}"
             )
 
     def _verify_ordering(self, a: Any, b: Any, sign: int):
@@ -74,7 +73,7 @@ class OrderTester:
                 "    if not isinstance(other, type(self)):\n"
                 "        return NotImplemented\n"
                 "\n"
-                "That rule is being violated by this value: {!r}".format(item)
+                f"That rule is being violated by this value: {item!r}"
             ) from ex
 
     def add_ascending(self, *items: Any):

cirq/testing/random_circuit.py

@@ -114,9 +114,7 @@ def random_circuit(
         free_qubits = set(qubits)
         while len(free_qubits) >= max_arity:
             gate, arity = gate_arity_pairs[prng.randint(num_gates)]
-            op_qubits = prng.choice(
-                sorted(free_qubits), size=arity, replace=False  # type: ignore[arg-type]
-            )
+            op_qubits = prng.choice(sorted(free_qubits), size=arity, replace=False)
             free_qubits.difference_update(op_qubits)
             if prng.rand() <= op_density:
                 operations.append(gate(*op_qubits))
@@ -127,8 +125,8 @@ def random_circuit(
 
 def random_two_qubit_circuit_with_czs(
     num_czs: int = 3,
-    q0: Qid = None,
-    q1: Qid = None,
+    q0: Optional[Qid] = None,
+    q1: Optional[Qid] = None,
     random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
 ) -> circuits.Circuit:
     """Creates a random two qubit circuit with the given number of CNOTs.