PennyLaneAI
diff --git a/‎.github/CHANGELOG.md
+3 b/‎.github/CHANGELOG.md
+3
diff --git a/‎.github/workflows/tests_gpu_cuda.yml
+6-2 b/‎.github/workflows/tests_gpu_cuda.yml
+6-2
diff --git a/‎.github/workflows/tests_linux_x86_mpi_gpu.yml
+4-2 b/‎.github/workflows/tests_linux_x86_mpi_gpu.yml
+4-2
diff --git a/‎.github/workflows/wheel_macos_x86_64.yml
+3-1 b/‎.github/workflows/wheel_macos_x86_64.yml
+3-1
diff --git a/‎.github/workflows/wheel_noarch.yml
+3-1 b/‎.github/workflows/wheel_noarch.yml
+3-1
diff --git a/‎.github/workflows/wheel_win_x86_64.yml
+3-1 b/‎.github/workflows/wheel_win_x86_64.yml
+3-1
diff --git a/‎mpitests/test_apply.py
+2-2 b/‎mpitests/test_apply.py
+2-2
diff --git a/‎pennylane_lightning/core/_serialize.py
+27-12 b/‎pennylane_lightning/core/_serialize.py
+27-12
diff --git a/‎pennylane_lightning/core/_version.py
+1-1 b/‎pennylane_lightning/core/_version.py
+1-1
diff --git a/‎pennylane_lightning/core/lightning_base.py
+56-4 b/‎pennylane_lightning/core/lightning_base.py
+56-4
diff --git a/‎pennylane_lightning/core/src/bindings/Bindings.hpp
+8 b/‎pennylane_lightning/core/src/bindings/Bindings.hpp
+8
diff --git a/‎pennylane_lightning/lightning_gpu/lightning_gpu.py
+3-48 b/‎pennylane_lightning/lightning_gpu/lightning_gpu.py
+3-48
@@ -24,6 +24,9 @@
   [(#607)](https://github.com/PennyLaneAI/pennylane-lightning/pull/607)
   [(#628)](https://github.com/PennyLaneAI/pennylane-lightning/pull/628)
 
+* Add support for using new operator arithmetic as the default.
+  [(#649)](https://github.com/PennyLaneAI/pennylane-lightning/pull/649)
+
 ### Breaking changes
 
 * Migrate `lightning.qubit` to the new device API.
 
@@ -119,7 +119,9 @@ jobs:
 
       - name: Install required packages
         run: |
-          python -m pip install ninja cmake custatevec-cu${{ matrix.cuda_version }}
+          # Omitting the installation of cmake v3.29.0 due to
+          # https://github.com/scikit-build/cmake-python-distributions/pull/474
+          python -m pip install ninja "cmake!=3.29.0" custatevec-cu${{ matrix.cuda_version }}
           sudo apt-get -y -q install liblapack-dev
 
       - name: Build and run unit tests
@@ -241,7 +243,9 @@ jobs:
         run: |
           cd main
           python -m pip install -r requirements-dev.txt
-          python -m pip install cmake custatevec-cu${{ matrix.cuda_version }} openfermionpyscf
+          # Omitting the installation of cmake v3.29.0 due to
+          # https://github.com/scikit-build/cmake-python-distributions/pull/474
+          python -m pip install "cmake!=3.29.0" custatevec-cu${{ matrix.cuda_version }} openfermionpyscf
 
       - name: Checkout PennyLane for release build
         if: inputs.pennylane-version == 'release'
 
@@ -94,7 +94,9 @@ jobs:
       - name: Install required packages
         run: |
           python -m pip install -r requirements-dev.txt
-          python -m pip install cmake custatevec-cu12
+          # Omitting the installation of cmake v3.29.0 due to
+          # https://github.com/scikit-build/cmake-python-distributions/pull/474
+          python -m pip install "cmake!=3.29.0" custatevec-cu12
           sudo apt-get -y -q install liblapack-dev
 
       - name: Validate GPU version and installed compiler and modules
@@ -240,7 +242,7 @@ jobs:
           source /etc/profile.d/modules.sh && module use /opt/modules/ && module load ${{ matrix.mpilib }}/cuda-${{ matrix.cuda_version_maj }}.${{ matrix.cuda_version_min }}
           python -m pip install -r requirements-dev.txt
           python -m pip install custatevec-cu${{ matrix.cuda_version_maj }} mpi4py openfermionpyscf
-          SKIP_COMPILATION=True PL_BACKEND=lightning_qubit python -m pip install -e . -vv
+          PL_BACKEND=lightning_qubit python -m pip install -e . -vv
 
       - name: Checkout PennyLane for release build
         if: inputs.pennylane-version == 'release'
 
@@ -68,7 +68,9 @@ jobs:
         run: |
           mkdir -p ${{ github.workspace}}/Kokkos_install/${{ matrix.exec_model }}
           cd kokkos
-          python -m pip install cmake ninja
+          # Omitting the installation of cmake v3.29.0 due to
+          # https://github.com/scikit-build/cmake-python-distributions/pull/474
+          python -m pip install "cmake!=3.29.0" ninja
 
           cmake -BBuild . -DCMAKE_INSTALL_PREFIX=${{ github.workspace}}/Kokkos_install/${{ matrix.exec_model }} \
                           -DKokkos_ENABLE_COMPLEX_ALIGN=OFF \
 
@@ -44,7 +44,9 @@ jobs:
 
       - name: Install CMake and ninja
         run: |
-          python -m pip install --upgrade cmake ninja
+          # Omitting the installation of cmake v3.29.0 due to
+          # https://github.com/scikit-build/cmake-python-distributions/pull/474
+          python -m pip install --upgrade "cmake!=3.29.0" ninja
 
       - name: Build wheels
         if: ${{ matrix.pl_backend == 'lightning_qubit'}}
 
@@ -64,7 +64,9 @@ jobs:
       - name: Install dependencies
         if: steps.kokkos-cache.outputs.cache-hit != 'true'
         run: |
-          python -m pip install cmake build
+          # Omitting the installation of cmake v3.29.0 due to
+          # https://github.com/scikit-build/cmake-python-distributions/pull/474
+          python -m pip install "cmake!=3.29.0" build
 
       - name: Build Kokkos core library
         if: steps.kokkos-cache.outputs.cache-hit != 'true'
 
@@ -450,7 +450,7 @@ def test_dev_reset(self, tol, dev_mpi):
         comm.Scatter(state_vector, local_state_vector, root=0)
         dev_cpu = qml.device("lightning.qubit", wires=num_wires, c_dtype=c_dtype)
 
-        dev_cpu.reset()
+        dev_cpu._statevector.reset_state()
 
         def circuit():
             qml.PauliX(wires=[0])
@@ -556,7 +556,7 @@ def circuit():
 
         cpu_qnode = qml.QNode(circuit, dev_cpu)
         expected_output_cpu = cpu_qnode()
-        comm.Bcast(expected_output_cpu, root=0)
+        comm.Bcast(np.array(expected_output_cpu), root=0)
 
         mpi_qnode = qml.QNode(circuit, dev_mpi)
         expected_output_mpi = mpi_qnode()
 
@@ -14,7 +14,7 @@
 r"""
 Helper functions for serializing quantum tapes.
 """
-from typing import List, Tuple
+from typing import List, Sequence, Tuple
 
 import numpy as np
 from pennylane import (
@@ -34,6 +34,7 @@
 )
 from pennylane.math import unwrap
 from pennylane.operation import Tensor
+from pennylane.ops import Prod, SProd, Sum
 from pennylane.tape import QuantumTape
 
 pauli_name_map = {
@@ -183,19 +184,22 @@ def _named_obs(self, observable, wires_map: dict = None):
 
     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] 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 = None):
         """Serialize a tensor observable"""
-        assert isinstance(observable, Tensor)
-        return self.tensor_obs([self._ob(obs, wires_map) for obs in observable.obs])
+        obs = observable.obs if isinstance(observable, Tensor) else observable.operands
+        return self.tensor_obs([self._ob(o, wires_map) for o in obs])
 
     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]
+        coeffs, ops = observable.terms()
+        coeffs = np.array(unwrap(coeffs)).astype(self.rtype)
+        terms = [self._ob(t, wires_map) for t in ops]
+        # TODO: This is in case `_hamiltonian` is called recursively which would cause a list
+        # to be passed where `_ob` expects an observable.
+        terms = [t[0] if isinstance(t, Sequence) and len(t) == 1 else t for t in terms]
 
         if self.split_obs:
             return [self.hamiltonian_obs([c], [t]) for (c, t) in zip(coeffs, terms)]
@@ -254,23 +258,33 @@ def _pauli_sentence(self, observable, wires_map: dict = None):
         terms = [self._pauli_word(pw, wires_map) for pw in pwords]
         coeffs = np.array(coeffs).astype(self.rtype)
 
+        # TODO: Add this
+        # if len(terms) == 1 and coeffs[0] == 1.0:
+        #     return terms[0]
+
         if self.split_obs:
             return [self.hamiltonian_obs([c], [t]) for (c, t) in zip(coeffs, terms)]
         return self.hamiltonian_obs(coeffs, terms)
 
-    # pylint: disable=protected-access
+    # pylint: disable=protected-access, too-many-return-statements
     def _ob(self, observable, wires_map: dict = None):
         """Serialize a :class:`pennylane.operation.Observable` into an Observable."""
-        if isinstance(observable, Tensor):
+        if isinstance(observable, (Prod, Sum, SProd)) and observable.pauli_rep is not None:
+            return self._pauli_sentence(observable.pauli_rep, wires_map)
+        if isinstance(observable, Tensor) or (
+            isinstance(observable, Prod) and not observable.has_overlapping_wires
+        ):
             return self._tensor_ob(observable, wires_map)
-        if observable.name == "Hamiltonian":
+        if observable.name in ("Hamiltonian", "LinearCombination"):
             return self._hamiltonian(observable, wires_map)
         if observable.name == "SparseHamiltonian":
             return self._sparse_hamiltonian(observable, wires_map)
         if isinstance(observable, (PauliX, PauliY, PauliZ, Identity, Hadamard)):
             return self._named_obs(observable, wires_map)
-        if observable._pauli_rep is not None:
-            return self._pauli_sentence(observable._pauli_rep, wires_map)
+        if observable.pauli_rep is not None:
+            return self._pauli_sentence(observable.pauli_rep, wires_map)
+        # if isinstance(observable, (Prod, Sum)):
+        #     return self._hamiltonian(observable, wires_map)
         return self._hermitian_ob(observable, wires_map)
 
     def serialize_observables(self, tape: QuantumTape, wires_map: dict = None) -> List:
@@ -282,7 +296,8 @@ def serialize_observables(self, tape: QuantumTape, wires_map: dict = None) -> Li
 
         Returns:
             list(ObsStructC128 or ObsStructC64): A list of observable objects compatible with
-                the C++ backend
+                the C++ backend. For unsupported observables, the observable matrix is used
+                to create a :class:`~pennylane.Hermitian` to be used for serialization.
         """
 
         serialized_obs = []
 
@@ -16,4 +16,4 @@
    Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.36.0-dev18"
+__version__ = "0.36.0-dev19"
@@ -23,8 +23,9 @@
 import pennylane as qml
 from pennylane import BasisState, QubitDevice, StatePrep
 from pennylane.devices import DefaultQubitLegacy
-from pennylane.measurements import MeasurementProcess
-from pennylane.operation import Operation
+from pennylane.measurements import Expectation, MeasurementProcess, State
+from pennylane.operation import Operation, Tensor
+from pennylane.ops import Prod, Projector, SProd, Sum
 from pennylane.wires import Wires
 
 from ._serialize import QuantumScriptSerializer
@@ -306,18 +307,69 @@ def _process_jacobian_tape(
             "obs_idx_offsets": obs_idx_offsets,
         }
 
+    @staticmethod
+    def _assert_adjdiff_no_projectors(observable):
+        """Helper function to validate that an observable is not or does not contain
+        Projectors
+
+        Args:
+            observable (~pennylane.operation.Operator): Observable to check
+
+        Raises:
+            ~pennylane.QuantumFunctionError: if a ``Projector`` is found.
+        """
+        if isinstance(observable, Tensor):
+            if any(isinstance(o, Projector) for o in observable.non_identity_obs):
+                raise qml.QuantumFunctionError(
+                    "Adjoint differentiation method does not support the Projector observable"
+                )
+
+        elif isinstance(observable, Projector):
+            raise qml.QuantumFunctionError(
+                "Adjoint differentiation method does not support the Projector observable"
+            )
+
+        elif isinstance(observable, SProd):
+            LightningBase._assert_adjdiff_no_projectors(observable.base)
+
+        elif isinstance(observable, (Sum, Prod)):
+            for obs in observable:
+                LightningBase._assert_adjdiff_no_projectors(obs)
+
     # pylint: disable=unnecessary-pass
     @staticmethod
     def _check_adjdiff_supported_measurements(measurements: List[MeasurementProcess]):
-        """Check whether given list of measurement is supported by adjoint_differentiation.
+        """Check whether given list of measurements is supported by adjoint_differentiation.
 
         Args:
             measurements (List[MeasurementProcess]): a list of measurement processes to check.
 
         Returns:
             Expectation or State: a common return type of measurements.
+
+        Raises:
+            ~pennylane.QuantumFunctionError: if a measurement is unsupported with adjoint
+            differentiation.
         """
-        pass
+        if not measurements:
+            return None
+
+        if len(measurements) == 1 and measurements[0].return_type is State:
+            # return State
+            raise qml.QuantumFunctionError(
+                "Adjoint differentiation does not support State measurements."
+            )
+
+        # The return_type of measurement processes must be expectation
+        if any(m.return_type is not Expectation for m in measurements):
+            raise qml.QuantumFunctionError(
+                "Adjoint differentiation method does not support expectation return type "
+                "mixed with other return types"
+            )
+
+        for measurement in measurements:
+            LightningBase._assert_adjdiff_no_projectors(measurement.obs)
+        return Expectation
 
     @staticmethod
     def _adjoint_jacobian_processing(jac):
 
@@ -350,6 +350,8 @@ void registerBackendAgnosticObservables(py::module_ &m) {
         .def("__repr__", &HermitianObs<StateVectorT>::getObsName)
         .def("get_wires", &HermitianObs<StateVectorT>::getWires,
              "Get wires of observables")
+        .def("get_matrix", &HermitianObs<StateVectorT>::getMatrix,
+             "Get matrix representation of Hermitian operator")
         .def(
             "__eq__",
             [](const HermitianObs<StateVectorT> &self,
@@ -373,6 +375,8 @@ void registerBackendAgnosticObservables(py::module_ &m) {
         .def("__repr__", &TensorProdObs<StateVectorT>::getObsName)
         .def("get_wires", &TensorProdObs<StateVectorT>::getWires,
              "Get wires of observables")
+        .def("get_ops", &TensorProdObs<StateVectorT>::getObs,
+             "Get operations list")
         .def(
             "__eq__",
             [](const TensorProdObs<StateVectorT> &self,
@@ -401,6 +405,10 @@ void registerBackendAgnosticObservables(py::module_ &m) {
         .def("__repr__", &Hamiltonian<StateVectorT>::getObsName)
         .def("get_wires", &Hamiltonian<StateVectorT>::getWires,
              "Get wires of observables")
+        .def("get_ops", &Hamiltonian<StateVectorT>::getObs,
+             "Get operations contained by Hamiltonian")
+        .def("get_coeffs", &Hamiltonian<StateVectorT>::getCoeffs,
+             "Get Hamiltonian coefficients")
         .def(
             "__eq__",
             [](const Hamiltonian<StateVectorT> &self,
 
@@ -77,17 +77,8 @@
     from typing import List, Union
 
     import pennylane as qml
-    from pennylane import (
-        BasisState,
-        DeviceError,
-        Projector,
-        QuantumFunctionError,
-        Rot,
-        StatePrep,
-        math,
-    )
-    from pennylane.measurements import Expectation, MeasurementProcess, State
-    from pennylane.operation import Tensor
+    from pennylane import BasisState, DeviceError, QuantumFunctionError, Rot, StatePrep, math
+    from pennylane.measurements import Expectation, State
     from pennylane.ops.op_math import Adjoint
     from pennylane.wires import Wires
 
@@ -196,6 +187,7 @@ def _mebibytesToBytes(mebibytes):
         "Hadamard",
         "SparseHamiltonian",
         "Hamiltonian",
+        "LinearCombination",
         "Hermitian",
         "Identity",
         "Sum",
@@ -583,43 +575,6 @@ def apply(self, operations, rotations=None, **kwargs):
 
             self.apply_lightning(operations)
 
-        @staticmethod
-        def _check_adjdiff_supported_measurements(measurements: List[MeasurementProcess]):
-            """Check whether given list of measurement is supported by adjoint_diff.
-            Args:
-                measurements (List[MeasurementProcess]): a list of measurement processes to check.
-            Returns:
-                Expectation or State: a common return type of measurements.
-            """
-            if not measurements:
-                return None
-
-            if len(measurements) == 1 and measurements[0].return_type is State:
-                # return State
-                raise QuantumFunctionError(
-                    "Adjoint differentiation does not support State measurements."
-                )
-
-            # The return_type of measurement processes must be expectation
-            if any(m.return_type is not Expectation for m in measurements):
-                raise QuantumFunctionError(
-                    "Adjoint differentiation method does not support expectation return type "
-                    "mixed with other return types"
-                )
-
-            for measurement in measurements:
-                if isinstance(measurement.obs, Tensor):
-                    if any(isinstance(o, Projector) for o in measurement.obs.non_identity_obs):
-                        raise QuantumFunctionError(
-                            "Adjoint differentiation method does not support the "
-                            "Projector observable"
-                        )
-                elif isinstance(measurement.obs, Projector):
-                    raise QuantumFunctionError(
-                        "Adjoint differentiation method does not support the Projector observable"
-                    )
-            return Expectation
-
         @staticmethod
         def _check_adjdiff_supported_operations(operations):
             """Check Lightning adjoint differentiation method support for a tape.