qml.Reflection Operation

doc/releases/changelog-dev.md

@@ -178,6 +178,10 @@
 
 * The module `pennylane/math/quantum.py` has now support for the min-entropy.
   [(#3959)](https://github.com/PennyLaneAI/pennylane/pull/3959/)
+
+* Create the `qml.Reflection` operator, useful for amplitude amplification and its variants.
+  [(##5159)](https://github.com/PennyLaneAI/pennylane/pull/5159)
+
 
 * A function called `apply_operation` has been added to the new `qutrit_mixed` module found in `qml.devices` that applies operations to device-compatible states.
   [(#5032)](https://github.com/PennyLaneAI/pennylane/pull/5032)
@@ -497,7 +501,9 @@
 
 This release contains contributions from (in alphabetical order):
 
+
 Abhishek Abhishek,
+Guillermo Alonso,
 Utkarsh Azad,
 Gabriel Bottrill,
 Astral Cai,

pennylane/ops/op_math/controlled_ops.py

@@ -353,7 +353,6 @@ def decomposition(self):
 
 
 def _check_and_convert_control_values(control_values, control_wires):
-
     if isinstance(control_values, str):
         # Make sure all values are either 0 or 1
         if not set(control_values).issubset({"1", "0"}):

pennylane/templates/subroutines/__init__.py

@@ -39,3 +39,4 @@
 from .controlled_sequence import ControlledSequence
 from .trotter import TrotterProduct
 from .aqft import AQFT
+from .reflection import Reflection

pennylane/templates/subroutines/reflection.py

@@ -0,0 +1,134 @@
+# Copyright 2018-2023 Xanadu Quantum Technologies Inc.
+
+# 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
+
+#     http://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.
+
+"""
+This submodule contains the template for the Reflection operation.
+"""
+
+import numpy as np
+import pennylane as qml
+from pennylane.operation import Operation
+from pennylane.ops import SymbolicOp
+
+
+class Reflection(SymbolicOp, Operation):
+    r"""Reflection(U, alpha = np.pi, reflection_wires = None)
+    Apply a :math:`\alpha`-reflection over the state :math:`|\Psi\rangle = U|0\rangle`.
+
+    .. math::
+
+        \text{Reflection}(U, \alpha) = -\mathbb{I} + (1 - e^{i\alpha}) |\Psi\rangle \langle \Psi|
+
+
+    Args:
+        U (qml.ops.op_math.prod.Prod): the product of operations that generate the state :math:`|\Psi\rangle`.
+        alpha (float): the reflection angle. Default is :math:`\pi`.
+        reflection_wires (Any or Iterable[Any]): Subsystem of wires on which to reflect. The default is None and the reflection will be applied on the U wires.
+
+    **Example**
+
+    The reflection :math:`-\mathbb{I} + 2|+\rangle \langle +|` applied to the state :math:`|1\rangle` would be as follows:
+
+    .. code-block::
+
+        @qml.prod
+        def generator(wires):
+            qml.Hadamard(wires=wires)
+
+        U = generator(wires=0)
+
+        dev = qml.device('default.qubit')
+
+        @qml.qnode(dev)
+        def circuit():
+
+            # Initialize to the state |1>
+            qml.qml.PauliX(wires=0)
+
+            # Apply the reflection
+            qml.Reflection(U)
+
+            return qml.state()
+
+        circuit()
+
+
+    .. details::
+        :title: Theory
+
+        The operator is built as follows:
+
+        .. math::
+
+            \text{Reflection}(U, \alpha) = -\mathbb{I} + (1 - e^{i\alpha}) |\Psi\rangle \langle \Psi| = U(-\mathbb{I} + (1 - e^{i\alpha}) |0\rangle \langle 0|)U^{\dagger}.
+
+        The central block is obtained through a PhaseShift controlled operator.
+
+        In the case of specifying the reflection wires,  the operator would have the following expression.
+
+        .. math::
+
+            U(\mathbb{I} - (1 - e^{i\alpha}) |0\rangle^{\otimes m} \langle 0|^{\otimes m}\otimes \mathbb{I}^{n-m}})U^{\dagger},
+
+        where :math:`m` is the number of reflection wires and :math:`n` is the total number of wires.
+
+    """
+
+    def __init__(self, U, alpha=np.pi, reflection_wires=None, id=None):
+        self.U = U
+        self.alpha = alpha
+
+        if reflection_wires is None:
+            self.reflection_wires = U.wires
+        else:
+            self.reflection_wires = reflection_wires
+
+        if not set(self.reflection_wires).issubset(set(U.wires)):
+            raise ValueError("The reflection_wires must be a subset of the U wires.")
+
+        self._name = "Reflection"
+
+        super().__init__(base=U, id=id)
+
+    @property
+    def has_matrix(self):
+        return False
+
+    def decomposition(self):
+        wires = qml.wires.Wires(self.reflection_wires)
+
+        ops = []
+
+        ops.append(qml.GlobalPhase(np.pi))
+        ops.append(qml.adjoint(self.U))
+
+        if len(wires) > 1:
+            ops.append(qml.PauliX(wires=wires[-1]))
+            ops.append(
+                qml.ctrl(
+                    qml.PhaseShift(self.alpha, wires=wires[-1]),
+                    control=wires[:-1],
+                    control_values=[0] * (len(wires) - 1),
+                )
+            )
+            ops.append(qml.PauliX(wires=wires[-1]))
+
+        else:
+            ops.append(qml.PauliX(wires=wires))
+            ops.append(qml.PhaseShift(self.alpha, wires=wires))
+            ops.append(qml.PauliX(wires=wires))
+
+        ops.append(self.U)
+
+        return ops

tests/templates/test_subroutines/test_reflection.py

@@ -0,0 +1,206 @@
+# Copyright 2018-2021 Xanadu Quantum Technologies Inc.
+
+# 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
+
+#     http://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.
+"""
+Tests for the Reflection Operator template
+"""
+
+import pytest
+import numpy as np
+import pennylane as qml
+
+
+@pytest.mark.parametrize(
+    ("prod", "reflection_wires"),
+    [
+        (qml.QFT([0, 1, 4]), [0, 1, 2]),
+        (qml.QFT([0, 1, 2]), [3]),
+        (qml.QFT([0, 1, 2]), [0, 1, 2, 3]),
+    ],
+)
+def test_reflection_wires(prod, reflection_wires):
+    """Assert reflection_wires is a subset of the U wires"""
+    with pytest.raises(ValueError, match="The reflection_wires must be a subset of the U wires."):
+        qml.Reflection(prod, 0.5, reflection_wires=reflection_wires)
+
+
+def test_decomposition_one_wire():
+    """Test that the decomposition of the Reflection operator is correct"""
+    op = qml.Reflection(qml.Hadamard(wires=0), 0.5, reflection_wires=[0])
+    decomp = op.decomposition()
+    expected = [
+        qml.GlobalPhase(np.pi),
+        qml.adjoint(qml.Hadamard(0)),
+        qml.PauliX(wires=[0]),
+        qml.PhaseShift(0.5, wires=[0]),
+        qml.PauliX(wires=[0]),
+        qml.Hadamard(0),
+    ]
+    assert decomp == expected
+
+
+def test_decomposition_two_wire():
+    """Test that the decomposition of the Reflection operator is correct"""
+    op = qml.Reflection(qml.QFT(wires=[0, 1]), 0.5)
+
+    decomp = op.decomposition()
+    expected = [
+        qml.GlobalPhase(np.pi),
+        qml.adjoint(qml.QFT(wires=[0, 1])),
+        qml.PauliX(wires=[1]),
+        qml.ctrl(qml.PhaseShift(0.5, wires=[1]), control=0, control_values=[0]),
+        qml.PauliX(wires=[1]),
+        qml.QFT(wires=[0, 1]),
+    ]
+
+    assert decomp == expected
+
+
+def test_default_values():
+    """Test that the default values are correct"""
+
+    U = qml.QFT(wires=[0, 1, 4])
+    op = qml.Reflection(U)
+
+    assert op.alpha == np.pi
+    assert op.reflection_wires == U.wires
+
+
+@pytest.mark.parametrize("n_wires", [3, 4, 5])
+def test_grover_as_reflection(n_wires):
+    """Test that the GroverOperator can be used as a Reflection operator"""
+
+    @qml.prod
+    def hadamards(wires):
+        for wire in wires:
+            qml.Hadamard(wires=wire)
+
+    grover_matrix = qml.matrix(qml.GroverOperator(wires=range(n_wires)))
+    reflection_matrix = qml.matrix(qml.Reflection(hadamards(wires=range(n_wires))))
+
+    assert np.allclose(grover_matrix, reflection_matrix)
+
+
+@pytest.mark.tf
+@pytest.mark.jax
+@pytest.mark.torch
+@pytest.mark.parametrize("value", [1.2, 2.1, 3.4])
+def test_gradients_all_interfaces(value):
+    import torch
+    import jax
+    import pennylane.numpy as pnp
+    import tensorflow as tf
+
+    n_wires = 3
+
+    @qml.prod
+    def hadamards(wires):
+        for wire in wires:
+            qml.Hadamard(wires=wire)
+
+    dev = qml.device("default.qubit")
+
+    @qml.qnode(dev)
+    def circuit(alpha):
+        qml.RY(1.2, wires=0)
+        qml.RY(-1.4, wires=1)
+        qml.RX(-2, wires=0)
+        qml.CRX(1, wires=[0, 1])
+        qml.Reflection(hadamards(range(n_wires)), alpha)
+
+        return qml.expval(qml.PauliZ(0))
+
+    def cost(alpha):
+        return circuit(alpha)
+
+    alpha = pnp.array([value], requires_grad=True)
+    grad_autograd = qml.grad(cost)(alpha)
+
+    grad_jax = jax.grad(cost)(jax.numpy.array(value, dtype=jax.numpy.float32))
+
+    x = torch.tensor([value], requires_grad=True)
+
+    y = cost(x)
+    y.backward()
+    grad_torch = x.grad
+
+    x = tf.Variable([value], dtype=tf.float32)
+
+    with tf.GradientTape() as tape:
+        y = cost(x)
+
+    grad_tf = tape.gradient(y, x)
+
+    assert np.allclose(grad_autograd, grad_jax, atol=1e-3)
+    assert np.allclose(grad_autograd, grad_torch, atol=1e-3)
+    assert np.allclose(grad_autograd, grad_tf, atol=1e-3)
+
+
+def test_lightning_qubit():
+    dev1 = qml.device("lightning.qubit", wires=2)
+
+    @qml.qnode(dev1)
+    def circuit1():
+        qml.RX(2, wires=0)
+        qml.CRY(1, wires=[0, 1])
+        qml.Reflection(U=qml.PauliX(wires=0), alpha=2.0)
+        return qml.probs(wires=[0, 1])
+
+    dev2 = qml.device("default.qubit", wires=2)
+
+    @qml.qnode(dev2)
+    def circuit2():
+        qml.RX(2, wires=0)
+        qml.CRY(1, wires=[0, 1])
+        qml.Reflection(U=qml.PauliX(wires=0), alpha=2.0)
+        return qml.probs(wires=[0, 1])
+
+    assert np.allclose(circuit1(), circuit2())
+
+
+def test_correct_queueing():
+    """Test that the Reflection operator is correctly queued in the circuit"""
+    dev = qml.device("default.qubit", wires=2)
+
+    @qml.qnode(dev)
+    def circuit1():
+        qml.Hadamard(wires=0)
+        qml.RY(2, wires=0)
+        qml.CRY(1, wires=[0, 1])
+        qml.Reflection(U=qml.Hadamard(wires=0), alpha=2.0)
+        return qml.state()
+
+    @qml.prod
+    def generator(wires):
+        qml.Hadamard(wires=wires)
+
+    @qml.qnode(dev)
+    def circuit2():
+        generator(wires=0)
+        qml.RY(2, wires=0)
+        qml.CRY(1, wires=[0, 1])
+        qml.Reflection(U=generator(wires=0), alpha=2.0)
+        return qml.state()
+
+    U = generator(0)
+
+    @qml.qnode(dev)
+    def circuit3():
+        generator(wires=0)
+        qml.RY(2, wires=0)
+        qml.CRY(1, wires=[0, 1])
+        qml.Reflection(U=U, alpha=2.0)
+        return qml.state()
+
+    assert np.allclose(circuit1(), circuit2())
+    assert np.allclose(circuit1(), circuit3())