Evolution operator

pennylane/ops/op_math/__init__.py

@@ -42,6 +42,7 @@
     ~CompositeOp
     ~Controlled
     ~ControlledOp
+    ~Evolution
     ~Exp
     ~Pow
     ~Prod
@@ -54,7 +55,7 @@
 from .adjoint_class import Adjoint
 from .adjoint_constructor import adjoint
 from .controlled_class import Controlled, ControlledOp
-from .exp import exp, Exp
+from .exp import exp, Exp, Evolution
 
 from .prod import prod, Prod
 

pennylane/ops/op_math/exp.py

@@ -14,15 +14,18 @@
 """
 This submodule defines the symbolic operation that stands for an exponential of an operator.
 """
-from warnings import warn
+from warnings import warn, catch_warnings, filterwarnings
 from scipy.sparse.linalg import expm as sparse_expm
+import numpy as np
 
 import pennylane as qml
 from pennylane import math
 from pennylane.operation import (
     DecompositionUndefinedError,
     expand_matrix,
     OperatorPropertyUndefined,
+    GeneratorUndefinedError,
+    ParameterFrequenciesUndefinedError,
     Tensor,
 )
 from pennylane.pauli import is_pauli_word, pauli_word_to_string
@@ -181,6 +184,11 @@ def has_decomposition(self):
                 )
         return math.real(self.coeff) == 0 and is_pauli_word(self.base)
 
+    @property
+    def inverse(self):
+        """Setting inverse not defined for Exp, so inverse is always False"""
+        return False
+
     def decomposition(self):
         r"""Representation of the operator as a product of other operators. Decomposes into
         :class:`~.PauliRot` if the coefficient is imaginary and the base is a Pauli Word.
@@ -280,3 +288,162 @@ def simplify(self):
         if isinstance(self.base, qml.ops.op_math.SProd):  # pylint: disable=no-member
             return Exp(self.base.base.simplify(), self.coeff * self.base.scalar)
         return Exp(self.base.simplify(), self.coeff)
+
+    def generator(self):
+        r"""Generator of an operator that is in single-parameter-form.
+
+        For example, for operator
+
+        .. math::
+
+            U(\phi) = e^{i\phi (0.5 Y + Z\otimes X)}
+
+        we get the generator
+
+        >>> U.generator()
+          (0.5) [Y0]
+        + (1.0) [Z0 X1]
+
+        """
+        if np.real(self.coeff) != 0 or not self.base.is_hermitian:
+            raise GeneratorUndefinedError(
+                f"Exponential with coefficient {self.coeff} and base operator {self.base} does not have a generator."
+            )
+        return self.base
+
+    @property
+    def parameter_frequencies(self):
+        r"""Returns the frequencies for each operator parameter with respect
+        to an expectation value of the form
+        :math:`\langle \psi | U(\mathbf{p})^\dagger \hat{O} U(\mathbf{p})|\psi\rangle`.
+
+        These frequencies encode the behaviour of the operator :math:`U(\mathbf{p})`
+        on the value of the expectation value as the parameters are modified.
+        For more details, please see the :mod:`.pennylane.fourier` module.
+
+        Returns:
+            list[tuple[int or float]]: Tuple of frequencies for each parameter.
+            Note that only non-negative frequency values are returned.
+
+        **Example**
+
+        >>> op = qml.PauliX(0)
+        >>> U = qml.exp(op, 1j)
+        >>> U.parameter_frequencies
+        [(2,)]
+
+        For operators that define a generator, the parameter frequencies are directly
+        related to the eigenvalues of the generator:
+
+        >>> gen = qml.generator(U, format="observable")
+        >>> gen
+        PauliX(wires=[0])
+        >>> gen_eigvals = qml.eigvals(gen)
+        >>> qml.gradients.eigvals_to_frequencies(tuple(gen_eigvals))
+        (2,)
+
+        For more details on this relationship, see :func:`.eigvals_to_frequencies`.
+        """
+        if self.num_params == 1:
+            # if the operator has a single parameter, we can query the
+            # generator, and if defined, use its eigenvalues.
+            try:
+                gen = qml.generator(self, format="observable")
+            except GeneratorUndefinedError as e:
+                raise ParameterFrequenciesUndefinedError(
+                    f"Operation {self.name} does not have parameter frequencies defined."
+                ) from e
+
+            with catch_warnings():
+                filterwarnings(
+                    action="ignore", message=r".+ eigenvalues will be computed numerically\."
+                )
+                eigvals = qml.eigvals(gen)
+
+            eigvals = tuple(np.round(eigvals, 8))
+            return [qml.gradients.eigvals_to_frequencies(eigvals)]
+
+        raise ParameterFrequenciesUndefinedError(
+            f"Operation {self.name} does not have parameter frequencies defined, "
+            "and parameter frequencies can not be computed as no generator is defined."
+        )
+
+
+class Evolution(Exp):
+
+    r"""Create an exponential operator that defines a generator, of the form :math:`e^{ix\hat{G}}`
+
+    Args:
+        base (~.operation.Operator): The Operator to be used as a Generator, G.
+        param (float): The evolution parameter, x. This parameter is not expected to have
+            any complex component.
+
+    Returns:
+       :class:`Evolution`: A :class`~.operation.Operator` representing an operator exponential of the form exp(ixG),
+       where x is real.
+
+    **Use Details**
+
+    In contrast to the general Exp class, the Evolution operator is constrained to a single trainable
+    parameter, x. Any parameters contained in the base operator are not trainable. This allows the operator
+    to be differentiated with regard to the evolution parameter. Defining a mathematically identical operator
+    using the Exp class will be incompatible with a variety of PennyLane functions that require only a single
+    trainable parameter.
+
+    **Example**
+    This symbolic operator can be used to make general rotation operators:
+    >>> theta = np.array(1.23)
+    >>> op = Evolution(qml.PauliX(0), -0.5 * theta)
+    >>> qml.math.allclose(op.matrix(), qml.RX(theta, wires=0).matrix())
+    True
+
+    Or to define a time evolution operator for a time-independent Hamiltonian:
+    >>> H = qml.Hamiltonian([1, 1], [qml.PauliY(0), qml.PauliX(1)])
+    >>> t = 10e-6
+    >>> U = Evolution(H, -1 * t)
+
+    Even for more complicated generators, this operator is defined to have a single parameter,
+    allowing it to be differentiated with respect to that parameter (base operator parameters are
+    treated as constants):
+    >>> base_op = 0.5 * qml.PauliY(0) + qml.PauliZ(0) @ qml.PauliX(1)
+    >>> op = Evolution(base_op, 1.23)
+    >>> op.num_params
+    1
+
+    If the base operator is Hermitian, then the gate can be used in a circuit,
+    though it may not be supported by the device and may not be differentiable.
+
+    >>> @qml.qnode(qml.device('default.qubit', wires=1))
+    ... def circuit(x):
+    ...     Evolution(qml.PauliX(0), -0.5 * x)
+    ...     return qml.expval(qml.PauliZ(0))
+    >>> print(qml.draw(circuit)(1.23))
+    0: ──Exp(-0.61j X)─┤  <Z>
+
+    """
+
+    def __init__(self, generator, param, do_queue=True, id=None):
+        super().__init__(generator, coeff=1j * param, do_queue=do_queue, id=id)
+        self._name = "Evolution"
+        self.param = param
+
+    @property
+    def data(self):
+        return [self.param]
+
+    @data.setter
+    def data(self, new_data):
+        self.coeff = 1j * new_data[0]
+        self.param = new_data[0]
+
+    @property
+    def num_params(self):
+        return 1
+
+    def label(self, decimals=None, base_label=None, cache=None):
+        param = (
+            self.data[0]
+            if decimals is None
+            else format(math.toarray(self.data[0]), f".{decimals}f")
+        )
+        return base_label or f"Exp({param}j {self.base.label(decimals=decimals, cache=cache)})"

tests/ops/op_math/test_exp.py

@@ -17,8 +17,12 @@
 
 import pennylane as qml
 from pennylane import numpy as np
-from pennylane.operation import DecompositionUndefinedError
-from pennylane.ops.op_math import Exp
+from pennylane.operation import (
+    DecompositionUndefinedError,
+    GeneratorUndefinedError,
+    ParameterFrequenciesUndefinedError,
+)
+from pennylane.ops.op_math import Exp, Evolution
 
 
 @pytest.mark.parametrize("constructor", (qml.exp, Exp))
@@ -577,3 +581,123 @@ def test_draw_integration(self):
         qml.drawer.tape_text(tape)
 
         assert "0: ──Exp─┤  "
+
+
+class TestDifferentiation:
+    """Test generator and parameter_frequency for differentiation"""
+
+    def test_base_not_hermitian_generator_undefined(self):
+        """That that imaginary coefficient but non-Hermitian base operator raises GeneratorUndefinedError"""
+        op = Exp(qml.RX(1.23, 0), 1j)
+        with pytest.raises(GeneratorUndefinedError):
+            op.generator()
+
+    def test_real_component_coefficient_generator_undefined(self):
+        """Test that Hermitian base operator but real coefficient raises GeneratorUndefinedError"""
+        op = Exp(qml.PauliX(0), 1)
+        with pytest.raises(GeneratorUndefinedError):
+            op.generator()
+
+    def test_generator_is_base_operator(self):
+        """Test that generator is base operator"""
+        base_op = qml.PauliX(0)
+        op = Exp(base_op, 1j)
+        assert op.base == op.generator()
+
+    def test_parameter_frequencies(self):
+        """Test parameter_frequencies property"""
+        op = Exp(qml.PauliZ(1), 1j)
+        assert op.parameter_frequencies == [(2,)]
+
+    def test_parameter_frequencies_raises_error(self):
+        """Test that parameter_frequencies raises an error if the op.generator() is undefined"""
+        op = Exp(qml.PauliX(0), 1)
+        with pytest.raises(GeneratorUndefinedError):
+            op.generator()
+        with pytest.raises(ParameterFrequenciesUndefinedError):
+            op.parameter_frequencies
+
+    def test_parameter_frequency_with_parameters_in_base_operator(self):
+        """Test that parameter_frequency raises an error for the Exp class, but not the
+        Evolution class, if there are additional parameters in the base operator"""
+
+        base_op = 2 * qml.PauliX(0)
+        op1 = Exp(base_op, 1j)
+        op2 = Evolution(base_op, 1)
+
+        with pytest.raises(ParameterFrequenciesUndefinedError):
+            op1.parameter_frequencies()
+
+        assert op2.parameter_frequencies == [(4.0,)]
+
+
+class TestEvolution:
+    """Test Evolution(Exp) class that takes a parameter x and a generator G and defines an evolution exp(ixG)"""
+
+    def test_initialization(self):
+        """Test initialization with a provided coefficient and a Tensor base."""
+        base = qml.PauliZ("b") @ qml.PauliZ("c")
+        param = 1.23
+
+        op = Evolution(base, param)
+
+        assert op.base is base
+        assert op.coeff == 1j * param
+        assert op.name == "Evolution"
+        assert isinstance(op, Exp)
+
+        assert op.num_params == 1
+        assert op.parameters == [param]
+        assert op.data == [param]
+
+        assert op.wires == qml.wires.Wires(("b", "c"))
+
+    def test_evolution_matches_corresponding_exp(self):
+        base_op = 2 * qml.PauliX(0)
+        op1 = Exp(base_op, 1j)
+        op2 = Evolution(base_op, 1)
+
+        assert np.all(op1.matrix() == op2.matrix())
+
+    def test_generator(self):
+        U = Evolution(qml.PauliX(0), 3)
+        assert U.base == U.generator()
+
+    def test_num_params_for_parametric_base(self):
+        base_op = 0.5 * qml.PauliY(0) + qml.PauliZ(0) @ qml.PauliX(1)
+        op = Evolution(base_op, 1.23)
+
+        assert base_op.num_params == 2
+        assert op.num_params == 1
+
+    def test_data(self):
+        """Test accessing and setting the data property."""
+
+        param = np.array(1.234)
+
+        base = qml.PauliX(0)
+        op = Evolution(base, param)
+
+        assert op.data == [param]
+
+        new_data = [2.345]
+        op.data = new_data
+
+        assert op.data == new_data
+        assert op.coeff == 1j * op.data[0]
+        assert op.param == op.data[0]
+
+    @pytest.mark.parametrize(
+        "op,decimals,expected",
+        [
+            (Evolution(qml.PauliZ(0), 2), None, "Exp(2j Z)"),
+            (Evolution(qml.PauliZ(0), 2), 2, "Exp(2.00j Z)"),
+            (Evolution(qml.prod(qml.PauliZ(0), qml.PauliY(1)), 2), None, "Exp(2j Z@Y)"),
+            (Evolution(qml.prod(qml.PauliZ(0), qml.PauliY(1)), 2), 2, "Exp(2.00j Z@Y)"),
+            (Evolution(qml.RZ(1.234, wires=[0]), 5.678), None, "Exp(5.678j RZ)"),
+            (Evolution(qml.RZ(1.234, wires=[0]), 5.678), 2, "Exp(5.68j RZ\n(1.23))"),
+        ],
+    )
+    def test_label(self, op, decimals, expected):
+        """Test that the label is informative and uses decimals."""
+        assert op.label(decimals=decimals) == expected