Integration into the current PL device ecosys

doc/releases/changelog-dev.md

@@ -133,43 +133,20 @@
   [(#6396)](https://github.com/PennyLaneAI/pennylane/pull/6396)
 
 
-<h4>New API for Qubit Mixed</h4>
-
-* Added `qml.devices.qubit_mixed` module for mixed-state qubit device support [(#6379)](https://github.com/PennyLaneAI/pennylane/pull/6379). This module introduces an `apply_operation` helper function that features:
-
-  * Two density matrix contraction methods using `einsum` and `tensordot`
-
-  * Optimized handling of special cases including: Diagonal operators, Identity operators, CX (controlled-X), Multi-controlled X gates, Grover operators
-
-* Added submodule 'initialize_state' featuring a `create_initial_state` function for initializing a density matrix from `qml.StatePrep` operations or `qml.QubitDensityMatrix` operations.
-  [(#6503)](https://github.com/PennyLaneAI/pennylane/pull/6503)
-
 * Added support for constructing `BoseWord` and `BoseSentence`, similar to `FermiWord` and `FermiSentence`.
   [(#6518)](https://github.com/PennyLaneAI/pennylane/pull/6518)
 
-* Added method `preprocess` to the `QubitMixed` device class to preprocess the quantum circuit before execution. Necessary non-intrusive interfaces changes to class init method were made along the way to the `QubitMixed` device class to support new API feature.
+* New API for `default_mixed`: migrate the old `DefaultMixed` to follow our new device API standard. Basically, previous class `qml.devices.default_mixed.DefaultMixed` was refactored. Users will not experience any differences in principle, but for some users who delved deep into PennyLane codebase and happened to use certain deprecated methods or properties of the legacy code this might introduce breaking changes.
+  [(#6379)](https://github.com/PennyLaneAI/pennylane/pull/6379)
+  [(#6503)](https://github.com/PennyLaneAI/pennylane/pull/6503)
   [(#6601)](https://github.com/PennyLaneAI/pennylane/pull/6601)
-
-* Added a second class `DefaultMixedNewAPI` to the `qml.devices.qubit_mixed` module, which is to be the replacement of legacy `DefaultMixed` which for now to hold the implementations of `preprocess` and `execute` methods.
   [(#6607)](https://github.com/PennyLaneAI/pennylane/pull/6607)
-
-* Added submodule `devices.qubit_mixed.measure` as a necessary step for the new API, featuring a `measure` function for measuring qubits in mixed-state devices.
   [(#6637)](https://github.com/PennyLaneAI/pennylane/pull/6637)
-
-* Added submodule `devices.qubit_mixed.simulate` as a necessary step for the new API,
-featuring a `simulate` function for simulating mixed states in analytic mode.
   [(#6618)](https://github.com/PennyLaneAI/pennylane/pull/6618)
-
-* Added submodule `devices.qubit_mixed.sampling` as a necessary step for the new API, featuring functions `sample_state`, `measure_with_samples` and `sample_probs` for sampling qubits in mixed-state devices.
   [(#6639)](https://github.com/PennyLaneAI/pennylane/pull/6639)
-
-* Added support `qml.Snapshot` operation in `qml.devices.qubit_mixed.apply_operation`.
   [(#6659)](https://github.com/PennyLaneAI/pennylane/pull/6659)
-
-* Implemented the finite-shot branch of `devices.qubit_mixed.simulate`. Now, the 
-new device API of `default_mixed` should be able to take the stochastic arguments
-such as `shots`, `rng` and `prng_key`.
-[(#6665)](https://github.com/PennyLaneAI/pennylane/pull/6665)
+  [(#6665)](https://github.com/PennyLaneAI/pennylane/pull/6665)
+  [(#6684)](https://github.com/PennyLaneAI/pennylane/pull/6684)
 
 * Added `christiansen_mapping()` function to map `BoseWord` and `BoseSentence` to qubit operators, using christiansen mapping.
   [(#6623)](https://github.com/PennyLaneAI/pennylane/pull/6623)

pennylane/devices/__init__.py

@@ -51,6 +51,7 @@
     ExecutionConfig
     MCMConfig
     Device
+    DefaultMixed
     DefaultQubit
     DefaultTensor
     NullQubit
@@ -134,6 +135,13 @@ def execute(self, circuits, execution_config = qml.devices.DefaultExecutionConfi
 .. automodule:: pennylane.devices.qubit
 
 
+Qubit Mixed-State Simulation Tools
+----------------------
+
+.. currentmodule:: pennylane.devices.qubit_mixed
+.. automodule:: pennylane.devices.qubit_mixed
+
+
 Qutrit Mixed-State Simulation Tools
 -----------------------------------
 
@@ -153,7 +161,7 @@ def execute(self, circuits, execution_config = qml.devices.DefaultExecutionConfi
 # DefaultTensor is not imported here to avoid warnings
 # from quimb in case it is installed on the system.
 from .default_gaussian import DefaultGaussian
-from .default_mixed import DefaultMixed
+from .default_mixed import DefaultMixed, DefaultMixedLegacy
 from .default_clifford import DefaultClifford
 from .default_tensor import DefaultTensor
 from .null_qubit import NullQubit

pennylane/devices/_legacy_device.py

@@ -103,9 +103,9 @@ class _LegacyMeta(abc.ABCMeta):
     checking the instance of a device against a Legacy device type.
 
     To illustrate, if "dev" is of type LegacyDeviceFacade, and a user is
-    checking "isinstance(dev, qml.devices.DefaultMixed)", the overridden
+    checking "isinstance(dev, qml.devices.DefaultMixedLegacy)", the overridden
     "__instancecheck__" will look behind the facade, and will evaluate instead
-    "isinstance(dev.target_device, qml.devices.DefaultMixed)"
+    "isinstance(dev.target_device, qml.devices.DefaultMixedLegacy)"
     """
 
     def __instancecheck__(cls, instance):

pennylane/devices/default_mixed.py

@@ -91,7 +91,7 @@
     "Sum",
 }
 
-operations_mixed = {
+operations = {
     "Identity",
     "Snapshot",
     "BasisState",
@@ -175,7 +175,7 @@
 
 def stopping_condition(op: qml.operation.Operator) -> bool:
     """Specify whether an Operator object is supported by the device."""
-    expected_set = operations_mixed | {"Snapshot"} | channels
+    expected_set = operations | {"Snapshot"} | channels
     return op.name in expected_set
 
 
@@ -204,8 +204,7 @@
 tolerance = 1e-10
 
 
-# !TODO: when removing this class, rename operations_mixed back to operations
-class DefaultMixed(QubitDevice):
+class DefaultMixedLegacy(QubitDevice):
     """Default qubit device for performing mixed-state computations in PennyLane.
 
     .. warning::
@@ -235,12 +234,13 @@
     """
 
     name = "Default mixed-state qubit PennyLane plugin"
-    short_name = "default.mixed"
+    short_name = "default.mixed.legacy"
     pennylane_requires = __version__
     version = __version__
     author = "Xanadu Inc."
 
-    operations = operations_mixed
+    # copy the operations from external
+    operations = operations.copy()
 
     _reshape = staticmethod(qnp.reshape)
     _flatten = staticmethod(qnp.flatten)
@@ -325,10 +325,10 @@
         capabilities.update(
             returns_state=True,
             passthru_devices={
-                "autograd": "default.mixed",
-                "tf": "default.mixed",
-                "torch": "default.mixed",
-                "jax": "default.mixed",
+                "autograd": "default.mixed.legacy",
+                "tf": "default.mixed.legacy",
+                "torch": "default.mixed.legacy",
+                "jax": "default.mixed.legacy",
             },
         )
         return capabilities
@@ -731,7 +731,7 @@
 
         else:
             raise qml.DeviceError(
-                f"Snapshots of {type(measurement)} are not yet supported on default.mixed"
+                f"Snapshots of {type(measurement)} are not yet supported on default.mixed.legacy"
             )
 
         self._state = pre_rotated_state
@@ -853,7 +853,7 @@
         return super().execute(circuit, **kwargs)
 
     @debug_logger
     def apply(self, operations, rotations=None, **kwargs):
         rotations = rotations or []
 
         # apply the circuit operations
@@ -882,7 +882,7 @@
 
 @simulator_tracking
 @single_tape_support
-class DefaultMixedNewAPI(Device):
+class DefaultMixed(Device):
     r"""A PennyLane Python-based device for mixed-state qubit simulation.
 
     Args:
@@ -918,7 +918,7 @@
         wires=None,
         shots=None,
         seed="global",
-        # The following parameters are inherited from DefaultMixed
+        # The following parameters are inherited from DefaultMixedLegacy
         readout_prob=None,
     ) -> None:
 

pennylane/devices/legacy_facade.py

@@ -137,8 +137,8 @@ class LegacyDeviceFacade(Device):
     Args:
         device (qml.device.LegacyDevice): a device that follows the legacy device interface.
 
-    >>> from pennylane.devices import DefaultMixed, LegacyDeviceFacade
-    >>> legacy_dev = DefaultMixed(wires=2)
+    >>> from pennylane.devices import DefaultMixedLegacy, LegacyDeviceFacade
+    >>> legacy_dev = DefaultMixedLegacy(wires=2)
     >>> new_dev = LegacyDeviceFacade(legacy_dev)
     >>> new_dev.preprocess()
     (TransformProgram(legacy_device_batch_transform, legacy_device_expand_fn, defer_measurements),

pennylane/devices/qubit_mixed/apply_operation.py

@@ -260,7 +260,7 @@ def apply_operation_tensordot(
         kraus = [mat]
     kraus = [math.reshape(k, kraus_shape) for k in kraus]
     kraus = math.array(kraus)  # Necessary for Jax
-    # Small trick: following the same logic as in the legacy DefaultMixed._apply_channel_tensordot, here for the contraction on the right side we also directly contract the col ids of channel instead of rows for simplicity. This can also save a step of transposing the kraus operators.
+    # Small trick: following the same logic as in the legacy DefaultMixedLegacy._apply_channel_tensordot, here for the contraction on the right side we also directly contract the col ids of channel instead of rows for simplicity. This can also save a step of transposing the kraus operators.
     row_wires_list = [w + is_state_batched for w in channel_wires.tolist()]
     col_wires_list = [w + num_wires for w in row_wires_list]
     channel_col_ids = list(range(-num_ch_wires, 0))

pennylane/devices/qubit_mixed/measure.py

@@ -264,10 +264,38 @@ def get_measurement_function(
                 return calculate_probability
             if isinstance(measurementprocess, VarianceMP):
                 return calculate_variance
+            return state_diagonalizing_gates
 
     raise NotImplementedError
 
 
+def state_diagonalizing_gates(  # pylint: disable=unused-argument
+    measurementprocess: StateMeasurement,
+    state: TensorLike,
+    is_state_batched: bool = False,
+    readout_errors: list[Callable] = None,
+) -> TensorLike:
+    """Apply a measurement to state when the measurement process has an observable with diagonalizing gates.
+
+    Args:
+        measurementprocess (StateMeasurement): measurement to apply to the state
+        state (TensorLike): state to apply the measurement to
+        is_state_batched (bool): whether the state is batched or not
+        readout_errors (List[Callable]): List of channels to apply to each wire being measured
+        to simulate readout errors.
+
+    Returns:
+        TensorLike: the result of the measurement
+    """
+    for op in measurementprocess.diagonalizing_gates():
+        state = apply_operation(op, state, is_state_batched=is_state_batched)
+
+    num_wires = _get_num_wires(state, is_state_batched)
+    wires = Wires(range(num_wires))
+    flattened_state = _reshape_state_as_matrix(state, num_wires)
+    return measurementprocess.process_density_matrix(flattened_state, wires)
+
+
 def measure(
     measurementprocess: MeasurementProcess,
     state: TensorLike,

pennylane/devices/qubit_mixed/simulate.py

@@ -16,32 +16,14 @@
 from numpy.random import default_rng
 
 import pennylane as qml
+from pennylane.math.interface_utils import get_canonical_interface_name
 from pennylane.typing import Result
 
 from .apply_operation import apply_operation
 from .initialize_state import create_initial_state
 from .measure import measure
 from .sampling import measure_with_samples
 
-INTERFACE_TO_LIKE = {
-    # map interfaces known by autoray to themselves
-    "numpy": "numpy",
-    "autograd": "autograd",
-    "jax": "jax",
-    "torch": "torch",
-    "tensorflow": "tensorflow",
-    # map non-standard interfaces to those known by autoray
-    "auto": None,
-    "scipy": "numpy",
-    "jax-jit": "jax",
-    "jax-python": "jax",
-    "JAX": "jax",
-    "pytorch": "torch",
-    "tf": "tensorflow",
-    "tensorflow-autograph": "tensorflow",
-    "tf-autograph": "tensorflow",
-}
-
 
 def get_final_state(circuit, debugger=None, interface=None, **kwargs):
     """
@@ -65,8 +47,9 @@ def get_final_state(circuit, debugger=None, interface=None, **kwargs):
     if len(circuit) > 0 and isinstance(circuit[0], qml.operation.StatePrepBase):
         prep = circuit[0]
 
+    interface = get_canonical_interface_name(interface)
     state = create_initial_state(
-        sorted(circuit.op_wires), prep, like=INTERFACE_TO_LIKE[interface] if interface else None
+        sorted(circuit.op_wires), prep, like=interface.get_like()
     )
 
     # initial state is batched only if the state preparation (if it exists) is batched

setup.py

@@ -52,6 +52,7 @@
             "default.qubit = pennylane.devices:DefaultQubit",
             "default.gaussian = pennylane.devices:DefaultGaussian",
             "default.mixed = pennylane.devices.default_mixed:DefaultMixed",
+            "default.mixed.legacy = pennylane.devices.default_mixed:DefaultMixedLegacy",
             "reference.qubit = pennylane.devices.reference_qubit:ReferenceQubit",
             "null.qubit = pennylane.devices.null_qubit:NullQubit",
             "default.qutrit = pennylane.devices.default_qutrit:DefaultQutrit",

tests/devices/modifiers/test_all_modifiers.py

@@ -60,7 +60,7 @@ def test_error_on_old_interface(self, modifier):
         """Test that a ValueError is raised is called on something that is not a subclass of Device."""
 
         with pytest.raises(ValueError, match=f"{modifier.__name__} only accepts"):
-            modifier(qml.devices.DefaultMixed)
+            modifier(qml.devices.DefaultMixedLegacy)
 
     def test_adds_to_applied_modifiers_private_property(self, modifier):
         """Test that the modifier is added to the `_applied_modifiers` property."""