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

cirq/ops/fourier_transform_test.py

@@ -21,7 +21,7 @@ import sympy
 import cirq
 
 
-def test_phase_gradient():
+def test_phase_gradient() -> None:
     np.testing.assert_allclose(
         cirq.unitary(cirq.PhaseGradientGate(num_qubits=2, exponent=1)), np.diag([1, 1j, -1, -1j])
     )
@@ -33,7 +33,7 @@ def test_phase_gradient():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_phase_gradient_symbolic(resolve_fn):
+def test_phase_gradient_symbolic(resolve_fn) -> None:
     a = cirq.PhaseGradientGate(num_qubits=2, exponent=0.5)
     b = cirq.PhaseGradientGate(num_qubits=2, exponent=sympy.Symbol('t'))
     assert not cirq.is_parameterized(a)
@@ -45,22 +45,22 @@ def test_phase_gradient_symbolic(resolve_fn):
     assert resolve_fn(b, {'t': 0.25}) == cirq.PhaseGradientGate(num_qubits=2, exponent=0.25)
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.PhaseGradientGate(num_qubits=2, exponent=0.5)) == 'Grad[2]^0.5'
     assert str(cirq.PhaseGradientGate(num_qubits=2, exponent=1)) == 'Grad[2]'
 
 
-def test_phase_gradient_gate_repr():
+def test_phase_gradient_gate_repr() -> None:
     a = cirq.PhaseGradientGate(num_qubits=2, exponent=0.5)
     cirq.testing.assert_equivalent_repr(a)
 
 
-def test_quantum_fourier_transform_gate_repr():
+def test_quantum_fourier_transform_gate_repr() -> None:
     b = cirq.QuantumFourierTransformGate(num_qubits=2, without_reverse=False)
     cirq.testing.assert_equivalent_repr(b)
 
 
-def test_pow():
+def test_pow() -> None:
     a = cirq.PhaseGradientGate(num_qubits=2, exponent=0.5)
     assert a**0.5 == cirq.PhaseGradientGate(num_qubits=2, exponent=0.25)
     assert a ** sympy.Symbol('t') == cirq.PhaseGradientGate(
@@ -68,7 +68,7 @@ def test_pow():
     )
 
 
-def test_qft():
+def test_qft() -> None:
     # fmt: off
     np.testing.assert_allclose(
         cirq.unitary(cirq.qft(*cirq.LineQubit.range(2))),
@@ -105,9 +105,10 @@ def test_qft():
         atol=1e-8,
     )
 
+    arr = np.array([[1, 1, 1, 1], [1, -1j, -1, 1j], [1, -1, 1, -1], [1, 1j, -1, -1j]]) / 2
     np.testing.assert_allclose(
-        cirq.unitary(cirq.qft(*cirq.LineQubit.range(2)) ** -1),
-        np.array([[1, 1, 1, 1], [1, -1j, -1, 1j], [1, -1, 1, -1], [1, 1j, -1, -1j]]) / 2,
+        cirq.unitary(cirq.qft(*cirq.LineQubit.range(2)) ** -1),  # type: ignore[operator]
+        arr,  # type: ignore[arg-type]
         atol=1e-8,
     )
 
@@ -118,15 +119,15 @@ def test_qft():
             )
 
 
-def test_inverse():
+def test_inverse() -> None:
     a, b, c = cirq.LineQubit.range(3)
-    assert cirq.qft(a, b, c, inverse=True) == cirq.qft(a, b, c) ** -1
+    assert cirq.qft(a, b, c, inverse=True) == cirq.qft(a, b, c) ** -1  # type: ignore[operator]
     assert cirq.qft(a, b, c, inverse=True, without_reverse=True) == cirq.inverse(
         cirq.qft(a, b, c, without_reverse=True)
     )
 
 
-def test_circuit_diagram():
+def test_circuit_diagram() -> None:
     cirq.testing.assert_has_diagram(
         cirq.Circuit(cirq.decompose_once(cirq.qft(*cirq.LineQubit.range(4)))),
         """

cirq/ops/gate_operation_test.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import collections.abc
 import pathlib
+from typing import cast
 
 import numpy as np
 import pytest
@@ -25,7 +26,7 @@ import cirq
 import cirq.testing
 
 
-def test_gate_operation_init():
+def test_gate_operation_init() -> None:
     q = cirq.NamedQubit('q')
     g = cirq.testing.SingleQubitGate()
     v = cirq.GateOperation(g, (q,))
@@ -33,14 +34,14 @@ def test_gate_operation_init():
     assert v.qubits == (q,)
 
 
-def test_invalid_gate_operation():
+def test_invalid_gate_operation() -> None:
     three_qubit_gate = cirq.testing.ThreeQubitGate()
     single_qubit = [cirq.GridQubit(0, 0)]
     with pytest.raises(ValueError, match="number of qubits"):
         cirq.GateOperation(three_qubit_gate, single_qubit)
 
 
-def test_immutable():
+def test_immutable() -> None:
     a, b = cirq.LineQubit.range(2)
     op = cirq.X(a)
 
@@ -60,7 +61,7 @@ def test_immutable():
         op.qubits = [b]
 
 
-def test_gate_operation_eq():
+def test_gate_operation_eq() -> None:
     g1 = cirq.testing.SingleQubitGate()
     g2 = cirq.testing.SingleQubitGate()
     g3 = cirq.testing.TwoQubitGate()
@@ -105,7 +106,7 @@ def test_gate_operation_eq():
     eq.add_equality_group(p(b0, a1, a0, b1, c0))
 
 
-def test_gate_operation_approx_eq():
+def test_gate_operation_approx_eq() -> None:
     a = [cirq.NamedQubit('r1')]
     b = [cirq.NamedQubit('r2')]
 
@@ -131,7 +132,7 @@ def test_gate_operation_approx_eq():
     )
 
 
-def test_gate_operation_qid_shape():
+def test_gate_operation_qid_shape() -> None:
     class ShapeGate(cirq.Gate):
         def _qid_shape_(self):
             return (1, 2, 3, 4)
@@ -141,7 +142,7 @@ def test_gate_operation_qid_shape():
     assert cirq.num_qubits(op) == 4
 
 
-def test_gate_operation_num_qubits():
+def test_gate_operation_num_qubits() -> None:
     class NumQubitsGate(cirq.Gate):
         def _num_qubits_(self):
             return 4
@@ -151,25 +152,25 @@ def test_gate_operation_num_qubits():
     assert cirq.num_qubits(op) == 4
 
 
-def test_gate_operation_pow():
+def test_gate_operation_pow() -> None:
     Y = cirq.Y
     q = cirq.NamedQubit('q')
     assert (Y**0.5)(q) == Y(q) ** 0.5
 
 
-def test_with_qubits_and_transform_qubits():
+def test_with_qubits_and_transform_qubits() -> None:
     g = cirq.testing.ThreeQubitGate()
     g = cirq.testing.ThreeQubitGate()
     op = cirq.GateOperation(g, cirq.LineQubit.range(3))
     assert op.with_qubits(*cirq.LineQubit.range(3, 0, -1)) == cirq.GateOperation(
         g, cirq.LineQubit.range(3, 0, -1)
     )
-    assert op.transform_qubits(lambda e: cirq.LineQubit(-e.x)) == cirq.GateOperation(
-        g, [cirq.LineQubit(0), cirq.LineQubit(-1), cirq.LineQubit(-2)]
-    )
+    assert op.transform_qubits(
+        lambda e: cirq.LineQubit(-cast(cirq.LineQubit, e).x)
+    ) == cirq.GateOperation(g, [cirq.LineQubit(0), cirq.LineQubit(-1), cirq.LineQubit(-2)])
 
 
-def test_extrapolate():
+def test_extrapolate() -> None:
     q = cirq.NamedQubit('q')
 
     # If the gate isn't extrapolatable, you get a type error.
@@ -182,7 +183,7 @@ def test_extrapolate():
     assert (cirq.Y**0.5).on(q) == cirq.Y(q) ** 0.5
 
 
-def test_inverse():
+def test_inverse() -> None:
     q = cirq.NamedQubit('q')
 
     # If the gate isn't reversible, you get a type error.
@@ -194,7 +195,7 @@ def test_inverse():
     assert cirq.inverse(cirq.S).on(q) == cirq.inverse(cirq.S.on(q))
 
 
-def test_text_diagrammable():
+def test_text_diagrammable() -> None:
     q = cirq.NamedQubit('q')
 
     # If the gate isn't diagrammable, you get a type error.
@@ -208,7 +209,7 @@ def test_text_diagrammable():
     assert actual == expected
 
 
-def test_bounded_effect():
+def test_bounded_effect() -> None:
     q = cirq.NamedQubit('q')
 
     # If the gate isn't bounded, you get a type error.
@@ -220,7 +221,7 @@ def test_bounded_effect():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameterizable_effect(resolve_fn):
+def test_parameterizable_effect(resolve_fn) -> None:
     q = cirq.NamedQubit('q')
     r = cirq.ParamResolver({'a': 0.5})
 
@@ -231,7 +232,7 @@ def test_parameterizable_effect(resolve_fn):
     assert op2 == cirq.S.on(q)
 
 
-def test_pauli_expansion():
+def test_pauli_expansion() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -253,7 +254,7 @@ def test_pauli_expansion():
     assert cirq.pauli_expansion(Yes().on(a)) == cirq.LinearDict({'X': 0.5})
 
 
-def test_unitary():
+def test_unitary() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -263,7 +264,7 @@ def test_unitary():
     np.testing.assert_allclose(cirq.unitary(cirq.CNOT(a, b)), cirq.unitary(cirq.CNOT), atol=1e-8)
 
 
-def test_channel():
+def test_channel() -> None:
     a = cirq.NamedQubit('a')
     op = cirq.bit_flip(0.5).on(a)
     np.testing.assert_allclose(cirq.kraus(op), cirq.kraus(op.gate))
@@ -273,19 +274,19 @@ def test_channel():
     assert not cirq.has_kraus(cirq.testing.SingleQubitGate()(a))
 
 
-def test_measurement_key():
+def test_measurement_key() -> None:
     a = cirq.NamedQubit('a')
     assert cirq.measurement_key_name(cirq.measure(a, key='lock')) == 'lock'
 
 
-def assert_mixtures_equal(actual, expected):
+def assert_mixtures_equal(actual, expected) -> None:
     """Assert equal for tuple of mixed scalar and array types."""
     for a, e in zip(actual, expected):
         np.testing.assert_almost_equal(a[0], e[0])
         np.testing.assert_almost_equal(a[1], e[1])
 
 
-def test_mixture():
+def test_mixture() -> None:
     a = cirq.NamedQubit('a')
     op = cirq.bit_flip(0.5).on(a)
     assert_mixtures_equal(cirq.mixture(op), cirq.mixture(op.gate))
@@ -298,7 +299,7 @@ def test_mixture():
     np.testing.assert_allclose(m[0][1], cirq.unitary(cirq.X))
 
 
-def test_repr():
+def test_repr() -> None:
     a, b = cirq.LineQubit.range(2)
     assert (
         repr(cirq.GateOperation(cirq.CZ, (a, b))) == 'cirq.CZ(cirq.LineQubit(0), cirq.LineQubit(1))'
@@ -327,7 +328,7 @@ def test_repr():
         (cirq.Z ** sympy.Symbol('e'), cirq.Z ** sympy.Symbol('f'), False),
     ],
 )
-def test_equal_up_to_global_phase_on_gates(gate1, gate2, eq_up_to_global_phase):
+def test_equal_up_to_global_phase_on_gates(gate1, gate2, eq_up_to_global_phase) -> None:
     num_qubits1, num_qubits2 = (cirq.num_qubits(g) for g in (gate1, gate2))
     qubits = cirq.LineQubit.range(max(num_qubits1, num_qubits2) + 1)
     op1, op2 = gate1(*qubits[:num_qubits1]), gate2(*qubits[:num_qubits2])
@@ -336,12 +337,12 @@ def test_equal_up_to_global_phase_on_gates(gate1, gate2, eq_up_to_global_phase):
     assert not cirq.equal_up_to_global_phase(op1, op2_on_diff_qubits)
 
 
-def test_equal_up_to_global_phase_on_diff_types():
+def test_equal_up_to_global_phase_on_diff_types() -> None:
     op = cirq.X(cirq.LineQubit(0))
     assert not cirq.equal_up_to_global_phase(op, 3)
 
 
-def test_gate_on_operation_besides_gate_operation():
+def test_gate_on_operation_besides_gate_operation() -> None:
     a, b = cirq.LineQubit.range(2)
 
     op = -1j * cirq.X(a) * cirq.Y(b)
@@ -350,7 +351,7 @@ def test_gate_on_operation_besides_gate_operation():
     assert not isinstance(op.gate, cirq.XPowGate)
 
 
-def test_mul():
+def test_mul() -> None:
     class GateRMul(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -376,29 +377,29 @@ def test_mul():
     # Delegates right multiplication.
     q = cirq.LineQubit(0)
     r = GateRMul().on(q)
-    assert 2 * r == 3
+    assert 2 * r == 3  # type: ignore[operator]
     with pytest.raises(TypeError):
-        _ = r * 2
+        _ = r * 2  # type: ignore[operator]
 
     # Delegates left multiplication.
     m = GateMul().on(q)
-    assert m * 2 == 5
+    assert m * 2 == 5  # type: ignore[operator]
     with pytest.raises(TypeError):
-        _ = 2 * m
+        _ = 2 * m  # type: ignore[operator]
 
     # Handles the symmetric type case correctly.
-    assert m * m == 6
-    assert r * r == 4
+    assert m * m == 6  # type: ignore[operator]
+    assert r * r == 4  # type: ignore[operator]
 
 
-def test_with_gate():
+def test_with_gate() -> None:
     g1 = cirq.GateOperation(cirq.X, cirq.LineQubit.range(1))
     g2 = cirq.GateOperation(cirq.Y, cirq.LineQubit.range(1))
     assert g1.with_gate(cirq.X) is g1
     assert g1.with_gate(cirq.Y) == g2
 
 
-def test_with_measurement_key_mapping():
+def test_with_measurement_key_mapping() -> None:
     a = cirq.LineQubit(0)
     op = cirq.measure(a, key='m')
 
@@ -407,7 +408,7 @@ def test_with_measurement_key_mapping():
     assert cirq.with_measurement_key_mapping(op, {'x': 'k'}) is op
 
 
-def test_with_key_path():
+def test_with_key_path() -> None:
     a = cirq.LineQubit(0)
     op = cirq.measure(a, key='m')
 
@@ -420,7 +421,7 @@ def test_with_key_path():
     assert cirq.with_key_path(cirq.X(a), ('a', 'b')) is NotImplemented
 
 
-def test_with_key_path_prefix():
+def test_with_key_path_prefix() -> None:
     a = cirq.LineQubit(0)
     op = cirq.measure(a, key='m')
     remap_op = cirq.with_key_path_prefix(op, ('a', 'b'))
@@ -430,14 +431,14 @@ def test_with_key_path_prefix():
     assert cirq.with_key_path_prefix(cirq.X(a), ('a', 'b')) is NotImplemented
 
 
-def test_cannot_remap_non_measurement_gate():
+def test_cannot_remap_non_measurement_gate() -> None:
     a = cirq.LineQubit(0)
     op = cirq.X(a)
 
     assert cirq.with_measurement_key_mapping(op, {'m': 'k'}) is NotImplemented
 
 
-def test_is_parameterized():
+def test_is_parameterized() -> None:
     class No1(cirq.testing.SingleQubitGate):
         def num_qubits(self) -> int:
             return 1
@@ -463,7 +464,7 @@ def test_is_parameterized():
     assert cirq.is_parameterized(Yes().on(q))
 
 
-def test_group_interchangeable_qubits_creates_tuples_with_unique_keys():
+def test_group_interchangeable_qubits_creates_tuples_with_unique_keys() -> None:
     class MyGate(cirq.Gate, cirq.InterchangeableQubitsGate):
         def __init__(self, num_qubits) -> None:
             self._num_qubits = num_qubits
@@ -484,7 +485,7 @@ def test_group_interchangeable_qubits_creates_tuples_with_unique_keys():
     )
 
 
-def test_gate_to_operation_to_gate_round_trips():
+def test_gate_to_operation_to_gate_round_trips() -> None:
     def all_subclasses(cls):
         return set(cls.__subclasses__()).union(
             [s for c in cls.__subclasses__() for s in all_subclasses(c)]

cirq/ops/global_phase_op_test.py

@@ -21,9 +21,11 @@ import sympy
 import cirq
 
 
-def test_init():
+def test_init() -> None:
     op = cirq.global_phase_operation(1j)
-    assert op.gate.coefficient == 1j
+    gate = op.gate
+    assert isinstance(gate, cirq.GlobalPhaseGate)
+    assert gate.coefficient == 1j
     assert op.qubits == ()
     assert op.with_qubits() == op
     assert cirq.has_stabilizer_effect(op)
@@ -34,7 +36,7 @@ def test_init():
         _ = cirq.global_phase_operation(1j).with_qubits(cirq.LineQubit(0))
 
 
-def test_protocols():
+def test_protocols() -> None:
     for p in [1, 1j, -1, sympy.Symbol('s')]:
         cirq.testing.assert_implements_consistent_protocols(cirq.global_phase_operation(p))
 
@@ -44,7 +46,7 @@ def test_protocols():
 
 
 @pytest.mark.parametrize('phase', [1, 1j, -1])
-def test_act_on_tableau(phase):
+def test_act_on_tableau(phase) -> None:
     original_tableau = cirq.CliffordTableau(0)
     args = cirq.CliffordTableauSimulationState(original_tableau.copy(), np.random.RandomState())
     cirq.act_on(cirq.global_phase_operation(phase), args, allow_decompose=False)
@@ -52,7 +54,7 @@ def test_act_on_tableau(phase):
 
 
 @pytest.mark.parametrize('phase', [1, 1j, -1])
-def test_act_on_ch_form(phase):
+def test_act_on_ch_form(phase) -> None:
     state = cirq.StabilizerStateChForm(0)
     args = cirq.StabilizerChFormSimulationState(
         qubits=[], prng=np.random.RandomState(), initial_state=state
@@ -61,16 +63,16 @@ def test_act_on_ch_form(phase):
     assert state.state_vector() == [[phase]]
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.global_phase_operation(1j)) == '1j'
 
 
-def test_repr():
+def test_repr() -> None:
     op = cirq.global_phase_operation(1j)
     cirq.testing.assert_equivalent_repr(op)
 
 
-def test_diagram():
+def test_diagram() -> None:
     a, b = cirq.LineQubit.range(2)
     x, y = cirq.LineQubit.range(10, 12)
 
@@ -202,7 +204,7 @@ global phase:   -0.5π
     )
 
 
-def test_gate_init():
+def test_gate_init() -> None:
     gate = cirq.GlobalPhaseGate(1j)
     assert gate.coefficient == 1j
     assert isinstance(gate.on(), cirq.GateOperation)
@@ -215,7 +217,7 @@ def test_gate_init():
         _ = gate.on(cirq.LineQubit(0))
 
 
-def test_gate_protocols():
+def test_gate_protocols() -> None:
     for p in [1, 1j, -1]:
         cirq.testing.assert_implements_consistent_protocols(cirq.GlobalPhaseGate(p))
 
@@ -223,7 +225,7 @@ def test_gate_protocols():
 
 
 @pytest.mark.parametrize('phase', [1, 1j, -1])
-def test_gate_act_on_tableau(phase):
+def test_gate_act_on_tableau(phase) -> None:
     original_tableau = cirq.CliffordTableau(0)
     args = cirq.CliffordTableauSimulationState(original_tableau.copy(), np.random.RandomState())
     cirq.act_on(cirq.GlobalPhaseGate(phase), args, qubits=(), allow_decompose=False)
@@ -231,7 +233,7 @@ def test_gate_act_on_tableau(phase):
 
 
 @pytest.mark.parametrize('phase', [1, 1j, -1])
-def test_gate_act_on_ch_form(phase):
+def test_gate_act_on_ch_form(phase) -> None:
     state = cirq.StabilizerStateChForm(0)
     args = cirq.StabilizerChFormSimulationState(
         qubits=[], prng=np.random.RandomState(), initial_state=state
@@ -240,25 +242,25 @@ def test_gate_act_on_ch_form(phase):
     assert state.state_vector() == [[phase]]
 
 
-def test_gate_str():
+def test_gate_str() -> None:
     assert str(cirq.GlobalPhaseGate(1j)) == '1j'
 
 
-def test_gate_repr():
+def test_gate_repr() -> None:
     gate = cirq.GlobalPhaseGate(1j)
     cirq.testing.assert_equivalent_repr(gate)
 
 
-def test_gate_op_repr():
+def test_gate_op_repr() -> None:
     gate = cirq.GlobalPhaseGate(1j)
     cirq.testing.assert_equivalent_repr(gate.on())
 
 
-def test_gate_global_phase_op_json_dict():
+def test_gate_global_phase_op_json_dict() -> None:
     assert cirq.GlobalPhaseGate(-1j)._json_dict_() == {'coefficient': -1j}
 
 
-def test_parameterization():
+def test_parameterization() -> None:
     t = sympy.Symbol('t')
     gpt = cirq.GlobalPhaseGate(coefficient=t)
     assert cirq.is_parameterized(gpt)
@@ -269,14 +271,14 @@ def test_parameterization():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve(resolve_fn):
+def test_resolve(resolve_fn) -> None:
     t = sympy.Symbol('t')
     gpt = cirq.GlobalPhaseGate(coefficient=t)
     assert resolve_fn(gpt, {'t': -1}) == cirq.GlobalPhaseGate(coefficient=-1)
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve_error(resolve_fn):
+def test_resolve_error(resolve_fn) -> None:
     t = sympy.Symbol('t')
     gpt = cirq.GlobalPhaseGate(coefficient=t)
     with pytest.raises(ValueError, match='Coefficient is not unitary'):
@@ -286,7 +288,7 @@ def test_resolve_error(resolve_fn):
 @pytest.mark.parametrize(
     'coeff, exp', [(-1, 1), (1j, 0.5), (-1j, -0.5), (1 / np.sqrt(2) * (1 + 1j), 0.25)]
 )
-def test_global_phase_gate_controlled(coeff, exp):
+def test_global_phase_gate_controlled(coeff, exp) -> None:
     g = cirq.GlobalPhaseGate(coeff)
     op = cirq.global_phase_operation(coeff)
     q = cirq.LineQubit.range(3)