Merge remote-tracking branch 'origin/master' into lk_pauli_rot

.github/CHANGELOG.md

@@ -15,6 +15,9 @@
 * Optimize gate cache recording for `lightning.tensor` C++ layer.
   [(#879)](https://github.com/PennyLaneAI/pennylane-lightning/pull/879)
 
+* LightningKokkos gains native support for the `PauliRot` gate.
+  [(#855)](https://github.com/PennyLaneAI/pennylane-lightning/pull/855)
+
 ### Documentation
 
 ### Bug fixes
@@ -68,11 +71,17 @@ Amintor Dusko, Luis Alfredo Nuñez Meneses, Shuli Shu
 
 ### Improvements
 
-* LightningKokkos gains native support for the `PauliRot` gate.
-  [(#855)](https://github.com/PennyLaneAI/pennylane-lightning/pull/855)
+* Updated calls of ``size_t`` to ``std::size_t`` everywhere.
+  [(#816)](https://github.com/PennyLaneAI/pennylane-lightning/pull/816)
 
-* LightningQubit gains native support for the `PauliRot` gate.
-  [(#834)](https://github.com/PennyLaneAI/pennylane-lightning/pull/834)
+* Update Lightning tests to support the generalization of basis state preparation.
+  [(#864)](https://github.com/PennyLaneAI/pennylane-lightning/pull/864)
+
+* Add `SetState` and `SetBasisState` to `LightningKokkosSimulator`.
+  [(#861)](https://github.com/PennyLaneAI/pennylane-lightning/pull/861)
+
+* Remove use of the deprecated `Operator.expand` in favour of `Operator.decomposition`.
+  [(#846)](https://github.com/PennyLaneAI/pennylane-lightning/pull/846)
 
 * The `setBasisState` and `setStateVector` methods of `StateVectorLQubit` and `StateVectorKokkos` are overloaded to support PennyLane-like parameters.
   [(#843)](https://github.com/PennyLaneAI/pennylane-lightning/pull/843)

pennylane_lightning/core/_version.py

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

pennylane_lightning/lightning_kokkos/_state_vector.py

@@ -324,6 +324,12 @@ def _apply_lightning(
                 self._apply_lightning_midmeasure(
                     operation, mid_measurements, postselect_mode=postselect_mode
                 )
+            elif isinstance(operation, qml.PauliRot):
+                method = getattr(state, "applyPauliRot")
+                paulis = operation._hyperparameters["pauli_word"]
+                wires = [i for i, w in zip(wires, paulis) if w != "I"]
+                word = "".join(p for p in paulis if p != "I")  # pylint: disable=protected-access
+                method(wires, invert_param, operation.parameters, word)
             elif method is not None:  # apply specialized gate
                 param = operation.parameters
                 method(wires, invert_param, param)

pennylane_lightning/lightning_kokkos/lightning_kokkos.py

@@ -19,6 +19,7 @@
 import os
 import sys
 from dataclasses import replace
+from functools import reduce
 from numbers import Number
 from pathlib import Path
 from typing import Callable, Optional, Sequence, Tuple, Union
@@ -316,7 +317,10 @@ def stopping_condition(op: Operator) -> bool:
         return len(op.wires) < 10
     if isinstance(op, qml.GroverOperator):
         return len(op.wires) < 13
-
+    if isinstance(op, qml.PauliRot):
+        word = op._hyperparameters["pauli_word"]  # pylint: disable=protected-access
+        # decomposes to IsingXX, etc. for n <= 2
+        return reduce(lambda x, y: x + (y != "I"), word, 0) > 2
     return op.name in _operations
 
 
@@ -372,7 +376,7 @@ def _supports_adjoint(circuit):
 
 def _adjoint_ops(op: qml.operation.Operator) -> bool:
     """Specify whether or not an Operator is supported by adjoint differentiation."""
-    return adjoint_ops(op)
+    return not isinstance(op, qml.PauliRot) and adjoint_ops(op)
 
 
 def _add_adjoint_transforms(program: TransformProgram) -> None:
@@ -408,89 +412,9 @@ def _kokkos_configuration():
     return print_configuration()
 
 
-allowed_operations = {
-    "Identity",
-    "BasisState",
-    "QubitStateVector",
-    "StatePrep",
-    "QubitUnitary",
-    "ControlledQubitUnitary",
-    "MultiControlledX",
-    "DiagonalQubitUnitary",
-    "PauliX",
-    "PauliY",
-    "PauliZ",
-    "MultiRZ",
-    "GlobalPhase",
-    "C(GlobalPhase)",
-    "Hadamard",
-    "S",
-    "Adjoint(S)",
-    "T",
-    "Adjoint(T)",
-    "SX",
-    "Adjoint(SX)",
-    "CNOT",
-    "SWAP",
-    "ISWAP",
-    "PSWAP",
-    "Adjoint(ISWAP)",
-    "SISWAP",
-    "Adjoint(SISWAP)",
-    "SQISW",
-    "CSWAP",
-    "Toffoli",
-    "CY",
-    "CZ",
-    "PhaseShift",
-    "ControlledPhaseShift",
-    "RX",
-    "RY",
-    "RZ",
-    "Rot",
-    "CRX",
-    "CRY",
-    "CRZ",
-    "CRot",
-    "IsingXX",
-    "IsingYY",
-    "IsingZZ",
-    "IsingXY",
-    "SingleExcitation",
-    "SingleExcitationPlus",
-    "SingleExcitationMinus",
-    "DoubleExcitation",
-    "DoubleExcitationPlus",
-    "DoubleExcitationMinus",
-    "QubitCarry",
-    "QubitSum",
-    "OrbitalRotation",
-    "QFT",
-    "ECR",
-    "BlockEncode",
-    "C(BlockEncode)",
-    "PauliRot",
-}
-
-allowed_observables = {
-    "PauliX",
-    "PauliY",
-    "PauliZ",
-    "Hadamard",
-    "Hermitian",
-    "Identity",
-    "Projector",
-    "SparseHamiltonian",
-    "Hamiltonian",
-    "LinearCombination",
-    "Sum",
-    "SProd",
-    "Prod",
-    "Exp",
-}
-
-
-class LightningKokkos(LightningBase):
+@simulator_tracking
+@single_tape_support
+class LightningKokkos(Device):
     """PennyLane Lightning Kokkos device.
 
     A device that interfaces with C++ to perform fast linear algebra calculations.
@@ -643,69 +567,9 @@ def preprocess(self, execution_config: ExecutionConfig = DefaultExecutionConfig)
         )
         program.add_transform(qml.transforms.broadcast_expand)
 
-        Args:
-            operations (list[~pennylane.operation.Operation]): operations to apply
-            dtype (type): Type of numpy ``complex`` to be used. Can be important
-            to specify for large systems for memory allocation purposes.
-
-        Returns:
-            array[complex]: the output state tensor
-        """
-        # Skip over identity operations instead of performing
-        # matrix multiplication with the identity.
-        state = self.state_vector
-
-        for ops in operations:
-            if isinstance(ops, Adjoint):
-                name = ops.base.name
-                invert_param = True
-            else:
-                name = ops.name
-                invert_param = False
-            if isinstance(ops, qml.Identity):
-                continue
-            method = getattr(state, name, None)
-            wires = self.wires.indices(ops.wires)
-
-            if isinstance(ops, Conditional):
-                if ops.meas_val.concretize(mid_measurements):
-                    self.apply_lightning([ops.base])
-            elif isinstance(ops, MidMeasureMP):
-                self._apply_lightning_midmeasure(ops, mid_measurements, postselect_mode)
-            elif isinstance(ops, qml.PauliRot):
-                method = getattr(state, "applyPauliRot")
-                paulis = ops._hyperparameters["pauli_word"]
-                wires = [i for i, w in zip(wires, paulis) if w != "I"]
-                word = "".join(p for p in paulis if p != "I")  # pylint: disable=protected-access
-                method(wires, invert_param, ops.parameters, word)
-            elif isinstance(ops, qml.ops.op_math.Controlled) and isinstance(
-                ops.base, qml.GlobalPhase
-            ):
-                controls = ops.control_wires
-                control_values = ops.control_values
-                param = ops.base.parameters[0]
-                matrix = global_phase_diagonal(param, self.wires, controls, control_values)
-                state.apply(name, wires, False, [[param]], matrix)
-            elif method is None:
-                # Inverse can be set to False since qml.matrix(ops) is already in inverted form
-                try:
-                    mat = qml.matrix(ops)
-                except AttributeError:  # pragma: no cover
-                    # To support older versions of PL
-                    mat = ops.matrix
-
-                if len(mat) == 0:
-                    raise ValueError("Unsupported operation")
-                state.apply(
-                    name,
-                    wires,
-                    False,
-                    [],
-                    mat.ravel(order="C"),  # inv = False: Matrix already in correct form;
-                )  # Parameters can be ignored for explicit matrices; F-order for cuQuantum
-            else:
-                param = ops.parameters
-                method(wires, invert_param, param)
+        if exec_config.gradient_method == "adjoint":
+            _add_adjoint_transforms(program)
+        return program, exec_config
 
     # pylint: disable=unused-argument
     def execute(