cirq-core 1.6.0.dev20250529194600__py3-none-any.whl → 1.6.0.dev20250530203656__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 11, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.5.0")'
     )
 
-__version__ = "1.6.0.dev20250529194600"
+__version__ = "1.6.0.dev20250530203656"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version() -> None:
-    assert cirq.__version__ == "1.6.0.dev20250529194600"
+    assert cirq.__version__ == "1.6.0.dev20250530203656"

cirq/circuits/_bucket_priority_queue_test.py

@@ -20,8 +20,8 @@ import cirq
 from cirq.circuits._bucket_priority_queue import BucketPriorityQueue
 
 
-def test_init():
-    q = BucketPriorityQueue()
+def test_init() -> None:
+    q: BucketPriorityQueue = BucketPriorityQueue()
     assert not q.drop_duplicate_entries
     assert list(q) == []
     assert len(q) == 0
@@ -42,7 +42,7 @@ def test_init():
     assert bool(q)
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(
         BucketPriorityQueue(),
@@ -71,8 +71,8 @@ def test_eq():
     )
 
 
-def test_enqueue_dequeue():
-    q = BucketPriorityQueue()
+def test_enqueue_dequeue() -> None:
+    q: BucketPriorityQueue = BucketPriorityQueue()
     q.enqueue(5, 'a')
     assert q == BucketPriorityQueue([(5, 'a')])
     q.enqueue(4, 'b')
@@ -85,10 +85,10 @@ def test_enqueue_dequeue():
         _ = q.dequeue()
 
 
-def test_drop_duplicates_enqueue():
-    q0 = BucketPriorityQueue()
-    q1 = BucketPriorityQueue(drop_duplicate_entries=False)
-    q2 = BucketPriorityQueue(drop_duplicate_entries=True)
+def test_drop_duplicates_enqueue() -> None:
+    q0: BucketPriorityQueue = BucketPriorityQueue()
+    q1: BucketPriorityQueue = BucketPriorityQueue(drop_duplicate_entries=False)
+    q2: BucketPriorityQueue = BucketPriorityQueue(drop_duplicate_entries=True)
     for q in [q0, q1, q2]:
         for _ in range(2):
             q.enqueue(0, 'a')
@@ -97,10 +97,10 @@ def test_drop_duplicates_enqueue():
     assert q2 == BucketPriorityQueue([(0, 'a')], drop_duplicate_entries=True)
 
 
-def test_drop_duplicates_dequeue():
-    q0 = BucketPriorityQueue()
-    q1 = BucketPriorityQueue(drop_duplicate_entries=False)
-    q2 = BucketPriorityQueue(drop_duplicate_entries=True)
+def test_drop_duplicates_dequeue() -> None:
+    q0: BucketPriorityQueue = BucketPriorityQueue()
+    q1: BucketPriorityQueue = BucketPriorityQueue(drop_duplicate_entries=False)
+    q2: BucketPriorityQueue = BucketPriorityQueue(drop_duplicate_entries=True)
     for q in [q0, q1, q2]:
         q.enqueue(0, 'a')
         q.enqueue(0, 'b')
@@ -113,11 +113,11 @@ def test_drop_duplicates_dequeue():
     assert q2 == BucketPriorityQueue([(0, 'b'), (0, 'a')], drop_duplicate_entries=True)
 
 
-def test_same_priority_fifo():
+def test_same_priority_fifo() -> None:
     a = (5, 'a')
     b = (5, 'b')
     for x, y in [(a, b), (b, a)]:
-        q = BucketPriorityQueue()
+        q: BucketPriorityQueue = BucketPriorityQueue()
         q.enqueue(*x)
         q.enqueue(*y)
         assert q
@@ -127,23 +127,23 @@ def test_same_priority_fifo():
         assert not q
 
 
-def test_supports_arbitrary_offsets():
+def test_supports_arbitrary_offsets() -> None:
     m = 1 << 60
 
-    q_neg = BucketPriorityQueue()
+    q_neg: BucketPriorityQueue = BucketPriorityQueue()
     q_neg.enqueue(-m + 0, 'b')
     q_neg.enqueue(-m - 4, 'a')
     q_neg.enqueue(-m + 4, 'c')
     assert list(q_neg) == [(-m - 4, 'a'), (-m, 'b'), (-m + 4, 'c')]
 
-    q_pos = BucketPriorityQueue()
+    q_pos: BucketPriorityQueue = BucketPriorityQueue()
     q_pos.enqueue(m + 0, 'b')
     q_pos.enqueue(m + 4, 'c')
     q_pos.enqueue(m - 4, 'a')
     assert list(q_pos) == [(m - 4, 'a'), (m, 'b'), (m + 4, 'c')]
 
 
-def test_repr():
+def test_repr() -> None:
     r = repr(BucketPriorityQueue(entries=[(1, 2), (3, 4)], drop_duplicate_entries=True))
     assert r.endswith('BucketPriorityQueue(entries=[(1, 2), (3, 4)], drop_duplicate_entries=True)')
 
@@ -154,7 +154,7 @@ def test_repr():
     )
 
 
-def test_str():
+def test_str() -> None:
     s = str(BucketPriorityQueue(entries=[(1, 2), (3, 4)], drop_duplicate_entries=True))
     assert (
         s

cirq/circuits/circuit_operation_test.py

@@ -28,7 +28,7 @@ from cirq.circuits.circuit_operation import _full_join_string_lists
 ALL_SIMULATORS = (cirq.Simulator(), cirq.DensityMatrixSimulator(), cirq.CliffordSimulator())
 
 
-def test_properties():
+def test_properties() -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.FrozenCircuit(
         cirq.X(a),
@@ -50,7 +50,7 @@ def test_properties():
     assert op == circuit.to_op()
 
 
-def test_circuit_type():
+def test_circuit_type() -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(
         cirq.X(a),
@@ -60,10 +60,10 @@ def test_circuit_type():
         cirq.measure(a, b, c, key='m'),
     )
     with pytest.raises(TypeError, match='Expected circuit of type FrozenCircuit'):
-        _ = cirq.CircuitOperation(circuit)
+        _ = cirq.CircuitOperation(circuit)  # type: ignore[arg-type]
 
 
-def test_non_invertible_circuit():
+def test_non_invertible_circuit() -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.FrozenCircuit(
         cirq.X(a),
@@ -76,7 +76,7 @@ def test_non_invertible_circuit():
         _ = cirq.CircuitOperation(circuit, repetitions=-2)
 
 
-def test_repetitions_and_ids_length_mismatch():
+def test_repetitions_and_ids_length_mismatch() -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.FrozenCircuit(
         cirq.X(a),
@@ -89,7 +89,7 @@ def test_repetitions_and_ids_length_mismatch():
         _ = cirq.CircuitOperation(circuit, repetitions=2, repetition_ids=['a', 'b', 'c'])
 
 
-def test_is_measurement_memoization():
+def test_is_measurement_memoization() -> None:
     a = cirq.LineQubit(0)
     circuit = cirq.FrozenCircuit(cirq.measure(a, key='m'))
     c_op = cirq.CircuitOperation(circuit)
@@ -100,7 +100,7 @@ def test_is_measurement_memoization():
     assert hasattr(circuit, cache_name)
 
 
-def test_invalid_measurement_keys():
+def test_invalid_measurement_keys() -> None:
     a = cirq.LineQubit(0)
     circuit = cirq.FrozenCircuit(cirq.measure(a, key='m'))
     c_op = cirq.CircuitOperation(circuit)
@@ -120,7 +120,7 @@ def test_invalid_measurement_keys():
     _ = cirq.CircuitOperation(circuit, measurement_key_map={'m:a': 'ma'})
 
 
-def test_invalid_qubit_mapping():
+def test_invalid_qubit_mapping() -> None:
     q = cirq.LineQubit(0)
     q3 = cirq.LineQid(1, dimension=3)
 
@@ -138,7 +138,7 @@ def test_invalid_qubit_mapping():
         _ = c_op.with_qubit_mapping(lambda q: q3)
 
 
-def test_circuit_sharing():
+def test_circuit_sharing() -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.FrozenCircuit(
         cirq.X(a),
@@ -158,7 +158,7 @@ def test_circuit_sharing():
     assert hash(op1) == hash(op3)
 
 
-def test_with_qubits():
+def test_with_qubits() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     circuit = cirq.FrozenCircuit(cirq.H(a), cirq.CX(a, b))
     op_base = cirq.CircuitOperation(circuit)
@@ -195,10 +195,10 @@ def test_with_qubits():
         _ = op_base.with_qubit_mapping(lambda q: b)
     # with_qubit_mapping requires exactly one argument.
     with pytest.raises(TypeError, match='must be a function or dict'):
-        _ = op_base.with_qubit_mapping('bad arg')
+        _ = op_base.with_qubit_mapping('bad arg')  # type: ignore[arg-type]
 
 
-def test_with_measurement_keys():
+def test_with_measurement_keys() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.FrozenCircuit(cirq.X(a), cirq.measure(b, key='mb'), cirq.measure(a, key='ma'))
     op_base = cirq.CircuitOperation(circuit)
@@ -215,7 +215,7 @@ def test_with_measurement_keys():
         _ = op_base.with_measurement_key_mapping({'ma': 'mb'})
 
 
-def test_with_params():
+def test_with_params() -> None:
     a = cirq.LineQubit(0)
     z_exp = sympy.Symbol('z_exp')
     x_exp = sympy.Symbol('x_exp')
@@ -242,7 +242,7 @@ def test_with_params():
     )
 
 
-def test_recursive_params():
+def test_recursive_params() -> None:
     q = cirq.LineQubit(0)
     a, a2, b, b2 = sympy.symbols('a a2 b b2')
     circuitop = cirq.CircuitOperation(
@@ -359,7 +359,7 @@ def test_replace_repetition_ids() -> None:
 @pytest.mark.parametrize('add_measurements', [True, False])
 @pytest.mark.parametrize('use_repetition_ids', [True, False])
 @pytest.mark.parametrize('initial_reps', [0, 1, 2, 3])
-def test_repeat_zero_times(add_measurements, use_repetition_ids, initial_reps):
+def test_repeat_zero_times(add_measurements, use_repetition_ids, initial_reps) -> None:
     q = cirq.LineQubit(0)
     subcircuit = cirq.Circuit(cirq.X(q))
     if add_measurements:
@@ -374,7 +374,7 @@ def test_repeat_zero_times(add_measurements, use_repetition_ids, initial_reps):
     assert np.allclose(result.state_vector(), [1, 0])
 
 
-def test_no_repetition_ids():
+def test_no_repetition_ids() -> None:
     def default_repetition_ids(self):  # pragma: no cover
         assert False, "Should not call default_repetition_ids"
 
@@ -395,7 +395,7 @@ def test_no_repetition_ids():
         assert op2.repetition_ids is None
 
 
-def test_parameterized_repeat():
+def test_parameterized_repeat() -> None:
     q = cirq.LineQubit(0)
     op = cirq.CircuitOperation(cirq.FrozenCircuit(cirq.X(q))) ** sympy.Symbol('a')
     assert cirq.parameter_names(op) == {'a'}
@@ -455,7 +455,7 @@ def test_parameterized_repeat():
         cirq.Simulator().simulate(cirq.Circuit(op))
 
 
-def test_parameterized_repeat_side_effects():
+def test_parameterized_repeat_side_effects() -> None:
     q = cirq.LineQubit(0)
     op = cirq.CircuitOperation(
         cirq.FrozenCircuit(cirq.X(q).with_classical_controls('c'), cirq.measure(q, key='m')),
@@ -520,7 +520,7 @@ def test_parameterized_repeat_side_effects():
     )
 
 
-def test_parameterized_repeat_side_effects_when_not_using_rep_ids():
+def test_parameterized_repeat_side_effects_when_not_using_rep_ids() -> None:
     q = cirq.LineQubit(0)
     op = cirq.CircuitOperation(
         cirq.FrozenCircuit(cirq.X(q).with_classical_controls('c'), cirq.measure(q, key='m')),
@@ -546,7 +546,7 @@ def test_parameterized_repeat_side_effects_when_not_using_rep_ids():
         op.repeat(repetition_ids=['x', 'y'])
 
 
-def test_qid_shape():
+def test_qid_shape() -> None:
     circuit = cirq.FrozenCircuit(
         cirq.IdentityGate(qid_shape=(q.dimension,)).on(q)
         for q in cirq.LineQid.for_qid_shape((1, 2, 3, 4))
@@ -561,7 +561,7 @@ def test_qid_shape():
     assert cirq.num_qubits(id_op) == 3
 
 
-def test_string_format():
+def test_string_format() -> None:
     x, y, z = cirq.LineQubit.range(3)
 
     fc0 = cirq.FrozenCircuit()
@@ -735,7 +735,7 @@ cirq.CircuitOperation(
     )
 
 
-def test_json_dict():
+def test_json_dict() -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.FrozenCircuit(
         cirq.X(a),
@@ -764,7 +764,7 @@ def test_json_dict():
     }
 
 
-def test_terminal_matches():
+def test_terminal_matches() -> None:
     a, b = cirq.LineQubit.range(2)
     fc = cirq.FrozenCircuit(cirq.H(a), cirq.measure(b, key='m1'))
     op = cirq.CircuitOperation(fc)
@@ -802,23 +802,23 @@ def test_terminal_matches():
     assert c.are_any_measurements_terminal()
 
 
-def test_nonterminal_in_subcircuit():
+def test_nonterminal_in_subcircuit() -> None:
     a, b = cirq.LineQubit.range(2)
     fc = cirq.FrozenCircuit(cirq.H(a), cirq.measure(b, key='m1'), cirq.X(b))
-    op = cirq.CircuitOperation(fc)
-    c = cirq.Circuit(cirq.X(a), op)
-    assert isinstance(op, cirq.CircuitOperation)
+    circuit_op = cirq.CircuitOperation(fc)
+    c = cirq.Circuit(cirq.X(a), circuit_op)
+    assert isinstance(circuit_op, cirq.CircuitOperation)
     assert not c.are_all_measurements_terminal()
     assert not c.are_any_measurements_terminal()
 
-    op = op.with_tags('test')
+    op = circuit_op.with_tags('test')
     c = cirq.Circuit(cirq.X(a), op)
     assert not isinstance(op, cirq.CircuitOperation)
     assert not c.are_all_measurements_terminal()
     assert not c.are_any_measurements_terminal()
 
 
-def test_decompose_applies_maps():
+def test_decompose_applies_maps() -> None:
     a, b, c = cirq.LineQubit.range(3)
     exp = sympy.Symbol('exp')
     theta = sympy.Symbol('theta')
@@ -846,7 +846,7 @@ def test_decompose_applies_maps():
     assert cirq.Circuit(cirq.decompose_once(op)) == expected_circuit
 
 
-def test_decompose_loops():
+def test_decompose_loops() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.FrozenCircuit(cirq.H(a), cirq.CX(a, b))
     base_op = cirq.CircuitOperation(circuit)
@@ -862,7 +862,7 @@ def test_decompose_loops():
     assert cirq.Circuit(cirq.decompose_once(op)) == expected_circuit
 
 
-def test_decompose_loops_with_measurements():
+def test_decompose_loops_with_measurements() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.FrozenCircuit(cirq.H(a), cirq.CX(a, b), cirq.measure(a, b, key='m'))
     base_op = cirq.CircuitOperation(circuit)
@@ -882,7 +882,7 @@ def test_decompose_loops_with_measurements():
     assert cirq.Circuit(cirq.decompose_once(op)) == expected_circuit
 
 
-def test_decompose_loops_with_measurements_use_rep_ids():
+def test_decompose_loops_with_measurements_use_rep_ids() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.FrozenCircuit(cirq.H(a), cirq.CX(a, b), cirq.measure(a, b, key='m'))
     base_op = cirq.CircuitOperation(circuit, use_repetition_ids=True)
@@ -902,7 +902,7 @@ def test_decompose_loops_with_measurements_use_rep_ids():
     assert cirq.Circuit(cirq.decompose_once(op)) == expected_circuit
 
 
-def test_decompose_nested():
+def test_decompose_nested() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     exp1 = sympy.Symbol('exp1')
     exp_half = sympy.Symbol('exp_half')
@@ -982,7 +982,7 @@ def test_decompose_nested():
     assert final_op.mapped_circuit(deep=True) == expected_circuit
 
 
-def test_decompose_repeated_nested_measurements():
+def test_decompose_repeated_nested_measurements() -> None:
     # Details of this test described at
     # https://tinyurl.com/measurement-repeated-circuitop#heading=h.sbgxcsyin9wt.
     a = cirq.LineQubit(0)
@@ -1034,7 +1034,7 @@ def test_decompose_repeated_nested_measurements():
     assert op3.mapped_circuit(deep=True) == expected_circuit
 
 
-def test_keys_under_parent_path():
+def test_keys_under_parent_path() -> None:
     a = cirq.LineQubit(0)
     op1 = cirq.CircuitOperation(cirq.FrozenCircuit(cirq.measure(a, key='A')))
     assert cirq.measurement_key_names(op1) == {'A'}
@@ -1048,7 +1048,7 @@ def test_keys_under_parent_path():
     assert cirq.measurement_key_names(op4_rep) == {'C:B:0:A', 'C:B:1:A'}
 
 
-def test_mapped_circuit_preserves_moments():
+def test_mapped_circuit_preserves_moments() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     fc = cirq.FrozenCircuit(cirq.Moment(cirq.X(q0)), cirq.Moment(cirq.X(q1)))
     op = cirq.CircuitOperation(fc)
@@ -1056,7 +1056,7 @@ def test_mapped_circuit_preserves_moments():
     assert op.repeat(3).mapped_circuit(deep=True) == fc * 3
 
 
-def test_mapped_op():
+def test_mapped_op() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     a, b = (sympy.Symbol(x) for x in 'ab')
     fc1 = cirq.FrozenCircuit(cirq.X(q0) ** a, cirq.measure(q0, q1, key='m'))
@@ -1072,14 +1072,14 @@ def test_mapped_op():
     assert op1.mapped_op() == op2
 
 
-def test_tag_propagation():
+def test_tag_propagation() -> None:
     # Tags are not propagated from the CircuitOperation to its components.
     # TODO: support tag propagation for better serialization.
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.FrozenCircuit(cirq.X(a), cirq.H(b), cirq.H(c), cirq.CZ(a, c))
-    op = cirq.CircuitOperation(circuit)
+    circuit_op = cirq.CircuitOperation(circuit)
     test_tag = 'test_tag'
-    op = op.with_tags(test_tag)
+    op = circuit_op.with_tags(test_tag)
 
     assert test_tag in op.tags
 
@@ -1089,13 +1089,15 @@ def test_tag_propagation():
         assert test_tag not in op.tags
 
 
-def test_mapped_circuit_keeps_keys_under_parent_path():
+def test_mapped_circuit_keeps_keys_under_parent_path() -> None:
     q = cirq.LineQubit(0)
+    bit_flip = cirq.bit_flip(0.5)
+    assert isinstance(bit_flip, cirq.BitFlipChannel)
     op1 = cirq.CircuitOperation(
         cirq.FrozenCircuit(
             cirq.measure(q, key='A'),
             cirq.measure_single_paulistring(cirq.X(q), key='B'),
-            cirq.MixedUnitaryChannel.from_mixture(cirq.bit_flip(0.5), key='C').on(q),
+            cirq.MixedUnitaryChannel.from_mixture(bit_flip, key='C').on(q),
             cirq.KrausChannel.from_channel(cirq.phase_damp(0.5), key='D').on(q),
         )
     )
@@ -1103,7 +1105,7 @@ def test_mapped_circuit_keeps_keys_under_parent_path():
     assert cirq.measurement_key_names(op2.mapped_circuit()) == {'X:A', 'X:B', 'X:C', 'X:D'}
 
 
-def test_mapped_circuit_allows_repeated_keys():
+def test_mapped_circuit_allows_repeated_keys() -> None:
     q = cirq.LineQubit(0)
     op1 = cirq.CircuitOperation(cirq.FrozenCircuit(cirq.measure(q, key='A')))
     op2 = cirq.CircuitOperation(cirq.FrozenCircuit(op1, op1))
@@ -1111,16 +1113,16 @@ def test_mapped_circuit_allows_repeated_keys():
     cirq.testing.assert_has_diagram(
         circuit, "0: ───M('A')───M('A')───", use_unicode_characters=True
     )
-    op1 = cirq.measure(q, key='A')
-    op2 = cirq.CircuitOperation(cirq.FrozenCircuit(op1, op1))
-    circuit = op2.mapped_circuit()
+    op3 = cirq.measure(q, key='A')
+    op4 = cirq.CircuitOperation(cirq.FrozenCircuit(op3, op3))
+    circuit = op4.mapped_circuit()
     cirq.testing.assert_has_diagram(
         circuit, "0: ───M('A')───M('A')───", use_unicode_characters=True
     )
 
 
 @pytest.mark.parametrize('sim', ALL_SIMULATORS)
-def test_simulate_no_repetition_ids_both_levels(sim):
+def test_simulate_no_repetition_ids_both_levels(sim) -> None:
     q = cirq.LineQubit(0)
     inner = cirq.Circuit(cirq.measure(q, key='a'))
     middle = cirq.Circuit(cirq.CircuitOperation(inner.freeze(), repetitions=2))
@@ -1131,7 +1133,7 @@ def test_simulate_no_repetition_ids_both_levels(sim):
 
 
 @pytest.mark.parametrize('sim', ALL_SIMULATORS)
-def test_simulate_no_repetition_ids_outer(sim):
+def test_simulate_no_repetition_ids_outer(sim) -> None:
     q = cirq.LineQubit(0)
     inner = cirq.Circuit(cirq.measure(q, key='a'))
     middle = cirq.Circuit(
@@ -1145,7 +1147,7 @@ def test_simulate_no_repetition_ids_outer(sim):
 
 
 @pytest.mark.parametrize('sim', ALL_SIMULATORS)
-def test_simulate_no_repetition_ids_inner(sim):
+def test_simulate_no_repetition_ids_inner(sim) -> None:
     q = cirq.LineQubit(0)
     inner = cirq.Circuit(cirq.measure(q, key='a'))
     middle = cirq.Circuit(cirq.CircuitOperation(inner.freeze(), repetitions=2))
@@ -1159,7 +1161,7 @@ def test_simulate_no_repetition_ids_inner(sim):
 
 
 @pytest.mark.parametrize('sim', ALL_SIMULATORS)
-def test_repeat_until(sim):
+def test_repeat_until(sim) -> None:
     q = cirq.LineQubit(0)
     key = cirq.MeasurementKey('m')
     c = cirq.Circuit(
@@ -1176,7 +1178,7 @@ def test_repeat_until(sim):
 
 
 @pytest.mark.parametrize('sim', ALL_SIMULATORS)
-def test_repeat_until_sympy(sim):
+def test_repeat_until_sympy(sim) -> None:
     q1, q2 = cirq.LineQubit.range(2)
     circuitop = cirq.CircuitOperation(
         cirq.FrozenCircuit(cirq.X(q2), cirq.measure(q2, key='b')),
@@ -1193,7 +1195,7 @@ def test_repeat_until_sympy(sim):
 
 
 @pytest.mark.parametrize('sim', [cirq.Simulator(), cirq.DensityMatrixSimulator()])
-def test_post_selection(sim):
+def test_post_selection(sim) -> None:
     q = cirq.LineQubit(0)
     key = cirq.MeasurementKey('m')
     c = cirq.Circuit(
@@ -1208,7 +1210,7 @@ def test_post_selection(sim):
         assert result.records['m'][0][i] == (0,)
 
 
-def test_repeat_until_diagram():
+def test_repeat_until_diagram() -> None:
     q = cirq.LineQubit(0)
     key = cirq.MeasurementKey('m')
     c = cirq.Circuit(
@@ -1226,7 +1228,7 @@ def test_repeat_until_diagram():
     )
 
 
-def test_repeat_until_error():
+def test_repeat_until_error() -> None:
     q = cirq.LineQubit(0)
     with pytest.raises(ValueError, match='Cannot use repetitions with repeat_until'):
         cirq.CircuitOperation(
@@ -1241,7 +1243,7 @@ def test_repeat_until_error():
         )
 
 
-def test_repeat_until_protocols():
+def test_repeat_until_protocols() -> None:
     q = cirq.LineQubit(0)
     op = cirq.CircuitOperation(
         cirq.FrozenCircuit(cirq.H(q) ** sympy.Symbol('p'), cirq.measure(q, key='a')),
@@ -1272,7 +1274,7 @@ def test_repeat_until_protocols():
     assert not cirq.control_keys(resolved)
 
 
-def test_inner_repeat_until_simulate():
+def test_inner_repeat_until_simulate() -> None:
     sim = cirq.Simulator()
     q = cirq.LineQubit(0)
     inner_loop = cirq.CircuitOperation(

cirq/circuits/frozen_circuit_test.py

@@ -24,7 +24,7 @@ import sympy
 import cirq
 
 
-def test_from_moments():
+def test_from_moments() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     moment = cirq.Moment(cirq.Z(a), cirq.Z(b))
     subcircuit = cirq.FrozenCircuit.from_moments(cirq.X(c), cirq.Y(d))
@@ -51,10 +51,11 @@ def test_from_moments():
         cirq.Moment(cirq.measure(a, b, key='ab'), cirq.measure(c, d, key='cd')),
     )
     assert circuit[0] is moment
+    assert isinstance(circuit[1].operations[0], cirq.CircuitOperation)
     assert circuit[1].operations[0].circuit is subcircuit
 
 
-def test_freeze_and_unfreeze():
+def test_freeze_and_unfreeze() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.X(a), cirq.H(b))
 
@@ -80,7 +81,7 @@ def test_freeze_and_unfreeze():
     assert fcc is not f
 
 
-def test_immutable():
+def test_immutable() -> None:
     q = cirq.LineQubit(0)
     c = cirq.FrozenCircuit(cirq.X(q), cirq.H(q))
 
@@ -89,10 +90,10 @@ def test_immutable():
         AttributeError,
         match="(can't set attribute)|(property 'moments' of 'FrozenCircuit' object has no setter)",
     ):
-        c.moments = (cirq.Moment(cirq.H(q)), cirq.Moment(cirq.X(q)))
+        c.moments = (cirq.Moment(cirq.H(q)), cirq.Moment(cirq.X(q)))  # type: ignore[misc]
 
 
-def test_tagged_circuits():
+def test_tagged_circuits() -> None:
     q = cirq.LineQubit(0)
     ops = [cirq.X(q), cirq.H(q)]
     tags = [sympy.Symbol("a"), "b"]