[unitaryHACK] Add reset error to noise channels

.github/CHANGELOG.md

@@ -7,6 +7,9 @@
 * The `qml.Toffoli` operation now has a decomposition over elementary gates. 
   [(#1320)](https://github.com/PennyLaneAI/pennylane/pull/1320)
 
+* Added a new noise channel, `qml.ResetError`.
+  [(#1321)](https://github.com/PennyLaneAI/pennylane/pull/1321).
+
 * The `qml.SWAP`  operation now has a decomposition over elementary gates. [(#1329)](https://github.com/PennyLaneAI/pennylane/pull/1329)
 
 * Added functionality for constructing and manipulating the Pauli group

pennylane/ops/channel.py

@@ -267,6 +267,71 @@ def _kraus_matrices(cls, *params):
         return [K0, K1]
 
 
+class ResetError(Channel):
+    r"""ResetError(p_0, p_1, wires)
+    Single-qubit Reset error channel.
+
+    This channel is modelled by the following Kraus matrices:
+
+    .. math::
+        K_0 = \sqrt{1-p_0-p_1} \begin{bmatrix}
+                1 & 0 \\
+                0 & 1
+                \end{bmatrix}
+
+    .. math::
+        K_1 = \sqrt{p_0}\begin{bmatrix}
+                1 & 0  \\
+                0 & 0
+                \end{bmatrix}
+
+    .. math::
+        K_2 = \sqrt{p_0}\begin{bmatrix}
+                0 & 1  \\
+                0 & 0
+                \end{bmatrix}
+
+    .. math::
+        K_3 = \sqrt{p_1}\begin{bmatrix}
+                0 & 0  \\
+                1 & 0
+                \end{bmatrix}
+
+    .. math::
+        K_4 = \sqrt{p_1}\begin{bmatrix}
+                0 & 0  \\
+                0 & 1
+                \end{bmatrix}
+
+    where :math:`p_0 \in [0, 1]` is the probability of a reset to 0,
+    and :math:`p_1 \in [0, 1]` is the probability of a reset to 1 error.
+
+    **Details:**
+
+    * Number of wires: 1
+    * Number of parameters: 2
+
+    Args:
+        p_0 (float): The probability that a reset to 0 error occurs.
+        p_1 (float): The probability that a reset to 1 error occurs.
+        wires (Sequence[int] or int): the wire the channel acts on
+    """
+    num_params = 2
+    num_wires = 1
+    par_domain = "R"
+    grad_method = "F"
+
+    @classmethod
+    def _kraus_matrices(cls, *params):
+        p_0, p_1 = params[0], params[1]
+        K0 = np.sqrt(1 - p_0 - p_1) * np.eye(2)
+        K1 = np.sqrt(p_0) * np.array([[1, 0], [0, 0]])
+        K2 = np.sqrt(p_0) * np.array([[0, 1], [0, 0]])
+        K3 = np.sqrt(p_1) * np.array([[0, 0], [1, 0]])
+        K4 = np.sqrt(p_1) * np.array([[0, 0], [0, 1]])
+        return [K0, K1, K2, K3, K4]
+
+
 class PhaseFlip(Channel):
     r"""PhaseFlip(p, wires)
     Single-qubit bit flip (Pauli :math:`Z`) error channel.
@@ -371,6 +436,7 @@ def _kraus_matrices(cls, *params):
     "DepolarizingChannel",
     "BitFlip",
     "PhaseFlip",
+    "ResetError",
     "QubitChannel",
 }
 

tests/ops/test_channel_ops.py

@@ -32,6 +32,7 @@
     channel.BitFlip,
     channel.PhaseFlip,
     channel.DepolarizingChannel,
+    channel.ResetError,
 ]
 
 
@@ -44,6 +45,8 @@ def test_kraus_matrices_sum_identity(self, ops, p, tol):
         """Test channels are trace-preserving"""
         if ops.__name__ == "GeneralizedAmplitudeDamping":
             op = ops(p, p, wires=0)
+        elif ops.__name__ == "ResetError":
+            op = ops(p / 2, p / 3, wires=0)
         else:
             op = ops(p, wires=0)
         K_list = op.kraus_matrices
@@ -213,6 +216,30 @@ def circuit(p):
         assert np.allclose(gradient, -(4 / 3) * np.cos(angle))
 
 
+class TestResetError:
+    """Tests for the quantum channel ResetError"""
+
+    @pytest.mark.parametrize("p_0,p_1", list(zip([0.5, 0.1, 0.0, 0.0], [0, 0.1, 0.5, 0.0])))
+    def test_p0_p1_arbitrary(self, p_0, p_1, tol):
+        """Test that various values of p_0 and p_1 give correct Kraus matrices"""
+        op = channel.ResetError
+
+        expected_K0 = np.sqrt(1 - p_0 - p_1) * np.eye(2)
+        assert np.allclose(op(p_0, p_1, wires=0).kraus_matrices[0], expected_K0, atol=tol, rtol=0)
+
+        expected_K1 = np.sqrt(p_0) * np.array([[1, 0], [0, 0]])
+        assert np.allclose(op(p_0, p_1, wires=0).kraus_matrices[1], expected_K1, atol=tol, rtol=0)
+
+        expected_K2 = np.sqrt(p_0) * np.array([[0, 1], [0, 0]])
+        assert np.allclose(op(p_0, p_1, wires=0).kraus_matrices[2], expected_K2, atol=tol, rtol=0)
+
+        expected_K3 = np.sqrt(p_1) * np.array([[0, 0], [1, 0]])
+        assert np.allclose(op(p_0, p_1, wires=0).kraus_matrices[3], expected_K3, atol=tol, rtol=0)
+
+        expected_K4 = np.sqrt(p_1) * np.array([[0, 0], [0, 1]])
+        assert np.allclose(op(p_0, p_1, wires=0).kraus_matrices[4], expected_K4, atol=tol, rtol=0)
+
+
 class TestQubitChannel:
     """Tests for the quantum channel QubitChannel"""