KetBraSum

cirq/__init__.py

@@ -245,6 +245,7 @@
     PhasedXZGate,
     PhaseFlipChannel,
     RandomGateChannel,
+    Projector,
     qft,
     QFT,
     Qid,

cirq/ops/__init__.py

@@ -196,6 +196,9 @@
 from cirq.ops.phased_x_z_gate import (
     PhasedXZGate,)
 
+from cirq.ops.projectors import (
+    Projector,)
+
 from cirq.ops.random_gate_channel import (
     RandomGateChannel,)
 

cirq/ops/projectors.py

@@ -0,0 +1,68 @@
+from typing import Any, Dict, Tuple, TYPE_CHECKING
+
+import numpy as np
+
+from cirq import value
+from cirq.ops import raw_types
+
+if TYPE_CHECKING:
+    import cirq
+
+
+@value.value_equality
+class Projector(raw_types.Gate):
+    """A non-unitary gate that projects onto a single qubit."""
+
+    def __init__(self, projector_id: int, qid_shape: Tuple[int, ...] = (2,)):
+        """
+        Args:
+            projector_id: An integer smaller than qid_shape that specifies the
+                projector on the qubit.
+            qid_shape: Specifies the dimension of the projection. The default is
+                2 (qubit).
+
+        Raises:
+            ValueError: If the length of invert_mask is greater than num_qubits.
+                or if the length of qid_shape doesn't equal num_qubits.
+        """
+        if len(qid_shape) != 1:
+            raise ValueError(f"qid_shape must have a single entry.")
+        if projector_id >= qid_shape[0]:
+            raise ValueError(f"projector_id={projector_id} must be less " +
+                             f"than qid_shape[0]={qid_shape[0]}")
+        self._projector_id = projector_id
+        self._qid_shape = qid_shape
+
+    def _projector_id_(self) -> int:
+        return self._projector_id
+
+    def _qid_shape_(self) -> Tuple[int, ...]:
+        return self._qid_shape
+
+    def _has_unitary_(self) -> bool:
+        return False
+
+    def _is_parameterized_(self) -> bool:
+        return False
+
+    def _channel_(self):
+        result = np.zeros((self._qid_shape[0], self._qid_shape[0]))
+        result[self._projector_id][self._projector_id] = 1.0
+        return (result,)
+
+    def _has_channel_(self):
+        return True
+
+    def __repr__(self):
+        return (f"cirq.Projector(projector_id={self._projector_id}," +
+                f"qid_shape={self._qid_shape})")
+
+    def _json_dict_(self) -> Dict[str, Any]:
+        return {
+            'cirq_type': self.__class__.__name__,
+            'projector_id': self._projector_id,
+            'qid_shape': self._qid_shape,
+        }
+
+    def _value_equality_values_(self) -> Any:
+        return self._projector_id, self._qid_shape

cirq/ops/projectors_test.py

@@ -0,0 +1,61 @@
+import re
+
+import numpy as np
+import pytest
+
+import cirq
+
+
+def test_projector_qubit():
+    zero_projector = cirq.Projector(projector_id=0)
+    one_projector = cirq.Projector(projector_id=1)
+
+    np.testing.assert_allclose(cirq.channel(zero_projector),
+                               ([[1.0, 0.0], [0.0, 0.0]],))
+
+    np.testing.assert_allclose(cirq.channel(one_projector),
+                               ([[0.0, 0.0], [0.0, 1.0]],))
+
+
+def test_projector_qutrit():
+    zero_projector = cirq.Projector(projector_id=0, qid_shape=[3])
+    one_projector = cirq.Projector(projector_id=1, qid_shape=[3])
+    two_projector = cirq.Projector(projector_id=2, qid_shape=[3])
+
+    np.testing.assert_allclose(
+        cirq.channel(zero_projector),
+        ([[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],))
+
+    np.testing.assert_allclose(
+        cirq.channel(one_projector),
+        ([[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0]],))
+
+    np.testing.assert_allclose(
+        cirq.channel(two_projector),
+        ([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0]],))
+
+
+def test_bad_constructors():
+    with pytest.raises(ValueError, match="qid_shape must have a single entry."):
+        cirq.Projector(projector_id=0, qid_shape=[2, 2])
+
+    with pytest.raises(
+            ValueError,
+            match=re.escape("projector_id=2 must be less than qid_shape[0]=2")):
+        cirq.Projector(projector_id=2, qid_shape=[2])
+
+
+def test_get_values():
+    d = cirq.Projector(projector_id=0)
+
+    assert d._projector_id_() == 0
+    assert d._qid_shape_() == (2,)
+    assert not d._has_unitary_()
+    assert not d._is_parameterized_()
+    assert d._has_channel_()
+
+
+def test_repr():
+    d = cirq.Projector(projector_id=0)
+
+    assert d.__repr__() == "cirq.Projector(projector_id=0,qid_shape=(2,))"

cirq/protocols/json_serialization.py

@@ -146,6 +146,7 @@ def two_qubit_matrix_gate(matrix):
                 'PhasedXPowGate': cirq.PhasedXPowGate,
                 'PhasedXZGate': cirq.PhasedXZGate,
                 'PhysicalZTag': cirq.google.PhysicalZTag,
+                'Projector': cirq.Projector,
                 'RandomGateChannel': cirq.RandomGateChannel,
                 'QuantumFourierTransformGate': cirq.QuantumFourierTransformGate,
                 'ResetChannel': cirq.ResetChannel,

cirq/protocols/json_test_data/Projector.json

@@ -0,0 +1,7 @@
+{
+  "cirq_type": "Projector",
+  "projector_id": 1,
+  "qid_shape": [
+    2
+  ]
+}

cirq/protocols/json_test_data/Projector.repr

@@ -0,0 +1 @@
+cirq.Projector(projector_id=1,qid_shape=[2])

rtd_docs/api.rst

@@ -94,6 +94,7 @@ Unitary effects that can be applied to one or more qubits.
     cirq.PhasedISwapPowGate
     cirq.PhasedXPowGate
     cirq.PhasedXZGate
+    cirq.Projector
     cirq.QuantumFourierTransformGate
     cirq.QubitPermutationGate
     cirq.RandomGateChannel