From f904a09031b102a3ad5d7b55eff2c8efe565197f Mon Sep 17 00:00:00 2001 From: Dave Bacon Date: Tue, 28 Jun 2022 17:24:58 -0700 Subject: [PATCH] Roll back the default on unitary to np.complex64, change default for final_state_vector (#5636) Rolls back change in #5426 that set the default precision on `Circuit#unitary` to `np.complex128`. Also sets the default on `Circuit#final_state_vector` to `np.complex128`. There was a deprecation warning that this was going to be downgraded to `np.complex64`,, but this will now remain `np.complex128`. This is breaking in that is someone explicitly passed `dtype=None` to this method it would now break. Rolls back #5426 #5616 #5537 #5535 --- cirq-core/cirq/circuits/circuit.py | 21 +++---- cirq-core/cirq/circuits/circuit_test.py | 56 ------------------- .../contrib/acquaintance/executor_test.py | 4 +- .../paulistring/clifford_optimize_test.py | 2 +- .../cirq/contrib/paulistring/optimize_test.py | 12 ++-- .../paulistring/pauli_string_dag_test.py | 2 +- .../paulistring/pauli_string_optimize_test.py | 4 +- .../cirq/contrib/paulistring/separate_test.py | 2 +- .../cirq/contrib/qasm_import/qasm_test.py | 2 +- .../cirq/ion/convert_to_ion_gates_test.py | 2 +- cirq-core/cirq/linalg/decompositions.py | 14 +---- cirq-core/cirq/linalg/decompositions_test.py | 2 +- cirq-core/cirq/ops/diagonal_gate_test.py | 8 +-- cirq-core/cirq/ops/fsim_gate_test.py | 2 +- cirq-core/cirq/ops/matrix_gates.py | 2 +- cirq-core/cirq/ops/parallel_gate_test.py | 2 +- cirq-core/cirq/ops/phased_x_gate_test.py | 2 +- .../cirq/ops/two_qubit_diagonal_gate_test.py | 1 - .../optimizers/merge_interactions_test.py | 4 +- .../cirq/testing/circuit_compare_test.py | 3 +- .../cirq/testing/consistent_decomposition.py | 4 +- cirq-core/cirq/testing/consistent_qasm.py | 2 +- .../controlled_gate_decomposition_test.py | 6 +- .../three_qubit_decomposition_test.py | 6 +- .../two_qubit_to_cz_test.py | 8 +-- .../two_qubit_to_fsim.py | 4 +- .../two_qubit_to_fsim_test.py | 10 +--- .../merge_single_qubit_gates_test.py | 2 +- .../calibration/phased_fsim_test.py | 2 +- .../optimizers/convert_to_sqrt_iswap_test.py | 4 +- .../convert_to_sycamore_gates_test.py | 16 +++--- .../optimizers/optimize_for_sycamore_test.py | 4 +- .../two_qubit_to_sycamore_test.py | 2 +- .../target_gatesets/sycamore_gateset_test.py | 14 ++--- cirq-ionq/cirq_ionq/ionq_gateset_test.py | 6 +- docs/gatezoo.ipynb | 2 +- docs/start/intro.ipynb | 4 +- docs/transform/custom_transformers.ipynb | 4 +- examples/examples_test.py | 2 +- 39 files changed, 83 insertions(+), 166 deletions(-) diff --git a/cirq-core/cirq/circuits/circuit.py b/cirq-core/cirq/circuits/circuit.py index e52a99aa1c3..5a73520f020 100644 --- a/cirq-core/cirq/circuits/circuit.py +++ b/cirq-core/cirq/circuits/circuit.py @@ -1003,7 +1003,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.complexfloating] = np.complex64, + dtype: Type[np.complexfloating] = np.complex128, ) -> np.ndarray: """Converts the circuit into a unitary matrix, if possible. @@ -1018,10 +1018,11 @@ 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. `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. 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). Returns: A (possibly gigantic) 2d numpy array corresponding to a matrix @@ -1093,7 +1094,7 @@ def final_state_vector( qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT, qubits_that_should_be_present: Iterable['cirq.Qid'] = (), ignore_terminal_measurements: Optional[bool] = None, - dtype: Optional[Type[np.complexfloating]] = None, + dtype: Type[np.complexfloating] = np.complex128, param_resolver: 'cirq.ParamResolverOrSimilarType' = None, seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None, ) -> np.ndarray: @@ -1143,14 +1144,6 @@ def final_state_vector( ) ignore_terminal_measurements = True - if dtype is None: - _compat._warn_or_error( - '`dtype` will default to np.complex64 in v0.16. ' - 'To use the previous default, please explicitly include ' - '`dtype=np.complex128` when calling this method.' - ) - dtype = np.complex128 - from cirq.sim.mux import final_state_vector program = Circuit(cirq.I(q) for q in qubits_that_should_be_present) + self diff --git a/cirq-core/cirq/circuits/circuit_test.py b/cirq-core/cirq/circuits/circuit_test.py index 0f9c32fe332..7febde438fb 100644 --- a/cirq-core/cirq/circuits/circuit_test.py +++ b/cirq-core/cirq/circuits/circuit_test.py @@ -2957,62 +2957,6 @@ def test_final_state_vector(circuit_cls): ) -@pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit]) -def test_final_state_vector_deprecated_params(circuit_cls): - a = cirq.NamedQubit('a') - b = cirq.NamedQubit('b') - # Extra qubits. - cirq.testing.assert_allclose_up_to_global_phase( - circuit_cls().final_state_vector(ignore_terminal_measurements=False, dtype=np.complex128), - np.array([1]), - atol=1e-8, - ) - with cirq.testing.assert_deprecated("Inject identity operators", deadline="v0.16"): - cirq.testing.assert_allclose_up_to_global_phase( - circuit_cls().final_state_vector( - qubits_that_should_be_present=[a], - ignore_terminal_measurements=False, - dtype=np.complex128, - ), - np.array([1, 0]), - atol=1e-8, - ) - with cirq.testing.assert_deprecated("Inject identity operators", deadline="v0.16"): - cirq.testing.assert_allclose_up_to_global_phase( - circuit_cls(cirq.X(b)).final_state_vector( - qubits_that_should_be_present=[a], - ignore_terminal_measurements=False, - dtype=np.complex128, - ), - np.array([0, 1, 0, 0]), - atol=1e-8, - ) - - with cirq.testing.assert_deprecated("To drop terminal measurements", deadline="v0.16"): - cirq.testing.assert_allclose_up_to_global_phase( - circuit_cls(cirq.X(a), cirq.measure(a)).final_state_vector(dtype=np.complex128), - np.array([0, 1]), - atol=1e-8, - ) - - with cirq.testing.assert_deprecated("`dtype` will default to np.complex64", deadline="v0.16"): - cirq.testing.assert_allclose_up_to_global_phase( - circuit_cls(cirq.X(a)).final_state_vector(ignore_terminal_measurements=False), - np.array([0, 1]), - atol=1e-8, - ) - - # Non-keyword args. - with cirq.testing.assert_deprecated("Only use keyword arguments", deadline="v0.16"): - cirq.testing.assert_allclose_up_to_global_phase( - circuit_cls(cirq.X(a) ** 0.5).final_state_vector( - 1, ignore_terminal_measurements=False, dtype=np.complex128 - ), - np.array([1, 1j]) * np.sqrt(0.5), - atol=1e-8, - ) - - @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit]) @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once]) def test_is_parameterized(circuit_cls, resolve_fn): diff --git a/cirq-core/cirq/contrib/acquaintance/executor_test.py b/cirq-core/cirq/contrib/acquaintance/executor_test.py index eae7acbb0f0..231e7ab9d5c 100644 --- a/cirq-core/cirq/contrib/acquaintance/executor_test.py +++ b/cirq-core/cirq/contrib/acquaintance/executor_test.py @@ -119,9 +119,7 @@ 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, atol=1e-6 - ) + np.testing.assert_allclose(actual=actual_unitary, desired=expected_unitary, verbose=True) 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 9778a727f4c..12660581e20 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-6) + cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7) diff --git a/cirq-core/cirq/contrib/paulistring/optimize_test.py b/cirq-core/cirq/contrib/paulistring/optimize_test.py index 235683852f9..7fe17a1aaa6 100644 --- a/cirq-core/cirq/contrib/paulistring/optimize_test.py +++ b/cirq-core/cirq/contrib/paulistring/optimize_test.py @@ -48,17 +48,17 @@ 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-6) + cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7) # TODO(#5546) Fix '[Z]^1' (should be 'Z') cirq.testing.assert_has_diagram( c_opt, """ -0: ───X^0.5────────────@────────────────────────────────────────────── +0: ───X^0.5────────────@──────────────────────────────────────── │ -1: ───@───────X^-0.5───@───@────────────────@───Z^-0.5──────────────── +1: ───@───────X^-0.5───@───@────────────────@───Z^-0.5────────── │ │ │ -2: ───@────────────────────@───[X]^(-7/8)───@───[X]^-0.25───[Z]^(1)─── +2: ───@────────────────────@───[X]^(-7/8)───@───[X]^-0.25───Z─── """, ) @@ -69,7 +69,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-6) + cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7) assert ( sum( @@ -87,7 +87,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-6) + cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7) 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 4aa9e408ceb..11c29e73ebb 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-6 + c_left.unitary(), c_left_reordered.unitary(), atol=1e-7 ) 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 9e50bc49a58..6537c297a51 100644 --- a/cirq-core/cirq/contrib/paulistring/pauli_string_optimize_test.py +++ b/cirq-core/cirq/contrib/paulistring/pauli_string_optimize_test.py @@ -37,7 +37,7 @@ def test_optimize(): c_opt = pauli_string_optimized_circuit(c_orig) cirq.testing.assert_allclose_up_to_global_phase( - c_orig.unitary(), c_expected.unitary(), atol=1e-6 + c_orig.unitary(), c_expected.unitary(), atol=1e-7 ) cirq.testing.assert_has_diagram( @@ -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-6) + cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7) diff --git a/cirq-core/cirq/contrib/paulistring/separate_test.py b/cirq-core/cirq/contrib/paulistring/separate_test.py index 82ed1e649b4..e6e336d5c68 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-6 + circuit.unitary(), (c_left + c_right).unitary(), atol=1e-7 ) 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 7d76892c4c7..9605fbb60fa 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-6) + ct.assert_allclose_up_to_global_phase(cirq_unitary, cirq.unitary(circuit1), atol=1e-8) 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 fb04a7f4e66..780fe22c06c 100644 --- a/cirq-core/cirq/ion/convert_to_ion_gates_test.py +++ b/cirq-core/cirq/ion/convert_to_ion_gates_test.py @@ -88,7 +88,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)), atol=1e-6 + cirq.unitary(cirq.Circuit(rcnot)), cirq.unitary(OtherCNOT().on(q0, q1)), atol=1e-7 ) diff --git a/cirq-core/cirq/linalg/decompositions.py b/cirq-core/cirq/linalg/decompositions.py index 4b6eb6d1893..a14ca375f0f 100644 --- a/cirq-core/cirq/linalg/decompositions.py +++ b/cirq-core/cirq/linalg/decompositions.py @@ -549,8 +549,6 @@ 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. @@ -592,12 +590,6 @@ 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`, @@ -671,7 +663,7 @@ def coord_transform( else: interactions_extracted = [interactions] - points = kak_vector(interactions_extracted, rtol=rtol, atol=atol) * 4 / np.pi + points = kak_vector(interactions_extracted) * 4 / np.pi ax.scatter(*coord_transform(points), **kwargs) ax.set_xlim(0, +1) @@ -819,7 +811,7 @@ def kak_decomposition( ], *, rtol: float = 1e-5, - atol: float = 1e-6, + atol: float = 1e-8, check_preconditions: bool = True, ) -> KakDecomposition: """Decomposes a 2-qubit unitary into 1-qubit ops and XX/YY/ZZ interactions. @@ -955,7 +947,7 @@ def kak_vector( if check_preconditions: actual = np.einsum('...ba,...bc', unitary.conj(), unitary) - np.eye(4) - if not np.allclose(np.zeros_like(actual), actual, rtol=rtol, atol=atol): + if not np.allclose(actual, np.zeros_like(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 c0c861752ef..30f06cf054f 100644 --- a/cirq-core/cirq/linalg/decompositions_test.py +++ b/cirq-core/cirq/linalg/decompositions_test.py @@ -782,4 +782,4 @@ 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, atol=1e-6) == 2 + assert cirq.num_cnots_required(u @ diag) == 2 diff --git a/cirq-core/cirq/ops/diagonal_gate_test.py b/cirq-core/cirq/ops/diagonal_gate_test.py index 9e0500dcc0b..cf6da56b9ee 100644 --- a/cirq-core/cirq/ops/diagonal_gate_test.py +++ b/cirq-core/cirq/ops/diagonal_gate_test.py @@ -54,7 +54,7 @@ def test_decomposition_unitary(n): # 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) + np.testing.assert_allclose(decomposed_f, expected_f) @pytest.mark.parametrize('n', [1, 2, 3, 4]) @@ -65,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-6) + np.testing.assert_allclose(expected_angles, sqrt_diagonal_gate._diag_angles_radians, atol=1e-8) assert cirq.pow(cirq.DiagonalGate(diagonal_angles), "test", None) is None @@ -80,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, atol=1e-6) + np.testing.assert_allclose(decomposed_f, expected_f) @pytest.mark.parametrize('n', [1, 2, 3, 4]) @@ -99,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-6 + cirq.unitary(resolved_op), cirq.unitary(resolved_circuit), atol=1e-8 ) diff --git a/cirq-core/cirq/ops/fsim_gate_test.py b/cirq-core/cirq/ops/fsim_gate_test.py index 21dd6dba32c..684f36dffa8 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-6) + cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(f), cirq.unitary(c), atol=1e-8) @pytest.mark.parametrize( diff --git a/cirq-core/cirq/ops/matrix_gates.py b/cirq-core/cirq/ops/matrix_gates.py index 8788a57f3ef..99a82ec574d 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-6, + unitary_check_atol: float = 1e-8, ) -> 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 6a515f60f5a..dc2eb70601b 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-6 + cirq.unitary(g), cirq.unitary(cirq.Circuit(gate.on_each(qubit_lists))), atol=1e-8 ) diff --git a/cirq-core/cirq/ops/phased_x_gate_test.py b/cirq-core/cirq/ops/phased_x_gate_test.py index 575674ce2cc..a4873ee924e 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-6, + atol=1e-8, ) 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 7de1baf57f7..411d24136ff 100644 --- a/cirq-core/cirq/ops/two_qubit_diagonal_gate_test.py +++ b/cirq-core/cirq/ops/two_qubit_diagonal_gate_test.py @@ -51,7 +51,6 @@ 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 b4d90ead996..9156c948311 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-6) + cirq.testing.assert_allclose_up_to_global_phase(u_before, u_after, atol=1e-8) 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-6) + cirq.testing.assert_allclose_up_to_global_phase(u_before, u_after, atol=1e-8) diff --git a/cirq-core/cirq/testing/circuit_compare_test.py b/cirq-core/cirq/testing/circuit_compare_test.py index 101b87c5fb1..75e453f7f63 100644 --- a/cirq-core/cirq/testing/circuit_compare_test.py +++ b/cirq-core/cirq/testing/circuit_compare_test.py @@ -126,13 +126,12 @@ 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_copy, same) + cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit, 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 5e248a204ab..4ded1ec9525 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-6) + lin_alg_utils.assert_allclose_up_to_global_phase(actual, expected, atol=1e-8) else: # coverage: ignore - np.testing.assert_allclose(actual, expected, atol=1e-6) + np.testing.assert_allclose(actual, expected, atol=1e-8) 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 cc5cdd9cc6c..bcad22f3333 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-6, atol=1e-6) + lin_alg_utils.assert_allclose_up_to_global_phase(unitary, qiskit_unitary, rtol=1e-8, atol=1e-8) 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 07f475d7468..92bf8e31b63 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, atol=1e-6) + assert np.allclose(expected_matrix, result_matrix) def _random_unitary(): @@ -88,9 +88,7 @@ def _test_decompose(matrix, controls_count): [cirq.MatrixGate(matrix).on(qubits[-1]).controlled_by(*qubits[:-1])] ).unitary() - # 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) + cirq.testing.assert_allclose_up_to_global_phase(expected_matrix, result_matrix, atol=1e-8) def test_decompose_specific_matrices(): 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 3227a304ed4..491fc182ded 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-6) + cirq.testing.assert_allclose_up_to_global_phase(u, final_unitary, atol=1e-9) 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, 7) + assert_almost_equal(circuit_cs.unitary(qubits_that_should_be_present=[a, b, c]), cs, 10) assert ( len([cz for cz in list(circuit_cs.all_operations()) if isinstance(cz.gate, cirq.CZPowGate)]) @@ -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-6) + cirq.testing.assert_allclose_up_to_global_phase(expected, actual, atol=1e-8) 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 a033600f959..597f4dc6529 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 @@ -254,15 +254,15 @@ def test_kak_decomposition_depth_partial_cz(): @pytest.mark.parametrize( "v", [ - random_two_qubit_circuit_with_czs(3).unitary(dtype=np.complex128), - random_two_qubit_circuit_with_czs(2).unitary(dtype=np.complex128), + cirq.unitary(random_two_qubit_circuit_with_czs(3)), + cirq.unitary(random_two_qubit_circuit_with_czs(2)), np.diag(np.exp(1j * np.pi * np.random.random(4))), ], ) 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, atol=1e-6) + diagonal, ops = two_qubit_matrix_to_diagonal_and_cz_operations(b, c, v, atol=1e-8) 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]) - cirq.testing.assert_allclose_up_to_global_phase(circuit_unitary, v, atol=5e-5) + cirq.testing.assert_allclose_up_to_global_phase(circuit_unitary, v, atol=2e-6) diff --git a/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py b/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py index 2fbc37db6b5..ab8b649a426 100644 --- a/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py +++ b/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py @@ -252,9 +252,7 @@ def _fix_single_qubit_gates_around_kak_interaction( A list of operations whose kak decomposition approximately equals the desired kak decomposition. """ - actual = linalg.kak_decomposition( - circuits.Circuit(operations).unitary(qubit_order=qubits, dtype=np.complex128) - ) + actual = linalg.kak_decomposition(circuits.Circuit(operations).unitary(qubit_order=qubits)) def dag(a: np.ndarray) -> np.ndarray: return np.transpose(np.conjugate(a)) 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 86fd131e059..d32695c5f83 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,8 +83,7 @@ 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 - # 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=1e-4) + np.testing.assert_allclose(cirq.unitary(circuit), desired_unitary, atol=1e-6) def test_decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops_fail(): @@ -95,10 +94,7 @@ def test_decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops_fail(): canonical_y_kak_coefficient=np.pi / 8, ) np.testing.assert_allclose( - cirq.kak_decomposition( - cirq.Circuit(c).unitary(dtype=np.complex128) - ).interaction_coefficients, - [np.pi / 4, np.pi / 8, 0], + cirq.kak_decomposition(cirq.Circuit(c)).interaction_coefficients, [np.pi / 4, np.pi / 8, 0] ) with pytest.raises(ValueError, match='Failed to synthesize'): @@ -120,7 +116,7 @@ def test_decompose_two_qubit_interaction_into_four_fsim_gates_equivalence( for operation in circuit.all_operations(): assert len(operation.qubits) < 2 or operation.gate == fsim_gate assert len(circuit) <= 4 * 3 + 5 - assert cirq.approx_eq(circuit.unitary(qubit_order=qubits), desired_unitary, atol=2e-4) + assert cirq.approx_eq(circuit.unitary(qubit_order=qubits), desired_unitary, atol=1e-4) def test_decompose_two_qubit_interaction_into_four_fsim_gates_validate(): 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 8638ba0a0f1..719351c24af 100644 --- a/cirq-core/cirq/transformers/merge_single_qubit_gates_test.py +++ b/cirq-core/cirq/transformers/merge_single_qubit_gates_test.py @@ -217,5 +217,5 @@ 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_allclose_up_to_global_phase( - c_new.unitary(), c_expected.unitary(), atol=1e-6 + c_new.unitary(), c_expected.unitary(), atol=1e-7 ) diff --git a/cirq-google/cirq_google/calibration/phased_fsim_test.py b/cirq-google/cirq_google/calibration/phased_fsim_test.py index 4329965e352..dc2387a9a78 100644 --- a/cirq-google/cirq_google/calibration/phased_fsim_test.py +++ b/cirq-google/cirq_google/calibration/phased_fsim_test.py @@ -811,7 +811,7 @@ def test_phase_calibrated_fsim_gate_compensated(phase_exponent: float): ] ) ), - atol=1e-6, + atol=1e-8, ) 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 b36c886cbbe..049150c2560 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 @@ -122,7 +122,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-6) + np.testing.assert_allclose(expected_unitary, actual_unitary, atol=1e-7) def test_givens_rotation(): @@ -147,7 +147,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)), atol=1e-6 + 4, np.abs(np.trace(np.conjugate(np.transpose(test_unitary)) @ unitary)) ) 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 518846ad7d8..9d9dcbc6449 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-5 + circuit1, compiled_circuit1, atol=1e-7 ) @@ -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-6 + circuit, converted_circuit, atol=1e-8 ) @@ -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-6 + circuit, converted_circuit, atol=1e-8 ) @@ -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-6 + circuit, converted_circuit, atol=1e-8 ) @@ -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-6 + cirq.unitary(cirq_circuit), cirq.unitary(syc_circuit), atol=1e-7 ) @@ -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-6 + cirq.unitary(expected_circuit), cirq.unitary(actual_circuit), atol=1e-7 ) @@ -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-5) + cirq.testing.assert_allclose_up_to_global_phase(actual_unitary, expected_unitary, atol=1e-7) 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-6 + cirq.unitary(op), cirq.unitary(decomposed), atol=1e-8 ) # Should have decomposed into two Sycamores. 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 fa9d8299a61..57fb1ca01f9 100644 --- a/cirq-google/cirq_google/optimizers/optimize_for_sycamore_test.py +++ b/cirq-google/cirq_google/optimizers/optimize_for_sycamore_test.py @@ -176,8 +176,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-6 + ops[0].circuit, converted_subcircuit, atol=1e-8 ) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( - circuit, converted_circuit, atol=1e-6 + circuit, converted_circuit, atol=1e-8 ) 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 395dc84e818..54c096ab24f 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,7 +26,7 @@ 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-5 + cirq.unitary(circuit), cirq.unitary(target_op), atol=1e-7 ) 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 4511fb310c4..6d32114602b 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-5 + circuit1, compiled_circuit1, atol=1e-7 ) @@ -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-6 + circuit, converted_circuit, atol=1e-8 ) @@ -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-6 + circuit, converted_circuit, atol=1e-8 ) @@ -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-5 + circuit, converted_circuit, atol=1e-8 ) @@ -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-6 + circuit, converted_circuit, atol=1e-8 ) # 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-6 + circuit, converted_circuit, atol=1e-8 ) @@ -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-6 + circuit, converted_circuit, atol=1e-8 ) 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 3baeefb535a..1817469ca03 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-6 + circuit, decomposed_circuit, atol=1e-8 ) 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-6 + circuit, decomposed_circuit, atol=1e-8 ) 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-6 + circuit, decomposed_circuit, atol=1e-8 ) assert ionq_target_gateset.validate(decomposed_circuit) diff --git a/docs/gatezoo.ipynb b/docs/gatezoo.ipynb index c83e0b9eda4..dbe4fe71669 100644 --- a/docs/gatezoo.ipynb +++ b/docs/gatezoo.ipynb @@ -489,4 +489,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file diff --git a/docs/start/intro.ipynb b/docs/start/intro.ipynb index 121021853a8..95eb8da4579 100644 --- a/docs/start/intro.ipynb +++ b/docs/start/intro.ipynb @@ -2764,7 +2764,7 @@ "print(f\"Original Circuit (depth {len(circuit)}):\", circuit)\n", "cz_compiled_circuit = cirq.optimize_for_target_gateset(circuit, gateset=cirq.CZTargetGateset())\n", "cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(\n", - " circuit, cz_compiled_circuit, atol=1e-7\n", + " circuit, cz_compiled_circuit, atol=1e-6\n", ")\n", "print(f\"Compiled circuit for CZ Target (depth {len(cz_compiled_circuit)}):\", cz_compiled_circuit)\n", "sqrt_iswap_compiled_circuit = cirq.optimize_for_target_gateset(\n", @@ -2926,4 +2926,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file diff --git a/docs/transform/custom_transformers.ipynb b/docs/transform/custom_transformers.ipynb index 39bdf61941e..85d034894c4 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, atol=1e-6)\n", + "cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit, converted_circuit)\n", "# Show the steps executed.\n", "context.logger.show()" ] @@ -487,4 +487,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 38e29abacd3..015ceb57a35 100644 --- a/examples/examples_test.py +++ b/examples/examples_test.py @@ -118,7 +118,7 @@ def test_example_qaoa_same_unitary(): ] assert cirq.allclose_up_to_global_phase( - cirq.unitary(circuits[0]), cirq.unitary(circuits[1]), atol=1e-6 + cirq.unitary(circuits[0]), cirq.unitary(circuits[1]), atol=1e-8 )