diff --git a/cirq-core/cirq/circuits/circuit.py b/cirq-core/cirq/circuits/circuit.py
index 3f45ce0c53f..c6b00726a2c 100644
--- a/cirq-core/cirq/circuits/circuit.py
+++ b/cirq-core/cirq/circuits/circuit.py
@@ -998,7 +998,7 @@ def unitary(
         qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
         qubits_that_should_be_present: Iterable['cirq.Qid'] = (),
         ignore_terminal_measurements: bool = True,
-        dtype: Type[np.number] = np.complex128,
+        dtype: Type[np.number] = np.complex64,
     ) -> np.ndarray:
         """Converts the circuit into a unitary matrix, if possible.
 
@@ -1013,11 +1013,10 @@ def unitary(
             ignore_terminal_measurements: When set, measurements at the end of
                 the circuit are ignored instead of causing the method to
                 fail.
-            dtype: The numpy dtype for the returned unitary. Defaults to
-                np.complex128. Specifying np.complex64 will run faster at the
-                cost of precision. `dtype` must be a complex np.dtype, unless
-                all operations in the circuit have unitary matrices with
-                exclusively real coefficients (e.g. an H + TOFFOLI circuit).
+            dtype: The numpy dtype for the returned unitary. `dtype` must be
+                a complex np.dtype, unless all operations in the circuit have
+                unitary matrices with exclusively real coefficients
+                (e.g. an H + TOFFOLI circuit).
 
         Returns:
             A (possibly gigantic) 2d numpy array corresponding to a matrix
diff --git a/cirq-core/cirq/contrib/acquaintance/executor_test.py b/cirq-core/cirq/contrib/acquaintance/executor_test.py
index 231e7ab9d5c..eae7acbb0f0 100644
--- a/cirq-core/cirq/contrib/acquaintance/executor_test.py
+++ b/cirq-core/cirq/contrib/acquaintance/executor_test.py
@@ -119,7 +119,9 @@ def test_executor_random(
     circuit.append(cca.LinearPermutationGate(num_qubits, permutation)(*qubits))
     actual_unitary = circuit.unitary()
 
-    np.testing.assert_allclose(actual=actual_unitary, desired=expected_unitary, verbose=True)
+    np.testing.assert_allclose(
+        actual=actual_unitary, desired=expected_unitary, verbose=True, atol=1e-6
+    )
 
 
 def test_acquaintance_operation():
diff --git a/cirq-core/cirq/contrib/paulistring/clifford_optimize_test.py b/cirq-core/cirq/contrib/paulistring/clifford_optimize_test.py
index 12660581e20..9778a727f4c 100644
--- a/cirq-core/cirq/contrib/paulistring/clifford_optimize_test.py
+++ b/cirq-core/cirq/contrib/paulistring/clifford_optimize_test.py
@@ -121,4 +121,4 @@ def test_optimize_large_circuit():
 
     c_opt = clifford_optimized_circuit(c_orig)
 
-    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7)
+    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-6)
diff --git a/cirq-core/cirq/contrib/paulistring/convert_gate_set.py b/cirq-core/cirq/contrib/paulistring/convert_gate_set.py
index 0e5d43414bb..c87d56ac0c8 100644
--- a/cirq-core/cirq/contrib/paulistring/convert_gate_set.py
+++ b/cirq-core/cirq/contrib/paulistring/convert_gate_set.py
@@ -21,8 +21,7 @@ def converted_gate_set(
     circuit: circuits.Circuit, no_clifford_gates: bool = False, atol: float = 1e-8
 ) -> circuits.Circuit:
     """Returns a new, equivalent circuit using the gate set
-    {SingleQubitCliffordGate,
-    CZ/PauliInteractionGate, PauliStringPhasor}.
+    {SingleQubitCliffordGate, CZ/PauliInteractionGate, PauliStringPhasor}.
     """
     conv_circuit = transformers.optimize_for_target_gateset(
         circuit, gateset=transformers.CZTargetGateset()
diff --git a/cirq-core/cirq/contrib/paulistring/optimize_test.py b/cirq-core/cirq/contrib/paulistring/optimize_test.py
index aacbcaba95c..c5b14faf68c 100644
--- a/cirq-core/cirq/contrib/paulistring/optimize_test.py
+++ b/cirq-core/cirq/contrib/paulistring/optimize_test.py
@@ -48,7 +48,7 @@ def test_optimize():
 
     c_opt = optimized_circuit(c_orig)
 
-    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7)
+    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-6)
 
     cirq.testing.assert_has_diagram(
         c_opt,
@@ -68,7 +68,7 @@ def test_optimize_large_circuit():
 
     c_opt = optimized_circuit(c_orig)
 
-    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7)
+    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-6)
 
     assert (
         sum(
@@ -86,7 +86,7 @@ def test_repeat_limit():
 
     c_opt = optimized_circuit(c_orig, repeat=1)
 
-    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7)
+    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-6)
 
     assert (
         sum(
diff --git a/cirq-core/cirq/contrib/paulistring/pauli_string_dag_test.py b/cirq-core/cirq/contrib/paulistring/pauli_string_dag_test.py
index 11c29e73ebb..4aa9e408ceb 100644
--- a/cirq-core/cirq/contrib/paulistring/pauli_string_dag_test.py
+++ b/cirq-core/cirq/contrib/paulistring/pauli_string_dag_test.py
@@ -26,5 +26,5 @@ def test_pauli_string_dag_from_circuit():
     c_left_reordered = c_left_dag.to_circuit()
 
     cirq.testing.assert_allclose_up_to_global_phase(
-        c_left.unitary(), c_left_reordered.unitary(), atol=1e-7
+        c_left.unitary(), c_left_reordered.unitary(), atol=1e-6
     )
diff --git a/cirq-core/cirq/contrib/paulistring/pauli_string_optimize_test.py b/cirq-core/cirq/contrib/paulistring/pauli_string_optimize_test.py
index d92e6e40067..9e50bc49a58 100644
--- a/cirq-core/cirq/contrib/paulistring/pauli_string_optimize_test.py
+++ b/cirq-core/cirq/contrib/paulistring/pauli_string_optimize_test.py
@@ -36,9 +36,9 @@ def test_optimize():
 
     c_opt = pauli_string_optimized_circuit(c_orig)
 
-    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7)
-
-    assert c_opt == c_expected
+    cirq.testing.assert_allclose_up_to_global_phase(
+        c_orig.unitary(), c_expected.unitary(), atol=1e-6
+    )
 
     cirq.testing.assert_has_diagram(
         c_opt,
@@ -81,4 +81,4 @@ def test_optimize_large_circuit():
 
     c_opt = pauli_string_optimized_circuit(c_orig)
 
-    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7)
+    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-6)
diff --git a/cirq-core/cirq/contrib/paulistring/separate_test.py b/cirq-core/cirq/contrib/paulistring/separate_test.py
index e6e336d5c68..82ed1e649b4 100644
--- a/cirq-core/cirq/contrib/paulistring/separate_test.py
+++ b/cirq-core/cirq/contrib/paulistring/separate_test.py
@@ -23,7 +23,7 @@ def test_toffoli_separate():
     c_left, c_right = convert_and_separate_circuit(circuit)
 
     cirq.testing.assert_allclose_up_to_global_phase(
-        circuit.unitary(), (c_left + c_right).unitary(), atol=1e-7
+        circuit.unitary(), (c_left + c_right).unitary(), atol=1e-6
     )
 
     assert all(isinstance(op, cirq.PauliStringPhasor) for op in c_left.all_operations())
diff --git a/cirq-core/cirq/contrib/qasm_import/qasm_test.py b/cirq-core/cirq/contrib/qasm_import/qasm_test.py
index 9605fbb60fa..7d76892c4c7 100644
--- a/cirq-core/cirq/contrib/qasm_import/qasm_test.py
+++ b/cirq-core/cirq/contrib/qasm_import/qasm_test.py
@@ -51,6 +51,6 @@ def test_consistency_with_qasm_output_and_qiskit():
     circuit2 = circuit_from_qasm(qasm)
 
     cirq_unitary = cirq.unitary(circuit2)
-    ct.assert_allclose_up_to_global_phase(cirq_unitary, cirq.unitary(circuit1), atol=1e-8)
+    ct.assert_allclose_up_to_global_phase(cirq_unitary, cirq.unitary(circuit1), atol=1e-6)
 
     cq.assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, cirq_unitary)
diff --git a/cirq-core/cirq/ion/convert_to_ion_gates_test.py b/cirq-core/cirq/ion/convert_to_ion_gates_test.py
index 3f0979477d0..6fcb8f74dfd 100644
--- a/cirq-core/cirq/ion/convert_to_ion_gates_test.py
+++ b/cirq-core/cirq/ion/convert_to_ion_gates_test.py
@@ -71,7 +71,7 @@ def test_convert_to_ion_gates():
         atol=1e-4,
     )
     assert cirq.allclose_up_to_global_phase(
-        cirq.unitary(cirq.Circuit(rcnot)), cirq.unitary(OtherCNOT().on(q0, q1))
+        cirq.unitary(cirq.Circuit(rcnot)), cirq.unitary(OtherCNOT().on(q0, q1)), atol=1e-6
     )
 
 
diff --git a/cirq-core/cirq/linalg/decompositions.py b/cirq-core/cirq/linalg/decompositions.py
index 22e11b3ebe7..4b6eb6d1893 100644
--- a/cirq-core/cirq/linalg/decompositions.py
+++ b/cirq-core/cirq/linalg/decompositions.py
@@ -549,6 +549,8 @@ def scatter_plot_normalized_kak_interaction_coefficients(
     *,
     include_frame: bool = True,
     ax: Optional[plt.Axes] = None,
+    rtol: float = 1e-5,
+    atol: float = 1e-6,
     **kwargs,
 ):
     r"""Plots the interaction coefficients of many two-qubit operations.
@@ -590,6 +592,13 @@ def scatter_plot_normalized_kak_interaction_coefficients(
             wireframe. Defaults to `True`.
         ax: A matplotlib 3d axes object to plot into. If not specified, a new
             figure is created, plotted, and shown.
+        rtol: Per-matrix-entry relative tolerance on equality used if the
+            kak decomposition is calculated from the `interactions`.
+        atol: Per-matrix-entry absolute tolerance on equality used if the
+            kak decomposition is calculated from the `interaction`s. T
+            This determines how close $k_x$  must be to π/4 to guarantee
+            $k_z$ ≥ 0. Must be non-negative.
+
         **kwargs: Arguments forwarded into the call to `scatter` that plots the
             points. Working arguments include color `c='blue'`, scale `s=2`,
             labelling `label="theta=pi/4"`, etc. For reference see the
@@ -662,7 +671,7 @@ def coord_transform(
     else:
         interactions_extracted = [interactions]
 
-    points = kak_vector(interactions_extracted) * 4 / np.pi
+    points = kak_vector(interactions_extracted, rtol=rtol, atol=atol) * 4 / np.pi
 
     ax.scatter(*coord_transform(points), **kwargs)
     ax.set_xlim(0, +1)
@@ -810,7 +819,7 @@ def kak_decomposition(
     ],
     *,
     rtol: float = 1e-5,
-    atol: float = 1e-8,
+    atol: float = 1e-6,
     check_preconditions: bool = True,
 ) -> KakDecomposition:
     """Decomposes a 2-qubit unitary into 1-qubit ops and XX/YY/ZZ interactions.
@@ -848,9 +857,7 @@ def kak_decomposition(
     if check_preconditions and (
         mat.shape != (4, 4) or not predicates.is_unitary(mat, rtol=rtol, atol=atol)
     ):
-        raise ValueError(
-            'Input must correspond to a 4x4 unitary matrix. Received matrix:\n' + str(mat)
-        )
+        raise ValueError(f'Input must correspond to a 4x4 unitary matrix. Received matrix:\n{mat}')
 
     # Diagonalize in magic basis.
     left, d, right = diagonalize.bidiagonalize_unitary_with_special_orthogonals(
@@ -948,7 +955,7 @@ def kak_vector(
 
     if check_preconditions:
         actual = np.einsum('...ba,...bc', unitary.conj(), unitary) - np.eye(4)
-        if not np.allclose(actual, np.zeros_like(actual), rtol, atol):
+        if not np.allclose(np.zeros_like(actual), actual, rtol=rtol, atol=atol):
             raise ValueError(
                 'Input must correspond to a 4x4 unitary matrix or tensor of '
                 f'unitary matrices. Received input:\n{unitary}'
diff --git a/cirq-core/cirq/linalg/decompositions_test.py b/cirq-core/cirq/linalg/decompositions_test.py
index e34dc8a49a5..c0c861752ef 100644
--- a/cirq-core/cirq/linalg/decompositions_test.py
+++ b/cirq-core/cirq/linalg/decompositions_test.py
@@ -738,7 +738,7 @@ def test_kak_vector_input_not_unitary():
 def test_kak_decompose(unitary: np.ndarray):
     kak = cirq.kak_decomposition(unitary)
     circuit = cirq.Circuit(kak._decompose_(cirq.LineQubit.range(2)))
-    np.testing.assert_allclose(cirq.unitary(circuit), unitary, atol=1e-8)
+    np.testing.assert_allclose(cirq.unitary(circuit), unitary, atol=1e-6)
     assert len(circuit) == 5
     assert len(list(circuit.all_operations())) == 8
 
@@ -746,7 +746,9 @@ def test_kak_decompose(unitary: np.ndarray):
 def test_num_two_qubit_gates_required():
     for i in range(4):
         assert (
-            cirq.num_cnots_required(cirq.testing.random_two_qubit_circuit_with_czs(i).unitary())
+            cirq.num_cnots_required(
+                cirq.testing.random_two_qubit_circuit_with_czs(i).unitary(), atol=1e-6
+            )
             == i
         )
 
@@ -759,7 +761,7 @@ def test_num_two_qubit_gates_required_invalid():
 
 
 @pytest.mark.parametrize(
-    "U",
+    "u",
     [
         cirq.testing.random_two_qubit_circuit_with_czs(3).unitary(),
         # an example where gamma(special(u))=I, so the denominator becomes 0
@@ -776,8 +778,8 @@ def test_num_two_qubit_gates_required_invalid():
         ),
     ],
 )
-def test_extract_right_diag(U):
-    assert cirq.num_cnots_required(U) == 3
-    diag = cirq.linalg.extract_right_diag(U)
+def test_extract_right_diag(u):
+    assert cirq.num_cnots_required(u) == 3
+    diag = cirq.linalg.extract_right_diag(u)
     assert cirq.is_diagonal(diag)
-    assert cirq.num_cnots_required(U @ diag) == 2
+    assert cirq.num_cnots_required(u @ diag, atol=1e-6) == 2
diff --git a/cirq-core/cirq/ops/diagonal_gate_test.py b/cirq-core/cirq/ops/diagonal_gate_test.py
index 9bb987dab62..9e0500dcc0b 100644
--- a/cirq-core/cirq/ops/diagonal_gate_test.py
+++ b/cirq-core/cirq/ops/diagonal_gate_test.py
@@ -52,7 +52,9 @@ def test_decomposition_unitary(n):
     expected_f = [np.exp(1j * angle) for angle in diagonal_angles]
     decomposed_f = cirq.unitary(decomposed_circ).diagonal()
 
-    np.testing.assert_allclose(decomposed_f, expected_f)
+    # For large qubit counts, the decomposed circuit is rather large, so we lose a lot of
+    # precision.
+    np.testing.assert_allclose(decomposed_f, expected_f, atol=5e-6)
 
 
 @pytest.mark.parametrize('n', [1, 2, 3, 4])
@@ -63,7 +65,7 @@ def test_diagonal_exponent(n):
     sqrt_diagonal_gate = diagonal_gate**0.5
 
     expected_angles = [prime / 2 for prime in diagonal_angles]
-    np.testing.assert_allclose(expected_angles, sqrt_diagonal_gate._diag_angles_radians, atol=1e-8)
+    np.testing.assert_allclose(expected_angles, sqrt_diagonal_gate._diag_angles_radians, atol=1e-6)
 
     assert cirq.pow(cirq.DiagonalGate(diagonal_angles), "test", None) is None
 
@@ -78,7 +80,7 @@ def test_decomposition_diagonal_exponent(n):
     expected_f = [np.exp(1j * angle / 2) for angle in diagonal_angles]
     decomposed_f = cirq.unitary(decomposed_circ).diagonal()
 
-    np.testing.assert_allclose(decomposed_f, expected_f)
+    np.testing.assert_allclose(decomposed_f, expected_f, atol=1e-6)
 
 
 @pytest.mark.parametrize('n', [1, 2, 3, 4])
@@ -97,7 +99,7 @@ def test_decomposition_with_parameterization(n):
             resolved_op = cirq.resolve_parameters(parameterized_op, resolver)
             resolved_circuit = cirq.resolve_parameters(decomposed_circuit, resolver)
             np.testing.assert_allclose(
-                cirq.unitary(resolved_op), cirq.unitary(resolved_circuit), atol=1e-8
+                cirq.unitary(resolved_op), cirq.unitary(resolved_circuit), atol=1e-6
             )
 
 
diff --git a/cirq-core/cirq/ops/fsim_gate_test.py b/cirq-core/cirq/ops/fsim_gate_test.py
index 684f36dffa8..21dd6dba32c 100644
--- a/cirq-core/cirq/ops/fsim_gate_test.py
+++ b/cirq-core/cirq/ops/fsim_gate_test.py
@@ -317,7 +317,7 @@ def test_phased_fsim_from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after)
         cirq.rz(rz_angles_after[0]).on(q0),
         cirq.rz(rz_angles_after[1]).on(q1),
     )
-    cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(f), cirq.unitary(c), atol=1e-8)
+    cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(f), cirq.unitary(c), atol=1e-6)
 
 
 @pytest.mark.parametrize(
diff --git a/cirq-core/cirq/ops/matrix_gates.py b/cirq-core/cirq/ops/matrix_gates.py
index 99a82ec574d..8788a57f3ef 100644
--- a/cirq-core/cirq/ops/matrix_gates.py
+++ b/cirq-core/cirq/ops/matrix_gates.py
@@ -56,7 +56,7 @@ def __init__(
         name: str = None,
         qid_shape: Optional[Iterable[int]] = None,
         unitary_check_rtol: float = 1e-5,
-        unitary_check_atol: float = 1e-8,
+        unitary_check_atol: float = 1e-6,
     ) -> None:
         """Initializes a matrix gate.
 
diff --git a/cirq-core/cirq/ops/parallel_gate_test.py b/cirq-core/cirq/ops/parallel_gate_test.py
index dc2eb70601b..6a515f60f5a 100644
--- a/cirq-core/cirq/ops/parallel_gate_test.py
+++ b/cirq-core/cirq/ops/parallel_gate_test.py
@@ -119,7 +119,7 @@ def test_unitary(gate, num_copies, qubits):
     step = gate.num_qubits()
     qubit_lists = [qubits[i * step : (i + 1) * step] for i in range(num_copies)]
     np.testing.assert_allclose(
-        cirq.unitary(g), cirq.unitary(cirq.Circuit(gate.on_each(qubit_lists))), atol=1e-8
+        cirq.unitary(g), cirq.unitary(cirq.Circuit(gate.on_each(qubit_lists))), atol=1e-6
     )
 
 
diff --git a/cirq-core/cirq/ops/phased_x_gate_test.py b/cirq-core/cirq/ops/phased_x_gate_test.py
index 4214ad2db78..609d491bbe4 100644
--- a/cirq-core/cirq/ops/phased_x_gate_test.py
+++ b/cirq-core/cirq/ops/phased_x_gate_test.py
@@ -176,7 +176,7 @@ def test_parameterize(resolve_fn, global_shift):
         np.testing.assert_allclose(
             cirq.unitary(resolved_gate(q)),
             cirq.unitary(resolve_fn(parameterized_decomposed_circuit, resolver)),
-            atol=1e-8,
+            atol=1e-6,
         )
 
     unparameterized_gate = cirq.PhasedXPowGate(
diff --git a/cirq-core/cirq/ops/two_qubit_diagonal_gate_test.py b/cirq-core/cirq/ops/two_qubit_diagonal_gate_test.py
index 405b0fcd029..c24231e4ec6 100644
--- a/cirq-core/cirq/ops/two_qubit_diagonal_gate_test.py
+++ b/cirq-core/cirq/ops/two_qubit_diagonal_gate_test.py
@@ -51,6 +51,7 @@ def test_parameterized_decompose():
         np.testing.assert_allclose(
             cirq.unitary(cirq.resolve_parameters(parameterized_op, resolver)),
             cirq.unitary(cirq.resolve_parameters(decomposed_circuit, resolver)),
+            atol=1e-6,
         )
 
 
diff --git a/cirq-core/cirq/optimizers/merge_interactions_test.py b/cirq-core/cirq/optimizers/merge_interactions_test.py
index 9156c948311..b4d90ead996 100644
--- a/cirq-core/cirq/optimizers/merge_interactions_test.py
+++ b/cirq-core/cirq/optimizers/merge_interactions_test.py
@@ -54,7 +54,7 @@ def assert_optimization_not_broken(circuit):
         cirq.MergeInteractions().optimize_circuit(circuit)
     u_after = circuit.unitary()
 
-    cirq.testing.assert_allclose_up_to_global_phase(u_before, u_after, atol=1e-8)
+    cirq.testing.assert_allclose_up_to_global_phase(u_before, u_after, atol=1e-6)
 
 
 def test_clears_paired_cnot():
@@ -254,4 +254,4 @@ def clean_up(operations):
 
     u_before = c_orig.unitary()
     u_after = circuit[1:-1].unitary()
-    cirq.testing.assert_allclose_up_to_global_phase(u_before, u_after, atol=1e-8)
+    cirq.testing.assert_allclose_up_to_global_phase(u_before, u_after, atol=1e-6)
diff --git a/cirq-core/cirq/testing/circuit_compare_test.py b/cirq-core/cirq/testing/circuit_compare_test.py
index 75e453f7f63..101b87c5fb1 100644
--- a/cirq-core/cirq/testing/circuit_compare_test.py
+++ b/cirq-core/cirq/testing/circuit_compare_test.py
@@ -126,12 +126,13 @@ def test_measuring_qubits():
     'circuit', [cirq.testing.random_circuit(cirq.LineQubit.range(2), 4, 0.5) for _ in range(5)]
 )
 def test_random_same_matrix(circuit):
+    circuit_copy = circuit.copy()
     a, b = cirq.LineQubit.range(2)
     same = cirq.Circuit(
         cirq.MatrixGate(circuit.unitary(qubits_that_should_be_present=[a, b])).on(a, b)
     )
 
-    cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit, same)
+    cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit_copy, same)
 
     mutable_circuit = circuit.copy()
     mutable_circuit.append(cirq.measure(a))
diff --git a/cirq-core/cirq/testing/consistent_decomposition.py b/cirq-core/cirq/testing/consistent_decomposition.py
index 4ded1ec9525..5e248a204ab 100644
--- a/cirq-core/cirq/testing/consistent_decomposition.py
+++ b/cirq-core/cirq/testing/consistent_decomposition.py
@@ -43,10 +43,10 @@ def assert_decompose_is_consistent_with_unitary(val: Any, ignoring_global_phase:
     actual = circuits.Circuit(dec).unitary(qubit_order=qubits)
 
     if ignoring_global_phase:
-        lin_alg_utils.assert_allclose_up_to_global_phase(actual, expected, atol=1e-8)
+        lin_alg_utils.assert_allclose_up_to_global_phase(actual, expected, atol=1e-6)
     else:
         # coverage: ignore
-        np.testing.assert_allclose(actual, expected, atol=1e-8)
+        np.testing.assert_allclose(actual, expected, atol=1e-6)
 
 
 def _known_gate_with_no_decomposition(val: Any):
diff --git a/cirq-core/cirq/testing/consistent_qasm.py b/cirq-core/cirq/testing/consistent_qasm.py
index bcad22f3333..cc5cdd9cc6c 100644
--- a/cirq-core/cirq/testing/consistent_qasm.py
+++ b/cirq-core/cirq/testing/consistent_qasm.py
@@ -125,7 +125,7 @@ def assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, unitary):
     qiskit_unitary = result.result().get_unitary()
     qiskit_unitary = _reorder_indices_of_matrix(qiskit_unitary, list(reversed(range(num_qubits))))
 
-    lin_alg_utils.assert_allclose_up_to_global_phase(unitary, qiskit_unitary, rtol=1e-8, atol=1e-8)
+    lin_alg_utils.assert_allclose_up_to_global_phase(unitary, qiskit_unitary, rtol=1e-6, atol=1e-6)
 
 
 def _indent(*content: str) -> str:
diff --git a/cirq-core/cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py b/cirq-core/cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py
index 7a3610441ec..07f475d7468 100644
--- a/cirq-core/cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py
+++ b/cirq-core/cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py
@@ -46,7 +46,7 @@ def test_decompose_x():
                 *qubits[0 : controls_count + 1]
             )
             expected_matrix = circuit2.unitary()
-            assert np.allclose(expected_matrix, result_matrix)
+            assert np.allclose(expected_matrix, result_matrix, atol=1e-6)
 
 
 def _random_unitary():
@@ -88,7 +88,9 @@ def _test_decompose(matrix, controls_count):
         [cirq.MatrixGate(matrix).on(qubits[-1]).controlled_by(*qubits[:-1])]
     ).unitary()
 
-    assert np.allclose(expected_matrix, result_matrix)
+    # Decompose can build rather large circuits for large controls_count,
+    # so we lose a lot of precision.
+    np.testing.assert_allclose(expected_matrix, result_matrix, atol=1e-5)
 
 
 def test_decompose_specific_matrices():
diff --git a/cirq-core/cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py b/cirq-core/cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py
index 110d0811fc8..c650d29058f 100644
--- a/cirq-core/cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py
+++ b/cirq-core/cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py
@@ -84,7 +84,7 @@ def assert_decomposition_valid(cphase_gate, fsim_gate):
     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))
-    assert np.allclose(u_actual, u_expected)
+    assert np.allclose(u_actual, u_expected, atol=1e-6)
 
 
 @pytest.mark.parametrize(
diff --git a/cirq-core/cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py b/cirq-core/cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py
index 49d663a3121..3227a304ed4 100644
--- a/cirq-core/cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py
+++ b/cirq-core/cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py
@@ -69,7 +69,7 @@ def test_three_qubit_matrix_to_operations(u):
     operations = cirq.three_qubit_matrix_to_operations(a, b, c, u)
     final_circuit = cirq.Circuit(operations)
     final_unitary = final_circuit.unitary(qubits_that_should_be_present=[a, b, c])
-    cirq.testing.assert_allclose_up_to_global_phase(u, final_unitary, atol=1e-9)
+    cirq.testing.assert_allclose_up_to_global_phase(u, final_unitary, atol=1e-6)
     num_two_qubit_gates = len(
         [
             op
@@ -118,7 +118,7 @@ def test_cs_to_ops(theta, num_czs):
     cs = _theta_to_cs(theta)
     circuit_cs = cirq.Circuit(_cs_to_ops(a, b, c, theta))
 
-    assert_almost_equal(circuit_cs.unitary(qubits_that_should_be_present=[a, b, c]), cs, 10)
+    assert_almost_equal(circuit_cs.unitary(qubits_that_should_be_present=[a, b, c]), cs, 7)
 
     assert (
         len([cz for cz in list(circuit_cs.all_operations()) if isinstance(cz.gate, cirq.CZPowGate)])
@@ -130,7 +130,7 @@ def _theta_to_cs(theta: np.ndarray) -> np.ndarray:
     """Returns the CS matrix from the cosine sine decomposition.
 
     Args:
-        theta: the 4 angles that result from the CS decomposition
+        theta: the 4 angles that result from the CS decomposition.
     Returns:
         the CS matrix
     """
@@ -235,4 +235,4 @@ def test_two_qubit_multiplexor_to_circuit(shift_left):
     expected = block_diag(u1, u2)
     diagonal = np.kron(np.eye(2), d_ud) if d_ud is not None else np.eye(8)
     actual = cirq.Circuit(ud_ops).unitary(qubits_that_should_be_present=[a, b, c]) @ diagonal
-    cirq.testing.assert_allclose_up_to_global_phase(expected, actual, atol=1e-8)
+    cirq.testing.assert_allclose_up_to_global_phase(expected, actual, atol=1e-6)
diff --git a/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py b/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py
index e26e42b4a52..43cf99706b9 100644
--- a/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py
+++ b/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py
@@ -261,7 +261,7 @@ def test_kak_decomposition_depth_partial_cz():
 )
 def test_decompose_to_diagonal_and_circuit(v):
     b, c = cirq.LineQubit.range(2)
-    diagonal, ops = two_qubit_matrix_to_diagonal_and_cz_operations(b, c, v)
+    diagonal, ops = two_qubit_matrix_to_diagonal_and_cz_operations(b, c, v, atol=1e-6)
     assert cirq.is_diagonal(diagonal)
     combined_circuit = cirq.Circuit(cirq.MatrixGate(diagonal)(b, c), ops)
     circuit_unitary = combined_circuit.unitary(qubits_that_should_be_present=[b, c])
diff --git a/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim_test.py b/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim_test.py
index dba632b78aa..d9aeff38531 100644
--- a/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim_test.py
+++ b/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim_test.py
@@ -83,7 +83,8 @@ def test_decompose_two_qubit_interaction_into_two_b_gates(obj: Any):
     desired_unitary = obj if isinstance(obj, np.ndarray) else cirq.unitary(obj)
     for operation in circuit.all_operations():
         assert len(operation.qubits) < 2 or operation.gate == _B
-    assert cirq.approx_eq(cirq.unitary(circuit), desired_unitary, atol=1e-6)
+    # We lose a lot of precision in the random 4 qubit gates, so this atol is higher.
+    np.testing.assert_allclose(cirq.unitary(circuit), desired_unitary, atol=3e-5)
 
 
 def test_decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops_fail():
diff --git a/cirq-core/cirq/transformers/merge_single_qubit_gates_test.py b/cirq-core/cirq/transformers/merge_single_qubit_gates_test.py
index 40315308f46..8638ba0a0f1 100644
--- a/cirq-core/cirq/transformers/merge_single_qubit_gates_test.py
+++ b/cirq-core/cirq/transformers/merge_single_qubit_gates_test.py
@@ -216,4 +216,6 @@ def test_merge_single_qubit_moments_to_phxz_deep():
     )
     context = cirq.TransformerContext(tags_to_ignore=["ignore"], deep=True)
     c_new = cirq.merge_single_qubit_moments_to_phxz(c_orig, context=context)
-    cirq.testing.assert_same_circuits(c_new, c_expected)
+    cirq.testing.assert_allclose_up_to_global_phase(
+        c_new.unitary(), c_expected.unitary(), atol=1e-6
+    )
diff --git a/cirq-google/cirq_google/calibration/phased_fsim_test.py b/cirq-google/cirq_google/calibration/phased_fsim_test.py
index c3ab7ac7d37..1a208d72ffe 100644
--- a/cirq-google/cirq_google/calibration/phased_fsim_test.py
+++ b/cirq-google/cirq_google/calibration/phased_fsim_test.py
@@ -751,7 +751,7 @@ def test_phase_calibrated_fsim_gate_compensated(phase_exponent: float):
                 ]
             )
         ),
-        atol=1e-8,
+        atol=1e-6,
     )
 
 
diff --git a/cirq-google/cirq_google/optimizers/convert_to_sqrt_iswap_test.py b/cirq-google/cirq_google/optimizers/convert_to_sqrt_iswap_test.py
index 4525f472fcf..50769f8926c 100644
--- a/cirq-google/cirq_google/optimizers/convert_to_sqrt_iswap_test.py
+++ b/cirq-google/cirq_google/optimizers/convert_to_sqrt_iswap_test.py
@@ -123,7 +123,7 @@ def test_cphase():
         actual = cirq.Circuit(decomposition)
         expected_unitary = cirq.unitary(expected)
         actual_unitary = cirq.unitary(actual)
-        np.testing.assert_allclose(expected_unitary, actual_unitary, atol=1e-07)
+        np.testing.assert_allclose(expected_unitary, actual_unitary, atol=1e-6)
 
 
 def test_givens_rotation():
@@ -148,7 +148,7 @@ def test_givens_rotation():
             circuit.append(cirq.IdentityGate(2).on(*qubits))
             test_unitary = cirq.unitary(circuit)
             np.testing.assert_allclose(
-                4, np.abs(np.trace(np.conjugate(np.transpose(test_unitary)) @ unitary))
+                4, np.abs(np.trace(np.conjugate(np.transpose(test_unitary)) @ unitary)), atol=1e-6
             )
 
 
diff --git a/cirq-google/cirq_google/optimizers/convert_to_sycamore_gates_test.py b/cirq-google/cirq_google/optimizers/convert_to_sycamore_gates_test.py
index ddde36b9056..518846ad7d8 100644
--- a/cirq-google/cirq_google/optimizers/convert_to_sycamore_gates_test.py
+++ b/cirq-google/cirq_google/optimizers/convert_to_sycamore_gates_test.py
@@ -39,7 +39,7 @@ def test_convert_to_sycamore_gates_swap_zz():
         == 3
     )
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit1, compiled_circuit1, atol=1e-7
+        circuit1, compiled_circuit1, atol=1e-5
     )
 
 
@@ -65,7 +65,7 @@ def test_single_qubit_gate():
     assert len(ops) == 1
     assert isinstance(ops[0].gate, cirq.PhasedXZGate)
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, converted_circuit, atol=1e-8
+        circuit, converted_circuit, atol=1e-6
     )
 
 
@@ -109,7 +109,7 @@ def test_circuit_operation_conversion():
         cgoc.ConvertToSycamoreGates().optimize_circuit(reconverted_subcircuit)
     assert ops[0].circuit == reconverted_subcircuit
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, converted_circuit, atol=1e-8
+        circuit, converted_circuit, atol=1e-6
     )
 
 
@@ -151,7 +151,7 @@ def test_unsupported_phased_iswap():
     with cirq.testing.assert_deprecated("Use cirq.optimize_for_target_gateset", deadline='v1.0'):
         cgoc.ConvertToSycamoreGates().optimize_circuit(converted_circuit)
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, converted_circuit, atol=1e-8
+        circuit, converted_circuit, atol=1e-6
     )
 
 
@@ -225,7 +225,7 @@ def test_zztheta_qaoa_like():
             cgoc.ConvertToSycamoreGates().optimize_circuit(syc_circuit)
 
         cirq.testing.assert_allclose_up_to_global_phase(
-            cirq.unitary(cirq_circuit), cirq.unitary(syc_circuit), atol=1e-7
+            cirq.unitary(cirq_circuit), cirq.unitary(syc_circuit), atol=1e-6
         )
 
 
@@ -241,7 +241,7 @@ def test_zztheta_zzpow_unsorted_qubits():
         cgoc.ConvertToSycamoreGates().optimize_circuit(actual_circuit)
 
     cirq.testing.assert_allclose_up_to_global_phase(
-        cirq.unitary(expected_circuit), cirq.unitary(actual_circuit), atol=1e-7
+        cirq.unitary(expected_circuit), cirq.unitary(actual_circuit), atol=1e-6
     )
 
 
@@ -260,7 +260,7 @@ def test_swap_zztheta():
         ):
             cgoc.ConvertToSycamoreGates().optimize_circuit(actual_circuit)
         actual_unitary = cirq.unitary(actual_circuit)
-        cirq.testing.assert_allclose_up_to_global_phase(actual_unitary, expected_unitary, atol=1e-7)
+        cirq.testing.assert_allclose_up_to_global_phase(actual_unitary, expected_unitary, atol=1e-5)
 
 
 def test_known_two_q_operations_to_sycamore_operations_cnot():
@@ -271,7 +271,7 @@ def test_known_two_q_operations_to_sycamore_operations_cnot():
 
     # Should be equivalent.
     cirq.testing.assert_allclose_up_to_global_phase(
-        cirq.unitary(op), cirq.unitary(decomposed), atol=1e-8
+        cirq.unitary(op), cirq.unitary(decomposed), atol=1e-6
     )
 
     # Should have decomposed into two Sycamores.
@@ -303,7 +303,7 @@ def test_convert_to_sycamore_equivalent_unitaries(gate):
         converted = cgoc.ConvertToSycamoreGates().convert(operation)
     u1 = cirq.unitary(cirq.Circuit(converted))
     u2 = cirq.unitary(operation)
-    cirq.testing.assert_allclose_up_to_global_phase(u1, u2, atol=1e-8)
+    cirq.testing.assert_allclose_up_to_global_phase(u1, u2, atol=4e-6)
 
 
 def test_convert_to_sycamore_tabulation():
diff --git a/cirq-google/cirq_google/optimizers/optimize_for_sycamore_test.py b/cirq-google/cirq_google/optimizers/optimize_for_sycamore_test.py
index b95e42cafaa..b5159ed93f3 100644
--- a/cirq-google/cirq_google/optimizers/optimize_for_sycamore_test.py
+++ b/cirq-google/cirq_google/optimizers/optimize_for_sycamore_test.py
@@ -143,8 +143,8 @@ def test_circuit_operation_conversion(optimizer_type, two_qubit_gate_type):
         [*converted_subcircuit.findall_operations_with_gate_type(two_qubit_gate_type)]
     ) == len([*ops[0].circuit.findall_operations_with_gate_type(two_qubit_gate_type)])
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        ops[0].circuit, converted_subcircuit, atol=1e-8
+        ops[0].circuit, converted_subcircuit, atol=1e-6
     )
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, converted_circuit, atol=1e-8
+        circuit, converted_circuit, atol=1e-6
     )
diff --git a/cirq-google/cirq_google/transformers/analytical_decompositions/two_qubit_to_sycamore.py b/cirq-google/cirq_google/transformers/analytical_decompositions/two_qubit_to_sycamore.py
index 6f41f694a7c..50fc3f057f5 100644
--- a/cirq-google/cirq_google/transformers/analytical_decompositions/two_qubit_to_sycamore.py
+++ b/cirq-google/cirq_google/transformers/analytical_decompositions/two_qubit_to_sycamore.py
@@ -380,12 +380,15 @@ def _create_corrected_circuit(
         q1: Second qubit to operate on.
 
     Yields:
-        Operations in `program` with pre and post rotations added s.t. the resulting `cirq.OP_TREE`
+        Operations in `program` with pre- and post- rotations added s.t. the resulting
+        `cirq.OP_TREE`
         implements `target_unitary`.
     """
     # Get the local equivalents
+    # We use higher precision than normal to avoid numerical instabilities.
     b_0, b_1, a_0, a_1 = _find_local_equivalents(
-        target_unitary, program.unitary(qubit_order=cirq.QubitOrder.explicit([q0, q1]))
+        target_unitary,
+        program.unitary(qubit_order=cirq.QubitOrder.explicit([q0, q1]), dtype=np.complex128),
     )
 
     # Apply initial corrections
diff --git a/cirq-google/cirq_google/transformers/analytical_decompositions/two_qubit_to_sycamore_test.py b/cirq-google/cirq_google/transformers/analytical_decompositions/two_qubit_to_sycamore_test.py
index 94084191d15..395dc84e818 100644
--- a/cirq-google/cirq_google/transformers/analytical_decompositions/two_qubit_to_sycamore_test.py
+++ b/cirq-google/cirq_google/transformers/analytical_decompositions/two_qubit_to_sycamore_test.py
@@ -26,27 +26,37 @@ def assert_implements(circuit: cirq.Circuit, target_op: cirq.Operation):
     assert sum(1 for _ in circuit.findall_operations(lambda e: len(e.qubits) > 2)) <= 6
     circuit.append(cirq.I.on_each(*target_op.qubits))
     cirq.testing.assert_allclose_up_to_global_phase(
-        cirq.unitary(circuit), cirq.unitary(target_op), atol=1e-7
+        cirq.unitary(circuit), cirq.unitary(target_op), atol=1e-5
     )
 
 
-theta = sympy.Symbol('theta')
-all_exps = np.linspace(0, 1, 10)
-q = cirq.LineQubit.range(2)
+_THETA = sympy.Symbol('theta')
+_ALL_EXPS = np.linspace(0, 1, 10)
+_QUBITS = cirq.LineQubit.range(2)
 
 
 @pytest.mark.parametrize(
     'op, theta_range',
     [
-        (cirq.CircuitOperation(cirq.FrozenCircuit(cirq.SWAP(*q), cirq.ZZ(*q) ** theta)), all_exps),
-        (cirq.CircuitOperation(cirq.FrozenCircuit(cirq.ZZ(*q) ** theta, cirq.SWAP(*q))), all_exps),
-        (cirq.PhasedISwapPowGate(exponent=1, phase_exponent=theta).on(*q), all_exps),
-        (cirq.PhasedISwapPowGate(exponent=theta, phase_exponent=0.25).on(*q), all_exps),
-        (cirq.CNOT(*q) ** theta, all_exps),
-        (cirq.CZ(*q) ** theta, all_exps),
-        (cirq.ZZ(*q) ** theta, all_exps),
-        (cirq.SWAP(*q) ** theta, [1]),
-        (cirq.ISWAP(*q) ** theta, [1]),
+        (
+            cirq.CircuitOperation(
+                cirq.FrozenCircuit(cirq.SWAP(*_QUBITS), cirq.ZZ(*_QUBITS) ** _THETA)
+            ),
+            _ALL_EXPS,
+        ),
+        (
+            cirq.CircuitOperation(
+                cirq.FrozenCircuit(cirq.ZZ(*_QUBITS) ** _THETA, cirq.SWAP(*_QUBITS))
+            ),
+            _ALL_EXPS,
+        ),
+        (cirq.PhasedISwapPowGate(exponent=1, phase_exponent=_THETA).on(*_QUBITS), _ALL_EXPS),
+        (cirq.PhasedISwapPowGate(exponent=_THETA, phase_exponent=0.25).on(*_QUBITS), _ALL_EXPS),
+        (cirq.CNOT(*_QUBITS) ** _THETA, _ALL_EXPS),
+        (cirq.CZ(*_QUBITS) ** _THETA, _ALL_EXPS),
+        (cirq.ZZ(*_QUBITS) ** _THETA, _ALL_EXPS),
+        (cirq.SWAP(*_QUBITS) ** _THETA, [1]),
+        (cirq.ISWAP(*_QUBITS) ** _THETA, [1]),
     ],
 )
 def test_known_two_qubit_op_decomposition(op, theta_range):
@@ -54,7 +64,9 @@ def test_known_two_qubit_op_decomposition(op, theta_range):
         op_resolved = cirq.resolve_parameters(op, {'theta': theta_val}, recursive=False)
         known_2q_circuit = cirq.Circuit(cg.known_2q_op_to_sycamore_operations(op_resolved))
         matrix_2q_circuit = cirq.Circuit(
-            cg.two_qubit_matrix_to_sycamore_operations(q[0], q[1], cirq.unitary(op_resolved))
+            cg.two_qubit_matrix_to_sycamore_operations(
+                _QUBITS[0], _QUBITS[1], cirq.unitary(op_resolved)
+            )
         )
         assert_implements(known_2q_circuit, op_resolved)
         assert_implements(matrix_2q_circuit, op_resolved)
@@ -63,12 +75,14 @@ def test_known_two_qubit_op_decomposition(op, theta_range):
 @pytest.mark.parametrize(
     'op',
     [
-        cirq.CircuitOperation(cirq.FrozenCircuit(cirq.SWAP(*q), cirq.ZZ(*q), cirq.SWAP(*q))),
-        cirq.X(q[0]),
-        cirq.XX(*q) ** theta,
-        cirq.FSimGate(0.25, 0.85).on(*q),
-        cirq.XX(*q),
-        cirq.YY(*q),
+        cirq.CircuitOperation(
+            cirq.FrozenCircuit(cirq.SWAP(*_QUBITS), cirq.ZZ(*_QUBITS), cirq.SWAP(*_QUBITS))
+        ),
+        cirq.X(_QUBITS[0]),
+        cirq.XX(*_QUBITS) ** _THETA,
+        cirq.FSimGate(0.25, 0.85).on(*_QUBITS),
+        cirq.XX(*_QUBITS),
+        cirq.YY(*_QUBITS),
         *[cirq.testing.random_unitary(4, random_state=1234) for _ in range(10)],
     ],
 )
@@ -76,6 +90,6 @@ def test_unknown_two_qubit_op_decomposition(op):
     assert cg.known_2q_op_to_sycamore_operations(op) is None
     if cirq.has_unitary(op) and cirq.num_qubits(op) == 2:
         matrix_2q_circuit = cirq.Circuit(
-            cg.two_qubit_matrix_to_sycamore_operations(q[0], q[1], cirq.unitary(op))
+            cg.two_qubit_matrix_to_sycamore_operations(_QUBITS[0], _QUBITS[1], cirq.unitary(op))
         )
         assert_implements(matrix_2q_circuit, op)
diff --git a/cirq-google/cirq_google/transformers/target_gatesets/sycamore_gateset_test.py b/cirq-google/cirq_google/transformers/target_gatesets/sycamore_gateset_test.py
index 6d32114602b..4511fb310c4 100644
--- a/cirq-google/cirq_google/transformers/target_gatesets/sycamore_gateset_test.py
+++ b/cirq-google/cirq_google/transformers/target_gatesets/sycamore_gateset_test.py
@@ -167,7 +167,7 @@ def test_sycamore_gateset_compiles_swap_zz():
         == 3
     )
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit1, compiled_circuit1, atol=1e-7
+        circuit1, compiled_circuit1, atol=1e-5
     )
 
 
@@ -270,7 +270,7 @@ def test_zztheta_qaoa_like():
             circuit, gateset=cirq_google.SycamoreTargetGateset()
         )
         cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-            circuit, converted_circuit, atol=1e-8
+            circuit, converted_circuit, atol=1e-6
         )
 
 
@@ -284,7 +284,7 @@ def test_zztheta_zzpow_unsorted_qubits():
         circuit, gateset=cirq_google.SycamoreTargetGateset()
     )
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, converted_circuit, atol=1e-8
+        circuit, converted_circuit, atol=1e-6
     )
 
 
@@ -299,7 +299,7 @@ def test_swap_zztheta():
             circuit, gateset=cirq_google.SycamoreTargetGateset()
         )
         cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-            circuit, converted_circuit, atol=1e-8
+            circuit, converted_circuit, atol=1e-5
         )
 
 
@@ -312,7 +312,7 @@ def test_known_two_q_operations_to_sycamore_operations_cnot():
 
     # Should be equivalent.
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, converted_circuit, atol=1e-8
+        circuit, converted_circuit, atol=1e-6
     )
 
     # Should have decomposed into two Sycamores.
@@ -343,7 +343,7 @@ def test_convert_to_sycamore_equivalent_unitaries(gate):
         circuit, gateset=cirq_google.SycamoreTargetGateset()
     )
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, converted_circuit, atol=1e-8
+        circuit, converted_circuit, atol=1e-6
     )
 
 
@@ -383,7 +383,7 @@ def test_supported_operation(op):
         circuit, gateset=cirq_google.SycamoreTargetGateset()
     )
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, converted_circuit, atol=1e-8
+        circuit, converted_circuit, atol=1e-6
     )
     multi_qubit_ops = [e for e in converted_circuit.all_operations() if len(e.qubits) > 1]
     assert all(isinstance(e.gate, cirq_google.SycamoreGate) for e in multi_qubit_ops)
diff --git a/cirq-ionq/cirq_ionq/ionq_gateset_test.py b/cirq-ionq/cirq_ionq/ionq_gateset_test.py
index 97c73ac1d1f..3baeefb535a 100644
--- a/cirq-ionq/cirq_ionq/ionq_gateset_test.py
+++ b/cirq-ionq/cirq_ionq/ionq_gateset_test.py
@@ -79,7 +79,7 @@ def test_decompose_single_qubit_matrix_gate():
             circuit, gateset=ionq_target_gateset, ignore_failures=False
         )
         cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-            circuit, decomposed_circuit, atol=1e-8
+            circuit, decomposed_circuit, atol=1e-6
         )
         assert VALID_DECOMPOSED_GATES.validate(decomposed_circuit)
 
@@ -93,7 +93,7 @@ def test_decompose_two_qubit_matrix_gate():
             circuit, gateset=ionq_target_gateset, ignore_failures=False
         )
         cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-            circuit, decomposed_circuit, atol=1e-8
+            circuit, decomposed_circuit, atol=1e-6
         )
         assert VALID_DECOMPOSED_GATES.validate(decomposed_circuit)
 
@@ -112,7 +112,7 @@ def test_decompose_multi_qubit_cirq_gates(gate, qubits):
         circuit, gateset=ionq_target_gateset, ignore_failures=False
     )
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, decomposed_circuit, atol=1e-8
+        circuit, decomposed_circuit, atol=1e-6
     )
     assert ionq_target_gateset.validate(decomposed_circuit)
 
@@ -128,5 +128,6 @@ def test_decompose_parameterized_operation():
         cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
             cirq.resolve_parameters(circuit, {theta: theta_val}),
             cirq.resolve_parameters(decomposed_circuit, {theta: theta_val}),
+            atol=1e-6,
         )
     assert ionq_target_gateset.validate(decomposed_circuit)
diff --git a/docs/transform/custom_transformers.ipynb b/docs/transform/custom_transformers.ipynb
index 21c5d7a7f45..38775d56f79 100644
--- a/docs/transform/custom_transformers.ipynb
+++ b/docs/transform/custom_transformers.ipynb
@@ -439,7 +439,7 @@
     "# Run your transformer.\n",
     "converted_circuit = convert_to_cz_target(circuit, context=context)\n",
     "# Ensure that the resulting circuit is equivalent.\n",
-    "cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit, converted_circuit)\n",
+    "cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit, converted_circuit, atol=1e-6)\n",
     "# Show the steps executed.\n",
     "context.logger.show()"
    ]
diff --git a/docs/tutorials/educators/intro.ipynb b/docs/tutorials/educators/intro.ipynb
index 93341230d46..ed319741466 100644
--- a/docs/tutorials/educators/intro.ipynb
+++ b/docs/tutorials/educators/intro.ipynb
@@ -2768,7 +2768,7 @@
     "    circuit, gateset=cirq.SqrtIswapTargetGateset()\n",
     ")\n",
     "cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(\n",
-    "    circuit, sqrt_iswap_compiled_circuit, atol=1e-7\n",
+    "    circuit, sqrt_iswap_compiled_circuit, atol=1e-6\n",
     ")\n",
     "print(\n",
     "    f\"Compiled circuit for Sqrt-Iswap Target (depth {len(sqrt_iswap_compiled_circuit)}):\",\n",
diff --git a/docs/tutorials/quantum_walks.ipynb b/docs/tutorials/quantum_walks.ipynb
index cc8e762b7f8..5b20a974ebf 100644
--- a/docs/tutorials/quantum_walks.ipynb
+++ b/docs/tutorials/quantum_walks.ipynb
@@ -775,4 +775,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 0
-}
\ No newline at end of file
+}
diff --git a/examples/examples_test.py b/examples/examples_test.py
index f6dbfc53c31..1f415f238b7 100644
--- a/examples/examples_test.py
+++ b/examples/examples_test.py
@@ -114,7 +114,9 @@ def test_example_qaoa_same_unitary():
         for use_boolean_hamiltonian_gate in [True, False]
     ]
 
-    assert cirq.allclose_up_to_global_phase(cirq.unitary(circuits[0]), cirq.unitary(circuits[1]))
+    assert cirq.allclose_up_to_global_phase(
+        cirq.unitary(circuits[0]), cirq.unitary(circuits[1]), atol=1e-6
+    )
 
 
 def test_example_runs_quantum_teleportation():