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

cirq/interop/quirk/cells/qubit_permutation_cells_test.py

@@ -17,7 +17,7 @@ from cirq.interop.quirk.cells.qubit_permutation_cells import QuirkQubitPermutati
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_equality():
+def test_equality() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: QuirkQubitPermutationGate('a', 'b', [0, 1]))
     eq.add_equality_group(QuirkQubitPermutationGate('x', 'b', [0, 1]))
@@ -25,11 +25,11 @@ def test_equality():
     eq.add_equality_group(QuirkQubitPermutationGate('a', 'b', [1, 0]))
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(QuirkQubitPermutationGate('a', 'b', [0, 1]))
 
 
-def test_right_rotate():
+def test_right_rotate() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["X",">>4",1,1,1,"X"]]}',
         diagram="""
@@ -57,7 +57,7 @@ def test_right_rotate():
     )
 
 
-def test_left_rotate():
+def test_left_rotate() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["<<4"]]}',
         maps={
@@ -72,7 +72,7 @@ def test_left_rotate():
     )
 
 
-def test_reverse():
+def test_reverse() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["rev4"]]}',
         maps={
@@ -98,7 +98,7 @@ def test_reverse():
     )
 
 
-def test_interleave():
+def test_interleave() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["weave5"]]}',
         maps={
@@ -128,7 +128,7 @@ def test_interleave():
     )
 
 
-def test_deinterleave():
+def test_deinterleave() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["split5"]]}',
         maps={

cirq/interop/quirk/cells/scalar_cells_test.py

@@ -16,7 +16,7 @@ import cirq
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_scalar_operations():
+def test_scalar_operations() -> None:
     assert_url_to_circuit_returns('{"cols":[["…"]]}', cirq.Circuit())
 
     assert_url_to_circuit_returns(

cirq/interop/quirk/cells/single_qubit_rotation_cells_test.py

@@ -18,7 +18,7 @@ import cirq
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_fixed_single_qubit_rotations():
+def test_fixed_single_qubit_rotations() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     assert_url_to_circuit_returns(
@@ -89,7 +89,7 @@ def test_fixed_single_qubit_rotations():
     )
 
 
-def test_dynamic_single_qubit_rotations():
+def test_dynamic_single_qubit_rotations() -> None:
     a, b, c = cirq.LineQubit.range(3)
     t = sympy.Symbol('t')
 
@@ -118,7 +118,7 @@ def test_dynamic_single_qubit_rotations():
     )
 
 
-def test_formulaic_gates():
+def test_formulaic_gates() -> None:
     a, b = cirq.LineQubit.range(2)
     t = sympy.Symbol('t')
 

cirq/interop/quirk/cells/swap_cell_test.py

@@ -19,7 +19,7 @@ from cirq import quirk_url_to_circuit
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_swap():
+def test_swap() -> None:
     a, b, c = cirq.LineQubit.range(3)
     assert_url_to_circuit_returns('{"cols":[["Swap","Swap"]]}', cirq.Circuit(cirq.SWAP(a, b)))
     assert_url_to_circuit_returns(
@@ -34,7 +34,7 @@ def test_swap():
         )
 
 
-def test_controlled_swap():
+def test_controlled_swap() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     assert_url_to_circuit_returns(
         '{"cols":[["Swap","•","Swap"]]}', cirq.Circuit(cirq.SWAP(a, c).controlled_by(b))
@@ -44,7 +44,7 @@ def test_controlled_swap():
     )
 
 
-def test_with_line_qubits_mapped_to():
+def test_with_line_qubits_mapped_to() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     a2, b2, c2, d2 = cirq.NamedQubit.range(4, prefix='q')
     cell = cirq.interop.quirk.cells.swap_cell.SwapCell(qubits=[a, b], controls=[c, d])
@@ -53,7 +53,7 @@ def test_with_line_qubits_mapped_to():
     assert cell.with_line_qubits_mapped_to([a2, b2, c2, d2]) == mapped_cell
 
 
-def test_repr():
+def test_repr() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     cirq.testing.assert_equivalent_repr(
         cirq.interop.quirk.cells.swap_cell.SwapCell(qubits=[a, b], controls=[c, d])

cirq/interop/quirk/cells/testing_test.py

@@ -19,7 +19,7 @@ import cirq
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_assert_url_to_circuit_returns_circuit():
+def test_assert_url_to_circuit_returns_circuit() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["X"]]}', circuit=cirq.Circuit(cirq.X(cirq.LineQubit(0)))
     )
@@ -30,21 +30,21 @@ def test_assert_url_to_circuit_returns_circuit():
         )
 
 
-def test_assert_url_to_circuit_returns_unitary():
+def test_assert_url_to_circuit_returns_unitary() -> None:
     assert_url_to_circuit_returns('{"cols":[["X"]]}', unitary=cirq.unitary(cirq.X))
 
     with pytest.raises(AssertionError, match='Not equal to tolerance'):
         assert_url_to_circuit_returns('{"cols":[["X"]]}', unitary=np.eye(2))
 
 
-def test_assert_url_to_circuit_returns_diagram():
+def test_assert_url_to_circuit_returns_diagram() -> None:
     assert_url_to_circuit_returns('{"cols":[["X"]]}', diagram='0: ───X───')
 
     with pytest.raises(AssertionError, match='text diagram differs'):
         assert_url_to_circuit_returns('{"cols":[["X"]]}', diagram='not even close')
 
 
-def test_assert_url_to_circuit_returns_maps():
+def test_assert_url_to_circuit_returns_maps() -> None:
     assert_url_to_circuit_returns('{"cols":[["X"]]}', maps={0: 1})
     assert_url_to_circuit_returns('{"cols":[["X"]]}', maps={0: 1, 1: 0})
 
@@ -55,7 +55,7 @@ def test_assert_url_to_circuit_returns_maps():
         assert_url_to_circuit_returns('{"cols":[["H"]]}', maps={0: 0})
 
 
-def test_assert_url_to_circuit_returns_output_amplitudes_from_quirk():
+def test_assert_url_to_circuit_returns_output_amplitudes_from_quirk() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["X","Z"]]}',
         output_amplitudes_from_quirk=[
@@ -78,7 +78,7 @@ def test_assert_url_to_circuit_returns_output_amplitudes_from_quirk():
         )
 
 
-def test_assert_url_to_circuit_misc():
+def test_assert_url_to_circuit_misc() -> None:
     a, b = cirq.LineQubit.range(2)
 
     assert_url_to_circuit_returns(

cirq/interop/quirk/cells/unsupported_cells_test.py

@@ -17,7 +17,7 @@ import pytest
 from cirq import quirk_url_to_circuit
 
 
-def test_non_physical_operations():
+def test_non_physical_operations() -> None:
     with pytest.raises(NotImplementedError, match="unphysical operation"):
         _ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={"cols":[["__error__"]]}')
     with pytest.raises(NotImplementedError, match="unphysical operation"):
@@ -26,7 +26,7 @@ def test_non_physical_operations():
         )
 
 
-def test_not_implemented_gates():
+def test_not_implemented_gates() -> None:
     # This test mostly exists to ensure the gates are tested if added.
 
     for k in ["X^⌈t⌉", "X^⌈t-¼⌉", "Counting4", "Uncounting4", ">>t3", "<<t3"]:

cirq/linalg/combinators_test.py

@@ -17,7 +17,7 @@ import pytest
 import cirq
 
 
-def test_dot():
+def test_dot() -> None:
     assert cirq.dot(2) == 2
     assert cirq.dot(2.5, 2.5) == 6.25
 
@@ -33,7 +33,7 @@ def test_dot():
         cirq.dot()
 
 
-def test_kron_multiplies_sizes():
+def test_kron_multiplies_sizes() -> None:
     assert cirq.kron(np.array([1, 2])).shape == (1, 2)
     assert cirq.kron(np.array([1, 2]), shape_len=1).shape == (2,)
     assert cirq.kron(np.array([1, 2]), np.array([3, 4, 5]), shape_len=1).shape == (6,)
@@ -51,7 +51,7 @@ def test_kron_multiplies_sizes():
     assert np.allclose(cirq.kron(np.eye(2), np.eye(3), np.eye(4)), np.eye(24))
 
 
-def test_kron_spreads_values():
+def test_kron_spreads_values() -> None:
     u = np.array([[2, 3], [5, 7]])
 
     assert np.allclose(
@@ -68,7 +68,7 @@ def test_kron_spreads_values():
     )
 
 
-def test_acts_like_kron_multiplies_sizes():
+def test_acts_like_kron_multiplies_sizes() -> None:
     assert np.allclose(cirq.kron_with_controls(), np.eye(1))
     assert np.allclose(cirq.kron_with_controls(np.eye(2), np.eye(3), np.eye(4)), np.eye(24))
 
@@ -79,7 +79,7 @@ def test_acts_like_kron_multiplies_sizes():
     )
 
 
-def test_supports_controls():
+def test_supports_controls() -> None:
     u = np.array([[2, 3], [5, 7]])
     assert np.allclose(cirq.kron_with_controls(cirq.CONTROL_TAG), np.array([[1, 0], [0, 1]]))
     assert np.allclose(
@@ -92,7 +92,7 @@ def test_supports_controls():
     )
 
 
-def test_block_diag():
+def test_block_diag() -> None:
     assert np.allclose(cirq.block_diag(), np.zeros((0, 0)))
 
     assert np.allclose(cirq.block_diag(np.array([[1, 2], [3, 4]])), np.array([[1, 2], [3, 4]]))
@@ -108,7 +108,7 @@ def test_block_diag():
         _ = cirq.block_diag(np.array([[1, 2, 3], [3, 4, 5]]))
 
 
-def test_block_diag_dtype():
+def test_block_diag_dtype() -> None:
     assert cirq.block_diag().dtype == np.complex128
 
     assert cirq.block_diag(np.array([[1]], dtype=np.int8)).dtype == np.int8

cirq/linalg/diagonalize_test.py

@@ -107,7 +107,7 @@ def assert_bidiagonalized_by(m, p, q, rtol: float = 1e-5, atol: float = 1e-8):
     + [random_symmetric_matrix(4) for _ in range(10)]
     + [random_symmetric_matrix(k) for k in range(1, 10)],
 )
-def test_diagonalize_real_symmetric_matrix(matrix):
+def test_diagonalize_real_symmetric_matrix(matrix) -> None:
     p = cirq.diagonalize_real_symmetric_matrix(matrix)
     assert_diagonalized_by(matrix, p)
 
@@ -122,12 +122,12 @@ def test_diagonalize_real_symmetric_matrix(matrix):
         np.array([[3, 1], [7, 3]]),
     ],
 )
-def test_diagonalize_real_symmetric_matrix_fails(matrix):
+def test_diagonalize_real_symmetric_matrix_fails(matrix) -> None:
     with pytest.raises(ValueError):
         _ = cirq.diagonalize_real_symmetric_matrix(matrix)
 
 
-def test_diagonalize_real_symmetric_matrix_assertion_error():
+def test_diagonalize_real_symmetric_matrix_assertion_error() -> None:
     with pytest.raises(AssertionError):
         matrix = np.array([[0.5, 0], [0, 1]])
         m = np.array([[0, 1], [0, 0]])
@@ -151,7 +151,7 @@ def test_diagonalize_real_symmetric_matrix_assertion_error():
     ]
     + [([6, 6, 5, 5, 5], random_block_diagonal_symmetric_matrix(2, 3)) for _ in range(10)],
 )
-def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars(s, m):
+def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars(s, m) -> None:
     m = np.array(m)
     s = np.diag(s)
     p = cirq.diagonalize_real_symmetric_and_sorted_diagonal_matrices(m, s)
@@ -171,7 +171,7 @@ def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars(s, m):
         ([3, 2, 1], QFT, 'must be real symmetric'),
     ],
 )
-def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars_fail(s, m, match: str):
+def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars_fail(s, m, match: str) -> None:
     m = np.array(m)
     s = np.diag(s)
     with pytest.raises(ValueError, match=match):
@@ -199,7 +199,7 @@ def test_simultaneous_diagonalize_real_symmetric_matrix_vs_singulars_fail(s, m,
     ]
     + [random_bi_diagonalizable_pair(k) for k in range(1, 10)],
 )
-def test_bidiagonalize_real_matrix_pair_with_symmetric_products(a, b):
+def test_bidiagonalize_real_matrix_pair_with_symmetric_products(a, b) -> None:
     a = np.array(a)
     b = np.array(b)
     p, q = cirq.bidiagonalize_real_matrix_pair_with_symmetric_products(a, b)
@@ -220,14 +220,14 @@ def test_bidiagonalize_real_matrix_pair_with_symmetric_products(a, b):
         [np.array([[1, 1], [1, 0]]), np.array([[1, 0], [1, 1]]), 'mat1 @ mat2.T must be symmetric'],
     ],
 )
-def test_bidiagonalize_real_fails(a, b, match: str):
+def test_bidiagonalize_real_fails(a, b, match: str) -> None:
     a = np.array(a)
     b = np.array(b)
     with pytest.raises(ValueError, match=match):
         cirq.bidiagonalize_real_matrix_pair_with_symmetric_products(a, b)
 
 
-def test_bidiagonalize__assertion_error():
+def test_bidiagonalize__assertion_error() -> None:
     with pytest.raises(AssertionError):
         a = np.diag([0, 1])
         assert_bidiagonalized_by(a, a, a)
@@ -261,7 +261,7 @@ def test_bidiagonalize__assertion_error():
     + [cirq.testing.random_unitary(4) for _ in range(10)]
     + [cirq.testing.random_unitary(k) for k in range(1, 10)],
 )
-def test_bidiagonalize_unitary_with_special_orthogonals(mat):
+def test_bidiagonalize_unitary_with_special_orthogonals(mat) -> None:
     p, d, q = cirq.bidiagonalize_unitary_with_special_orthogonals(mat)
     assert cirq.is_special_orthogonal(p)
     assert cirq.is_special_orthogonal(q)
@@ -273,6 +273,6 @@ def test_bidiagonalize_unitary_with_special_orthogonals(mat):
     'mat',
     [np.diag([0]), np.diag([0.5]), np.diag([1, 0]), np.diag([0.5, 2]), np.array([[0, 1], [0, 0]])],
 )
-def test_bidiagonalize_unitary_fails(mat):
+def test_bidiagonalize_unitary_fails(mat) -> None:
     with pytest.raises(ValueError):
         cirq.bidiagonalize_unitary_with_special_orthogonals(mat)

cirq/linalg/operator_spaces_test.py

@@ -84,7 +84,7 @@ def _one_hot_matrix(size: int, i: int, j: int) -> np.ndarray:
         ),
     ),
 )
-def test_kron_bases(basis1, basis2, expected_kron_basis):
+def test_kron_bases(basis1, basis2, expected_kron_basis) -> None:
     kron_basis = cirq.kron_bases(basis1, basis2)
     assert len(kron_basis) == 16
     assert set(kron_basis.keys()) == set(expected_kron_basis.keys())
@@ -115,14 +115,14 @@ def test_kron_bases(basis1, basis2, expected_kron_basis):
         ),
     ),
 )
-def test_kron_bases_consistency(basis1, basis2):
+def test_kron_bases_consistency(basis1, basis2) -> None:
     assert set(basis1.keys()) == set(basis2.keys())
     for name in basis1.keys():
         assert np.all(basis1[name] == basis2[name])
 
 
 @pytest.mark.parametrize('basis,repeat', itertools.product((PAULI_BASIS, STANDARD_BASIS), range(5)))
-def test_kron_bases_repeat_sanity_checks(basis, repeat):
+def test_kron_bases_repeat_sanity_checks(basis, repeat) -> None:
     product_basis = cirq.kron_bases(basis, repeat=repeat)
     assert len(product_basis) == 4**repeat
     for name1, matrix1 in product_basis.items():
@@ -138,7 +138,7 @@ def test_kron_bases_repeat_sanity_checks(basis, repeat):
     'm1,m2,expect_real',
     ((X, X, True), (X, Y, True), (X, H, True), (X, SQRT_X, False), (I, SQRT_Z, False)),
 )
-def test_hilbert_schmidt_inner_product_is_conjugate_symmetric(m1, m2, expect_real):
+def test_hilbert_schmidt_inner_product_is_conjugate_symmetric(m1, m2, expect_real) -> None:
     v1 = cirq.hilbert_schmidt_inner_product(m1, m2)
     v2 = cirq.hilbert_schmidt_inner_product(m2, m1)
     assert v1 == v2.conjugate()
@@ -149,7 +149,7 @@ def test_hilbert_schmidt_inner_product_is_conjugate_symmetric(m1, m2, expect_rea
 
 
 @pytest.mark.parametrize('a,m1,b,m2', ((1, X, 1, Z), (2, X, 3, Y), (2j, X, 3, I), (2, X, 3, X)))
-def test_hilbert_schmidt_inner_product_is_linear(a, m1, b, m2):
+def test_hilbert_schmidt_inner_product_is_linear(a, m1, b, m2) -> None:
     v1 = cirq.hilbert_schmidt_inner_product(H, (a * m1 + b * m2))
     v2 = a * cirq.hilbert_schmidt_inner_product(H, m1) + b * cirq.hilbert_schmidt_inner_product(
         H, m2
@@ -158,7 +158,7 @@ def test_hilbert_schmidt_inner_product_is_linear(a, m1, b, m2):
 
 
 @pytest.mark.parametrize('m', (I, X, Y, Z, H, SQRT_X, SQRT_Y, SQRT_Z))
-def test_hilbert_schmidt_inner_product_is_positive_definite(m):
+def test_hilbert_schmidt_inner_product_is_positive_definite(m) -> None:
     v = cirq.hilbert_schmidt_inner_product(m, m)
     # Cannot check using np.is_real due to bug in aarch64.
     # See https://github.com/quantumlib/Cirq/issues/4379
@@ -186,7 +186,7 @@ def test_hilbert_schmidt_inner_product_is_positive_definite(m):
         (SQRT_X, E11, np.sqrt(-0.5j)),
     ),
 )
-def test_hilbert_schmidt_inner_product_values(m1, m2, expected_value):
+def test_hilbert_schmidt_inner_product_values(m1, m2, expected_value) -> None:
     v = cirq.hilbert_schmidt_inner_product(m1, m2)
     assert np.isclose(v, expected_value)
 
@@ -195,7 +195,7 @@ def test_hilbert_schmidt_inner_product_values(m1, m2, expected_value):
     'm,basis',
     itertools.product((I, X, Y, Z, H, SQRT_X, SQRT_Y, SQRT_Z), (PAULI_BASIS, STANDARD_BASIS)),
 )
-def test_expand_matrix_in_orthogonal_basis(m, basis):
+def test_expand_matrix_in_orthogonal_basis(m, basis) -> None:
     expansion = cirq.expand_matrix_in_orthogonal_basis(m, basis)
 
     reconstructed = np.zeros(m.shape, dtype=complex)
@@ -216,7 +216,7 @@ def test_expand_matrix_in_orthogonal_basis(m, basis):
         {'I': 1, 'X': 2, 'Y': 3, 'Z': 4},
     ),
 )
-def test_matrix_from_basis_coefficients(expansion):
+def test_matrix_from_basis_coefficients(expansion) -> None:
     m = cirq.matrix_from_basis_coefficients(expansion, PAULI_BASIS)
 
     for name, coefficient in expansion.items():
@@ -236,7 +236,7 @@ def test_matrix_from_basis_coefficients(expansion):
         )
     ),
 )
-def test_expand_is_inverse_of_reconstruct(m1, basis):
+def test_expand_is_inverse_of_reconstruct(m1, basis) -> None:
     c1 = cirq.expand_matrix_in_orthogonal_basis(m1, basis)
     m2 = cirq.matrix_from_basis_coefficients(c1, basis)
     c2 = cirq.expand_matrix_in_orthogonal_basis(m2, basis)
@@ -299,7 +299,7 @@ def test_expand_is_inverse_of_reconstruct(m1, basis):
         (0, 1, 2, 3, 4, 5, 100, 101),
     ),
 )
-def test_pow_pauli_combination(coefficients, exponent):
+def test_pow_pauli_combination(coefficients, exponent) -> None:
     is_symbolic = any(isinstance(a, sympy.Basic) for a in coefficients)
     if is_symbolic and exponent > 2:
         return  # too slow

cirq/linalg/tolerance_test.py

@@ -15,7 +15,7 @@
 from cirq.linalg.tolerance import all_near_zero, all_near_zero_mod, near_zero, near_zero_mod
 
 
-def test_all_zero():
+def test_all_zero() -> None:
     atol = 5
     assert all_near_zero(0, atol=atol)
     assert all_near_zero(4.5, atol=atol)
@@ -25,7 +25,7 @@ def test_all_zero():
     assert not all_near_zero([-4.5, 0, 1, 4.5, 30], atol=atol)
 
 
-def test_all_zero_mod():
+def test_all_zero_mod() -> None:
     atol = 5
     assert all_near_zero_mod(0, 100, atol=atol)
     assert all_near_zero_mod(4.5, 100, atol=atol)
@@ -45,14 +45,14 @@ def test_all_zero_mod():
     assert not all_near_zero_mod([-4.5, 0, 1, 4.5, 30], 100, atol=atol)
 
 
-def test_near_zero():
+def test_near_zero() -> None:
     atol = 5
     assert near_zero(0, atol=atol)
     assert near_zero(4.5, atol=atol)
     assert not near_zero(5.5, atol=atol)
 
 
-def test_near_zero_mod():
+def test_near_zero_mod() -> None:
     atol = 5
     assert near_zero_mod(0, 100, atol=atol)
     assert near_zero_mod(4.5, 100, atol=atol)

cirq/neutral_atoms/convert_to_neutral_atom_gates_test.py

@@ -43,7 +43,7 @@ Q, Q2, Q3 = cirq.LineQubit.range(3)
         (cirq.ZPowGate(exponent=0.5)(Q).controlled_by(Q2, Q3), False),
     ],
 )
-def test_gateset(op: cirq.Operation, expected: bool):
+def test_gateset(op: cirq.Operation, expected: bool) -> None:
     assert cirq.is_native_neutral_atom_op(op) == expected
     if op.gate is not None:
         assert cirq.is_native_neutral_atom_gate(op.gate) == expected

cirq/ops/arithmetic_operation_test.py

@@ -36,7 +36,7 @@ def adder_matrix(target_width: int, source_width: int) -> np.ndarray:
     return result
 
 
-def test_the_tests():
+def test_the_tests() -> None:
     # fmt: off
     np.testing.assert_allclose(
         shift_matrix(4, 1),
@@ -85,7 +85,7 @@ def test_the_tests():
     )
 
 
-def test_arithmetic_gate_apply_unitary():
+def test_arithmetic_gate_apply_unitary() -> None:
     class Add(cirq.ArithmeticGate):
         def __init__(
             self,