cirq-core 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/transformers/heuristic_decompositions/two_qubit_gate_tabulation_test.py

@@ -17,14 +17,14 @@ import pytest
 
 import cirq
 from cirq import value
+from cirq.testing import assert_equivalent_repr, random_special_unitary
+from cirq.transformers.heuristic_decompositions.gate_tabulation_math_utils import (
+    unitary_entanglement_fidelity,
+)
 from cirq.transformers.heuristic_decompositions.two_qubit_gate_tabulation import (
     two_qubit_gate_product_tabulation,
     TwoQubitGateTabulation,
 )
-from cirq.transformers.heuristic_decompositions.gate_tabulation_math_utils import (
-    unitary_entanglement_fidelity,
-)
-from cirq.testing import random_special_unitary, assert_equivalent_repr
 
 _rng = value.parse_random_state(11)  # for determinism
 

cirq/transformers/insertion_sort.py

@@ -0,0 +1,64 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+"""Transformer that sorts commuting operations in increasing order of their `.qubits` tuple."""
+
+from typing import Dict, List, Optional, TYPE_CHECKING
+
+from cirq import circuits, protocols
+from cirq.transformers import transformer_api
+
+if TYPE_CHECKING:
+    import cirq
+
+
+@transformer_api.transformer(add_deep_support=True)
+def insertion_sort_transformer(
+    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
+) -> 'cirq.Circuit':
+    """Sorts the operations using their sorted `.qubits` property as comparison key.
+
+    Operations are swapped only if they commute.
+
+    Args:
+        circuit: input circuit.
+        context: optional TransformerContext (not used),
+    """
+    final_operations: List['cirq.Operation'] = []
+    qubit_index: Dict['cirq.Qid', int] = {
+        q: idx for idx, q in enumerate(sorted(circuit.all_qubits()))
+    }
+    cached_qubit_indices: Dict[int, List[int]] = {}
+    for pos, op in enumerate(circuit.all_operations()):
+        # here `pos` is at the append position of final_operations
+        if (op_qubit_indices := cached_qubit_indices.get(id(op))) is None:
+            op_qubit_indices = cached_qubit_indices[id(op)] = sorted(
+                qubit_index[q] for q in op.qubits
+            )
+        for tail_op in reversed(final_operations):
+            tail_qubit_indices = cached_qubit_indices[id(tail_op)]
+            if op_qubit_indices < tail_qubit_indices and (
+                # special case for zero-qubit gates
+                not op_qubit_indices
+                # check if two sorted sequences are disjoint
+                or op_qubit_indices[-1] < tail_qubit_indices[0]
+                or set(op_qubit_indices).isdisjoint(tail_qubit_indices)
+                # fallback to more expensive commutation check
+                or protocols.commutes(op, tail_op, default=False)
+            ):
+                pos -= 1
+                continue
+            break
+        final_operations.insert(pos, op)
+    return circuits.Circuit(final_operations)

cirq/transformers/insertion_sort_test.py

@@ -0,0 +1,34 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+import cirq
+import cirq.transformers
+
+
+def test_insertion_sort():
+    c = cirq.Circuit(
+        cirq.CZ(cirq.q(2), cirq.q(1)),
+        cirq.CZ(cirq.q(2), cirq.q(4)),
+        cirq.CZ(cirq.q(0), cirq.q(1)),
+        cirq.CZ(cirq.q(2), cirq.q(1)),
+        cirq.GlobalPhaseGate(1j).on(),
+    )
+    sorted_circuit = cirq.transformers.insertion_sort_transformer(c)
+    assert sorted_circuit == cirq.Circuit(
+        cirq.GlobalPhaseGate(1j).on(),
+        cirq.CZ(cirq.q(0), cirq.q(1)),
+        cirq.CZ(cirq.q(2), cirq.q(1)),
+        cirq.CZ(cirq.q(2), cirq.q(1)),
+        cirq.CZ(cirq.q(2), cirq.q(4)),
+    )

cirq/transformers/measurement_transformers.py

@@ -292,7 +292,20 @@ def drop_terminal_measurements(
     def flip_inversion(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
         if isinstance(op.gate, ops.MeasurementGate):
             return [
-                ops.X(q) if b else ops.I(q) for q, b in zip(op.qubits, op.gate.full_invert_mask())
+                (
+                    (ops.X if b else ops.I)
+                    if q.dimension == 2
+                    else (
+                        ops.MatrixGate(
+                            # Per SimulationState.measure(), swap 0,1 but leave other dims alone
+                            np.eye(q.dimension)[[1, 0, *range(2, q.dimension)]],
+                            qid_shape=(q.dimension,),
+                        )
+                        if b
+                        else ops.IdentityGate(qid_shape=(q.dimension,))
+                    )
+                ).on(q)
+                for q, b in zip(op.qubits, op.gate.full_invert_mask())
             ]
         return op
 

cirq/transformers/measurement_transformers_test.py

@@ -759,6 +759,41 @@ def test_drop_terminal():
     )
 
 
+def test_drop_terminal_qudit():
+    q0, q1 = cirq.LineQid.range(2, dimension=3)
+    circuit = cirq.Circuit(
+        cirq.CircuitOperation(cirq.FrozenCircuit(cirq.measure(q0, q1, key='m', invert_mask=[0, 1])))
+    )
+    dropped = cirq.drop_terminal_measurements(circuit)
+    expected_inversion_matrix = np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
+    cirq.testing.assert_same_circuits(
+        dropped,
+        cirq.Circuit(
+            cirq.CircuitOperation(
+                cirq.FrozenCircuit(
+                    cirq.IdentityGate(qid_shape=(3,)).on(q0),
+                    cirq.MatrixGate(expected_inversion_matrix, qid_shape=(3,)).on(q1),
+                )
+            )
+        ),
+    )
+    # Verify behavior equivalent to simulator (invert_mask swaps 0,1 but leaves 2 alone)
+    dropped.append(cirq.measure(q0, q1, key='m'))
+    sim = cirq.Simulator()
+    c0 = sim.simulate(circuit, initial_state=[0, 0])
+    d0 = sim.simulate(dropped, initial_state=[0, 0])
+    assert np.all(c0.measurements['m'] == [0, 1])
+    assert np.all(d0.measurements['m'] == [0, 1])
+    c1 = sim.simulate(circuit, initial_state=[1, 1])
+    d1 = sim.simulate(dropped, initial_state=[1, 1])
+    assert np.all(c1.measurements['m'] == [1, 0])
+    assert np.all(d1.measurements['m'] == [1, 0])
+    c2 = sim.simulate(circuit, initial_state=[2, 2])
+    d2 = sim.simulate(dropped, initial_state=[2, 2])
+    assert np.all(c2.measurements['m'] == [2, 2])
+    assert np.all(d2.measurements['m'] == [2, 2])
+
+
 def test_drop_terminal_nonterminal_error():
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(

cirq/transformers/merge_k_qubit_gates.py

@@ -14,9 +14,9 @@
 
 """Transformer pass to merge connected components of k-qubit unitary operations."""
 
-from typing import cast, Optional, Callable, TYPE_CHECKING
+from typing import Callable, cast, Optional, TYPE_CHECKING
 
-from cirq import ops, protocols, circuits
+from cirq import circuits, ops, protocols
 from cirq.transformers import transformer_api, transformer_primitives
 
 if TYPE_CHECKING:

cirq/transformers/merge_single_qubit_gates.py

@@ -17,8 +17,8 @@
 from typing import Optional, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
+from cirq.transformers import merge_k_qubit_gates, transformer_api, transformer_primitives
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
-from cirq.transformers import transformer_api, transformer_primitives, merge_k_qubit_gates
 
 if TYPE_CHECKING:
     import cirq

cirq/transformers/merge_single_qubit_gates_test.py

@@ -45,7 +45,7 @@ def test_merge_single_qubit_gates_to_phased_x_and_z():
         optimized=cirq.merge_single_qubit_gates_to_phased_x_and_z(c),
         expected=cirq.Circuit(
             cirq.PhasedXPowGate(phase_exponent=1)(a),
-            cirq.Y(b) ** 0.5,
+            cirq.PhasedXPowGate(phase_exponent=0.5)(b) ** 0.5,
             cirq.CZ(a, b),
             (cirq.PhasedXPowGate(phase_exponent=-0.5)(a)) ** 0.5,
             cirq.measure(b, key="m"),

cirq/transformers/noise_adding.py

@@ -0,0 +1,115 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 collections.abc import Mapping
+from typing import cast
+
+import numpy as np
+
+from cirq import circuits, ops
+from cirq.transformers import transformer_api
+
+
+def _gate_in_moment(gate: ops.Gate, moment: circuits.Moment) -> bool:
+    """Check whether `gate` is in `moment`."""
+    return any(op.gate == gate for op in moment)
+
+
+@transformer_api.transformer
+class DepolarizingNoiseTransformer:
+    """Add local depolarizing noise after two-qubit gates in a specified circuit. More specifically,
+    with probability p, append a random non-identity two-qubit Pauli operator after each specified
+    two-qubit gate.
+
+    Attrs:
+        p: The probability with which to add noise.
+        target_gate: Add depolarizing nose after this type of gate
+    """
+
+    def __init__(
+        self, p: float | Mapping[tuple[ops.Qid, ops.Qid], float], target_gate: ops.Gate = ops.CZ
+    ):
+        """Initialize the depolarizing noise transformer with some depolarizing probability and
+        target gate.
+
+        Args:
+            p: The depolarizing probability, either a single float or a mapping from pairs of qubits
+               to floats.
+           target_gate: The gate after which to add depolarizing noise.
+
+        Raises:
+            TypeError: If `p` is not either be a float or a mapping from sorted qubit pairs to
+                       floats.
+        """
+
+        if not isinstance(p, (Mapping, float)):
+            raise TypeError(  # pragma: no cover
+                "p must either be a float or a mapping from"  # pragma: no cover
+                + "sorted qubit pairs to floats"  # pragma: no cover
+            )  # pragma: no cover
+        self.p = p
+        self.p_func = (
+            (lambda _: p)
+            if isinstance(p, (int, float))
+            else (lambda pair: cast(Mapping, p).get(pair, 0.0))
+        )
+        self.target_gate = target_gate
+
+    def __call__(
+        self,
+        circuit: circuits.AbstractCircuit,
+        rng: np.random.Generator | None = None,
+        *,
+        context: transformer_api.TransformerContext | None = None,
+    ):
+        """Apply the transformer to the given circuit.
+
+        Args:
+            circuit: The circuit to add noise to.
+            context: Not used; to satisfy transformer API.
+
+        Returns:
+            The transformed circuit.
+        """
+        if rng is None:
+            rng = np.random.default_rng()
+        target_gate = self.target_gate
+
+        # add random Pauli gates with probability p after each of the specified gate
+        assert target_gate.num_qubits() == 2, "`target_gate` must be a two-qubit gate."
+        paulis = [ops.I, ops.X, ops.Y, ops.Z]
+        new_moments = []
+        for moment in circuit:
+            new_moments.append(moment)
+            if _gate_in_moment(target_gate, moment):
+                # add a new moment with the Paulis
+                target_pairs = {
+                    tuple(sorted(op.qubits)) for op in moment.operations if op.gate == target_gate
+                }
+                added_moment_ops = []
+                for pair in target_pairs:
+                    pair_sorted_tuple = (pair[0], pair[1])
+                    p_i = self.p_func(pair_sorted_tuple)
+                    apply = rng.choice([True, False], p=[p_i, 1 - p_i])
+                    if apply:
+                        choices = [
+                            (pauli_a(pair[0]), pauli_b(pair[1]))
+                            for pauli_a in paulis
+                            for pauli_b in paulis
+                        ][1:]
+                        pauli_to_apply = rng.choice(np.array(choices, dtype=object))
+                        added_moment_ops.append(pauli_to_apply)
+                if len(added_moment_ops) > 0:
+                    new_moments.append(circuits.Moment(*added_moment_ops))
+        return circuits.Circuit.from_moments(*new_moments)

cirq/transformers/noise_adding_test.py

@@ -0,0 +1,54 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+import numpy as np
+
+import cirq.transformers.noise_adding as na
+from cirq import circuits, devices, ops
+
+
+def test_noise_adding():
+    qubits = devices.LineQubit.range(4)
+    one_layer = circuits.Circuit(ops.CZ(*qubits[:2]), ops.CZ(*qubits[2:]))
+    circuit = one_layer * 10
+
+    # test that p=0 does nothing
+    transformed_circuit_p0 = na.DepolarizingNoiseTransformer(0.0)(circuit)
+    assert transformed_circuit_p0 == circuit
+
+    # test that p=1 doubles the circuit depth
+    transformed_circuit_p1 = na.DepolarizingNoiseTransformer(1.0)(circuit)
+    assert len(transformed_circuit_p1) == 20
+
+    # test that we get a deterministic result when using a specific rng
+    rng = np.random.default_rng(0)
+    transformed_circuit_p0_03 = na.DepolarizingNoiseTransformer(0.03)(circuit, rng=rng)
+    expected_circuit = (
+        one_layer * 2
+        + circuits.Circuit(ops.I(qubits[2]), ops.Z(qubits[3]))
+        + one_layer * 4
+        + circuits.Circuit(ops.Z(qubits[0]), ops.X(qubits[1]))
+        + one_layer * 4
+        + circuits.Circuit(ops.I(qubits[2]), ops.X(qubits[3]))
+    )
+    assert transformed_circuit_p0_03 == expected_circuit
+
+    # test that supplying a dictionary for p works
+    transformed_circuit_p_dict = na.DepolarizingNoiseTransformer(
+        {tuple(qubits[:2]): 1.0, tuple(qubits[2:]): 0.0}
+    )(circuit)
+    assert len(transformed_circuit_p_dict) == 20  # depth should be doubled
+    assert transformed_circuit_p_dict[1::2].all_qubits() == frozenset(
+        qubits[:2]
+    )  # no single-qubit gates get added to qubits[2:]

cirq/transformers/optimize_for_target_gateset.py

@@ -14,7 +14,7 @@
 
 """Transformers to rewrite a circuit using gates from a given target gateset."""
 
-from typing import Optional, Callable, Hashable, Sequence, TYPE_CHECKING, Union
+from typing import Callable, Hashable, Optional, Sequence, TYPE_CHECKING, Union
 
 from cirq import circuits
 from cirq.protocols import decompose_protocol as dp

cirq/transformers/optimize_for_target_gateset_test.py

@@ -14,10 +14,11 @@
 
 from typing import Union
 
+import pytest
+
 import cirq
 from cirq.protocols.decompose_protocol import DecomposeResult
 from cirq.transformers.optimize_for_target_gateset import _decompose_operations_to_target_gateset
-import pytest
 
 
 def test_decompose_operations_raises_on_stuck():
@@ -327,7 +328,7 @@ def test_optimize_for_target_gateset_multiple_passes(max_num_passes: Union[int,
 
 @pytest.mark.parametrize('max_num_passes', [2, None])
 def test_optimize_for_target_gateset_multiple_passes_dont_preserve_moment_structure(
-    max_num_passes: Union[int, None]
+    max_num_passes: Union[int, None],
 ):
     gateset = cirq.CZTargetGateset(preserve_moment_structure=False)
 

cirq/transformers/qubit_management_transformers.py

@@ -169,7 +169,7 @@ def map_clean_and_borrowable_qubits(
                     # one from the original system qubits.
                     allocated_map[q] = qm.qborrow(1)[0]
             else:
-                assert False, f"Unknown temporary qubit type {q}"
+                assert False, f"Unknown temporary qubit type {q}"  # pragma: no cover
 
         # Return the transformed operation / decomposed op-tree.
         return op.transform_qubits({**allocated_map, **trivial_map})

cirq/transformers/randomized_measurements.py

@@ -0,0 +1,171 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+import cirq
+from cirq.ops import SingleQubitCliffordGate
+from cirq.transformers import transformer_api
+
+
+@transformer_api.transformer
+class RandomizedMeasurements:
+    """A transformer that appends a moment of random rotations from a given unitary ensemble (pauli,
+    clifford, cue)"""
+
+    def __init__(self, subsystem: Sequence[int] | None = None):
+        """Class structure for performing and analyzing a general randomized measurement protocol.
+        For more details on the randomized measurement toolbox see https://arxiv.org/abs/2203.11374
+
+        Args:
+            subsystem: The specific subsystem (e.g qubit index) to measure in random basis
+            rest of the qubits are measured in the computational basis
+        """
+        self.subsystem = subsystem
+
+    def __call__(
+        self,
+        circuit: "cirq.AbstractCircuit",
+        unitary_ensemble: str = "pauli",
+        rng: np.random.Generator | None = None,
+        *,
+        context: transformer_api.TransformerContext | None = None,
+    ) -> "cirq.Circuit":
+        """Apply the transformer to the given circuit. Given an input circuit returns
+        a new circuit with the pre-measurement unitaries and measurements gates added.
+        to the qubits in the subsystem provided.If no subsystem is specified in the
+        construction of this class it defaults to measuring all the qubits in the
+        randomized bases.
+
+        Args:
+            circuit: The circuit to add randomized measurements to.
+            unitary_ensemble: Choice of unitary ensemble (pauli/clifford/cue(circular
+                unitary ensemble))
+            context: Not used; to satisfy transformer API.
+            rng: Random number generator.
+
+        Returns:
+            A circuit with pre-measurement unitaries and measurements added
+        """
+
+        all_qubits = sorted(circuit.all_qubits())
+        if self.subsystem is None:
+            subsystem_qubits = all_qubits
+        else:
+            subsystem_qubits = [all_qubits[s] for s in self.subsystem]
+        if rng is None:
+            rng = np.random.default_rng()
+
+        pre_measurement_moment = self.random_single_qubit_unitary_moment(
+            unitary_ensemble, subsystem_qubits, rng
+        )
+
+        return cirq.Circuit.from_moments(
+            *circuit.moments, pre_measurement_moment, cirq.M(*subsystem_qubits, key="m")
+        )
+
+    def random_single_qubit_unitary_moment(
+        self, unitary_ensemble: str, qubits: Sequence[Any], rng: np.random.Generator
+    ) -> "cirq.Moment":
+        """Outputs the cirq moment associated with the pre-measurement rotations.
+
+        Args:
+            unitary_ensemble: clifford, pauli, cue
+            qubits: List of qubits
+            rng: Random number generator to be used in sampling.
+
+        Returns:
+            The cirq moment associated with the pre-measurement rotations
+
+        Raises:
+            ValueError: When unitary_ensemble is not one of "cue", "pauli" or "clifford"
+        """
+
+        if unitary_ensemble.lower() == "pauli":
+            unitaries = [_pauli_basis_rotation(rng) for _ in range(len(qubits))]
+
+        elif unitary_ensemble.lower() == "clifford":
+            unitaries = [_single_qubit_clifford(rng) for _ in range(len(qubits))]
+
+        elif unitary_ensemble.lower() == "cue":
+            unitaries = [_single_qubit_cue(rng) for _ in range(len(qubits))]
+
+        else:
+            raise ValueError("Only pauli, clifford and cue unitaries are available")
+
+        op_list: list[cirq.Operation] = []
+
+        for idx, unitary in enumerate(unitaries):
+            op_list.append(unitary.on(qubits[idx]))
+
+        return cirq.Moment.from_ops(*op_list)
+
+
+def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
+    """Randomly generate a Pauli basis rotation.
+
+    Args:
+        rng: Random number generator
+
+    Returns:
+        cirq gate
+    """
+    basis_idx = rng.choice(np.arange(3))
+
+    if basis_idx == 0:
+        gate: "cirq.Gate" = cirq.Ry(rads=-np.pi / 2)
+    elif basis_idx == 1:
+        gate = cirq.Rx(rads=np.pi / 2)
+    else:
+        gate = cirq.I
+    return gate
+
+
+def _single_qubit_clifford(rng: np.random.Generator) -> "cirq.Gate":
+    """Randomly generate a single-qubit Clifford rotation.
+
+    Args:
+        rng: Random number generator
+
+    Returns:
+        cirq gate
+    """
+
+    # there are 24 distinct single-qubit Clifford gates
+    clifford_idx = rng.choice(np.arange(24))
+
+    return SingleQubitCliffordGate.to_phased_xz_gate(
+        SingleQubitCliffordGate.all_single_qubit_cliffords[clifford_idx]
+    )
+
+
+def _single_qubit_cue(rng: np.random.Generator) -> "cirq.Gate":
+    """Randomly generate a CUE gate.
+
+    Args:
+        rng: Random number generator
+
+    Returns:
+        cirq gate
+    """
+
+    # phasedxz parameters are distinct between -1 and +1
+    x_exponent, z_exponent, axis_phase_exponent = 1 - 2 * rng.random(size=3)
+
+    return cirq.PhasedXZGate(
+        x_exponent=x_exponent, z_exponent=z_exponent, axis_phase_exponent=axis_phase_exponent
+    )

cirq/transformers/randomized_measurements_test.py

@@ -0,0 +1,68 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+import pytest
+
+import cirq
+import cirq.transformers.randomized_measurements as rand_meas
+
+
+def test_randomized_measurements_appends_two_moments_on_returned_circuit():
+    # Create a 4-qubit circuit
+    q0, q1, q2, q3 = cirq.LineQubit.range(4)
+    circuit_pre = cirq.Circuit(
+        [cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)]
+    )
+    num_moments_pre = len(circuit_pre.moments)
+
+    # Append randomized measurements to subsystem
+    unitary_ensembles = ['pauli', 'clifford', 'cue']
+    for u in unitary_ensembles:
+        circuit_post = rand_meas.RandomizedMeasurements()(circuit_pre, unitary_ensemble=u)
+        num_moments_post = len(circuit_post.moments)
+        assert num_moments_post == num_moments_pre + 2
+
+
+def test_append_randomized_measurements_leaves_qubits_not_in_specified_subsystem_unchanged():
+    # Create a 4-qubit circuit
+    q0, q1, q2, q3 = cirq.LineQubit.range(4)
+    circuit = cirq.Circuit([cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)])
+
+    # Append randomized measurements to subsystem
+    circuit = rand_meas.RandomizedMeasurements(subsystem=(0, 1))(circuit)
+    # assert latter subsystems were not changed.
+    assert circuit.operation_at(q2, 4) is None
+    assert circuit.operation_at(q3, 4) is None
+
+
+def test_append_randomized_measurements_leaves_qubits_not_in_noncontinuous_subsystem_unchanged():
+    # Create a 4-qubit circuit
+    q0, q1, q2, q3 = cirq.LineQubit.range(4)
+    circuit = cirq.Circuit([cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)])
+
+    # Append randomized measurements to subsystem
+    circuit = rand_meas.RandomizedMeasurements(subsystem=(0, 2))(circuit)
+
+    # assert latter subsystems were not changed.
+    assert circuit.operation_at(q1, 4) is None
+    assert circuit.operation_at(q3, 4) is None
+
+
+def test_exception():
+    q0, q1, q2, q3 = cirq.LineQubit.range(4)
+    circuit = cirq.Circuit([cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)])
+
+    # Append randomized measurements to subsystem
+    with pytest.raises(ValueError):
+        rand_meas.RandomizedMeasurements()(circuit, unitary_ensemble="coe")