Merge branch 'master' of https://github.com/quantumlib/cirq into controlled_op_gate_fix

Author: tanujkhattar

.github/workflows/ci.yml

@@ -191,11 +191,6 @@ jobs:
       - name: Install requirements
         run: |
           pip install -r dev_tools/requirements/deps/protos.txt
-          sudo apt install curl gnupg
-          curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor > bazel.gpg
-          sudo mv bazel.gpg /etc/apt/trusted.gpg.d/
-          echo "deb [arch=amd64] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
-          sudo apt update && sudo apt install bazel
       - name: Build protos
         run: check/build-changed-protos
   coverage:
@@ -335,4 +330,4 @@ jobs:
       - name: Install npm dependencies
         run: check/npm ci
       - name: Test
-        run: check/ts-coverage
+        run: check/ts-coverage

WORKSPACE

@@ -71,30 +71,9 @@ if [[ ! -z "$changed" ]]; then
     done
 fi
 
-# Check if any of the build files have changed.
-build_changed=$(git diff --name-only ${rev} -- \
-    | grep "google/api/.*BUILD$" \
-    | sed -e "s/BUILD//")
-
-if [[ -z "$build_changed" ]]; then
-    echo -e "No BUILD files changed."
-else
-    # Build all the targets for the changed BUILD rule.
-    echo -e "BUILD file changed in directories: '${build_changed[@]}'"
-    for build_prefix in $build_changed
-    do
-        (set -x; bazel build "${build_prefix}...:*")
-    done
-fi
-
-# We potentially will attempt to build a second time, but this is not
-# a problem as bazel returns immediately.
+# We potentially will attempt to build a second time.
 for base in $changed
 do
-    (set -x; bazel build "${base}_proto"; \
-    bazel build "${base}_py_proto"; \
-    bazel build "${base}_cc_proto")
-
     python -m grpc_tools.protoc -I=cirq-google --python_out=cirq-google --mypy_out=cirq-google ${base}.proto
 done
 
@@ -109,4 +88,4 @@ if [[ ! -z "$untracked" ]]; then
         echo -e "\033[31m   ${generated}\033[0m"
     done
     exit 1
-fi
+fi

check/build-changed-protos

@@ -259,6 +259,7 @@
     QubitOrderOrList,
     QubitPermutationGate,
     reset,
+    reset_each,
     ResetChannel,
     riswap,
     Rx,

check/build-protos

@@ -88,12 +88,7 @@ def is_virtual_moment(self, moment: 'cirq.Moment') -> bool:
         """
         if not moment.operations:
             return False
-        return all(
-            [
-                isinstance(op, ops.TaggedOperation) and ops.VirtualTag() in op.tags
-                for op in moment.operations
-            ]
-        )
+        return all(ops.VirtualTag() in op.tags for op in moment)
 
     def _noisy_moments_impl_moment(
         self, moments: 'Iterable[cirq.Moment]', system_qubits: Sequence['cirq.Qid']

cirq-core/cirq/__init__.py

@@ -287,7 +287,7 @@ def fractional_swap(target):
     return out
 
 
-def partial_trace(tensor: np.ndarray, keep_indices: List[int]) -> np.ndarray:
+def partial_trace(tensor: np.ndarray, keep_indices: Sequence[int]) -> np.ndarray:
     """Takes the partial trace of a given tensor.
 
     The input tensor must have shape `(d_0, ..., d_{k-1}, d_0, ..., d_{k-1})`.
@@ -620,12 +620,13 @@ def factor_density_matrix(
         `remainder` means the sub-matrix on the remaining axes, in the same
         order as the original density matrix.
     """
-    axes1 = list(axes) + [i + int(t.ndim / 2) for i in axes]
-    extracted, remainder = factor_state_vector(t, axes1, validate=False)
+    extracted = partial_trace(t, axes)
+    remaining_axes = [i for i in range(t.ndim // 2) if i not in axes]
+    remainder = partial_trace(t, remaining_axes)
     if validate:
         t1 = density_matrix_kronecker_product(extracted, remainder)
-        axes2 = list(axes) + [i for i in range(int(t.ndim / 2)) if i not in axes]
-        t2 = transpose_density_matrix_to_axis_order(t1, axes2)
+        product_axes = list(axes) + remaining_axes
+        t2 = transpose_density_matrix_to_axis_order(t1, product_axes)
         if not np.allclose(t2, t, atol=atol):
             raise ValueError('The tensor cannot be factored by the requested axes')
     return extracted, remainder

cirq-core/cirq/devices/noise_model.py

@@ -45,6 +45,7 @@
     PhaseDampingChannel,
     PhaseFlipChannel,
     reset,
+    reset_each,
     ResetChannel,
 )
 

cirq-core/cirq/linalg/transformations.py

@@ -15,7 +15,7 @@
 """Quantum channels that are commonly used in the literature."""
 
 import itertools
-from typing import Any, Dict, Iterable, Optional, Sequence, Tuple, Union, TYPE_CHECKING
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, Union, TYPE_CHECKING
 
 import numpy as np
 
@@ -789,6 +789,11 @@ def reset(qubit: 'cirq.Qid') -> raw_types.Operation:
     return ResetChannel(qubit.dimension).on(qubit)
 
 
+def reset_each(*qubits: 'cirq.Qid') -> List[raw_types.Operation]:
+    """Returns a list of `ResetChannel` instances on the given qubits."""
+    return [ResetChannel(q.dimension).on(q) for q in qubits]
+
+
 @value.value_equality
 class PhaseDampingChannel(gate_features.SingleQubitGate):
     """Dampen qubit phase.

cirq-core/cirq/ops/__init__.py

@@ -241,11 +241,22 @@ def test_deprecated_on_each_for_depolarizing_channel_one_qubit():
 
 
 def test_deprecated_on_each_for_depolarizing_channel_two_qubits():
-    q0, q1 = cirq.LineQubit.range(2)
+    q0, q1, q2, q3, q4, q5 = cirq.LineQubit.range(6)
     op = cirq.DepolarizingChannel(p=0.1, n_qubits=2)
 
-    with pytest.raises(ValueError, match="one qubit"):
+    op.on_each([(q0, q1)])
+    op.on_each([(q0, q1), (q2, q3)])
+    op.on_each(zip([q0, q2, q4], [q1, q3, q5]))
+    op.on_each((q0, q1))
+    op.on_each([q0, q1])
+    with pytest.raises(ValueError, match='Inputs to multi-qubit gates must be Sequence'):
         op.on_each(q0, q1)
+    with pytest.raises(ValueError, match='All values in sequence should be Qids'):
+        op.on_each([('bogus object 0', 'bogus object 1')])
+    with pytest.raises(ValueError, match='All values in sequence should be Qids'):
+        op.on_each(['01'])
+    with pytest.raises(ValueError, match='All values in sequence should be Qids'):
+        op.on_each([(False, None)])
 
 
 def test_depolarizing_channel_apply_two_qubits():
@@ -506,6 +517,16 @@ def test_reset_act_on():
     )
 
 
+def test_reset_each():
+    qubits = cirq.LineQubit.range(8)
+    for n in range(len(qubits) + 1):
+        ops = cirq.reset_each(*qubits[:n])
+        assert len(ops) == n
+        for i, op in enumerate(ops):
+            assert isinstance(op.gate, cirq.ResetChannel)
+            assert op.qubits == (qubits[i],)
+
+
 def test_phase_damping_channel():
     d = cirq.phase_damp(0.3)
     np.testing.assert_almost_equal(

cirq-core/cirq/ops/common_channels.py

@@ -18,7 +18,7 @@
 """
 
 import abc
-from typing import Union, Iterable, Any, List
+from typing import Union, Iterable, Any, List, Sequence
 
 from cirq.ops import raw_types
 
@@ -36,20 +36,39 @@ class SupportsOnEachGate(raw_types.Gate, metaclass=abc.ABCMeta):
 
     def on_each(self, *targets: Union[raw_types.Qid, Iterable[Any]]) -> List[raw_types.Operation]:
         """Returns a list of operations applying the gate to all targets.
-
         Args:
-            *targets: The qubits to apply this gate to.
-
+            *targets: The qubits to apply this gate to. For single-qubit gates
+            this can be provided as varargs or a combination of nested
+            iterables. For multi-qubit gates this must be provided as an
+            `Iterable[Sequence[Qid]]`, where each sequence has `num_qubits`
+            qubits.
         Returns:
             Operations applying this gate to the target qubits.
-
         Raises:
-            ValueError if targets are not instances of Qid or List[Qid].
-            ValueError if the gate operates on two or more Qids.
+            ValueError if targets are not instances of Qid or Iterable[Qid].
+            ValueError if the gate qubit number is incompatible.
         """
+        operations: List[raw_types.Operation] = []
         if self._num_qubits_() > 1:
-            raise ValueError('This gate only supports on_each when it is a one qubit gate.')
-        operations = []  # type: List[raw_types.Operation]
+            iterator: Iterable = targets
+            if len(targets) == 1:
+                if not isinstance(targets[0], Iterable):
+                    raise TypeError(f'{targets[0]} object is not iterable.')
+                t0 = list(targets[0])
+                iterator = [t0] if t0 and isinstance(t0[0], raw_types.Qid) else t0
+            for target in iterator:
+                if not isinstance(target, Sequence):
+                    raise ValueError(
+                        f'Inputs to multi-qubit gates must be Sequence[Qid].'
+                        f' Type: {type(target)}'
+                    )
+                if not all(isinstance(x, raw_types.Qid) for x in target):
+                    raise ValueError(f'All values in sequence should be Qids, but got {target}')
+                if len(target) != self._num_qubits_():
+                    raise ValueError(f'Expected {self._num_qubits_()} qubits, got {target}')
+                operations.append(self.on(*target))
+            return operations
+
         for target in targets:
             if isinstance(target, raw_types.Qid):
                 operations.append(self.on(target))

cirq-core/cirq/ops/common_channels_test.py

@@ -66,8 +66,28 @@ def test_identity_on_each_only_single_qubit():
         cirq.IdentityGate(1, (3,)).on(q0_3),
         cirq.IdentityGate(1, (3,)).on(q1_3),
     ]
-    with pytest.raises(ValueError, match='one qubit'):
-        cirq.IdentityGate(num_qubits=2).on_each(q0, q1)
+
+
+def test_identity_on_each_two_qubits():
+    q0, q1, q2, q3 = cirq.LineQubit.range(4)
+    q0_3, q1_3 = q0.with_dimension(3), q1.with_dimension(3)
+    assert cirq.IdentityGate(2).on_each([(q0, q1)]) == [cirq.IdentityGate(2)(q0, q1)]
+    assert cirq.IdentityGate(2).on_each([(q0, q1), (q2, q3)]) == [
+        cirq.IdentityGate(2)(q0, q1),
+        cirq.IdentityGate(2)(q2, q3),
+    ]
+    assert cirq.IdentityGate(2, (3, 3)).on_each([(q0_3, q1_3)]) == [
+        cirq.IdentityGate(2, (3, 3))(q0_3, q1_3),
+    ]
+    assert cirq.IdentityGate(2).on_each((q0, q1)) == [cirq.IdentityGate(2)(q0, q1)]
+    with pytest.raises(ValueError, match='Inputs to multi-qubit gates must be Sequence'):
+        cirq.IdentityGate(2).on_each(q0, q1)
+    with pytest.raises(ValueError, match='All values in sequence should be Qids'):
+        cirq.IdentityGate(2).on_each([[(q0, q1)]])
+    with pytest.raises(ValueError, match='Expected 2 qubits'):
+        cirq.IdentityGate(2).on_each([(q0,)])
+    with pytest.raises(ValueError, match='Expected 2 qubits'):
+        cirq.IdentityGate(2).on_each([(q0, q1, q2)])
 
 
 @pytest.mark.parametrize('num_qubits', [1, 2, 4])

cirq-core/cirq/ops/gate_features.py

@@ -425,7 +425,7 @@ def untagged(self) -> 'cirq.Operation':
         """Returns the underlying operation without any tags."""
         return self
 
-    def with_tags(self, *new_tags: Hashable) -> 'cirq.TaggedOperation':
+    def with_tags(self, *new_tags: Hashable) -> 'cirq.Operation':
         """Creates a new TaggedOperation, with this op and the specified tags.
 
         This method can be used to attach meta-data to specific operations
@@ -443,6 +443,8 @@ def with_tags(self, *new_tags: Hashable) -> 'cirq.TaggedOperation':
         Args:
             new_tags: The tags to wrap this operation in.
         """
+        if not new_tags:
+            return self
         return TaggedOperation(self, *new_tags)
 
     def transform_qubits(
@@ -608,6 +610,8 @@ def with_tags(self, *new_tags: Hashable) -> 'cirq.TaggedOperation':
         that has the tags of this operation combined with the new_tags
         specified as the parameter.
         """
+        if not new_tags:
+            return self
         return TaggedOperation(self.sub_operation, *self._tags, *new_tags)
 
     def __str__(self) -> str: