cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/transformers/align_test.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import cirq
 
 
-def test_align_basic_no_context():
+def test_align_basic_no_context() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     c = cirq.Circuit(
@@ -45,7 +45,7 @@ def test_align_basic_no_context():
     )
 
 
-def test_align_left_no_compile_context():
+def test_align_left_no_compile_context() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     cirq.testing.assert_same_circuits(
@@ -59,7 +59,7 @@ def test_align_left_no_compile_context():
                     cirq.measure(*[q1, q2], key='a'),
                 ]
             ),
-            context=cirq.TransformerContext(tags_to_ignore=["nocompile"]),
+            context=cirq.TransformerContext(tags_to_ignore=("nocompile",)),
         ),
         cirq.Circuit(
             [
@@ -73,7 +73,7 @@ def test_align_left_no_compile_context():
     )
 
 
-def test_align_left_deep():
+def test_align_left_deep() -> None:
     q1, q2 = cirq.LineQubit.range(2)
     c_nested = cirq.FrozenCircuit(
         [
@@ -104,11 +104,11 @@ def test_align_left_deep():
         c_nested_aligned,
         cirq.CircuitOperation(c_nested_aligned).repeat(5).with_tags("preserve_tag"),
     )
-    context = cirq.TransformerContext(tags_to_ignore=["nocompile"], deep=True)
+    context = cirq.TransformerContext(tags_to_ignore=("nocompile",), deep=True)
     cirq.testing.assert_same_circuits(cirq.align_left(c_orig, context=context), c_expected)
 
 
-def test_align_left_subset_of_operations():
+def test_align_left_subset_of_operations() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     tag = "op_to_align"
@@ -134,7 +134,7 @@ def test_align_left_subset_of_operations():
         cirq.toggle_tags(
             cirq.align_left(
                 cirq.toggle_tags(c_orig, [tag]),
-                context=cirq.TransformerContext(tags_to_ignore=[tag]),
+                context=cirq.TransformerContext(tags_to_ignore=(tag,)),
             ),
             [tag],
         ),
@@ -142,7 +142,7 @@ def test_align_left_subset_of_operations():
     )
 
 
-def test_align_right_no_compile_context():
+def test_align_right_no_compile_context() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     cirq.testing.assert_same_circuits(
@@ -156,7 +156,7 @@ def test_align_right_no_compile_context():
                     cirq.measure(*[q1, q2], key='a'),
                 ]
             ),
-            context=cirq.TransformerContext(tags_to_ignore=["nocompile"]),
+            context=cirq.TransformerContext(tags_to_ignore=("nocompile",)),
         ),
         cirq.Circuit(
             [
@@ -170,7 +170,7 @@ def test_align_right_no_compile_context():
     )
 
 
-def test_align_right_deep():
+def test_align_right_deep() -> None:
     q1, q2 = cirq.LineQubit.range(2)
     c_nested = cirq.FrozenCircuit(
         cirq.Moment([cirq.X(q1)]),
@@ -199,11 +199,11 @@ def test_align_right_deep():
         c_nested_aligned,
         cirq.CircuitOperation(c_nested_aligned).repeat(5).with_tags("preserve_tag"),
     )
-    context = cirq.TransformerContext(tags_to_ignore=["nocompile"], deep=True)
+    context = cirq.TransformerContext(tags_to_ignore=("nocompile",), deep=True)
     cirq.testing.assert_same_circuits(cirq.align_right(c_orig, context=context), c_expected)
 
 
-def test_classical_control():
+def test_classical_control() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.H(q0), cirq.measure(q0, key='m'), cirq.X(q1).with_classical_controls('m')
@@ -212,7 +212,7 @@ def test_classical_control():
     cirq.testing.assert_same_circuits(cirq.align_right(circuit), circuit)
 
 
-def test_measurement_and_classical_control_same_moment_preserve_order():
+def test_measurement_and_classical_control_same_moment_preserve_order() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     op_measure = cirq.measure(q0, key='m')

cirq/transformers/analytical_decompositions/clifford_decomposition.py

@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 import functools
+from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -31,7 +32,7 @@ def _X(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.X, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.X(qubits[q]))
@@ -41,7 +42,7 @@ def _Z(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.Z, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.Z(qubits[q]))
@@ -51,7 +52,7 @@ def _Sdg(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     # Apply the tableau with S^\{dagger}
     protocols.act_on(ops.S**-1, args, qubits=[qubits[q]], allow_decompose=False)
@@ -62,7 +63,7 @@ def _H(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.H, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.H(qubits[q]))
@@ -73,7 +74,7 @@ def _CNOT(
     q2: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.CNOT, args, qubits=[qubits[q1], qubits[q2]], allow_decompose=False)
     operations.append(ops.CNOT(qubits[q1], qubits[q2]))
@@ -84,14 +85,14 @@ def _SWAP(
     q2: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.SWAP, args, qubits=[qubits[q1], qubits[q2]], allow_decompose=False)
     operations.append(ops.SWAP(qubits[q1], qubits[q2]))
 
 
 def decompose_clifford_tableau_to_operations(
-    qubits: list[cirq.Qid], clifford_tableau: qis.CliffordTableau
+    qubits: Sequence[cirq.Qid], clifford_tableau: qis.CliffordTableau
 ) -> list[ops.Operation]:
     """Decompose an n-qubit Clifford Tableau into a list of one/two qubit operations.
 

cirq/transformers/analytical_decompositions/clifford_decomposition_test.py

@@ -21,14 +21,14 @@ import cirq
 from cirq.testing import assert_allclose_up_to_global_phase
 
 
-def test_misaligned_qubits():
+def test_misaligned_qubits() -> None:
     qubits = cirq.LineQubit.range(1)
     tableau = cirq.CliffordTableau(num_qubits=2)
     with pytest.raises(ValueError):
         cirq.decompose_clifford_tableau_to_operations(qubits, tableau)
 
 
-def test_clifford_decompose_one_qubit():
+def test_clifford_decompose_one_qubit() -> None:
     """Two random instance for one qubit decomposition."""
     qubits = cirq.LineQubit.range(1)
     args = cirq.CliffordTableauSimulationState(
@@ -63,7 +63,7 @@ def test_clifford_decompose_one_qubit():
     assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7)
 
 
-def test_clifford_decompose_two_qubits():
+def test_clifford_decompose_two_qubits() -> None:
     """Two random instance for two qubits decomposition."""
     qubits = cirq.LineQubit.range(2)
     args = cirq.CliffordTableauSimulationState(
@@ -98,7 +98,7 @@ def test_clifford_decompose_two_qubits():
     assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7)
 
 
-def test_clifford_decompose_by_unitary():
+def test_clifford_decompose_by_unitary() -> None:
     """Validate the decomposition of random Clifford Tableau by unitary matrix.
 
     Due to the exponential growth in dimension, it cannot validate very large number of qubits.
@@ -125,7 +125,7 @@ def test_clifford_decompose_by_unitary():
         assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7)
 
 
-def test_clifford_decompose_by_reconstruction():
+def test_clifford_decompose_by_reconstruction() -> None:
     """Validate the decomposition of random Clifford Tableau by reconstruction.
 
     This approach can validate large number of qubits compared with the unitary one.

cirq/transformers/analytical_decompositions/controlled_gate_decomposition.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import itertools
+from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -114,7 +115,7 @@ def _ccnot_congruent(c0: cirq.Qid, c1: cirq.Qid, target: cirq.Qid) -> list[cirq.
 
 
 def decompose_multi_controlled_x(
-    controls: list[cirq.Qid], target: cirq.Qid, free_qubits: list[cirq.Qid]
+    controls: Sequence[cirq.Qid], target: cirq.Qid, free_qubits: Sequence[cirq.Qid]
 ) -> list[cirq.Operation]:
     """Implements action of multi-controlled Pauli X gate.
 
@@ -152,11 +153,11 @@ def decompose_multi_controlled_x(
     elif len(free_qubits) >= 1:
         # See [1], Lemma 7.3.
         m1 = n // 2
-        free1 = controls[m1:] + [target] + free_qubits[1:]
+        free1 = [*controls[m1:], target, *free_qubits[1:]]
         ctrl1 = controls[:m1]
         part1 = decompose_multi_controlled_x(ctrl1, free_qubits[0], free1)
-        free2 = controls[:m1] + free_qubits[1:]
-        ctrl2 = controls[m1:] + [free_qubits[0]]
+        free2 = [*controls[:m1], *free_qubits[1:]]
+        ctrl2 = [*controls[m1:], free_qubits[0]]
         part2 = decompose_multi_controlled_x(ctrl2, target, free2)
         return [*part1, *part2, *part1, *part2]
     else:
@@ -167,7 +168,7 @@ def decompose_multi_controlled_x(
 
 
 def _decompose_su(
-    matrix: np.ndarray, controls: list[cirq.Qid], target: cirq.Qid
+    matrix: np.ndarray, controls: Sequence[cirq.Qid], target: cirq.Qid
 ) -> list[cirq.Operation]:
     """Decomposes controlled special unitary gate into elementary gates.
 
@@ -193,9 +194,9 @@ def _decompose_su(
 def _decompose_recursive(
     matrix: np.ndarray,
     power: float,
-    controls: list[cirq.Qid],
+    controls: Sequence[cirq.Qid],
     target: cirq.Qid,
-    free_qubits: list[cirq.Qid],
+    free_qubits: Sequence[cirq.Qid],
 ) -> list[cirq.Operation]:
     """Decomposes controlled unitary gate into elementary gates.
 
@@ -205,20 +206,20 @@ def _decompose_recursive(
     if len(controls) == 1:
         return _decompose_single_ctrl(_unitary_power(matrix, power), controls[0], target)
 
-    cnots = decompose_multi_controlled_x(controls[:-1], controls[-1], free_qubits + [target])
+    cnots = decompose_multi_controlled_x(controls[:-1], controls[-1], [*free_qubits, target])
     return [
         *_decompose_single_ctrl(_unitary_power(matrix, 0.5 * power), controls[-1], target),
         *cnots,
         *_decompose_single_ctrl(_unitary_power(matrix, -0.5 * power), controls[-1], target),
         *cnots,
         *_decompose_recursive(
-            matrix, 0.5 * power, controls[:-1], target, [controls[-1]] + free_qubits
+            matrix, 0.5 * power, controls[:-1], target, [controls[-1], *free_qubits]
         ),
     ]
 
 
 def decompose_multi_controlled_rotation(
-    matrix: np.ndarray, controls: list[cirq.Qid], target: cirq.Qid
+    matrix: np.ndarray, controls: Sequence[cirq.Qid], target: cirq.Qid
 ) -> list[cirq.Operation]:
     """Implements action of multi-controlled unitary gate.
 

cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py

@@ -20,7 +20,7 @@ import scipy.stats
 import cirq
 
 
-def test_decompose_x():
+def test_decompose_x() -> None:
     """Verifies correctness of multi-controlled X decomposition."""
     for total_qubits_count in range(1, 8):
         qubits = cirq.LineQubit.range(total_qubits_count)
@@ -83,14 +83,14 @@ def _test_decompose(matrix, controls_count):
     cirq.testing.assert_allclose_up_to_global_phase(expected_matrix, result_matrix, atol=1e-8)
 
 
-def test_decompose_specific_matrices():
+def test_decompose_specific_matrices() -> None:
     for gate in [cirq.X, cirq.Y, cirq.Z, cirq.H, cirq.I, cirq.T, cirq.S]:
         for controls_count in range(7):
             _test_decompose(cirq.unitary(gate), controls_count)
 
 
 @cirq.testing.retry_once_with_later_random_values
-def test_decompose_random_unitary():
+def test_decompose_random_unitary() -> None:
     for controls_count in range(5):
         for _ in range(10):
             _test_decompose(_random_unitary(), controls_count)
@@ -99,7 +99,7 @@ def test_decompose_random_unitary():
 
 
 @cirq.testing.retry_once_with_later_random_values
-def test_decompose_random_special_unitary():
+def test_decompose_random_special_unitary() -> None:
     for controls_count in range(5):
         for _ in range(10):
             _test_decompose(_random_special_unitary(), controls_count)
@@ -113,7 +113,7 @@ def _decomposition_size(U, controls_count):
     return _count_operations(operations)
 
 
-def test_decompose_size_special_unitary():
+def test_decompose_size_special_unitary() -> None:
     np.random.seed(0)
     u = _random_special_unitary()
     assert _decomposition_size(u, 0) == (1, 0, 0)
@@ -126,7 +126,7 @@ def test_decompose_size_special_unitary():
         assert _decomposition_size(u, i) == (64 * i - 312, 48 * i - 234, 16)
 
 
-def test_decompose_size_unitary():
+def test_decompose_size_unitary() -> None:
     np.random.seed(0)
     u = _random_unitary()
     assert _decomposition_size(u, 0) == (1, 0, 0)

cirq/transformers/analytical_decompositions/cphase_to_fsim.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Sequence, TYPE_CHECKING
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -100,7 +101,7 @@ def decompose_cphase_into_two_fsim(
     fsim_gate: cirq.FSimGate,
     qubits: Sequence[cirq.Qid] | None = None,
     atol: float = 1e-8,
-) -> cirq.OP_TREE:
+) -> Sequence[cirq.Operation]:
     """Decomposes CZPowGate into two FSimGates.
 
     This function implements the decomposition described in section VII F I

cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Sequence
+from collections.abc import Sequence
 
 import numpy as np
 import pytest
@@ -24,7 +24,7 @@ import sympy
 import cirq
 
 
-def test_symbols():
+def test_symbols() -> None:
     with pytest.raises(ValueError, match='Symbolic arguments'):
         cirq.compute_cphase_exponents_for_fsim_decomposition(
             cirq.FSimGate(theta=sympy.Symbol('t'), phi=sympy.Symbol('phi'))
@@ -36,8 +36,9 @@ class FakeSycamoreGate(cirq.FSimGate):
         super().__init__(theta=np.pi / 2, phi=np.pi / 6)
 
 
-def test_parameterized_gates():
+def test_parameterized_gates() -> None:
     t = sympy.Symbol('t')
+    fsim_gate: cirq.FSimGate
     with pytest.raises(ValueError):
         cphase_gate = cirq.CZPowGate(exponent=t)
         fsim_gate = FakeSycamoreGate()
@@ -54,14 +55,14 @@ def test_parameterized_gates():
         cirq.decompose_cphase_into_two_fsim(cphase_gate, fsim_gate=fsim_gate)
 
 
-def test_invalid_qubits():
+def test_invalid_qubits() -> None:
     with pytest.raises(ValueError):
         cirq.decompose_cphase_into_two_fsim(
             cphase_gate=cirq.CZ, fsim_gate=FakeSycamoreGate(), qubits=cirq.LineQubit.range(3)
         )
 
 
-def test_circuit_structure():
+def test_circuit_structure() -> None:
     syc = FakeSycamoreGate()
     ops = cirq.decompose_cphase_into_two_fsim(cirq.CZ, fsim_gate=syc)
     num_interaction_moments = 0
@@ -73,7 +74,7 @@ def test_circuit_structure():
     assert num_interaction_moments == 2
 
 
-def assert_decomposition_valid(cphase_gate, fsim_gate):
+def assert_decomposition_valid(cphase_gate, fsim_gate) -> None:
     u_expected = cirq.unitary(cphase_gate)
     ops = cirq.decompose_cphase_into_two_fsim(cphase_gate, fsim_gate=fsim_gate)
     u_actual = cirq.unitary(cirq.Circuit(ops))
@@ -83,7 +84,7 @@ def assert_decomposition_valid(cphase_gate, fsim_gate):
 @pytest.mark.parametrize(
     'exponent', (-5.5, -3, -1.5, -1, -0.65, -0.2, 0, 0.1, 0.75, 1, 1.5, 2, 5.5)
 )
-def test_decomposition_to_sycamore_gate(exponent):
+def test_decomposition_to_sycamore_gate(exponent) -> None:
     cphase_gate = cirq.CZPowGate(exponent=exponent)
     assert_decomposition_valid(cphase_gate, FakeSycamoreGate())
 
@@ -95,7 +96,7 @@ def test_decomposition_to_sycamore_gate(exponent):
         (-1.4 * np.pi, -np.pi / 9, np.pi / 11, np.pi / 2, 2.4 * np.pi),
     ),
 )
-def test_valid_cphase_exponents(theta, phi):
+def test_valid_cphase_exponents(theta, phi) -> None:
     fsim_gate = cirq.FSimGate(theta=theta, phi=phi)
     valid_exponent_intervals = cirq.compute_cphase_exponents_for_fsim_decomposition(fsim_gate)
     assert valid_exponent_intervals
@@ -131,7 +132,7 @@ def complement_intervals(intervals: Sequence[tuple[float, float]]) -> Sequence[t
         (-1.7 * np.pi, -np.pi / 5, np.pi / 7, 2.5 * np.pi),
     ),
 )
-def test_invalid_cphase_exponents(theta, phi):
+def test_invalid_cphase_exponents(theta, phi) -> None:
     fsim_gate = cirq.FSimGate(theta=theta, phi=phi)
     valid_exponent_intervals = cirq.compute_cphase_exponents_for_fsim_decomposition(fsim_gate)
     invalid_exponent_intervals = complement_intervals(valid_exponent_intervals)
@@ -151,6 +152,6 @@ def test_invalid_cphase_exponents(theta, phi):
 @pytest.mark.parametrize(
     'bad_fsim_gate', (cirq.FSimGate(theta=0, phi=0), cirq.FSimGate(theta=np.pi / 4, phi=np.pi / 2))
 )
-def test_invalid_fsim_gate(bad_fsim_gate):
+def test_invalid_fsim_gate(bad_fsim_gate) -> None:
     with pytest.raises(ValueError):
         cirq.decompose_cphase_into_two_fsim(cirq.CZ, fsim_gate=bad_fsim_gate)

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py

@@ -21,10 +21,11 @@ https://arxiv.org/abs/quant-ph/0406176
 
 from __future__ import annotations
 
-from typing import Callable, cast, Iterable, TYPE_CHECKING
+from collections.abc import Callable, Iterable, Sequence
+from typing import cast, TYPE_CHECKING
 
+import attrs
 import numpy as np
-from attr import define
 from scipy.linalg import cossin
 
 from cirq import ops
@@ -40,14 +41,14 @@ if TYPE_CHECKING:
     import cirq
 
 
-@define
+@attrs.define
 class _TwoQubitGate:
     location: int
     matrix: np.ndarray
 
 
 def quantum_shannon_decomposition(
-    qubits: list[cirq.Qid], u: np.ndarray, atol: float = 1e-8
+    qubits: Sequence[cirq.Qid], u: np.ndarray, atol: float = 1e-8
 ) -> Iterable[cirq.Operation]:
     """Decomposes n-qubit unitary 1-q, 2-q and GlobalPhase gates, preserving global phase.
 
@@ -149,7 +150,7 @@ def quantum_shannon_decomposition(
     yield from cast(Iterable[ops.Operation], ops.flatten_op_tree(shannon_decomp))
 
 
-def _recursive_decomposition(qubits: list[cirq.Qid], u: np.ndarray) -> Iterable[cirq.Operation]:
+def _recursive_decomposition(qubits: Sequence[cirq.Qid], u: np.ndarray) -> Iterable[cirq.Operation]:
     """Recursive step in the quantum shannon decomposition.
 
     Decomposes n-qubit unitary into generic 2-qubit gates, CNOT, CZ and 1-qubit gates.
@@ -270,7 +271,7 @@ def _single_qubit_decomposition(qubit: cirq.Qid, u: np.ndarray) -> Iterable[cirq
 
 
 def _msb_demuxer(
-    demux_qubits: list[cirq.Qid], u1: np.ndarray, u2: np.ndarray
+    demux_qubits: Sequence[cirq.Qid], u1: np.ndarray, u2: np.ndarray
 ) -> Iterable[cirq.Operation]:
     """Demultiplexes a unitary matrix that is multiplexed in its most-significant-qubit.
 
@@ -336,7 +337,7 @@ def _nth_gray(n: int) -> int:
 
 
 def _multiplexed_cossin(
-    cossin_qubits: list[cirq.Qid], angles: list[float], rot_func: Callable = ops.ry
+    cossin_qubits: Sequence[cirq.Qid], angles: list[float], rot_func: Callable = ops.ry
 ) -> Iterable[cirq.Operation]:
     """Performs a multiplexed rotation over all qubits in this unitary matrix,
 

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition_test.py

@@ -31,9 +31,8 @@ from cirq.transformers.analytical_decompositions.quantum_shannon_decomposition i
 )
 
 
-@pytest.mark.xfail(reason='#6765')
 @pytest.mark.parametrize('n_qubits', list(range(1, 8)))
-def test_random_qsd_n_qubit(n_qubits):
+def test_random_qsd_n_qubit(n_qubits) -> None:
     U = unitary_group.rvs(2**n_qubits)
     qubits = [cirq.NamedQubit(f'q{i}') for i in range(n_qubits)]
     circuit = cirq.Circuit(quantum_shannon_decomposition(qubits, U))
@@ -43,7 +42,7 @@ def test_random_qsd_n_qubit(n_qubits):
     assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())
 
 
-def test_qsd_n_qubit_errors():
+def test_qsd_n_qubit_errors() -> None:
     qubits = [cirq.NamedQubit(f'q{i}') for i in range(3)]
     with pytest.raises(ValueError, match="shaped numpy array"):
         cirq.Circuit(quantum_shannon_decomposition(qubits, np.eye(9)))
@@ -51,7 +50,7 @@ def test_qsd_n_qubit_errors():
         cirq.Circuit(quantum_shannon_decomposition(qubits, np.ones((8, 8))))
 
 
-def test_recursive_decomposition_n_qubit_errors():
+def test_recursive_decomposition_n_qubit_errors() -> None:
     qubits = [cirq.NamedQubit(f'q{i}') for i in range(3)]
     with pytest.raises(ValueError, match="shaped numpy array"):
         cirq.Circuit(_recursive_decomposition(qubits, np.eye(9)))
@@ -59,7 +58,7 @@ def test_recursive_decomposition_n_qubit_errors():
         cirq.Circuit(_recursive_decomposition(qubits, np.eye(2)))
 
 
-def test_random_single_qubit_decomposition():
+def test_random_single_qubit_decomposition() -> None:
     U = unitary_group.rvs(2)
     qubit = cirq.NamedQubit('q0')
     circuit = cirq.Circuit(_single_qubit_decomposition(qubit, U))
@@ -69,7 +68,7 @@ def test_random_single_qubit_decomposition():
     assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())
 
 
-def test_msb_demuxer():
+def test_msb_demuxer() -> None:
     U1 = unitary_group.rvs(4)
     U2 = unitary_group.rvs(4)
     U_full = np.kron([[1, 0], [0, 0]], U1) + np.kron([[0, 0], [0, 1]], U2)
@@ -81,13 +80,12 @@ def test_msb_demuxer():
     assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())
 
 
-def test_multiplexed_cossin():
+def test_multiplexed_cossin() -> None:
     angle_1 = np.random.random_sample() * 2 * np.pi
     angle_2 = np.random.random_sample() * 2 * np.pi
     c1, s1 = np.cos(angle_1), np.sin(angle_1)
     c2, s2 = np.cos(angle_2), np.sin(angle_2)
-    multiplexed_ry = [[c1, 0, -s1, 0], [0, c2, 0, -s2], [s1, 0, c1, 0], [0, s2, 0, c2]]
-    multiplexed_ry = np.array(multiplexed_ry)
+    multiplexed_ry = np.asarray([[c1, 0, -s1, 0], [0, c2, 0, -s2], [s1, 0, c1, 0], [0, s2, 0, c2]])
     qubits = [cirq.NamedQubit(f'q{i}') for i in range(2)]
     circuit = cirq.Circuit(_multiplexed_cossin(qubits, [angle_1, angle_2]))
     # Add back the CZ gate removed by the A.1 optimization
@@ -126,11 +124,11 @@ def test_multiplexed_cossin():
         (15, 8),
     ],
 )
-def test_nth_gray(n, gray):
+def test_nth_gray(n, gray) -> None:
     assert _nth_gray(n) == gray
 
 
-def test_ghz_circuit_decomposes():
+def test_ghz_circuit_decomposes() -> None:
     # Test case from #6725
     ghz_circuit = cirq.Circuit(cirq.H(cirq.q(0)), cirq.CNOT(cirq.q(0), cirq.q(1)))
     ghz_unitary = cirq.unitary(ghz_circuit)
@@ -141,7 +139,7 @@ def test_ghz_circuit_decomposes():
     np.testing.assert_allclose(new_unitary, ghz_unitary, atol=1e-6)
 
 
-def test_qft_decomposes():
+def test_qft_decomposes() -> None:
     # Test case from #6666
     qs = cirq.LineQubit.range(4)
     qft_circuit = cirq.Circuit(cirq.qft(*qs))
@@ -163,7 +161,7 @@ def test_qft_decomposes():
         (cirq.S, 1),  # rz & ry
     ],
 )
-def test_cliffords(gate, num_ops):
+def test_cliffords(gate, num_ops) -> None:
     desired_unitary = cirq.unitary(gate)
     shannon_circuit = cirq.Circuit(quantum_shannon_decomposition((cirq.q(0),), desired_unitary))
     new_unitary = cirq.unitary(shannon_circuit)
@@ -173,7 +171,7 @@ def test_cliffords(gate, num_ops):
 
 
 @pytest.mark.parametrize('gate', [cirq.X, cirq.Y, cirq.Z, cirq.H, cirq.S])
-def test_cliffords_with_global_phase(gate):
+def test_cliffords_with_global_phase(gate) -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0.1, 2 * np.pi, 10)))
     desired_unitary = cirq.unitary(gate) * global_phase
     shannon_circuit = cirq.Circuit(quantum_shannon_decomposition((cirq.q(0),), desired_unitary))
@@ -181,7 +179,7 @@ def test_cliffords_with_global_phase(gate):
     np.testing.assert_allclose(new_unitary, desired_unitary)
 
 
-def test_global_phase():
+def test_global_phase() -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
     shannon_circuit = cirq.Circuit(
         quantum_shannon_decomposition((cirq.q(0),), np.eye(2) * global_phase)
@@ -191,7 +189,7 @@ def test_global_phase():
 
 
 @pytest.mark.parametrize('gate', [cirq.CZ, cirq.CNOT, cirq.XX, cirq.YY, cirq.ZZ])
-def test_two_qubit_gate(gate):
+def test_two_qubit_gate(gate) -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
     desired_unitary = cirq.unitary(gate) * global_phase
     shannon_circuit = cirq.Circuit(
@@ -202,7 +200,7 @@ def test_two_qubit_gate(gate):
 
 
 @pytest.mark.parametrize('gate', [cirq.CCNOT, cirq.qft(*cirq.LineQubit.range(3))])
-def test_three_qubit_gate(gate):
+def test_three_qubit_gate(gate) -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
     desired_unitary = cirq.unitary(gate) * global_phase
     shannon_circuit = cirq.Circuit(
@@ -212,8 +210,7 @@ def test_three_qubit_gate(gate):
     np.testing.assert_allclose(new_unitary, desired_unitary, atol=1e-6)
 
 
-@pytest.mark.xfail(reason='#6765')
-def test_qft5():
+def test_qft5() -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
     desired_unitary = cirq.unitary(cirq.qft(*cirq.LineQubit.range(5))) * global_phase
     shannon_circuit = cirq.Circuit(
@@ -223,7 +220,7 @@ def test_qft5():
     np.testing.assert_allclose(new_unitary, desired_unitary, atol=1e-6)
 
 
-def test_random_circuit_decomposition():
+def test_random_circuit_decomposition() -> None:
     qubits = cirq.LineQubit.range(3)
     test_circuit = (
         random_two_qubit_circuit_with_czs(3, qubits[0], qubits[1])