Add Simulate and update Serialize for LightningQubit2 class

.github/workflows/tests_linux.yml

@@ -237,7 +237,7 @@ jobs:
             lcov --directory . -b ../pennylane_lightning/core/src --capture --output-file coverage.info
             lcov --remove coverage.info '/usr/*' --output-file coverage.info
             mv coverage.info coverage-${{ github.job }}-${{ matrix.pl_backend }}-Lapack.info
-      
+
       - name: Upload test results
         uses: actions/upload-artifact@v3
         if: always()
@@ -642,7 +642,7 @@ jobs:
 
       - name: Combine coverage files
         run: |
-          python -m pip install coverage 
+          python -m pip install coverage
           python -m coverage combine .coverage-python*
           python -m coverage xml -o coverage-${{ github.job }}.xml
 

pennylane_lightning/core/_serialize.py

@@ -172,26 +172,26 @@ def sparse_hamiltonian_obs(self):
             )
         return self.sparse_hamiltonian_c64 if self.use_csingle else self.sparse_hamiltonian_c128
 
-    def _named_obs(self, observable, wires_map: dict):
+    def _named_obs(self, observable, wires_map: dict = None):
         """Serializes a Named observable"""
-        wires = [wires_map[w] for w in observable.wires]
+        wires = [wires_map[w] for w in observable.wires] if wires_map else observable.wires.tolist()
         if observable.name == "Identity":
             wires = wires[:1]
         return self.named_obs(observable.name, wires)
 
-    def _hermitian_ob(self, observable, wires_map: dict):
+    def _hermitian_ob(self, observable, wires_map: dict = None):
         """Serializes a Hermitian observable"""
         assert not isinstance(observable, Tensor)
 
-        wires = [wires_map[w] for w in observable.wires]
+        wires = [wires_map[w] for w in observable.wires] if wires_map else observable.wires.tolist()
         return self.hermitian_obs(matrix(observable).ravel().astype(self.ctype), wires)
 
-    def _tensor_ob(self, observable, wires_map: dict):
+    def _tensor_ob(self, observable, wires_map: dict = None):
         """Serialize a tensor observable"""
         assert isinstance(observable, Tensor)
         return self.tensor_obs([self._ob(obs, wires_map) for obs in observable.obs])
 
-    def _hamiltonian(self, observable, wires_map: dict):
+    def _hamiltonian(self, observable, wires_map: dict = None):
         coeffs = np.array(unwrap(observable.coeffs)).astype(self.rtype)
         terms = [self._ob(t, wires_map) for t in observable.ops]
 
@@ -200,7 +200,7 @@ def _hamiltonian(self, observable, wires_map: dict):
 
         return self.hamiltonian_obs(coeffs, terms)
 
-    def _sparse_hamiltonian(self, observable, wires_map: dict):
+    def _sparse_hamiltonian(self, observable, wires_map: dict = None):
         """Serialize an observable (Sparse Hamiltonian)
 
         Args:
@@ -215,7 +215,7 @@ def _sparse_hamiltonian(self, observable, wires_map: dict):
             Hmat = Hamiltonian([1.0], [Identity(0)]).sparse_matrix()
             H_sparse = SparseHamiltonian(Hmat, wires=range(1))
             spm = H_sparse.sparse_matrix()
-            # Only root 0 needs the overall sparsematrix data
+            # Only root 0 needs the overall sparse matrix data
             if self._mpi_manager().getRank() == 0:
                 spm = observable.sparse_matrix()
             self._mpi_manager().Barrier()
@@ -225,26 +225,28 @@ def _sparse_hamiltonian(self, observable, wires_map: dict):
         indices = np.array(spm.indices).astype(np.int64)
         offsets = np.array(spm.indptr).astype(np.int64)
 
-        wires = []
-        wires_list = observable.wires.tolist()
-        wires.extend([wires_map[w] for w in wires_list])
+        wires = [wires_map[w] for w in observable.wires] if wires_map else observable.wires.tolist()
 
         return self.sparse_hamiltonian_obs(data, indices, offsets, wires)
 
-    def _pauli_word(self, observable, wires_map: dict):
+    def _pauli_word(self, observable, wires_map: dict = None):
         """Serialize a :class:`pennylane.pauli.PauliWord` into a Named or Tensor observable."""
+
+        def map_wire(wire: int):
+            return wires_map[wire] if wires_map else wire
+
         if len(observable) == 1:
             wire, pauli = list(observable.items())[0]
-            return self.named_obs(pauli_name_map[pauli], [wires_map[wire]])
+            return self.named_obs(pauli_name_map[pauli], [map_wire(wire)])
 
         return self.tensor_obs(
             [
-                self.named_obs(pauli_name_map[pauli], [wires_map[wire]])
+                self.named_obs(pauli_name_map[pauli], [map_wire(wire)])
                 for wire, pauli in observable.items()
             ]
         )
 
-    def _pauli_sentence(self, observable, wires_map: dict):
+    def _pauli_sentence(self, observable, wires_map: dict = None):
         """Serialize a :class:`pennylane.pauli.PauliSentence` into a Hamiltonian."""
         pwords, coeffs = zip(*observable.items())
         terms = [self._pauli_word(pw, wires_map) for pw in pwords]
@@ -255,7 +257,7 @@ def _pauli_sentence(self, observable, wires_map: dict):
         return self.hamiltonian_obs(coeffs, terms)
 
     # pylint: disable=protected-access
-    def _ob(self, observable, wires_map):
+    def _ob(self, observable, wires_map: dict = None):
         """Serialize a :class:`pennylane.operation.Observable` into an Observable."""
         if isinstance(observable, Tensor):
             return self._tensor_ob(observable, wires_map)
@@ -269,7 +271,7 @@ def _ob(self, observable, wires_map):
             return self._pauli_sentence(observable._pauli_rep, wires_map)
         return self._hermitian_ob(observable, wires_map)
 
-    def serialize_observables(self, tape: QuantumTape, wires_map: dict) -> List:
+    def serialize_observables(self, tape: QuantumTape, wires_map: dict = None) -> List:
         """Serializes the observables of an input tape.
 
         Args:
@@ -295,7 +297,7 @@ def serialize_observables(self, tape: QuantumTape, wires_map: dict) -> List:
         return serialized_obs, offset_indices
 
     def serialize_ops(
-        self, tape: QuantumTape, wires_map: dict
+        self, tape: QuantumTape, wires_map: dict = None
     ) -> Tuple[
         List[List[str]],
         List[np.ndarray],
@@ -349,7 +351,7 @@ def get_wires(operation, single_op):
                 wires_list = single_op.wires.tolist()
                 controlled_wires_list = []
                 control_values_list = []
-            return single_op, name, wires_list, controlled_wires_list, control_values_list
+            return single_op, name, list(wires_list), controlled_wires_list, control_values_list
 
         for operation in tape.operations:
             if isinstance(operation, (BasisState, StatePrep)):
@@ -382,8 +384,12 @@ def get_wires(operation, single_op):
                     mats.append([])
 
                 controlled_values.append(controlled_values_list)
-                controlled_wires.append([wires_map[w] for w in controlled_wires_list])
-                wires.append([wires_map[w] for w in wires_list])
+                controlled_wires.append(
+                    [wires_map[w] for w in controlled_wires_list]
+                    if wires_map
+                    else list(controlled_wires_list)
+                )
+                wires.append([wires_map[w] for w in wires_list] if wires_map else wires_list)
 
         inverses = [False] * len(names)
         return (

pennylane_lightning/core/_version.py

@@ -16,4 +16,4 @@
    Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.36.0-dev1"
+__version__ = "0.36.0-dev2"

pennylane_lightning/lightning_qubit/_measurements.py

@@ -0,0 +1,191 @@
+# 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.
+"""
+Class implementation for state vector measurements.
+"""
+
+# pylint: disable=import-error, no-name-in-module, ungrouped-imports
+try:
+    from pennylane_lightning.lightning_qubit_ops import (
+        MeasurementsC64,
+        MeasurementsC128,
+    )
+except ImportError:
+    pass
+
+from typing import Callable, List
+
+import numpy as np
+import pennylane as qml
+from pennylane.measurements import ExpectationMP, MeasurementProcess, StateMeasurement
+from pennylane.tape import QuantumScript
+from pennylane.typing import Result, TensorLike
+from pennylane.wires import Wires
+
+from pennylane_lightning.core._serialize import QuantumScriptSerializer
+
+from ._state_vector import LightningStateVector
+
+
+class LightningMeasurements:
+    """Lightning Measurements class
+
+    Measures the state provided by the LightningStateVector class.
+
+    Args:
+        qubit_state(LightningStateVector): Lightning state-vector class containing the state vector to be measured.
+    """
+
+    def __init__(self, qubit_state: LightningStateVector) -> None:
+        self._qubit_state = qubit_state
+        self._state = qubit_state.state_vector
+        self._dtype = qubit_state.dtype
+        self._measurement_lightning = self._measurement_dtype()(self.state)
+
+    @property
+    def qubit_state(self):
+        """Returns a handle to the LightningStateVector class."""
+        return self._qubit_state
+
+    @property
+    def state(self):
+        """Returns a handle to the Lightning internal data class."""
+        return self._state
+
+    @property
+    def dtype(self):
+        """Returns the simulation data type."""
+        return self._dtype
+
+    def _measurement_dtype(self):
+        """Binding to Lightning Measurements C++ class.
+
+        Returns: the Measurements class
+        """
+        return MeasurementsC64 if self.dtype == np.complex64 else MeasurementsC128
+
+    def state_diagonalizing_gates(self, measurementprocess: StateMeasurement) -> TensorLike:
+        """Apply a measurement to state when the measurement process has an observable with diagonalizing gates.
+            This method is bypassing the measurement process to default.qubit implementation.
+
+        Args:
+            measurementprocess (StateMeasurement): measurement to apply to the state
+
+        Returns:
+            TensorLike: the result of the measurement
+        """
+        diagonalizing_gates = measurementprocess.diagonalizing_gates()
+        self._qubit_state.apply_operations(measurementprocess.diagonalizing_gates())
+
+        state_array = self._qubit_state.state
+        wires = Wires(range(self._qubit_state.num_wires))
+
+        result = measurementprocess.process_state(state_array, wires)
+
+        self._qubit_state.apply_operations([qml.adjoint(g) for g in reversed(diagonalizing_gates)])
+
+        return result
+
+    # pylint: disable=protected-access
+    def expval(self, measurementprocess: MeasurementProcess):
+        """Expectation value of the supplied observable contained in the MeasurementProcess.
+
+        Args:
+            measurementprocess (StateMeasurement): measurement to apply to the state
+
+        Returns:
+            Expectation value of the observable
+        """
+
+        if measurementprocess.obs.name == "SparseHamiltonian":
+            # ensuring CSR sparse representation.
+            CSR_SparseHamiltonian = measurementprocess.obs.sparse_matrix(
+                wire_order=list(range(self._qubit_state.num_wires))
+            ).tocsr(copy=False)
+            return self._measurement_lightning.expval(
+                CSR_SparseHamiltonian.indptr,
+                CSR_SparseHamiltonian.indices,
+                CSR_SparseHamiltonian.data,
+            )
+
+        if (
+            measurementprocess.obs.name in ["Hamiltonian", "Hermitian"]
+            or (measurementprocess.obs.arithmetic_depth > 0)
+            or isinstance(measurementprocess.obs.name, List)
+        ):
+            ob_serialized = QuantumScriptSerializer(
+                self._qubit_state.device_name, self.dtype == np.complex64
+            )._ob(measurementprocess.obs)
+            return self._measurement_lightning.expval(ob_serialized)
+
+        return self._measurement_lightning.expval(
+            measurementprocess.obs.name, measurementprocess.obs.wires
+        )
+
+    def get_measurement_function(
+        self, measurementprocess: MeasurementProcess
+    ) -> Callable[[MeasurementProcess, TensorLike], TensorLike]:
+        """Get the appropriate method for performing a measurement.
+
+        Args:
+            measurementprocess (MeasurementProcess): measurement process to apply to the state
+
+        Returns:
+            Callable: function that returns the measurement result
+        """
+        if isinstance(measurementprocess, StateMeasurement):
+            if isinstance(measurementprocess, ExpectationMP):
+                if measurementprocess.obs.name in [
+                    "Identity",
+                    "Projector",
+                ]:
+                    return self.state_diagonalizing_gates
+                return self.expval
+
+            if measurementprocess.obs is None or measurementprocess.obs.has_diagonalizing_gates:
+                return self.state_diagonalizing_gates
+
+        raise NotImplementedError
+
+    def measurement(self, measurementprocess: MeasurementProcess) -> TensorLike:
+        """Apply a measurement process to a state.
+
+        Args:
+            measurementprocess (MeasurementProcess): measurement process to apply to the state
+
+        Returns:
+            TensorLike: the result of the measurement
+        """
+        return self.get_measurement_function(measurementprocess)(measurementprocess)
+
+    def measure_final_state(self, circuit: QuantumScript) -> Result:
+        """
+        Perform the measurements required by the circuit on the provided state.
+
+        This is an internal function that will be called by the successor to ``lightning.qubit``.
+
+        Args:
+            circuit (QuantumScript): The single circuit to simulate
+
+        Returns:
+            Tuple[TensorLike]: The measurement results
+        """
+
+        if circuit.shots:
+            raise NotImplementedError
+        # analytic case
+        if len(circuit.measurements) == 1:
+            return self.measurement(circuit.measurements[0])
+
+        return tuple(self.measurement(mp) for mp in circuit.measurements)