Make numerical representations of operators differentiable

pennylane/devices/default_qubit_autograd.py

@@ -18,7 +18,6 @@
 from pennylane import numpy as np
 
 from pennylane.devices import DefaultQubit
-from pennylane.devices import autograd_ops
 
 
 class DefaultQubitAutograd(DefaultQubit):
@@ -81,30 +80,6 @@ class DefaultQubitAutograd(DefaultQubit):
     name = "Default qubit (Autograd) PennyLane plugin"
     short_name = "default.qubit.autograd"
 
-    parametric_ops = {
-        "PhaseShift": autograd_ops.PhaseShift,
-        "ControlledPhaseShift": autograd_ops.ControlledPhaseShift,
-        "CPhase": autograd_ops.ControlledPhaseShift,
-        "RX": autograd_ops.RX,
-        "RY": autograd_ops.RY,
-        "RZ": autograd_ops.RZ,
-        "Rot": autograd_ops.Rot,
-        "CRX": autograd_ops.CRX,
-        "CRY": autograd_ops.CRY,
-        "CRZ": autograd_ops.CRZ,
-        "CRot": autograd_ops.CRot,
-        "MultiRZ": autograd_ops.MultiRZ,
-        "IsingXX": autograd_ops.IsingXX,
-        "IsingYY": autograd_ops.IsingYY,
-        "IsingZZ": autograd_ops.IsingZZ,
-        "SingleExcitation": autograd_ops.SingleExcitation,
-        "SingleExcitationPlus": autograd_ops.SingleExcitationPlus,
-        "SingleExcitationMinus": autograd_ops.SingleExcitationMinus,
-        "DoubleExcitation": autograd_ops.DoubleExcitation,
-        "DoubleExcitationPlus": autograd_ops.DoubleExcitationPlus,
-        "DoubleExcitationMinus": autograd_ops.DoubleExcitationMinus,
-    }
-
     C_DTYPE = np.complex128
     R_DTYPE = np.float64
     _dot = staticmethod(np.dot)
@@ -154,32 +129,3 @@ def _scatter(indices, array, new_dimensions):
         new_array = np.zeros(new_dimensions, dtype=array.dtype.type)
         new_array[indices] = array
         return new_array
-
-    def _get_unitary_matrix(self, unitary):
-        """Return the matrix representing a unitary operation.
-
-        Args:
-            unitary (~.Operation): a PennyLane unitary operation
-
-        Returns:
-            array[complex]: Returns a 2D matrix representation of
-            the unitary in the computational basis, or, in the case of a diagonal unitary,
-            a 1D array representing the matrix diagonal.
-        """
-        op_name = unitary.name.split(".inv")[0]
-
-        if op_name in self.parametric_ops:
-            if op_name == "MultiRZ":
-                mat = self.parametric_ops[op_name](*unitary.parameters, len(unitary.wires))
-            else:
-                mat = self.parametric_ops[op_name](*unitary.parameters)
-
-            if unitary.inverse:
-                mat = self._transpose(self._conj(mat))
-
-            return mat
-
-        if isinstance(unitary, DiagonalOperation):
-            return unitary.eigvals
-
-        return unitary.matrix

pennylane/devices/default_qubit_jax.py

@@ -17,7 +17,6 @@
 import pennylane as qml
 from pennylane.operation import DiagonalOperation
 from pennylane.devices import DefaultQubit
-from pennylane.devices import jax_ops
 
 import numpy as np
 
@@ -133,30 +132,6 @@ def circuit():
     name = "Default qubit (jax) PennyLane plugin"
     short_name = "default.qubit.jax"
 
-    parametric_ops = {
-        "PhaseShift": jax_ops.PhaseShift,
-        "ControlledPhaseShift": jax_ops.ControlledPhaseShift,
-        "CPhase": jax_ops.ControlledPhaseShift,
-        "RX": jax_ops.RX,
-        "RY": jax_ops.RY,
-        "RZ": jax_ops.RZ,
-        "Rot": jax_ops.Rot,
-        "CRX": jax_ops.CRX,
-        "CRY": jax_ops.CRY,
-        "CRZ": jax_ops.CRZ,
-        "CRot": jax_ops.CRot,
-        "MultiRZ": jax_ops.MultiRZ,
-        "IsingXX": jax_ops.IsingXX,
-        "IsingYY": jax_ops.IsingYY,
-        "IsingZZ": jax_ops.IsingZZ,
-        "SingleExcitation": jax_ops.SingleExcitation,
-        "SingleExcitationPlus": jax_ops.SingleExcitationPlus,
-        "SingleExcitationMinus": jax_ops.SingleExcitationMinus,
-        "DoubleExcitation": jax_ops.DoubleExcitation,
-        "DoubleExcitationPlus": jax_ops.DoubleExcitationPlus,
-        "DoubleExcitationMinus": jax_ops.DoubleExcitationMinus,
-    }
-
     _asarray = staticmethod(jnp.array)
     _dot = staticmethod(jnp.dot)
     _abs = staticmethod(jnp.abs)
@@ -208,35 +183,6 @@ def _scatter(indices, array, new_dimensions):
         new_array = new_array.at[indices].set(array)
         return new_array
 
-    def _get_unitary_matrix(self, unitary):
-        """Return the matrix representing a unitary operation.
-
-        Args:
-            unitary (~.Operation): a PennyLane unitary operation
-
-        Returns:
-            array[complex]: Returns a 2D matrix representation of
-            the unitary in the computational basis, or, in the case of a diagonal unitary,
-            a 1D array representing the matrix diagonal.
-        """
-        op_name = unitary.name.split(".inv")[0]
-
-        if op_name in self.parametric_ops:
-            if op_name == "MultiRZ":
-                mat = self.parametric_ops[op_name](*unitary.parameters, len(unitary.wires))
-            else:
-                mat = self.parametric_ops[op_name](*unitary.parameters)
-
-            if unitary.inverse:
-                mat = self._transpose(self._conj(mat))
-
-            return mat
-
-        if isinstance(unitary, DiagonalOperation):
-            return unitary.eigvals
-
-        return unitary.matrix
-
     def sample_basis_states(self, number_of_states, state_probability):
         """Sample from the computational basis states based on the state
         probability.

pennylane/devices/default_qubit_tf.py

@@ -47,7 +47,6 @@
     pass
 
 from . import DefaultQubit
-from . import tf_ops
 
 
 class DefaultQubitTF(DefaultQubit):
@@ -129,30 +128,6 @@ class DefaultQubitTF(DefaultQubit):
     name = "Default qubit (TensorFlow) PennyLane plugin"
     short_name = "default.qubit.tf"
 
-    parametric_ops = {
-        "PhaseShift": tf_ops.PhaseShift,
-        "ControlledPhaseShift": tf_ops.ControlledPhaseShift,
-        "CPhase": tf_ops.ControlledPhaseShift,
-        "RX": tf_ops.RX,
-        "RY": tf_ops.RY,
-        "RZ": tf_ops.RZ,
-        "Rot": tf_ops.Rot,
-        "MultiRZ": tf_ops.MultiRZ,
-        "CRX": tf_ops.CRX,
-        "CRY": tf_ops.CRY,
-        "CRZ": tf_ops.CRZ,
-        "CRot": tf_ops.CRot,
-        "IsingXX": tf_ops.IsingXX,
-        "IsingYY": tf_ops.IsingYY,
-        "IsingZZ": tf_ops.IsingZZ,
-        "SingleExcitation": tf_ops.SingleExcitation,
-        "SingleExcitationPlus": tf_ops.SingleExcitationPlus,
-        "SingleExcitationMinus": tf_ops.SingleExcitationMinus,
-        "DoubleExcitation": tf_ops.DoubleExcitation,
-        "DoubleExcitationPlus": tf_ops.DoubleExcitationPlus,
-        "DoubleExcitationMinus": tf_ops.DoubleExcitationMinus,
-    }
-
     C_DTYPE = tf.complex128
     R_DTYPE = tf.float64
     _asarray = staticmethod(tf.convert_to_tensor)
@@ -209,34 +184,3 @@ def capabilities(cls):
     def _scatter(indices, array, new_dimensions):
         indices = np.expand_dims(indices, 1)
         return tf.scatter_nd(indices, array, new_dimensions)
-
-    def _get_unitary_matrix(self, unitary):
-        """Return the matrix representing a unitary operation.
-
-        Args:
-            unitary (~.Operation): a PennyLane unitary operation
-
-        Returns:
-            tf.Tensor[complex] or array[complex]: Returns a 2D matrix representation of
-            the unitary in the computational basis, or, in the case of a diagonal unitary,
-            a 1D array representing the matrix diagonal. For non-parametric unitaries,
-            the return type will be a ``np.ndarray``. For parametric unitaries, a ``tf.Tensor``
-            object will be returned.
-        """
-        op_name = unitary.name.split(".inv")[0]
-
-        if op_name in self.parametric_ops:
-            if op_name == "MultiRZ":
-                mat = self.parametric_ops[op_name](*unitary.parameters, len(unitary.wires))
-            else:
-                mat = self.parametric_ops[op_name](*unitary.parameters)
-
-            if unitary.inverse:
-                mat = self._transpose(self._conj(mat))
-
-            return mat
-
-        if isinstance(unitary, DiagonalOperation):
-            return unitary.eigvals
-
-        return unitary.matrix

pennylane/devices/default_qubit_torch.py

@@ -28,7 +28,6 @@
 
 import numpy as np
 from pennylane.operation import DiagonalOperation
-from pennylane.devices import torch_ops
 from . import DefaultQubit
 
 
@@ -132,29 +131,6 @@ def circuit(x):
     name = "Default qubit (Torch) PennyLane plugin"
     short_name = "default.qubit.torch"
 
-    parametric_ops = {
-        "PhaseShift": torch_ops.PhaseShift,
-        "ControlledPhaseShift": torch_ops.ControlledPhaseShift,
-        "RX": torch_ops.RX,
-        "RY": torch_ops.RY,
-        "RZ": torch_ops.RZ,
-        "MultiRZ": torch_ops.MultiRZ,
-        "Rot": torch_ops.Rot,
-        "CRX": torch_ops.CRX,
-        "CRY": torch_ops.CRY,
-        "CRZ": torch_ops.CRZ,
-        "CRot": torch_ops.CRot,
-        "IsingXX": torch_ops.IsingXX,
-        "IsingYY": torch_ops.IsingYY,
-        "IsingZZ": torch_ops.IsingZZ,
-        "SingleExcitation": torch_ops.SingleExcitation,
-        "SingleExcitationPlus": torch_ops.SingleExcitationPlus,
-        "SingleExcitationMinus": torch_ops.SingleExcitationMinus,
-        "DoubleExcitation": torch_ops.DoubleExcitation,
-        "DoubleExcitationPlus": torch_ops.DoubleExcitationPlus,
-        "DoubleExcitationMinus": torch_ops.DoubleExcitationMinus,
-    }
-
     C_DTYPE = torch.complex128
     R_DTYPE = torch.float64
 
@@ -261,21 +237,6 @@ def _get_unitary_matrix(self, unitary):
             the unitary in the computational basis, or, in the case of a diagonal unitary,
             a 1D array representing the matrix diagonal.
         """
-        op_name = unitary.base_name
-        if op_name in self.parametric_ops:
-            if op_name == "MultiRZ":
-                mat = self.parametric_ops[op_name](
-                    *unitary.parameters, len(unitary.wires), device=self._torch_device
-                )
-            else:
-                mat = self.parametric_ops[op_name](*unitary.parameters, device=self._torch_device)
-            if unitary.inverse:
-                if isinstance(unitary, DiagonalOperation):
-                    mat = self._conj(mat)
-                else:
-                    mat = self._transpose(self._conj(mat), axes=[1, 0])
-            return mat
-
         if isinstance(unitary, DiagonalOperation):
             return self._asarray(unitary.eigvals, dtype=self.C_DTYPE)
         return self._asarray(unitary.matrix, dtype=self.C_DTYPE)

pennylane/math/single_dispatch.py

@@ -134,6 +134,7 @@ def _take_autograd(tensor, indices, axis=None):
 ar.autoray._SUBMODULE_ALIASES["tensorflow", "arctan2"] = "tensorflow.math"
 ar.autoray._SUBMODULE_ALIASES["tensorflow", "diag"] = "tensorflow.linalg"
 ar.autoray._SUBMODULE_ALIASES["tensorflow", "kron"] = "tensorflow.experimental.numpy"
+ar.autoray._SUBMODULE_ALIASES["tensorflow", "moveaxis"] = "tensorflow.experimental.numpy"
 
 
 ar.autoray._FUNC_ALIASES["tensorflow", "arcsin"] = "asin"

pennylane/operation.py

@@ -767,7 +767,7 @@ def matrix(self):
         op_matrix = self._matrix(*self.parameters)
 
         if self.inverse:
-            return op_matrix.conj().T
+            return qml.math.conj(qml.math.T(op_matrix))
 
         return op_matrix
 
@@ -776,7 +776,7 @@ def eigvals(self):
         op_eigvals = self._eigvals(*self.parameters)
 
         if self.inverse:
-            return op_eigvals.conj()
+            return qml.math.conj(op_eigvals)
 
         return op_eigvals
 
@@ -1886,6 +1886,6 @@ def operation_derivative(operation) -> np.ndarray:
 
     if operation.inverse:
         prefactor *= -1
-        generator = generator.conj().T
+        generator = qml.math.conj(qml.math.T(generator))
 
     return 1j * prefactor * generator @ operation.matrix