Add act_on protocol

cirq/__init__.py

@@ -315,6 +315,7 @@
 )
 
 from cirq.sim import (
+    ActOnStateVectorArgs,
     StabilizerStateChForm,
     CIRCUIT_LIKE,
     CliffordSimulator,
@@ -394,6 +395,7 @@
 
 # pylint: disable=redefined-builtin
 from cirq.protocols import (
+    act_on,
     apply_channel,
     apply_mixture,
     apply_unitaries,
@@ -438,10 +440,11 @@
     QuilFormatter,
     read_json,
     resolve_parameters,
+    SupportsActOn,
     SupportsApplyChannel,
     SupportsApplyMixture,
-    SupportsConsistentApplyUnitary,
     SupportsApproximateEquality,
+    SupportsConsistentApplyUnitary,
     SupportsChannel,
     SupportsCircuitDiagramInfo,
     SupportsCommutes,

cirq/ops/common_channels.py

@@ -552,6 +552,29 @@ def __init__(self, dimension: int = 2) -> None:
     def _qid_shape_(self):
         return (self._dimension,)
 
+    def _act_on_(self, args: Any):
+        from cirq import sim
+
+        if isinstance(args, sim.ActOnStateVectorArgs):
+            # Do a silent measurement.
+            measurements, _ = sim.measure_state_vector(
+                args.target_tensor,
+                args.axes,
+                out=args.target_tensor,
+                qid_shape=args.target_tensor.shape)
+            result = measurements[0]
+
+            # Use measurement result to zero the qid.
+            if result:
+                zero = args.subspace_index(0)
+                other = args.subspace_index(result)
+                args.target_tensor[zero] = args.target_tensor[other]
+                args.target_tensor[other] = 0
+
+            return True
+
+        return NotImplemented
+
     def _channel_(self) -> Iterable[np.ndarray]:
         # The first axis is over the list of channel matrices
         channel = np.zeros((self._dimension,) * 3, dtype=np.complex64)

cirq/ops/gate_operation.py

@@ -56,6 +56,8 @@ def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'cirq.Operation':
         return self.gate.on(*new_qubits)
 
     def with_gate(self, new_gate: 'cirq.Gate') -> 'cirq.Operation':
+        if self.gate is new_gate:
+            return self
         return new_gate.on(*self.qubits)
 
     def __repr__(self):
@@ -103,7 +105,7 @@ def _value_equality_values_(self):
         return self.gate, self._group_interchangeable_qubits()
 
     def _qid_shape_(self):
-        return protocols.qid_shape(self.gate)
+        return self.gate._qid_shape_()
 
     def _num_qubits_(self):
         return len(self._qubits)
@@ -114,33 +116,57 @@ def _decompose_(self) -> 'cirq.OP_TREE':
                                                     NotImplemented)
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
-        return protocols.pauli_expansion(self.gate)
+        getter = getattr(self.gate, '_pauli_expansion_', None)
+        if getter is not None:
+            return getter()
+        return NotImplemented
 
     def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs'
                        ) -> Union[np.ndarray, None, NotImplementedType]:
-        return protocols.apply_unitary(self.gate, args, default=None)
+        getter = getattr(self.gate, '_apply_unitary_', None)
+        if getter is not None:
+            return getter(args)
+        return NotImplemented
 
     def _has_unitary_(self) -> bool:
-        return protocols.has_unitary(self.gate)
+        getter = getattr(self.gate, '_has_unitary_', None)
+        if getter is not None:
+            return getter()
+        return NotImplemented
 
     def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
-        return protocols.unitary(self.gate, default=None)
+        getter = getattr(self.gate, '_unitary_', None)
+        if getter is not None:
+            return getter()
+        return NotImplemented
 
     def _commutes_(self, other: Any,
                    atol: float) -> Union[bool, NotImplementedType, None]:
         return self.gate._commutes_on_qids_(self.qubits, other, atol=atol)
 
     def _has_mixture_(self) -> bool:
-        return protocols.has_mixture(self.gate)
+        getter = getattr(self.gate, '_has_mixture_', None)
+        if getter is not None:
+            return getter()
+        return NotImplemented
 
     def _mixture_(self) -> Sequence[Tuple[float, Any]]:
-        return protocols.mixture(self.gate, NotImplemented)
+        getter = getattr(self.gate, '_mixture_', None)
+        if getter is not None:
+            return getter()
+        return NotImplemented
 
     def _has_channel_(self) -> bool:
-        return protocols.has_channel(self.gate)
+        getter = getattr(self.gate, '_has_channel_', None)
+        if getter is not None:
+            return getter()
+        return NotImplemented
 
     def _channel_(self) -> Union[Tuple[np.ndarray], NotImplementedType]:
-        return protocols.channel(self.gate, NotImplemented)
+        getter = getattr(self.gate, '_channel_', None)
+        if getter is not None:
+            return getter()
+        return NotImplemented
 
     def _measurement_key_(self) -> Optional[str]:
         getter = getattr(self.gate, '_measurement_key_', None)
@@ -154,12 +180,21 @@ def _measurement_keys_(self) -> Optional[Iterable[str]]:
             return getter()
         return NotImplemented
 
+    def _act_on_(self, args: Any):
+        getter = getattr(self.gate, '_act_on_', None)
+        if getter is not None:
+            return getter(args)
+        return NotImplemented
+
     def _is_parameterized_(self) -> bool:
-        return protocols.is_parameterized(self.gate)
+        getter = getattr(self.gate, '_is_parameterized_', None)
+        if getter is not None:
+            return getter()
+        return NotImplemented
 
     def _resolve_parameters_(self, resolver):
         resolved_gate = protocols.resolve_parameters(self.gate, resolver)
-        return GateOperation(resolved_gate, self._qubits)
+        return self.with_gate(resolved_gate)
 
     def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs'
                               ) -> 'cirq.CircuitDiagramInfo':
@@ -174,7 +209,10 @@ def _decompose_into_clifford_(self):
         return sub(self.qubits)
 
     def _trace_distance_bound_(self) -> float:
-        return protocols.trace_distance_bound(self.gate)
+        getter = getattr(self.gate, '_trace_distance_bound_', None)
+        if getter is not None:
+            return getter()
+        return NotImplemented
 
     def _phase_by_(self, phase_turns: float,
                    qubit_index: int) -> 'GateOperation':

cirq/ops/gate_operation_test.py

@@ -207,6 +207,22 @@ def test_pauli_expansion():
     assert (cirq.pauli_expansion(cirq.CNOT(a, b)) == cirq.pauli_expansion(
         cirq.CNOT))
 
+    class No(cirq.Gate):
+
+        def num_qubits(self) -> int:
+            return 1
+
+    class Yes(cirq.Gate):
+
+        def num_qubits(self) -> int:
+            return 1
+
+        def _pauli_expansion_(self):
+            return cirq.LinearDict({'X': 0.5})
+
+    assert cirq.pauli_expansion(No().on(a), default=None) is None
+    assert cirq.pauli_expansion(Yes().on(a)) == cirq.LinearDict({'X': 0.5})
+
 
 def test_unitary():
     a = cirq.NamedQubit('a')
@@ -344,3 +360,39 @@ def _mul_with_qubits(self, qubits, other):
     # Handles the symmetric type case correctly.
     assert m * m == 6
     assert r * r == 4
+
+
+def test_with_gate():
+    g1 = cirq.GateOperation(cirq.X, cirq.LineQubit.range(1))
+    g2 = cirq.GateOperation(cirq.Y, cirq.LineQubit.range(1))
+    assert g1.with_gate(cirq.X) is g1
+    assert g1.with_gate(cirq.Y) == g2
+
+
+def test_is_parameterized():
+
+    class No1(cirq.Gate):
+
+        def num_qubits(self) -> int:
+            return 1
+
+    class No2(cirq.Gate):
+
+        def num_qubits(self) -> int:
+            return 1
+
+        def _is_parameterized_(self):
+            return False
+
+    class Yes(cirq.Gate):
+
+        def num_qubits(self) -> int:
+            return 1
+
+        def _is_parameterized_(self):
+            return True
+
+    q = cirq.LineQubit(0)
+    assert not cirq.is_parameterized(No1().on(q))
+    assert not cirq.is_parameterized(No2().on(q))
+    assert cirq.is_parameterized(Yes().on(q))

cirq/ops/measurement_gate.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Iterable, Optional, Tuple, Sequence, TYPE_CHECKING
+from typing import Any, Dict, Iterable, Optional, Tuple, Sequence, \
+    TYPE_CHECKING, Union
 
 import numpy as np
 
@@ -215,6 +216,28 @@ def _from_json_dict_(cls,
                    invert_mask=tuple(invert_mask),
                    qid_shape=None if qid_shape is None else tuple(qid_shape))
 
+    def _act_on_(self, args: Any) -> bool:
+        from cirq import sim
+
+        if isinstance(args, sim.ActOnStateVectorArgs):
+
+            invert_mask = self.full_invert_mask()
+            bits, _ = sim.measure_state_vector(
+                args.target_tensor,
+                args.axes,
+                out=args.target_tensor,
+                qid_shape=args.target_tensor.shape,
+                seed=args.prng)
+            corrected = [
+                bit ^ (bit < 2 and mask)
+                for bit, mask in zip(bits, invert_mask)
+            ]
+            args.record_measurement_result(self.key, corrected)
+
+            return True
+
+        return NotImplemented
+
 
 def _default_measurement_key(qubits: Iterable[raw_types.Qid]) -> str:
     return ','.join(str(q) for q in qubits)

cirq/protocols/__init__.py

@@ -13,6 +13,10 @@
 # limitations under the License.
 
 
+from cirq.protocols.act_on_protocol import (
+    act_on,
+    SupportsActOn,
+)
 from cirq.protocols.apply_unitary_protocol import (
     apply_unitaries,
     apply_unitary,