Add VnEntanglementEntropyMP measurement process

doc/releases/changelog-dev.md

@@ -3,6 +3,10 @@
 # Release 0.39.0-dev (development release)
 
 <h3>New features since last release</h3>
+
+* A new `qml.vn_entanglement_entropy` measurement process has been added which measures the
+  Von Neumann entanglement entropy of a quantum state.
+  [(#5911)](https://github.com/PennyLaneAI/pennylane/pull/5911)
 
 <h3>Improvements 🛠</h3>
 

pennylane/__init__.py

@@ -67,6 +67,7 @@
     state,
     var,
     vn_entropy,
+    vn_entanglement_entropy,
     purity,
     mutual_info,
     classical_shadow,

pennylane/devices/_qubit_device.py

@@ -50,6 +50,7 @@
     StateMeasurement,
     StateMP,
     VarianceMP,
+    VnEntanglementEntropyMP,
     VnEntropyMP,
 )
 from pennylane.operation import Operation, operation_derivative
@@ -740,6 +741,29 @@
                     )
                 result = self.vn_entropy(wires=obs.wires, log_base=obs.log_base)
 
+            elif isinstance(m, VnEntanglementEntropyMP):
+                if self.wires.labels != tuple(range(self.num_wires)):
+                    raise qml.QuantumFunctionError(
+                        "Returning the Von Neumann entanglement entropy is not supported when using custom wire labels"
+                    )
+
+                if self._shot_vector is not None:
+                    raise NotImplementedError(
+                        "Returning the Von Neumann entanglement entropy is not supported with shot vectors."
+                    )
+
+                if self.shots is not None:
+                    warnings.warn(
+                        "Requested Von Neumann entanglement entropy with finite shots; the returned "
+                        "state information is analytic and is unaffected by sampling. To silence "
+                        "this warning, set shots=None on the device.",
+                        UserWarning,
+                    )
+                wires0, wires1 = obs.raw_wires
+                result = self.vn_entanglement_entropy(
+                    wires0=wires0, wires1=wires1, log_base=obs.log_base
+                )
+
             elif isinstance(m, MutualInfoMP):
                 if self.wires.labels != tuple(range(self.num_wires)):
                     raise qml.QuantumFunctionError(
@@ -799,6 +823,7 @@
                     VarianceMP,
                     ProbabilityMP,
                     VnEntropyMP,
+                    VnEntanglementEntropyMP,
                     MutualInfoMP,
                     ShadowExpvalMP,
                 ),
@@ -1038,6 +1063,32 @@
         wires = wires.tolist()
         return qml.math.vn_entropy(state, indices=wires, c_dtype=self.C_DTYPE, base=log_base)
 
+    def vn_entanglement_entropy(self, wires0, wires1, log_base):
+        r"""Returns the Von Neumann entanglement entropy prior to measurement.
+        .. math::
+            S(\rho_A) = -\text{Tr}[\rho_A \log \rho_A] = -\text{Tr}[\rho_B \log \rho_B] = S(\rho_B)
+        Args:
+            wires0 (Sequence[int] or int): the wires of the first subsystem
+            wires1 (Sequence[int] or int): the wires of the second subsystem
+            log_base (float): Base for the logarithm.
+        Returns:
+            float: returns the Von Neumann entropy
+        """
+        try:
+            state = self.density_matrix(wires=self.wires)
+        except qml.QuantumFunctionError as e:  # pragma: no cover
+            raise NotImplementedError(
+                f"Cannot compute the Von Neumman entropy with device {self.name} that is not capable of returning the "
+                f"state. "
+            ) from e
+
+        wires0 = wires0.tolist()
+        wires1 = wires1.tolist()
+
+        return qml.math.vn_entanglement_entropy(
+            state, indices0=wires0, indices1=wires1, c_dtype=self.C_DTYPE, base=log_base
+        )
+
     def mutual_info(self, wires0, wires1, log_base):
         r"""Returns the mutual information prior to measurement:
 

pennylane/devices/_qutrit_device.py

@@ -183,6 +183,24 @@ def vn_entropy(self, wires, log_base):
             "Unsupported return type specified for observable Von Neumann entropy"
         )
 
+    def vn_entanglement_entropy(self, wires0, wires1, log_base):
+        r"""Returns the Von Neumann entanglement entropy prior to measurement.
+        .. math::
+            S(\rho_A) = -\text{Tr}[\rho_A \log \rho_A] = -\text{Tr}[\rho_B \log \rho_B] = S(\rho_B)
+        Args:
+            wires0 (Sequence[int] or int): the wires of the first subsystem
+            wires1 (Sequence[int] or int): the wires of the second subsystem
+            log_base (float): Base for the logarithm.
+        Returns:
+            float: returns the Von Neumann entropy
+        """
+        # TODO: Add support for VnEntanglementEntropy return type. Currently, qml.math is hard coded to calculate this for qubit
+        # states (see `qml.math.vn_entanglement_entropy()`), so it needs to be updated before VnEntanglementEntropy can be supported for qutrits.
+        # For now, if a user tries to request this return type, an error will be raised.
+        raise qml.QuantumFunctionError(
+            "Unsupported return type specified for observable Von Neumann entanglement entropy"
+        )
+
     def mutual_info(self, wires0, wires1, log_base):
         r"""Returns the mutual information prior to measurement:
 

pennylane/devices/default_mixed.py

@@ -41,6 +41,7 @@
     SampleMP,
     StateMP,
     VarianceMP,
+    VnEntanglementEntropyMP,
     VnEntropyMP,
 )
 from pennylane.operation import Channel
@@ -637,6 +638,9 @@ def _snapshot_measurements(self, density_matrix, measurement):
                 density_matrix, indices=map_wires, c_dtype=self.C_DTYPE, base=base
             )
 
+        elif isinstance(measurement, VnEntanglementEntropyMP):
+            snap_result = measurement.process_density_matrix(density_matrix, wire_order=self.wires)
+
         elif isinstance(measurement, MutualInfoMP):
             base = measurement.log_base
             wires0, wires1 = list(map(self.map_wires, measurement.raw_wires))
@@ -762,9 +766,9 @@ def execute(self, circuit, **kwargs):
                     # not specified or all wires specified.
                     self.measured_wires = self.wires
                     return super().execute(circuit, **kwargs)
-                if isinstance(m, (VnEntropyMP, MutualInfoMP)):
-                    # VnEntropy, MutualInfo: Computed for the state
-                    # prior to measurement. So, readout error need not be applied to the
+                if isinstance(m, (VnEntropyMP, VnEntanglementEntropyMP, MutualInfoMP)):
+                    # VnEntropy, VnEntanglementEntropyMP, MutualInfo: Computed for the state
+                    # prior to measurement. So, readout error need not be applied on the
                     # corresponding device wires.
                     continue
                 wires_list.append(m.wires)

pennylane/measurements/__init__.py

@@ -288,6 +288,7 @@ def circuit(x):
     StateMeasurement,
     Variance,
     VnEntropy,
+    VnEntanglementEntropy,
 )
 from .mid_measure import MeasurementValue, MidMeasureMP, measure, find_post_processed_mcms
 from .mutual_info import MutualInfoMP, mutual_info
@@ -298,3 +299,4 @@ def circuit(x):
 from .state import DensityMatrixMP, StateMP, density_matrix, state
 from .var import VarianceMP, var
 from .vn_entropy import VnEntropyMP, vn_entropy
+from .vn_entanglement_entropy import VnEntanglementEntropyMP, vn_entanglement_entropy

pennylane/measurements/measurements.py

@@ -46,6 +46,7 @@ class ObservableReturnTypes(Enum):
     State = "state"
     MidMeasure = "measure"
     VnEntropy = "vnentropy"
+    VnEntanglementEntropy = "vnentanglemententropy"
     MutualInfo = "mutualinfo"
     Shadow = "shadow"
     ShadowExpval = "shadowexpval"
@@ -90,6 +91,9 @@ def __repr__(self):
 VnEntropy = ObservableReturnTypes.VnEntropy
 """Enum: An enumeration which represents returning Von Neumann entropy before measurements."""
 
+VnEntanglementEntropy = ObservableReturnTypes.VnEntanglementEntropy
+"""Enum: An enumeration which represents returning Von Neumann entanglement entropy before measurements."""
+
 MutualInfo = ObservableReturnTypes.MutualInfo
 """Enum: An enumeration which represents returning the mutual information before measurements."""
 

pennylane/measurements/vn_entanglement_entropy.py

@@ -0,0 +1,184 @@
+# Copyright 2018-2024 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.
+# pylint: disable=protected-access
+"""
+This module contains the qml.vn_entanglement_entropy measurement.
+"""
+from copy import copy
+from typing import Optional, Sequence
+
+import pennylane as qml
+from pennylane.wires import Wires
+
+from .measurements import StateMeasurement, VnEntanglementEntropy
+
+
+def vn_entanglement_entropy(wires0, wires1, log_base=None):
+    r"""Measures the `Von Neumann entanglement entropy <https://en.wikipedia.org/wiki/Entropy_of_entanglement>`_
+    of a quantum state:
+
+    .. math::
+
+        S(\rho_A) = -\text{Tr}[\rho_A \log \rho_A] = -\text{Tr}[\rho_B \log \rho_B] = S(\rho_B)
+
+    where :math:`S` is the Von Neumann entropy; :math:`\rho_A = \text{Tr}_B [\rho_{AB}]` and
+    :math:`\rho_B = \text{Tr}_A [\rho_{AB}]` are the reduced density matrices for each partition.
+    The Von Neumann entanglement entropy is a measure of the degree of quantum entanglement between
+    two subsystems constituting a pure bipartite quantum state. The entropy of entanglement is the
+    Von Neumann entropy of the reduced density matrix for any of the subsystems. If it is non-zero,
+    it indicates the two subsystems are entangled.
+
+    Args:
+        wires0 (Sequence[int] or int): the wires of the first subsystem
+        wires1 (Sequence[int] or int): the wires of the second subsystem
+        log_base (float): Base for the logarithm.
+
+    Returns:
+        VnEntanglementEntropyMP: measurement process instance
+
+    **Example:**
+
+    .. code-block:: python3
+
+        dev = qml.device("default.qubit", wires=2)
+        @qml.qnode(dev)
+        def circuit(x):
+            qml.RY(x, 0)
+            qml.Hadamard(0)
+            qml.CNOT([0, 1])
+            return qml.vn_entanglement_entropy([0], [1])
+
+    Executing this QNode:
+
+    >>> circuit(1.967)
+    0.16389850379003218
+
+    It is also possible to get the gradient of the previous QNode:
+
+    >>> param = np.array(np.pi/4, requires_grad=True)
+    >>> qml.grad(circuit)(param)
+    tensor(-0.62322524, requires_grad=True)
+
+    .. note::
+
+        Calculating the derivative of :func:`~pennylane.vn_entanglement_entropy` is currently supported when
+        using the classical backpropagation differentiation method (``diff_method="backprop"``)
+        with a compatible device and finite differences (``diff_method="finite-diff"``).
+
+    .. seealso:: :func:`~pennylane.vn_entropy` and :func:`pennylane.math.vn_entanglement_entropy`
+    """
+    wires0 = qml.wires.Wires(wires0)
+    wires1 = qml.wires.Wires(wires1)
+
+    # the subsystems cannot overlap
+    if not any(qml.math.is_abstract(w) for w in wires0 + wires1) and [
+        wire for wire in wires0 if wire in wires1
+    ]:
+        raise qml.QuantumFunctionError(
+            "Subsystems for computing entanglement entropy must not overlap."
+        )
+    return VnEntanglementEntropyMP(wires=(wires0, wires1), log_base=log_base)
+
+
+class VnEntanglementEntropyMP(StateMeasurement):
+    """Measurement process that computes the Von Neumann entanglement entropy between the provided wires.
+    Please refer to :func:`~pennylane.vn_entanglement_entropy` for detailed documentation.
+
+    Args:
+        wires (Sequence[.Wires]): The wires the measurement process applies to.
+        id (str): custom label given to a measurement instance, can be useful for some applications
+            where the instance has to be identified
+        log_base (float): base for the logarithm
+    """
+
+    def _flatten(self):
+        metadata = (("wires", tuple(self.raw_wires)), ("log_base", self.log_base))
+        return (None, None), metadata
+
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self,
+        wires: Optional[Sequence[Wires]] = None,
+        id: Optional[str] = None,
+        log_base: Optional[float] = None,
+    ):
+        self.log_base = log_base
+        super().__init__(wires=wires, id=id)
+
+    # pylint: disable=arguments-differ
+    @classmethod
+    def _primitive_bind_call(cls, wires: Sequence, **kwargs):
+        if cls._wires_primitive is None:  # pragma: no cover
+            # just a safety check
+            return type.__call__(cls, wires=wires, **kwargs)  # pragma: no cover
+        return cls._wires_primitive.bind(*wires[0], *wires[1], n_wires0=len(wires[0]), **kwargs)
+
+    def __repr__(self):
+        return f"VnEntanglementEntropy(wires0={self.raw_wires[0].tolist()}, wires1={self.raw_wires[1].tolist()}, log_base={self.log_base})"
+
+    @property
+    def hash(self):
+        """int: returns an integer hash uniquely representing the measurement process"""
+        fingerprint = (
+            self.__class__.__name__,
+            tuple(self.raw_wires[0].tolist()),
+            tuple(self.raw_wires[1].tolist()),
+            self.log_base,
+        )
+
+        return hash(fingerprint)
+
+    @property
+    def return_type(self):
+        return VnEntanglementEntropy
+
+    @property
+    def numeric_type(self):
+        return float
+
+    def map_wires(self, wire_map: dict):
+        new_measurement = copy(self)
+        new_measurement._wires = [
+            Wires([wire_map.get(wire, wire) for wire in wires]) for wires in self.raw_wires
+        ]
+        return new_measurement
+
+    def shape(
+        self, shots: Optional[int] = None, num_device_wires: int = 0
+    ):  # pylint: disable=unused-argument
+        return ()
+
+    def process_state(self, state: Sequence[complex], wire_order: Wires):
+        density_matrix = qml.math.dm_from_state_vector(state)
+        return self.process_density_matrix(density_matrix=density_matrix, wire_order=wire_order)
+
+    def process_density_matrix(
+        self, density_matrix: Sequence[complex], wire_order: Wires
+    ):  # pylint: disable=unused-argument
+        return qml.math.vn_entanglement_entropy(
+            density_matrix,
+            indices0=list(self._wires[0]),
+            indices1=list(self._wires[1]),
+            c_dtype=density_matrix.dtype,
+            base=self.log_base,
+        )
+
+
+if VnEntanglementEntropyMP._wires_primitive is not None:
+
+    @VnEntanglementEntropyMP._wires_primitive.def_impl
+    def _(*all_wires, n_wires0, **kwargs):
+        wires0 = all_wires[:n_wires0]
+        wires1 = all_wires[n_wires0:]
+        return type.__call__(VnEntanglementEntropyMP, wires=(wires0, wires1), **kwargs)