Merge branch 'master' into fix-measure

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,
@@ -183,23 +184,23 @@ def __getattr__(name):
  if name == "QubitDevice":
  warn(
  "QubitDevice will no longer be accessible top level. Please access "
- " the class as pennylane.devices.QubitDevice",
+ "the class as pennylane.devices.QubitDevice",
  PennyLaneDeprecationWarning,
  )
  return pennylane.devices._qubit_device.QubitDevice # pylint:disable=protected-access
 
  if name == "QutritDevice":
  warn(
  "QutritDevice will no longer be accessible top level. Please access "
- " the class as pennylane.devices.QutritDevice",
+ "the class as pennylane.devices.QutritDevice",
  PennyLaneDeprecationWarning,
  )
  return pennylane.devices._qutrit_device.QutritDevice # pylint:disable=protected-access
 
  if name == "Device":
  warn(
  "Device will no longer be accessible top level. Please access "
- " the class as pennylane.devices.LegacyDevice",
+ "the class as pennylane.devices.LegacyDevice",
  PennyLaneDeprecationWarning,
  )
  return pennylane.devices._legacy_device.Device # pylint:disable=protected-access

pennylane/devices/_qubit_device.py

@@ -50,6 +50,7 @@
  StateMeasurement,
  StateMP,
  VarianceMP,
+ VnEntanglementEntropyMP,
  VnEntropyMP,
 )
 from pennylane.operation import Operation, operation_derivative
@@ -718,6 +719,29 @@ def statistics(
  )
  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(
@@ -777,6 +801,7 @@ def statistics(
  VarianceMP,
  ProbabilityMP,
  VnEntropyMP,
+ VnEntanglementEntropyMP,
  MutualInfoMP,
  ShadowExpvalMP,
  ),
@@ -1008,14 +1033,44 @@ def vn_entropy(self, wires, log_base):
  """
  try:
  state = self.density_matrix(wires=self.wires)
- except qml.QuantumFunctionError as e: # pragma: no cover
+ except (qml.QuantumFunctionError, NotImplementedError) 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
  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, NotImplementedError) 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:
 
@@ -1035,7 +1090,7 @@ def mutual_info(self, wires0, wires1, log_base):
  """
  try:
  state = self.density_matrix(wires=self.wires)
- except qml.QuantumFunctionError as e: # pragma: no cover
+ except (qml.QuantumFunctionError, NotImplementedError) as e: # pragma: no cover
  raise NotImplementedError(
  f"Cannot compute the mutual information with device {self.name} that is not capable of returning the "
  f"state. "

pennylane/devices/_qutrit_device.py

@@ -183,6 +183,28 @@ 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."""