cirq-core 1.6.0.dev20250508231110__py3-none-any.whl → 1.6.0.dev20250512192405__py3-none-any.whl

cirq/ops/fsim_gate_test.py

@@ -19,7 +19,7 @@ import sympy
 import cirq
 
 
-def test_fsim_init():
+def test_fsim_init() -> None:
     f = cirq.FSimGate(1, 2)
     assert f.theta == 1
     assert f.phi == 2
@@ -33,7 +33,7 @@ def test_fsim_init():
     assert f3.phi == -5 + 2 * np.pi
 
 
-def test_fsim_eq():
+def test_fsim_eq() -> None:
     eq = cirq.testing.EqualsTester()
     a, b = cirq.LineQubit.range(2)
 
@@ -45,7 +45,7 @@ def test_fsim_eq():
     eq.add_equality_group(cirq.FSimGate(np.pi, np.pi), cirq.FSimGate(-np.pi, -np.pi))
 
 
-def test_fsim_approx_eq():
+def test_fsim_approx_eq() -> None:
     assert cirq.approx_eq(cirq.FSimGate(1, 2), cirq.FSimGate(1.00001, 2.00001), atol=0.01)
 
 
@@ -60,12 +60,12 @@ def test_fsim_approx_eq():
         (np.pi / 2, 0.5),
     ],
 )
-def test_fsim_consistent(theta, phi):
+def test_fsim_consistent(theta, phi) -> None:
     gate = cirq.FSimGate(theta=theta, phi=phi)
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_fsim_circuit():
+def test_fsim_circuit() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(
         cirq.FSimGate(np.pi / 2, np.pi).on(a, b), cirq.FSimGate(-np.pi, np.pi / 2).on(a, b)
@@ -109,7 +109,7 @@ def test_fsim_circuit():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_fsim_resolve(resolve_fn):
+def test_fsim_resolve(resolve_fn) -> None:
     f = cirq.FSimGate(sympy.Symbol('a'), sympy.Symbol('b'))
     assert cirq.is_parameterized(f)
 
@@ -122,7 +122,7 @@ def test_fsim_resolve(resolve_fn):
     assert not cirq.is_parameterized(f)
 
 
-def test_fsim_unitary():
+def test_fsim_unitary() -> None:
     # fmt: off
     np.testing.assert_allclose(
         cirq.unitary(cirq.FSimGate(theta=0, phi=0)),
@@ -265,7 +265,7 @@ def test_fsim_unitary():
         (3.5 * np.pi, 4 * np.pi),
     ),
 )
-def test_fsim_iswap_cphase(theta, phi):
+def test_fsim_iswap_cphase(theta, phi) -> None:
     q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
     iswap = cirq.ISWAP ** (-theta * 2 / np.pi)
     cphase = cirq.CZPowGate(exponent=-phi / np.pi)
@@ -274,16 +274,16 @@ def test_fsim_iswap_cphase(theta, phi):
     assert np.allclose(cirq.unitary(iswap_cphase), cirq.unitary(fsim))
 
 
-def test_fsim_repr():
+def test_fsim_repr() -> None:
     f = cirq.FSimGate(sympy.Symbol('a'), sympy.Symbol('b'))
     cirq.testing.assert_equivalent_repr(f)
 
 
-def test_fsim_json_dict():
+def test_fsim_json_dict() -> None:
     assert cirq.FSimGate(theta=0.123, phi=0.456)._json_dict_() == {'theta': 0.123, 'phi': 0.456}
 
 
-def test_phased_fsim_init():
+def test_phased_fsim_init() -> None:
     f = cirq.PhasedFSimGate(1, 2, 3, 4, 5)
     assert f.theta == 1
     assert f.zeta == 2
@@ -307,7 +307,7 @@ def test_phased_fsim_init():
         (np.pi / 5, np.pi / 6, (0.1, 0.2), (0.3, 0.5)),
     ),
 )
-def test_phased_fsim_from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after):
+def test_phased_fsim_from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after) -> None:
     f = cirq.PhasedFSimGate.from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after)
     q0, q1 = cirq.LineQubit.range(2)
     c = cirq.Circuit(
@@ -330,7 +330,7 @@ def test_phased_fsim_from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after)
         ((np.pi / 5, -np.pi / 3), (0, np.pi / 2)),
     ),
 )
-def test_phased_fsim_recreate_from_phase_angles(rz_angles_before, rz_angles_after):
+def test_phased_fsim_recreate_from_phase_angles(rz_angles_before, rz_angles_after) -> None:
     f = cirq.PhasedFSimGate.from_fsim_rz(np.pi / 3, np.pi / 5, rz_angles_before, rz_angles_after)
     f2 = cirq.PhasedFSimGate.from_fsim_rz(f.theta, f.phi, f.rz_angles_before, f.rz_angles_after)
     assert cirq.approx_eq(f, f2)
@@ -346,7 +346,7 @@ def test_phased_fsim_recreate_from_phase_angles(rz_angles_before, rz_angles_afte
         ((np.pi, np.pi / 6), (-np.pi / 2, 0)),
     ),
 )
-def test_phased_fsim_phase_angle_symmetry(rz_angles_before, rz_angles_after):
+def test_phased_fsim_phase_angle_symmetry(rz_angles_before, rz_angles_after) -> None:
     f = cirq.PhasedFSimGate.from_fsim_rz(np.pi / 3, np.pi / 5, rz_angles_before, rz_angles_after)
     for d in (-10, -7, -2 * np.pi, -0.2, 0, 0.1, 0.2, np.pi, 8, 20):
         rz_angles_before2 = (rz_angles_before[0] + d, rz_angles_before[1] + d)
@@ -357,7 +357,7 @@ def test_phased_fsim_phase_angle_symmetry(rz_angles_before, rz_angles_after):
         assert cirq.approx_eq(f, f2)
 
 
-def test_phased_fsim_eq():
+def test_phased_fsim_eq() -> None:
     eq = cirq.testing.EqualsTester()
     a, b = cirq.LineQubit.range(2)
     r, s = sympy.Symbol('r'), sympy.Symbol('s')
@@ -435,7 +435,7 @@ def test_phased_fsim_eq():
         (cirq.PhasedFSimGate(1, np.pi / 2, 0, 4, 5), False),
     ),
 )
-def test_qubit_interchangeability(gate, interchangeable):
+def test_qubit_interchangeability(gate, interchangeable) -> None:
     a, b = cirq.LineQubit.range(2)
     c1 = cirq.Circuit(gate.on(a, b))
     c2 = cirq.Circuit(cirq.SWAP(a, b), gate.on(a, b), cirq.SWAP(a, b))
@@ -444,7 +444,7 @@ def test_qubit_interchangeability(gate, interchangeable):
     assert np.all(u1 == u2) == interchangeable
 
 
-def test_phased_fsim_approx_eq():
+def test_phased_fsim_approx_eq() -> None:
     assert cirq.approx_eq(
         cirq.PhasedFSimGate(1, 2, 3, 4, 5),
         cirq.PhasedFSimGate(1.00001, 2.00001, 3.00001, 4.00004, 5.00005),
@@ -469,12 +469,12 @@ def test_phased_fsim_approx_eq():
         (np.pi, 0, 0, sympy.Symbol('a'), 0),
     ],
 )
-def test_phased_fsim_consistent(theta, zeta, chi, gamma, phi):
+def test_phased_fsim_consistent(theta, zeta, chi, gamma, phi) -> None:
     gate = cirq.PhasedFSimGate(theta=theta, zeta=zeta, chi=chi, gamma=gamma, phi=phi)
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_phased_fsim_circuit():
+def test_phased_fsim_circuit() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(
         cirq.PhasedFSimGate(np.pi / 2, np.pi, np.pi / 2, 0, -np.pi / 4).on(a, b),
@@ -529,7 +529,7 @@ def test_phased_fsim_circuit():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_phased_fsim_resolve(resolve_fn):
+def test_phased_fsim_resolve(resolve_fn) -> None:
     f = cirq.PhasedFSimGate(
         sympy.Symbol('a'),
         sympy.Symbol('b'),
@@ -562,7 +562,7 @@ def test_phased_fsim_resolve(resolve_fn):
     assert not cirq.is_parameterized(f)
 
 
-def test_phased_fsim_unitary():
+def test_phased_fsim_unitary() -> None:
     # fmt: off
     np.testing.assert_allclose(
         cirq.unitary(cirq.PhasedFSimGate(theta=0, phi=0)),
@@ -776,13 +776,13 @@ def test_phased_fsim_unitary():
         (3.5 * np.pi, 4 * np.pi),
     ),
 )
-def test_phased_fsim_vs_fsim(theta, phi):
+def test_phased_fsim_vs_fsim(theta, phi) -> None:
     g1 = cirq.FSimGate(theta, phi)
     g2 = cirq.PhasedFSimGate(theta, 0, 0, 0, phi)
     assert np.allclose(cirq.unitary(g1), cirq.unitary(g2))
 
 
-def test_phased_fsim_repr():
+def test_phased_fsim_repr() -> None:
     f = cirq.PhasedFSimGate(
         sympy.Symbol('a'),
         sympy.Symbol('b'),
@@ -793,7 +793,7 @@ def test_phased_fsim_repr():
     cirq.testing.assert_equivalent_repr(f)
 
 
-def test_phased_fsim_json_dict():
+def test_phased_fsim_json_dict() -> None:
     assert cirq.PhasedFSimGate(
         theta=0.12, zeta=0.34, chi=0.56, gamma=0.78, phi=0.9
     )._json_dict_() == {'theta': 0.12, 'zeta': 0.34, 'chi': 0.56, 'gamma': 0.78, 'phi': 0.9}
@@ -811,10 +811,10 @@ def test_phased_fsim_json_dict():
         cirq.CZ**0.2,
     ],
 )
-def test_phase_fsim_from_matrix(gate):
+def test_phase_fsim_from_matrix(gate) -> None:
     u = cirq.unitary(gate)
     np.testing.assert_allclose(cirq.unitary(cirq.PhasedFSimGate.from_matrix(u)), u, atol=1e-8)
 
 
-def test_phase_fsim_from_matrix_not_fsim_returns_none():
+def test_phase_fsim_from_matrix_not_fsim_returns_none() -> None:
     assert cirq.PhasedFSimGate.from_matrix(np.ones((4, 4))) is None

cirq/ops/gate_features_test.py

@@ -17,7 +17,7 @@ import pytest
 import cirq
 
 
-def test_qasm_output_args_validate():
+def test_qasm_output_args_validate() -> None:
     args = cirq.QasmArgs(version='2.0')
     args.validate_version('2.0')
 
@@ -25,7 +25,7 @@ def test_qasm_output_args_validate():
         args.validate_version('2.1')
 
 
-def test_qasm_output_args_format():
+def test_qasm_output_args_format() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     m_a = cirq.measure(a, key='meas_a')
@@ -52,7 +52,7 @@ def test_qasm_output_args_format():
     assert args.format('_{0}_', 'other') == '_other_'
 
 
-def test_multi_qubit_gate_validate():
+def test_multi_qubit_gate_validate() -> None:
     class Example(cirq.Gate):
         def _num_qubits_(self) -> int:
             return self._num_qubits

cirq/ops/greedy_qubit_manager_test.py

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

cirq/ops/mixed_unitary_channel_test.py

@@ -5,7 +5,7 @@ import pytest
 import cirq
 
 
-def test_matrix_mixture_from_mixture():
+def test_matrix_mixture_from_mixture() -> None:
     q0 = cirq.LineQubit(0)
     dp = cirq.depolarize(0.1)
     mm = cirq.MixedUnitaryChannel.from_mixture(dp, key='dp')
@@ -22,7 +22,7 @@ def test_matrix_mixture_from_mixture():
     assert results.measurements['dp'] in range(4)
 
 
-def test_matrix_mixture_equality():
+def test_matrix_mixture_equality() -> None:
     dp_pt1 = cirq.depolarize(0.1)
     dp_pt2 = cirq.depolarize(0.2)
     mm_a1 = cirq.MixedUnitaryChannel.from_mixture(dp_pt1, key='a')
@@ -45,7 +45,7 @@ def test_matrix_mixture_equality():
     assert half_flip != half_flip_inv
 
 
-def test_matrix_mixture_remap_keys():
+def test_matrix_mixture_remap_keys() -> None:
     dp = cirq.depolarize(0.1)
     mm = cirq.MixedUnitaryChannel.from_mixture(dp)
     with pytest.raises(TypeError):
@@ -63,7 +63,7 @@ def test_matrix_mixture_remap_keys():
     assert cirq.with_measurement_key_mapping(mm_a, {'a': 'b'}) == mm_b
 
 
-def test_matrix_mixture_from_unitaries():
+def test_matrix_mixture_from_unitaries() -> None:
     q0 = cirq.LineQubit(0)
     mix = [(0.5, np.array([[1, 0], [0, 1]])), (0.5, np.array([[0, 1], [1, 0]]))]
     half_flip = cirq.MixedUnitaryChannel(mix, key='flip')
@@ -77,7 +77,7 @@ def test_matrix_mixture_from_unitaries():
     assert results.measurements['flip'] == results.measurements['m']
 
 
-def test_matrix_mixture_str():
+def test_matrix_mixture_str() -> None:
     mix = [(0.5, np.array([[1, 0], [0, 1]])), (0.5, np.array([[0, 1], [1, 0]]))]
     half_flip = cirq.MixedUnitaryChannel(mix)
     assert (
@@ -95,7 +95,7 @@ def test_matrix_mixture_str():
     )
 
 
-def test_matrix_mixture_repr():
+def test_matrix_mixture_repr() -> None:
     mix = [
         (0.5, np.array([[1, 0], [0, 1]], dtype=np.dtype('complex64'))),
         (0.5, np.array([[0, 1], [1, 0]], dtype=np.dtype('complex64'))),
@@ -111,19 +111,19 @@ key='flip')"""
     )
 
 
-def test_mix_no_unitaries_fails():
+def test_mix_no_unitaries_fails() -> None:
     with pytest.raises(ValueError, match='must have at least one unitary'):
         _ = cirq.MixedUnitaryChannel(mixture=[], key='m')
 
 
-def test_mix_bad_prob_fails():
+def test_mix_bad_prob_fails() -> None:
     mix = [(0.5, np.array([[1, 0], [0, 0]]))]
 
     with pytest.raises(ValueError, match='Unitary probabilities must sum to 1'):
         _ = cirq.MixedUnitaryChannel(mixture=mix, key='m')
 
 
-def test_mix_mismatch_fails():
+def test_mix_mismatch_fails() -> None:
     op2 = np.zeros((4, 4))
     op2[1][1] = 1
     mix = [(0.5, np.array([[1, 0], [0, 0]])), (0.5, op2)]
@@ -132,14 +132,14 @@ def test_mix_mismatch_fails():
         _ = cirq.MixedUnitaryChannel(mixture=mix, key='m')
 
 
-def test_nonqubit_mixture_fails():
+def test_nonqubit_mixture_fails() -> None:
     mix = [(0.5, np.array([[1, 0, 0], [0, 1, 0]])), (0.5, np.array([[0, 1, 0], [1, 0, 0]]))]
 
     with pytest.raises(ValueError, match='Input mixture'):
         _ = cirq.MixedUnitaryChannel(mixture=mix, key='m')
 
 
-def test_validate():
+def test_validate() -> None:
     mix = [(0.5, np.array([[1, 0], [0, 0]])), (0.5, np.array([[0, 0], [0, 1]]))]
     with pytest.raises(ValueError, match='non-unitary'):
         _ = cirq.MixedUnitaryChannel(mixture=mix, key='m', validate=True)

cirq/ops/parallel_gate_test.py

@@ -26,7 +26,7 @@ import cirq
         (cirq.X**0.5, 4, cirq.LineQubit.range(4)),
     ],
 )
-def test_parallel_gate_operation_init(gate, num_copies, qubits):
+def test_parallel_gate_operation_init(gate, num_copies, qubits) -> None:
     v = cirq.ParallelGate(gate, num_copies)
     assert v.sub_gate == gate
     assert v.num_copies == num_copies
@@ -52,7 +52,7 @@ def test_parallel_gate_operation_init(gate, num_copies, qubits):
         (cirq.testing.TwoQubitGate(), 2, cirq.LineQubit.range(4), "must be a single qubit gate"),
     ],
 )
-def test_invalid_parallel_gate_operation(gate, num_copies, qubits, error_msg):
+def test_invalid_parallel_gate_operation(gate, num_copies, qubits, error_msg) -> None:
     with pytest.raises(ValueError, match=error_msg):
         cirq.ParallelGate(gate, num_copies)(*qubits)
 
@@ -61,27 +61,27 @@ def test_invalid_parallel_gate_operation(gate, num_copies, qubits, error_msg):
     'gate, num_copies, qubits',
     [(cirq.X, 2, cirq.LineQubit.range(2)), (cirq.H**0.5, 4, cirq.LineQubit.range(4))],
 )
-def test_decompose(gate, num_copies, qubits):
+def test_decompose(gate, num_copies, qubits) -> None:
     g = cirq.ParallelGate(gate, num_copies)
     step = gate.num_qubits()
     qubit_lists = [qubits[i * step : (i + 1) * step] for i in range(num_copies)]
     assert set(cirq.decompose_once(g(*qubits))) == set(gate.on_each(qubit_lists))
 
 
-def test_decompose_raises():
+def test_decompose_raises() -> None:
     g = cirq.ParallelGate(cirq.X, 2)
     qubits = cirq.LineQubit.range(4)
     with pytest.raises(ValueError, match=r'len\(qubits\)=4 should be 2'):
         cirq.decompose_once_with_qubits(g, qubits)
 
 
-def test_with_num_copies():
+def test_with_num_copies() -> None:
     g = cirq.testing.SingleQubitGate()
     pg = cirq.ParallelGate(g, 3)
     assert pg.with_num_copies(5) == cirq.ParallelGate(g, 5)
 
 
-def test_extrapolate():
+def test_extrapolate() -> None:
     # If the gate isn't extrapolatable, you get a type error.
     g = cirq.ParallelGate(cirq.testing.SingleQubitGate(), 2)
     with pytest.raises(TypeError):
@@ -93,7 +93,7 @@ def test_extrapolate():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameterizable_gates(resolve_fn):
+def test_parameterizable_gates(resolve_fn) -> None:
     r = cirq.ParamResolver({'a': 0.5})
     g1 = cirq.ParallelGate(cirq.Z ** sympy.Symbol('a'), 2)
     assert cirq.is_parameterized(g1)
@@ -102,7 +102,7 @@ def test_parameterizable_gates(resolve_fn):
 
 
 @pytest.mark.parametrize('gate', [cirq.X ** sympy.Symbol("a"), cirq.testing.SingleQubitGate()])
-def test_no_unitary(gate):
+def test_no_unitary(gate) -> None:
     g = cirq.ParallelGate(gate, 2)
     assert not cirq.has_unitary(g)
     assert cirq.unitary(g, None) is None
@@ -115,7 +115,7 @@ def test_no_unitary(gate):
         (cirq.MatrixGate(cirq.unitary(cirq.H**0.25)), 6, cirq.LineQubit.range(6)),
     ],
 )
-def test_unitary(gate, num_copies, qubits):
+def test_unitary(gate, num_copies, qubits) -> None:
     g = cirq.ParallelGate(gate, num_copies)
     step = gate.num_qubits()
     qubit_lists = [qubits[i * step : (i + 1) * step] for i in range(num_copies)]
@@ -124,7 +124,7 @@ def test_unitary(gate, num_copies, qubits):
     )
 
 
-def test_not_implemented_diagram():
+def test_not_implemented_diagram() -> None:
     q = cirq.LineQubit.range(2)
     g = cirq.testing.SingleQubitGate()
     c = cirq.Circuit()
@@ -132,15 +132,15 @@ def test_not_implemented_diagram():
     assert 'cirq.testing.gate_features.SingleQubitGate ' in str(c)
 
 
-def test_repr():
+def test_repr() -> None:
     assert repr(cirq.ParallelGate(cirq.X, 2)) == 'cirq.ParallelGate(sub_gate=cirq.X, num_copies=2)'
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.ParallelGate(cirq.X**0.5, 10)) == 'X**0.5 x 10'
 
 
-def test_equivalent_circuit():
+def test_equivalent_circuit() -> None:
     qreg = cirq.LineQubit.range(4)
     oldc = cirq.Circuit()
     newc = cirq.Circuit()
@@ -154,11 +154,11 @@ def test_equivalent_circuit():
 
 
 @pytest.mark.parametrize('gate, num_copies', [(cirq.X, 1), (cirq.Y, 2), (cirq.Z, 3), (cirq.H, 4)])
-def test_parallel_gate_operation_is_consistent(gate, num_copies):
+def test_parallel_gate_operation_is_consistent(gate, num_copies) -> None:
     cirq.testing.assert_implements_consistent_protocols(cirq.ParallelGate(gate, num_copies))
 
 
-def test_trace_distance():
+def test_trace_distance() -> None:
     s = cirq.X**0.25
     two_g = cirq.ParallelGate(s, 2)
     three_g = cirq.ParallelGate(s, 3)
@@ -171,6 +171,6 @@ def test_trace_distance():
 
 
 @pytest.mark.parametrize('gate, num_copies', [(cirq.X, 1), (cirq.Y, 2), (cirq.Z, 3), (cirq.H, 4)])
-def test_parallel_gate_op(gate, num_copies):
+def test_parallel_gate_op(gate, num_copies) -> None:
     qubits = cirq.LineQubit.range(num_copies * gate.num_qubits())
     assert cirq.parallel_gate_op(gate, *qubits) == cirq.ParallelGate(gate, num_copies).on(*qubits)