Create a base LKokkos new device API backend.

pennylane_lightning/core/_version.py

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

pennylane_lightning/core/src/simulators/lightning_qubit/measurements/MeasurementsLQubit.hpp

@@ -124,7 +124,7 @@ class Measurements final
 
         const ComplexT *arr_data = this->_statevector.getData();
 
-        // Templated 1-4 wire cases; return probs 
+        // Templated 1-4 wire cases; return probs
         PROBS_SPECIAL_CASE(1);
         PROBS_SPECIAL_CASE(2);
         PROBS_SPECIAL_CASE(3);

pennylane_lightning/lightning_kokkos/_state_vector.py

@@ -0,0 +1,31 @@
+# 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 manipulation.
+"""
+
+
+class LightningStateVector:  # pylint: disable=too-few-public-methods
+    """Lightning state-vector class.
+
+    Interfaces with C++ python binding methods for state-vector manipulation.
+
+    Args:
+        num_wires(int): the number of wires to initialize the device with
+        dtype: Datatypes for state-vector representation. Must be one of
+            ``np.complex64`` or ``np.complex128``. Default is ``np.complex128``
+        device_name(string): state vector device name. Options: ["lightning.qubit"]
+    """
+
+    pass  # pylint: disable=unnecessary-pass

pennylane_lightning/lightning_kokkos/lightning_kokkos.py

@@ -17,9 +17,10 @@
 interfaces with C++ for fast linear algebra calculations.
 """
 
+from numbers import Number
 from os import getenv
 from pathlib import Path
-from typing import List
+from typing import List, Tuple
 from warnings import warn
 
 import numpy as np
@@ -28,12 +29,16 @@
 from pennylane.measurements import Expectation, MidMeasureMP, State
 from pennylane.ops import Conditional
 from pennylane.ops.op_math import Adjoint
+from pennylane.tape import QuantumScript, QuantumTape
+from pennylane.typing import Result
 from pennylane.wires import Wires
 
 from pennylane_lightning.core._serialize import QuantumScriptSerializer, global_phase_diagonal
 from pennylane_lightning.core._version import __version__
 from pennylane_lightning.core.lightning_base import LightningBase, _chunk_iterable
 
+from ._state_vector import LightningStateVector
+
 try:
     # pylint: disable=import-error, no-name-in-module
     from pennylane_lightning.lightning_kokkos_ops import (
@@ -71,6 +76,173 @@
     return print_configuration()
 
 
+def simulate(  # pylint: disable=unused-argument
+    circuit: QuantumScript,
+    state: LightningStateVector,
+    mcmc: dict = None,
+    postselect_mode: str = None,
+) -> Result:
+    """Simulate a single quantum script.
+
+    Args:
+        circuit (QuantumTape): The single circuit to simulate
+        state (LightningStateVector): handle to Lightning state vector
+        mcmc (dict): Dictionary containing the Markov Chain Monte Carlo
+            parameters: mcmc, kernel_name, num_burnin. Descriptions of
+            these fields are found in :class:`~.LightningQubit`.
+        postselect_mode (str): Configuration for handling shots with mid-circuit measurement
+            postselection. Use ``"hw-like"`` to discard invalid shots and ``"fill-shots"`` to
+            keep the same number of shots. Default is ``None``.
+
+    Returns:
+        Tuple[TensorLike]: The results of the simulation
+
+    Note that this function can return measurements for non-commuting observables simultaneously.
+    """
+    return 0
+    # if mcmc is None:
+    #     mcmc = {}
+    # state.reset_state()
+    # has_mcm = any(isinstance(op, MidMeasureMP) for op in circuit.operations)
+    # if circuit.shots and has_mcm:
+    #     results = []
+    #     aux_circ = qml.tape.QuantumScript(
+    #         circuit.operations,
+    #         circuit.measurements,
+    #         shots=[1],
+    #         trainable_params=circuit.trainable_params,
+    #     )
+    #     for _ in range(circuit.shots.total_shots):
+    #         state.reset_state()
+    #         mid_measurements = {}
+    #         final_state = state.get_final_state(
+    #             aux_circ, mid_measurements=mid_measurements, postselect_mode=postselect_mode
+    #         )
+    #         results.append(
+    #             LightningMeasurements(final_state, **mcmc).measure_final_state(
+    #                 aux_circ, mid_measurements=mid_measurements
+    #             )
+    #         )
+    #     return tuple(results)
+    # final_state = state.get_final_state(circuit)
+    # return LightningMeasurements(final_state, **mcmc).measure_final_state(circuit)
+
+
+def jacobian(  # pylint: disable=unused-argument
+    circuit: QuantumTape, state: LightningStateVector, batch_obs=False, wire_map=None
+):
+    """Compute the Jacobian for a single quantum script.
+
+    Args:
+        circuit (QuantumTape): The single circuit to simulate
+        state (LightningStateVector): handle to Lightning state vector
+        batch_obs (bool): Determine whether we process observables in parallel when
+            computing the jacobian. This value is only relevant when the lightning
+            qubit is built with OpenMP. Default is False.
+        wire_map (Optional[dict]): a map from wire labels to simulation indices
+
+    Returns:
+        TensorLike: The Jacobian of the quantum script
+    """
+    return 0
+    # if wire_map is not None:
+    #     [circuit], _ = qml.map_wires(circuit, wire_map)
+    # state.reset_state()
+    # final_state = state.get_final_state(circuit)
+    # return LightningAdjointJacobian(final_state, batch_obs=batch_obs).calculate_jacobian(circuit)
+
+
+def simulate_and_jacobian(  # pylint: disable=unused-argument
+    circuit: QuantumTape, state: LightningStateVector, batch_obs=False, wire_map=None
+):
+    """Simulate a single quantum script and compute its Jacobian.
+
+    Args:
+        circuit (QuantumTape): The single circuit to simulate
+        state (LightningStateVector): handle to Lightning state vector
+        batch_obs (bool): Determine whether we process observables in parallel when
+            computing the jacobian. This value is only relevant when the lightning
+            qubit is built with OpenMP. Default is False.
+        wire_map (Optional[dict]): a map from wire labels to simulation indices
+
+    Returns:
+        Tuple[TensorLike]: The results of the simulation and the calculated Jacobian
+
+    Note that this function can return measurements for non-commuting observables simultaneously.
+    """
+    return 0
+    # if wire_map is not None:
+    #     [circuit], _ = qml.map_wires(circuit, wire_map)
+    # res = simulate(circuit, state)
+    # jac = LightningAdjointJacobian(state, batch_obs=batch_obs).calculate_jacobian(circuit)
+    # return res, jac
+
+
+def vjp(  # pylint: disable=unused-argument
+    circuit: QuantumTape,
+    cotangents: Tuple[Number],
+    state: LightningStateVector,
+    batch_obs=False,
+    wire_map=None,
+):
+    """Compute the Vector-Jacobian Product (VJP) for a single quantum script.
+    Args:
+        circuit (QuantumTape): The single circuit to simulate
+        cotangents (Tuple[Number, Tuple[Number]]): Gradient-output vector. Must
+            have shape matching the output shape of the corresponding circuit. If
+            the circuit has a single output, ``cotangents`` may be a single number,
+            not an iterable of numbers.
+        state (LightningStateVector): handle to Lightning state vector
+        batch_obs (bool): Determine whether we process observables in parallel when
+            computing the VJP. This value is only relevant when the lightning
+            qubit is built with OpenMP.
+        wire_map (Optional[dict]): a map from wire labels to simulation indices
+
+    Returns:
+        TensorLike: The VJP of the quantum script
+    """
+    return 0
+    # if wire_map is not None:
+    #     [circuit], _ = qml.map_wires(circuit, wire_map)
+    # state.reset_state()
+    # final_state = state.get_final_state(circuit)
+    # return LightningAdjointJacobian(final_state, batch_obs=batch_obs).calculate_vjp(
+    #     circuit, cotangents
+    # )
+
+
+def simulate_and_vjp(  # pylint: disable=unused-argument
+    circuit: QuantumTape,
+    cotangents: Tuple[Number],
+    state: LightningStateVector,
+    batch_obs=False,
+    wire_map=None,
+):
+    """Simulate a single quantum script and compute its Vector-Jacobian Product (VJP).
+    Args:
+        circuit (QuantumTape): The single circuit to simulate
+        cotangents (Tuple[Number, Tuple[Number]]): Gradient-output vector. Must
+            have shape matching the output shape of the corresponding circuit. If
+            the circuit has a single output, ``cotangents`` may be a single number,
+            not an iterable of numbers.
+        state (LightningStateVector): handle to Lightning state vector
+        batch_obs (bool): Determine whether we process observables in parallel when
+            computing the jacobian. This value is only relevant when the lightning
+            qubit is built with OpenMP.
+        wire_map (Optional[dict]): a map from wire labels to simulation indices
+
+    Returns:
+        Tuple[TensorLike]: The results of the simulation and the calculated VJP
+    Note that this function can return measurements for non-commuting observables simultaneously.
+    """
+    return 0
+    # if wire_map is not None:
+    #     [circuit], _ = qml.map_wires(circuit, wire_map)
+    # res = simulate(circuit, state)
+    # _vjp = LightningAdjointJacobian(state, batch_obs=batch_obs).calculate_vjp(circuit, cotangents)
+    # return res, _vjp
+
+
 allowed_operations = {
     "Identity",
     "BasisState",

tests/test_native_mcm.py

@@ -28,6 +28,13 @@
 if not LightningDevice._CPP_BINARY_AVAILABLE:  # pylint: disable=protected-access
     pytest.skip("No binary module found. Skipping.", allow_module_level=True)
 
+# TODO: remove this after the new device API implementation for Kokkos is implemented
+if device_name == "lightning.kokkos":
+    pytest.skip(
+        "Native Kokkos device has compatible issues with the new device API. Skipping.",
+        allow_module_level=True,
+    )
+
 
 def get_device(wires, **kwargs):
     kwargs.setdefault("shots", None)