[WIP] Redesign capabilities dictionary

doc/development/plugins.rst

@@ -101,15 +101,27 @@ as well as potential further capabilities, by providing the following class attr
       conversion between the two conventions takes place automatically
       by the plugin device.
 
-* :attr:`.Device._capabilities`: a dictionary containing information about the capabilities of
-  the device. Keys currently supported include:
+* :attr:`.Device.capabilities()`: a function overriding the corresponding base class method,
+  which updates the ``_capabilities`` dictionary containing information about the properties of
+  the device. These properties are queried by PennyLane core and/or external apps. Examples are:
 
   * ``'model'`` (*str*): either ``'qubit'`` or ``'CV'``.
 
-  * ``'inverse_operations'`` (*bool*): ``True`` if the device supports
+  * ``'supports_inverse_operations'`` (*bool*): ``True`` if the device supports
     applying the inverse of operations. Operations which should be inverted
     have the property ``operation.inverse == True``.
 
+  * ``'supports_exact'`` (*bool*): ``True`` if the device is a simulator that returns analytic results.
+
+  *  ``'supports_sampled'`` (*bool*): ``True`` if outputs are estimates computed from samples of measurement outcomes.
+
+  *  ``'supports_tensor_observables'`` (*bool*): ``True`` if the device supports observables composed from tensor
+     products such as ``PauliZ(wires=0) @ PauliZ(wires=1)``.
+
+  *  ``'executes_in_remote'`` (*bool*): ``True`` if the device runs in remote.
+
+  *  ``'takes_fixed_number_of_wires'`` (*bool*): ``True`` if the device's number of wires are fixed.
+
 Adding arguments to your device
 --------------------------------
 

pennylane/_device.py

@@ -51,7 +51,22 @@ class Device(abc.ABC):
     """
 
     # pylint: disable=too-many-public-methods
-    _capabilities = {}  #: dict[str->*]: plugin capabilities
+    _capabilities = {
+        'model': None,
+        'passthru_interface': None,
+        'supports_reversible_diff': False,
+        'supports_exact': False,
+        'supports_sampled': False,
+        'supports_inverse_operations': False,
+        'supports_tensor_observables': False,
+        'provides_jacobian': False,
+        'executes_in_remote': False,
+        'takes_fixed_number_of_wires': False,
+        'performs_noisy_computation': False,
+        }
+    """The capabilities dictionary stores the properties of a device. Devices can add their 
+    own custom properties and overwrite existing ones by overwriting the ``capabilities`` class method."""
+
     _circuits = {}  #: dict[str->Circuit]: circuit templates associated with this API class
     _asarray = staticmethod(np.asarray)
 
@@ -213,9 +228,19 @@ def map_wires(self, wires):
 
     @classmethod
     def capabilities(cls):
-        """Get the other capabilities of the plugin.
+        """Get the capabilities of this device class.
+
+        Inheriting classes that overwrite or add capabilities should overwrite this method with
 
-        Measurements, batching etc.
+        .. code-block::
+
+            @classmethod
+            def capabilities(cls):
+                capabilities = super().capabilities().copy()
+                capabilities.update(
+                    new_capability=...,
+                )
+                return capabilities
 
         Returns:
             dict[str->*]: results
@@ -413,7 +438,7 @@ def supports_operation(self, operation):
             if operation.endswith(Operation.string_for_inverse):
                 return operation[
                     : -len(Operation.string_for_inverse)
-                ] in self.operations and self.capabilities().get("inverse_operations", False)
+                ] in self.operations and self.capabilities().get("supports_inverse_operations", False)
 
             return operation in self.operations
 
@@ -468,7 +493,7 @@ def check_validity(self, queue, observables):
             operation_name = o.name
 
             if o.inverse:
-                if not self.capabilities().get("inverse_operations", False):
+                if not self.capabilities().get("supports_inverse_operations", False):
                     raise DeviceError(
                         "The inverse of gates are not supported on device {}".format(
                             self.short_name
@@ -484,7 +509,7 @@ def check_validity(self, queue, observables):
         for o in observables:
 
             if isinstance(o, Tensor):
-                if not self.capabilities().get("tensor_observables", False):
+                if not self.capabilities().get("supports_tensor_observables", False):
                     raise DeviceError(
                         "Tensor observables not supported on device {}".format(self.short_name)
                     )
@@ -501,7 +526,7 @@ def check_validity(self, queue, observables):
                 observable_name = o.name
 
                 if issubclass(o.__class__, Operation) and o.inverse:
-                    if not self.capabilities().get("inverse_operations", False):
+                    if not self.capabilities().get("supports_inverse_operations", False):
                         raise DeviceError(
                             "The inverse of gates are not supported on device {}".format(
                                 self.short_name

pennylane/_qubit_device.py

@@ -111,32 +111,14 @@ def __init__(self, wires=1, shots=1000, analytic=True):
 
     @classmethod
     def capabilities(cls):
-        """Get the capabilities of the plugin.
 
-        Capabilities include:
-
-        * ``"model"`` (*str*): either ``"qubit"`` or ``"CV"``.
-
-        * ``"inverse_operations"`` (*bool*): ``True`` if the device supports
-          applying the inverse of operations. Operations which should be inverted
-          have ``operation.inverse == True``.
-
-        * ``"tensor_observables" (*bool*): ``True`` if the device supports
-          expectation values/variance/samples of :class:`~.Tensor` observables.
-
-        The qubit device class has built-in support for tensor observables. As a
-        result, devices that inherit from this class automatically
-        have the following items in their capabilities
-        dictionary:
-
-        * ``"model": "qubit"``
-        * ``"tensor_observables": True``
-
-        Returns:
-            dict[str->*]: results
-        """
-        capabilities = cls._capabilities
-        capabilities.update(model="qubit", tensor_observables=True)
+        capabilities = super().capabilities().copy()
+        capabilities.update(
+            model='qubit',
+            supports_exact=True,
+            supports_sampled=True,
+            supports_tensor_observables=True,
+        )
         return capabilities
 
     def reset(self):

pennylane/beta/devices/default_tensor.py

@@ -101,7 +101,6 @@ class DefaultTensor(Device):
     pennylane_requires = "0.12"
     version = "0.12.0"
     author = "Xanadu Inc."
-    _capabilities = {"model": "qubit", "tensor_observables": True}
 
     _operation_map = {
         "BasisState": None,
@@ -165,6 +164,17 @@ def __init__(self, wires, shots=1000, representation="exact", contraction_method
         self._contraction_method = contraction_method
         self.reset()
 
+    @classmethod
+    def capabilities(cls):
+        capabilities = super().capabilities().copy()
+        capabilities.update(
+            model='qubit',
+            supports_exact=True,
+            supports_sampled=True,
+            supports_tensor_observables=True,
+        )
+        return capabilities
+
     def reset(self):
         """Reset the device."""
         self._clear_network_data()

pennylane/beta/devices/default_tensor_tf.py

@@ -115,12 +115,6 @@ class DefaultTensorTF(DefaultTensor):
     # pylint: disable=too-many-instance-attributes
     name = "PennyLane TensorNetwork (TensorFlow) simulator plugin"
     short_name = "default.tensor.tf"
-    _capabilities = {
-        "model": "qubit",
-        "tensor_observables": True,
-        "provides_jacobian": True,
-        "passthru_interface": "tf",
-    }
 
     _operation_map = copy.copy(DefaultTensor._operation_map)
     _operation_map.update(
@@ -174,6 +168,15 @@ def __init__(self, wires, shots=1000, representation="exact", contraction_method
             contraction_method=contraction_method,
         )
 
+    @classmethod
+    def capabilities(cls):
+        capabilities = super().capabilities().copy()
+        capabilities.update(
+            provides_jacobian=True,
+            passthru_interface='tf',
+        )
+        return capabilities
+
     def reset(self):
         self.res = None
         self.variables = []

pennylane/devices/__init__.py

@@ -32,3 +32,5 @@
 """
 from .default_qubit import DefaultQubit
 from .default_gaussian import DefaultGaussian
+from .default_qubit_tf import DefaultQubitTF
+from .default_qubit_autograd import DefaultQubitAutograd

pennylane/devices/default_gaussian.py

@@ -656,8 +656,6 @@ class DefaultGaussian(Device):
     version = "0.12.0"
     author = "Xanadu Inc."
 
-    _capabilities = {"model": "cv"}
-
     _operation_map = {
         "Beamsplitter": beamsplitter,
         "ControlledAddition": controlled_addition,
@@ -695,6 +693,16 @@ def __init__(self, wires, *, shots=1000, hbar=2, analytic=True):
 
         self.reset()
 
+    @classmethod
+    def capabilities(cls):
+        capabilities = super().capabilities().copy()
+        capabilities.update(
+            model='cv',
+            supports_exact=True,
+            supports_sampling=True,
+        )
+        return capabilities
+
     def pre_apply(self):
         self.reset()
 

pennylane/devices/default_qubit.py

@@ -54,7 +54,6 @@ class DefaultQubit(QubitDevice):
     pennylane_requires = "0.12"
     version = "0.12.0"
     author = "Xanadu Inc."
-    _capabilities = {"inverse_operations": True, "reversible_diff": True}
 
     operations = {
         "BasisState",
@@ -158,6 +157,15 @@ def _get_unitary_matrix(self, unitary):  # pylint: disable=no-self-use
 
         return unitary.matrix
 
+    @classmethod
+    def capabilities(cls):
+        capabilities = super().capabilities().copy()
+        capabilities.update(
+            supports_reversible_diff=True,
+            supports_inverse_operations=True,
+        )
+        return capabilities
+
     def _create_basis_state(self, index):
         """Return a computational basis state over all wires.
 

pennylane/devices/default_qubit_autograd.py

@@ -74,12 +74,6 @@ class DefaultQubitAutograd(DefaultQubit):
     name = "Default qubit (Autograd) PennyLane plugin"
     short_name = "default.qubit.autograd"
 
-    _capabilities = {
-        "model": "qubit",
-        "provides_jacobian": False,
-        "passthru_interface": "autograd",
-    }
-
     parametric_ops = {
         "PhaseShift": autograd_ops.PhaseShift,
         "RX": autograd_ops.RX,
@@ -107,6 +101,15 @@ class DefaultQubitAutograd(DefaultQubit):
     _conj = staticmethod(np.conj)
     _imag = staticmethod(np.imag)
 
+    @classmethod
+    def capabilities(cls):
+        capabilities = super().capabilities().copy()
+        capabilities.update(
+            provides_jacobian=False,
+            passthru_interface='autograd',
+        )
+        return capabilities
+
     @staticmethod
     def _scatter(indices, array, new_dimensions):
         new_array = np.zeros(new_dimensions, dtype=array.dtype.type)

pennylane/devices/default_qubit_tf.py

@@ -124,12 +124,6 @@ class DefaultQubitTF(DefaultQubit):
     name = "Default qubit (TensorFlow) PennyLane plugin"
     short_name = "default.qubit.tf"
 
-    _capabilities = {
-        "model": "qubit",
-        "provides_jacobian": False,
-        "passthru_interface": "tf",
-    }
-
     parametric_ops = {
         "PhaseShift": tf_ops.PhaseShift,
         "RX": tf_ops.RX,
@@ -157,6 +151,15 @@ class DefaultQubitTF(DefaultQubit):
     _conj = staticmethod(tf.math.conj)
     _imag = staticmethod(tf.math.conj)
 
+    @classmethod
+    def capabilities(cls):
+        capabilities = super().capabilities().copy()
+        capabilities.update(
+            provides_jacobian=False,
+            passthru_interface='tf',
+        )
+        return capabilities
+
     @staticmethod
     def _scatter(indices, array, new_dimensions):
         indices = np.expand_dims(indices, 1)

pennylane/devices/tests/conftest.py

@@ -29,7 +29,7 @@
 # Tolerance for analytic tests
 TOL = 1e-6
 # Tolerance for non-analytic tests
-TOL_STOCHASTIC = 0.05
+TOL_STOCHASTIC = 0.1
 # Number of shots to call the devices with
 N_SHOTS = 10000
 # List of all devices that are included in PennyLane
@@ -104,7 +104,7 @@ def _device(wires):
             )
 
         capabilities = dev.capabilities()
-        if "model" not in capabilities or not capabilities["model"] == "qubit":
+        if capabilities.get("model", None) != "qubit":
             # exit the tests if device based on cv model (currently not supported)
             pytest.exit("The device test suite currently only runs on qubit-based devices.")