cirq-core 1.3.0.dev20231201141002__py3-none-any.whl → 1.4.0__py3-none-any.whl

cirq/sim/classical_simulator_test.py

@@ -11,6 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from itertools import product
 import numpy as np
 import pytest
 import cirq
@@ -77,6 +79,43 @@ def test_CCNOT():
     np.testing.assert_equal(results, expected_results)
 
 
+@pytest.mark.parametrize(['initial_state'], [(list(x),) for x in product([0, 1], repeat=4)])
+def test_CCCX(initial_state):
+    CCCX = cirq.CCNOT.controlled()
+    qubits = cirq.LineQubit.range(4)
+
+    circuit = cirq.Circuit()
+    circuit.append(CCCX(*qubits))
+    circuit.append(cirq.measure(qubits, key='key'))
+
+    final_state = initial_state.copy()
+    final_state[-1] ^= all(final_state[:-1])
+
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.simulate(circuit, initial_state=initial_state).measurements['key']
+    np.testing.assert_equal(results, final_state)
+
+
+@pytest.mark.parametrize(['initial_state'], [(list(x),) for x in product([0, 1], repeat=3)])
+def test_CSWAP(initial_state):
+    CSWAP = cirq.SWAP.controlled()
+    qubits = cirq.LineQubit.range(3)
+    circuit = cirq.Circuit()
+
+    circuit = cirq.Circuit()
+    circuit.append(CSWAP(*qubits))
+    circuit.append(cirq.measure(qubits, key='key'))
+
+    a, b, c = initial_state
+    if a:
+        b, c = c, b
+    final_state = [a, b, c]
+
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.simulate(circuit, initial_state=initial_state).measurements['key']
+    np.testing.assert_equal(results, final_state)
+
+
 def test_measurement_gate():
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
@@ -205,3 +244,99 @@ def test_compatible_measurement():
     sim = cirq.ClassicalStateSimulator()
     res = sim.run(c, repetitions=3).records
     np.testing.assert_equal(res['key'], np.array([[[0, 0], [1, 1]]] * 3, dtype=np.uint8))
+
+
+def test_simulate_sweeps_param_resolver():
+    q0, q1 = cirq.LineQubit.range(2)
+    simulator = cirq.ClassicalStateSimulator()
+    for b0 in [0, 1]:
+        for b1 in [0, 1]:
+            circuit = cirq.Circuit(
+                (cirq.X ** sympy.Symbol('b0'))(q0), (cirq.X ** sympy.Symbol('b1'))(q1)
+            )
+            params = [
+                cirq.ParamResolver({'b0': b0, 'b1': b1}),
+                cirq.ParamResolver({'b0': b1, 'b1': b0}),
+            ]
+            results = simulator.simulate_sweep(circuit, params=params)
+
+            assert results[0].params == params[0]
+            assert results[1].params == params[1]
+
+
+def test_create_partial_simulation_state_from_int_with_no_qubits():
+    sim = cirq.ClassicalStateSimulator()
+    initial_state = 5
+    qs = None
+    classical_data = cirq.value.ClassicalDataDictionaryStore()
+    with pytest.raises(ValueError):
+        sim._create_partial_simulation_state(
+            initial_state=initial_state, qubits=qs, classical_data=classical_data
+        )
+
+
+def test_create_partial_simulation_state_from_invalid_state():
+    sim = cirq.ClassicalStateSimulator()
+    initial_state = None
+    qs = cirq.LineQubit.range(2)
+    classical_data = cirq.value.ClassicalDataDictionaryStore()
+    with pytest.raises(ValueError):
+        sim._create_partial_simulation_state(
+            initial_state=initial_state, qubits=qs, classical_data=classical_data
+        )
+
+
+def test_create_partial_simulation_state_from_int():
+    sim = cirq.ClassicalStateSimulator()
+    initial_state = 15
+    qs = cirq.LineQubit.range(4)
+    classical_data = cirq.value.ClassicalDataDictionaryStore()
+    expected_result = [1, 1, 1, 1]
+    result = sim._create_partial_simulation_state(
+        initial_state=initial_state, qubits=qs, classical_data=classical_data
+    )._state.basis
+    assert result == expected_result
+
+
+def test_create_valid_partial_simulation_state_from_list():
+    sim = cirq.ClassicalStateSimulator()
+    initial_state = [1, 1, 1, 1]
+    qs = cirq.LineQubit.range(4)
+    classical_data = cirq.value.ClassicalDataDictionaryStore()
+    expected_result = [1, 1, 1, 1]
+    result = sim._create_partial_simulation_state(
+        initial_state=initial_state, qubits=qs, classical_data=classical_data
+    )._state.basis
+    assert result == expected_result
+
+
+def test_create_valid_partial_simulation_state_from_np():
+    sim = cirq.ClassicalStateSimulator()
+    initial_state = np.array([1, 1])
+    qs = cirq.LineQubit.range(2)
+    classical_data = cirq.value.ClassicalDataDictionaryStore()
+    sim_state = sim._create_partial_simulation_state(
+        initial_state=initial_state, qubits=qs, classical_data=classical_data
+    )
+    sim_state._act_on_fallback_(action=cirq.CX, qubits=qs)
+    result = sim_state._state.basis
+    expected_result = np.array([1, 0])
+    np.testing.assert_equal(result, expected_result)
+
+
+def test_create_invalid_partial_simulation_state_from_np():
+    initial_state = np.array([[1, 1], [1, 1]])
+    qs = cirq.LineQubit.range(2)
+    classical_data = cirq.value.ClassicalDataDictionaryStore()
+    sim = cirq.ClassicalStateSimulator()
+    sim_state = sim._create_partial_simulation_state(
+        initial_state=initial_state, qubits=qs, classical_data=classical_data
+    )
+    with pytest.raises(ValueError):
+        sim_state._act_on_fallback_(action=cirq.CX, qubits=qs)
+
+
+def test_noise_model():
+    noise_model = cirq.NoiseModel.from_noise_model_like(cirq.depolarize(p=0.01))
+    with pytest.raises(ValueError):
+        cirq.ClassicalStateSimulator(noise=noise_model)

cirq/sim/clifford/clifford_simulator_test.py

@@ -324,9 +324,11 @@ def test_clifford_circuit_SHSYSHS():
     clifford_simulator = cirq.CliffordSimulator()
     state_vector_simulator = cirq.Simulator()
 
+    # workaround until #6402 is resolved.
+    final_state_vector = state_vector_simulator.simulate(circuit).final_state_vector
+    final_state_vector /= np.linalg.norm(final_state_vector)
     np.testing.assert_almost_equal(
-        clifford_simulator.simulate(circuit).final_state.state_vector(),
-        state_vector_simulator.simulate(circuit).final_state_vector,
+        clifford_simulator.simulate(circuit).final_state.state_vector(), final_state_vector
     )
 
 

cirq/sim/mux.py

@@ -292,9 +292,11 @@ def final_density_matrix(
         density_result = density_matrix_simulator.DensityMatrixSimulator(
             dtype=dtype, noise=noise, seed=seed
         ).simulate(
-            program=measurement_transformers.dephase_measurements(circuit_like)
-            if ignore_measurement_results
-            else circuit_like,
+            program=(
+                measurement_transformers.dephase_measurements(circuit_like)
+                if ignore_measurement_results
+                else circuit_like
+            ),
             initial_state=initial_state,
             qubit_order=qubit_order,
             param_resolver=param_resolver,

cirq/sim/simulation_product_state.py

@@ -63,12 +63,19 @@ class SimulationProductState(
         return self._split_untangled_states
 
     def create_merged_state(self) -> TSimulationState:
+        merged_state = self.sim_states[None]
         if not self.split_untangled_states:
-            return self.sim_states[None]
-        final_args = self.sim_states[None]
-        for args in set([self.sim_states[k] for k in self.sim_states.keys() if k is not None]):
-            final_args = final_args.kronecker_product(args)
-        return final_args.transpose_to_qubit_order(self.qubits)
+            return merged_state
+        extra_states = set([self.sim_states[k] for k in self.sim_states.keys() if k is not None])
+        if not extra_states:
+            return merged_state
+
+        # This comes from a member variable so we need to copy it if we're going to modify inplace
+        # before returning. We're not running a step currently, so no need to copy buffers.
+        merged_state = merged_state.copy(deep_copy_buffers=False)
+        for state in extra_states:
+            merged_state.kronecker_product(state, inplace=True)
+        return merged_state.transpose_to_qubit_order(self.qubits, inplace=True)
 
     def _act_on_fallback_(
         self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
@@ -76,9 +83,7 @@ class SimulationProductState(
         gate_opt = (
             action
             if isinstance(action, ops.Gate)
-            else action.gate
-            if isinstance(action, ops.Operation)
-            else None
+            else action.gate if isinstance(action, ops.Operation) else None
         )
 
         if isinstance(gate_opt, ops.IdentityGate):
@@ -106,7 +111,7 @@ class SimulationProductState(
             if op_args_opt is None:
                 op_args_opt = self.sim_states[q]
             elif q not in op_args_opt.qubits:
-                op_args_opt = op_args_opt.kronecker_product(self.sim_states[q])
+                op_args_opt.kronecker_product(self.sim_states[q], inplace=True)
         op_args = op_args_opt or self.sim_states[None]
 
         # (Backfill the args map with the new value)
@@ -123,7 +128,7 @@ class SimulationProductState(
         ):
             for q in qubits:
                 if op_args.allows_factoring and len(op_args.qubits) > 1:
-                    q_args, op_args = op_args.factor((q,), validate=False)
+                    q_args, _ = op_args.factor((q,), validate=False, inplace=True)
                     self._sim_states[q] = q_args
 
             # (Backfill the args map with the new value)

cirq/sim/simulation_state.py

@@ -111,7 +111,7 @@ class SimulationState(SimulationStateBase, Generic[TState], metaclass=abc.ABCMet
         return [self.qubit_map[q] for q in qubits]
 
     def _perform_measurement(self, qubits: Sequence['cirq.Qid']) -> List[int]:
-        """Delegates the call to measure the density matrix."""
+        """Delegates the call to measure the `QuantumStateRepresentation`."""
         if self._state is not None:
             return self._state.measure(self.get_axes(qubits), self.prng)
         raise NotImplementedError()

cirq/sim/simulation_state_test.py

@@ -43,8 +43,8 @@ class ExampleSimulationState(cirq.SimulationState):
         return True
 
     def add_qubits(self, qubits):
-        ret = super().add_qubits(qubits)
-        return self if NotImplemented else ret
+        super().add_qubits(qubits)
+        return self
 
 
 class DelegatingAncillaZ(cirq.Gate):

cirq/sim/simulator_base.py

@@ -261,9 +261,9 @@ class SimulatorBase(
         for i in range(repetitions):
             for step_result in self._core_iterator(
                 general_suffix,
-                sim_state=sim_state.copy(deep_copy_buffers=False)
-                if i < repetitions - 1
-                else sim_state,
+                sim_state=(
+                    sim_state.copy(deep_copy_buffers=False) if i < repetitions - 1 else sim_state
+                ),
             ):
                 pass
             for k, r in step_result._classical_data.records.items():

cirq/sim/state_vector_simulation_state.py

@@ -60,11 +60,11 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         This initializer creates the buffer if necessary.
 
         Args:
-            initial_state: The density matrix, must be correctly formatted. The data is not
+            initial_state: The state vector, must be correctly formatted. The data is not
                 checked for validity here due to performance concerns.
-            qid_shape: The shape of the density matrix, if the initial state is provided as an int.
-            dtype: The dtype of the density matrix, if the initial state is provided as an int.
-            buffer: Optional, must be length 3 and same shape as the density matrix. If not
+            qid_shape: The shape of the state vector, if the initial state is provided as an int.
+            dtype: The dtype of the state vector, if the initial state is provided as an int.
+            buffer: Optional, must be length 3 and same shape as the state vector. If not
                 provided, a buffer will be created automatically.
         Raises:
             ValueError: If initial state is provided as integer, but qid_shape is not provided.

cirq/sim/state_vector_simulator.py

@@ -14,7 +14,9 @@
 """Abstract classes for simulations which keep track of state vector."""
 
 import abc
+from functools import cached_property
 from typing import Any, Dict, Iterator, Sequence, Type, TYPE_CHECKING, Generic, TypeVar
+import warnings
 
 import numpy as np
 
@@ -121,9 +123,22 @@ class StateVectorTrialResult(
             qubit_map=final_simulator_state.qubit_map,
         )
 
-    @_compat.cached_property
+    @cached_property
     def final_state_vector(self) -> np.ndarray:
-        return self._get_merged_sim_state().target_tensor.reshape(-1)
+        ret = self._get_merged_sim_state().target_tensor.reshape(-1)
+        norm = np.linalg.norm(ret)
+        if abs(norm - 1) > np.sqrt(np.finfo(ret.dtype).eps):
+            warnings.warn(
+                f"final state vector's {norm=} is too far from 1,"
+                f" {abs(norm-1)} > {np.sqrt(np.finfo(ret.dtype).eps)}."
+                "skipping renormalization"
+            )
+            return ret
+        # normalize only if doing so improves the round-off on total probability
+        ret_norm = ret / norm
+        round_off_change = abs(np.vdot(ret_norm, ret_norm) - 1) - abs(np.vdot(ret, ret) - 1)
+        result = ret_norm if round_off_change < 0 else ret
+        return result
 
     def state_vector(self, copy: bool = False) -> np.ndarray:
         """Return the state vector at the end of the computation.

cirq/study/__init__.py

@@ -36,6 +36,7 @@ from cirq.study.sweeps import (
     Points,
     Product,
     Sweep,
+    UNIT_SWEEP,
     UnitSweep,
     Zip,
     ZipLongest,

cirq/study/result.py

@@ -74,6 +74,18 @@ def _keyed_repeated_bitstrings(vals: Mapping[str, np.ndarray]) -> str:
     return '\n'.join(keyed_bitstrings)
 
 
+def _keyed_repeated_records(vals: Mapping[str, np.ndarray]) -> str:
+    keyed_bitstrings = []
+    for key in sorted(vals.keys()):
+        reps = vals[key]
+        n = reps.shape[2]
+        num_records = reps.shape[1]
+        for j in range(num_records):
+            all_bits = ', '.join(_bitstring(reps[:, j, i]) for i in range(n))
+            keyed_bitstrings.append(f'{key}={all_bits}')
+    return '\n'.join(keyed_bitstrings)
+
+
 def _key_to_str(key: TMeasurementKey) -> str:
     if isinstance(key, str):
         return key
@@ -388,6 +400,8 @@ class ResultDict(Result):
             p.text(str(self))
 
     def __str__(self) -> str:
+        if self._records:
+            return _keyed_repeated_records(self.records)
         return _keyed_repeated_bitstrings(self.measurements)
 
     def _json_dict_(self):

cirq/study/result_test.py

@@ -127,6 +127,12 @@ def test_str():
     )
     assert str(result) == 'ab=13579, 2 4 6 8 10\nc=01234'
 
+    result = cirq.ResultDict(records={'c': np.array([[[True], [True]]])})
+    assert str(result) == 'c=1\nc=1'
+
+    result = cirq.ResultDict(records={'c': np.array([[[True, False], [False, True]]])})
+    assert str(result) == 'c=1, 0\nc=0, 1'
+
 
 def test_df():
     result = cirq.ResultDict(

cirq/study/sweeps.py

@@ -205,6 +205,10 @@ class _Unit(Sweep):
 UnitSweep = _Unit()
 document(UnitSweep, """The singleton sweep with no parameters.""")
 
+# Alternate name to designate as a constant.
+UNIT_SWEEP = UnitSweep
+document(UNIT_SWEEP, """The singleton sweep with no parameters.""")
+
 
 class Product(Sweep):
     """Cartesian product of one or more sweeps.
@@ -232,8 +236,6 @@ class Product(Sweep):
         return sum((factor.keys for factor in self.factors), [])
 
     def __len__(self) -> int:
-        if not self.factors:
-            return 0
         length = 1
         for factor in self.factors:
             length *= len(factor)

cirq/study/sweeps_test.py

@@ -142,6 +142,11 @@ def test_product():
     assert _values(sweep, 'b') == [4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7]
 
 
+def test_empty_product():
+    sweep = cirq.Product()
+    assert len(sweep) == len(list(sweep)) == 1
+
+
 def test_slice_access_error():
     sweep = cirq.Points('a', [1, 2, 3])
     with pytest.raises(TypeError, match='<class \'str\'>'):
@@ -232,6 +237,9 @@ def test_equality():
 
     et.add_equality_group(cirq.UnitSweep, cirq.UnitSweep)
 
+    # Test singleton
+    assert cirq.UNIT_SWEEP is cirq.UnitSweep
+
     # Simple sweeps with the same key are equal to themselves, but different
     # from each other even if they happen to contain the same points.
     et.make_equality_group(lambda: cirq.Linspace('a', 0, 10, 11))

cirq/testing/__init__.py

@@ -69,7 +69,12 @@ from cirq.testing.equivalent_basis_map import assert_equivalent_computational_ba
 
 from cirq.testing.equivalent_repr_eval import assert_equivalent_repr
 
-from cirq.testing.gate_features import SingleQubitGate, TwoQubitGate, ThreeQubitGate
+from cirq.testing.gate_features import (
+    SingleQubitGate,
+    TwoQubitGate,
+    ThreeQubitGate,
+    DoesNotSupportSerializationGate,
+)
 
 from cirq.testing.json import assert_json_roundtrip_works
 

cirq/testing/_compat_test_data/__init__.py

@@ -3,11 +3,11 @@
 See cirq/_compat_test.py for the tests.
 This module contains example deprecations for modules.
 """
-import sys
-from logging import info
+import logging
+
 from cirq import _compat
 
-info("init:compat_test_data")
+logging.info("init:compat_test_data")
 
 # simulates a rename of a child module
 # fake_a -> module_a

cirq/testing/_compat_test_data/module_a/__init__.py

@@ -1,7 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 """module_a for module deprecation tests"""
 
-from logging import info
+import logging
 
 from cirq.testing._compat_test_data.module_a import module_b
 
@@ -11,4 +11,4 @@ from cirq.testing._compat_test_data.module_a.types import SampleType
 
 MODULE_A_ATTRIBUTE = "module_a"
 
-info("init:module_a")
+logging.info("init:module_a")

cirq/testing/circuit_compare.py

@@ -226,7 +226,7 @@ def assert_circuits_have_same_unitary_given_final_permutation(
     expected: circuits.AbstractCircuit,
     qubit_map: Dict[ops.Qid, ops.Qid],
 ) -> None:
-    """Asserts two circuits have the same unitary up to a final permuation of qubits.
+    """Asserts two circuits have the same unitary up to a final permutation of qubits.
 
     Args:
         actual: A circuit computed by some code under test.

cirq/testing/consistent_qasm.py

@@ -42,6 +42,7 @@ def assert_qasm_is_consistent_with_unitary(val: Any):
     if isinstance(val, ops.Operation):
         qubits: Sequence[ops.Qid] = val.qubits
         op = val
+        gate = val.gate
     elif isinstance(val, ops.Gate):
         qid_shape = protocols.qid_shape(val)
         remaining_shape = list(qid_shape)
@@ -52,9 +53,14 @@ def assert_qasm_is_consistent_with_unitary(val: Any):
                     remaining_shape.pop(i)
         qubits = devices.LineQid.for_qid_shape(remaining_shape)
         op = val.on(*qubits)
+        gate = val
     else:
         raise NotImplementedError(f"Don't know how to test {val!r}")
 
+    if isinstance(gate, ops.GlobalPhaseGate):
+        # OpenQASM 2.0 does not support global phase gates.
+        return
+
     args = protocols.QasmArgs(qubit_id_map={q: f'q[{i}]' for i, q in enumerate(qubits)})
     qasm = protocols.qasm(op, args=args, default=None)
     if qasm is None:

cirq/testing/gate_features.py

@@ -36,3 +36,13 @@ class ThreeQubitGate(raw_types.Gate):
 
     def _num_qubits_(self) -> int:
         return 3
+
+
+class DoesNotSupportSerializationGate(raw_types.Gate):
+    """A gate that can't be serialized."""
+
+    def __init__(self, n_qubits: int = 1):
+        self.n_qubits = n_qubits
+
+    def _num_qubits_(self) -> int:
+        return self.n_qubits

cirq/testing/lin_alg_utils.py

@@ -133,7 +133,8 @@ def random_special_unitary(
         The sampled special unitary.
     """
     r = random_unitary(dim, random_state=random_state)
-    r[0, :] /= np.linalg.det(r)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        r[0, :] /= np.linalg.det(r)
     return r
 
 
@@ -152,8 +153,9 @@ def random_special_orthogonal(
         The sampled special orthogonal matrix.
     """
     m = random_orthogonal(dim, random_state=random_state)
-    if np.linalg.det(m) < 0:
-        m[0, :] *= -1
+    with np.errstate(divide="ignore", invalid="ignore"):
+        if np.linalg.det(m) < 0:
+            m[0, :] *= -1
     return m
 
 

cirq/transformers/__init__.py

@@ -78,6 +78,8 @@ from cirq.transformers.drop_empty_moments import drop_empty_moments
 
 from cirq.transformers.drop_negligible_operations import drop_negligible_operations
 
+from cirq.transformers.dynamical_decoupling import add_dynamical_decoupling
+
 from cirq.transformers.eject_z import eject_z
 
 from cirq.transformers.measurement_transformers import (
@@ -119,3 +121,16 @@ from cirq.transformers.transformer_primitives import (
     unroll_circuit_op_greedy_earliest,
     unroll_circuit_op_greedy_frontier,
 )
+
+
+from cirq.transformers.gauge_compiling import (
+    CZGaugeTransformer,
+    ConstantGauge,
+    Gauge,
+    GaugeSelector,
+    GaugeTransformer,
+    ISWAPGaugeTransformer,
+    SpinInversionGaugeTransformer,
+    SqrtCZGaugeTransformer,
+    SqrtISWAPGaugeTransformer,
+)

cirq/transformers/analytical_decompositions/controlled_gate_decomposition.py

@@ -47,7 +47,9 @@ def _decompose_abc(matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarr
     See [1], chapter 4.
     """
     assert matrix.shape == (2, 2)
-    delta = np.angle(np.linalg.det(matrix)) * 0.5
+    with np.errstate(divide="ignore", invalid="ignore"):
+        # On MacOS, np.linalg.det emits superflous warnings
+        delta = np.angle(np.linalg.det(matrix)) * 0.5
     alpha = np.angle(matrix[0, 0]) + np.angle(matrix[0, 1]) - 2 * delta
     beta = np.angle(matrix[0, 0]) - np.angle(matrix[0, 1])
 

cirq/transformers/analytical_decompositions/two_qubit_to_cz.py

@@ -31,6 +31,24 @@ if TYPE_CHECKING:
     import cirq
 
 
+def _remove_partial_czs_or_fail(
+    operations: Iterable['cirq.Operation'], atol: float
+) -> List['cirq.Operation']:
+    result = []
+    for op in operations:
+        if isinstance(op.gate, ops.CZPowGate):
+            t = op.gate.exponent % 2  # CZ^t is periodic with period 2.
+            if t < atol:
+                continue  # Identity.
+            elif abs(t - 1) < atol:
+                result.append(ops.CZ(*op.qubits))  # Was either CZ or CZ**-1.
+            else:
+                raise ValueError(f'CZ^t is not allowed for t={t}')
+        else:
+            result.append(op)
+    return result
+
+
 def two_qubit_matrix_to_cz_operations(
     q0: 'cirq.Qid',
     q1: 'cirq.Qid',
@@ -53,10 +71,16 @@ def two_qubit_matrix_to_cz_operations(
 
     Returns:
         A list of operations implementing the matrix.
+
+    Raises:
+        ValueError: If allow_partial_czs=False and the matrix requires partial CZs.
     """
     kak = linalg.kak_decomposition(mat, atol=atol)
     operations = _kak_decomposition_to_operations(q0, q1, kak, allow_partial_czs, atol=atol)
     if clean_operations:
+        if not allow_partial_czs:
+            # CZ^t is not allowed for any $t$ except $t=1$.
+            return _remove_partial_czs_or_fail(cleanup_operations(operations), atol=atol)
         return cleanup_operations(operations)
     return operations
 

cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py

@@ -257,3 +257,20 @@ def test_decompose_to_diagonal_and_circuit(v):
     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=2e-6)
+
+
+def test_remove_partial_czs_or_fail():
+    CZ = cirq.CZ(*cirq.LineQubit.range(2))
+    assert (
+        cirq.transformers.analytical_decompositions.two_qubit_to_cz._remove_partial_czs_or_fail(
+            [CZ**1e-15], atol=1e-9
+        )
+        == []
+    )
+    assert cirq.transformers.analytical_decompositions.two_qubit_to_cz._remove_partial_czs_or_fail(
+        [CZ**-1, CZ], atol=1e-9
+    ) == [CZ, CZ]
+    with pytest.raises(ValueError):
+        _ = cirq.transformers.analytical_decompositions.two_qubit_to_cz._remove_partial_czs_or_fail(
+            [CZ**-0.5], atol=1e-9
+        )