pennylane-lightning-kokkos 0.42.0__cp313-cp313-macosx_13_0_arm64.whl → 0.43.0__cp313-cp313-macosx_13_0_arm64.whl

pennylane_lightning/lightning_kokkos/_adjoint_jacobian.py

@@ -41,7 +41,6 @@ try:
         mpi_error = ex_mpi
         MPI_SUPPORT = False
 
-
 except ImportError as ex:
     warn(str(ex), UserWarning)
 

pennylane_lightning/lightning_kokkos/_state_vector.py

@@ -92,7 +92,6 @@ class LightningKokkosStateVector(LightningBaseStateVector):
         self._mpi = mpi
 
         # Initialize the state vector
-
         sv_init_args = [self.num_wires]
         if mpi:
             self._mpi_manager = MPIManagerKokkos()
@@ -210,17 +209,21 @@ class LightningKokkosStateVector(LightningBaseStateVector):
         """Initialize the internal state vector in a specified state.
         Args:
             state (Union[array[complex], scipy.SparseABC]): normalized input state of length ``2**len(wires)`` as a dense array or Scipy sparse array.
-            device_wires (Wires): wires that get initialized in the state
+            device_wires (Wires): wires that get initialized in the state.
         """
 
         if sp.sparse.issparse(state):
             state = state.toarray().flatten()
 
         if isinstance(state, self._qubit_state.__class__):
-            state_data = allocate_aligned_array(state.size, np.dtype(self.dtype), True)
+            state_data = allocate_aligned_array(state.size(), np.dtype(self.dtype), True)
             state.DeviceToHost(state_data)
             state = state_data
 
+        # Convert PennyLane tensor to NumPy array if needed
+        if hasattr(state, "numpy"):
+            state = state.numpy()
+
         if len(device_wires) == self._num_wires and Wires(sorted(device_wires)) == device_wires:
             # Initialize the entire device state with the input state
             if self._mpi:

pennylane_lightning/lightning_kokkos/lightning_kokkos.py

@@ -15,8 +15,9 @@ r"""
 This module contains the :class:`~.LightningKokkos` class, a PennyLane simulator device that
 interfaces with C++ for fast linear algebra calculations.
 """
+
 from dataclasses import replace
-from functools import reduce
+from functools import partial, reduce
 from pathlib import Path
 from typing import List, Optional, Union
 from warnings import warn
@@ -25,28 +26,30 @@ import numpy as np
 import pennylane as qml
 from numpy.random import BitGenerator, Generator, SeedSequence
 from numpy.typing import ArrayLike
-from pennylane.devices import DefaultExecutionConfig, ExecutionConfig
+from pennylane.devices import ExecutionConfig
 from pennylane.devices.capabilities import OperatorProperties
 from pennylane.devices.modifiers import simulator_tracking, single_tape_support
 from pennylane.devices.preprocess import (
     decompose,
-    mid_circuit_measurements,
+    device_resolve_dynamic_wires,
     no_sampling,
     validate_adjoint_trainable_params,
     validate_device_wires,
     validate_measurements,
     validate_observables,
 )
-from pennylane.exceptions import DeviceError
+from pennylane.exceptions import DecompositionUndefinedError, DeviceError
 from pennylane.measurements import MidMeasureMP
-from pennylane.operation import DecompositionUndefinedError, Operator
+from pennylane.operation import Operator
 from pennylane.ops import Conditional, PauliRot, Prod, SProd, Sum
+from pennylane.transforms import defer_measurements, dynamic_one_shot
 from pennylane.transforms.core import TransformProgram
 
 from pennylane_lightning.lightning_base.lightning_base import (
     LightningBase,
     QuantumTape_or_Batch,
     Result_or_ResultBatch,
+    resolve_mcm_method,
 )
 
 try:
@@ -75,28 +78,22 @@ _to_matrix_ops = {
 }
 
 
-def stopping_condition(op: Operator) -> bool:
+def stopping_condition(op: Operator, allow_mcms: bool = True) -> bool:
     """A function that determines whether or not an operation is supported by ``lightning.kokkos``."""
     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
-    if op.name in ("C(SProd)", "C(Exp)"):
-        return True
 
-    if (isinstance(op, Conditional) and stopping_condition(op.base)) or isinstance(
-        op, MidMeasureMP
-    ):
-        # Conditional and MidMeasureMP should not be decomposed
-        return True
+    if isinstance(op, MidMeasureMP):
+        return allow_mcms
 
     return _supports_operation(op.name)
 
 
-def stopping_condition_shots(op: Operator) -> bool:
-    """A function that determines whether or not an operation is supported by ``lightning.kokkos``
-    with finite shots."""
-    return stopping_condition(op) or isinstance(op, (MidMeasureMP, qml.ops.op_math.Conditional))
+# need to create these once so we can compare in tests
+allow_mcms_stopping_condition = partial(stopping_condition, allow_mcms=True)
+no_mcms_stopping_condition = partial(stopping_condition, allow_mcms=False)
 
 
 def accepted_observables(obs: Operator) -> bool:
@@ -124,12 +121,12 @@ def adjoint_measurements(mp: qml.measurements.MeasurementProcess) -> bool:
     return isinstance(mp, qml.measurements.ExpectationMP)
 
 
-def _supports_adjoint(circuit):
+def _supports_adjoint(circuit, device_wires=None):
     if circuit is None:
         return True
 
     prog = TransformProgram()
-    _add_adjoint_transforms(prog)
+    _add_adjoint_transforms(prog, device_wires=device_wires)
 
     try:
         prog((circuit,))
@@ -147,7 +144,7 @@ def _adjoint_ops(op: qml.operation.Operator) -> bool:
     )
 
 
-def _add_adjoint_transforms(program: TransformProgram) -> None:
+def _add_adjoint_transforms(program: TransformProgram, device_wires=None) -> None:
     """Private helper function for ``preprocess`` that adds the transforms specific
     for adjoint differentiation.
 
@@ -165,9 +162,10 @@ def _add_adjoint_transforms(program: TransformProgram) -> None:
     program.add_transform(
         decompose,
         stopping_condition=_adjoint_ops,
-        stopping_condition_shots=stopping_condition_shots,
         name=name,
         skip_initial_state_prep=False,
+        device_wires=device_wires,
+        target_gates=LightningKokkos.capabilities.operations.keys(),
     )
     program.add_transform(validate_observables, accepted_observables, name=name)
     program.add_transform(
@@ -276,10 +274,14 @@ class LightningKokkos(LightningBase):
         self.LightningMeasurements = LightningKokkosMeasurements
         self.LightningAdjointJacobian = LightningKokkosAdjointJacobian
 
-    def _setup_execution_config(self, config):
+    def setup_execution_config(
+        self, config: ExecutionConfig | None = None, circuit: qml.tape.QuantumScript | None = None
+    ) -> ExecutionConfig:
         """
         Update the execution config with choices for how the device should be used and the device options.
         """
+        if config is None:
+            config = ExecutionConfig()
         updated_values = {}
 
         # It is necessary to set the mcmc default configuration to complete the requirements of ExecuteConfig
@@ -312,36 +314,13 @@ class LightningKokkos(LightningBase):
 
         new_device_options.update(mcmc_default)
 
-        mcm_supported_methods = (
-            ("deferred", "tree-traversal", "one-shot", None)
-            if not qml.capture.enabled()
-            else ("deferred", "single-branch-statistics", None)
-        )
-
-        mcm_config = config.mcm_config
-
-        if (mcm_method := mcm_config.mcm_method) not in mcm_supported_methods:
-            raise DeviceError(f"mcm_method='{mcm_method}' is not supported with lightning.kokkos.")
-
-        if qml.capture.enabled():
-
-            mcm_updated_values = {}
-
-            if mcm_method == "single-branch-statistics" and mcm_config.postselect_mode is not None:
-                warn(
-                    "Setting 'postselect_mode' is not supported with mcm_method='single-branch-"
-                    "statistics'. 'postselect_mode' will be ignored.",
-                    UserWarning,
-                )
-                mcm_updated_values["postselect_mode"] = None
-            elif mcm_method is None:
-                mcm_updated_values["mcm_method"] = "deferred"
-
-            updated_values["mcm_config"] = replace(mcm_config, **mcm_updated_values)
-
+        mcm_config = resolve_mcm_method(config.mcm_config, circuit, "lightning.kokkos")
+        updated_values["mcm_config"] = mcm_config
         return replace(config, **updated_values, device_options=new_device_options)
 
-    def preprocess(self, execution_config: ExecutionConfig = DefaultExecutionConfig):
+    def preprocess_transforms(
+        self, execution_config: ExecutionConfig | None = None
+    ) -> TransformProgram:
         """This function defines the device transform program to be applied and an updated device configuration.
 
         Args:
@@ -360,42 +339,55 @@ class LightningKokkos(LightningBase):
         * Currently does not intrinsically support parameter broadcasting
 
         """
-        exec_config = self._setup_execution_config(execution_config)
+        if execution_config is None:
+            execution_config = ExecutionConfig()
+        exec_config = execution_config
         program = TransformProgram()
 
         if qml.capture.enabled():
-
             if exec_config.mcm_config.mcm_method == "deferred":
                 program.add_transform(qml.defer_measurements, num_wires=len(self.wires))
-            # Using stopping_condition_shots because we don't want to decompose Conditionals or MCMs
-            program.add_transform(qml.transforms.decompose, gate_set=stopping_condition_shots)
-            return program, exec_config
+            program.add_transform(qml.transforms.decompose, gate_set=no_mcms_stopping_condition)
+            return program
 
         program.add_transform(validate_measurements, name=self.name)
         program.add_transform(validate_observables, accepted_observables, name=self.name)
-        program.add_transform(
-            mid_circuit_measurements, device=self, mcm_config=exec_config.mcm_config
-        )
-        program.add_transform(validate_device_wires, self.wires, name=self.name)
+        if exec_config.mcm_config.mcm_method == "deferred":
+            program.add_transform(defer_measurements, allow_postselect=False)
+            _stopping_condition = no_mcms_stopping_condition
+        else:
+            _stopping_condition = allow_mcms_stopping_condition
 
         program.add_transform(
             decompose,
-            stopping_condition=stopping_condition,
-            stopping_condition_shots=stopping_condition_shots,
+            stopping_condition=_stopping_condition,
             skip_initial_state_prep=True,
             name=self.name,
+            device_wires=self.wires,
+            target_gates=self.capabilities.operations.keys(),
+        )
+
+        _allow_resets = exec_config.mcm_config.mcm_method != "deferred"
+        program.add_transform(
+            device_resolve_dynamic_wires, wires=self.wires, allow_resets=_allow_resets
         )
+        program.add_transform(validate_device_wires, self.wires, name=self.name)
+        if exec_config.mcm_config.mcm_method == "one-shot":
+            program.add_transform(
+                dynamic_one_shot, postselect_mode=exec_config.mcm_config.postselect_mode
+            )
+
         program.add_transform(qml.transforms.broadcast_expand)
 
         if exec_config.gradient_method == "adjoint":
-            _add_adjoint_transforms(program)
-        return program, exec_config
+            _add_adjoint_transforms(program, device_wires=self.wires)
+        return program
 
     # pylint: disable=unused-argument
     def execute(
         self,
         circuits: QuantumTape_or_Batch,
-        execution_config: ExecutionConfig = DefaultExecutionConfig,
+        execution_config: ExecutionConfig | None = None,
     ) -> Result_or_ResultBatch:
         """Execute a circuit or a batch of circuits and turn it into results.
 
@@ -406,6 +398,8 @@ class LightningKokkos(LightningBase):
         Returns:
             TensorLike, tuple[TensorLike], tuple[tuple[TensorLike]]: A numeric result of the computation.
         """
+        if execution_config is None:
+            execution_config = ExecutionConfig()
         results = []
         for circuit in circuits:
             if self._wire_map is not None:
@@ -423,7 +417,7 @@ class LightningKokkos(LightningBase):
 
     def supports_derivatives(
         self,
-        execution_config: Optional[ExecutionConfig] = None,
+        execution_config: ExecutionConfig | None = None,
         circuit: Optional[qml.tape.QuantumTape] = None,
     ) -> bool:
         """Check whether or not derivatives are available for a given configuration and circuit.
@@ -440,11 +434,13 @@ class LightningKokkos(LightningBase):
         """
         if execution_config is None and circuit is None:
             return True
-        if execution_config.gradient_method not in {"adjoint", "best"}:
-            return False
-        if circuit is None:
-            return True
-        return _supports_adjoint(circuit=circuit)
+
+        if execution_config and execution_config.gradient_method in {"adjoint", "best"}:
+            if circuit is None:
+                return True
+            return _supports_adjoint(circuit=circuit, device_wires=self.wires)
+
+        return False
 
     @staticmethod
     def get_c_interface():

pennylane_lightning/lightning_kokkos/lightning_kokkos.toml

@@ -119,7 +119,7 @@ runtime_code_generation = false
 # The methods of handling mid-circuit measurements that the device supports, e.g.,
 # "one-shot", "device", "tree-traversal", etc. An empty list indicates that the device
 # does not support mid-circuit measurements.
-supported_mcm_methods = [ "one-shot", "tree-traversal" ]
+supported_mcm_methods = [ "device", "one-shot", "tree-traversal" ]
 
 # Whether the device supports dynamic qubit allocation/deallocation.
 dynamic_qubit_management = false

{pennylane_lightning_kokkos-0.42.0.dist-info → pennylane_lightning_kokkos-0.43.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pennylane_lightning_kokkos
-Version: 0.42.0
+Version: 0.43.0
 Summary: PennyLane-Lightning plugin
 Maintainer-email: "Xanadu Quantum Technologies Inc." <software@xanadu.ai>
 License-Expression: Apache-2.0
@@ -15,17 +15,16 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Physics
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pennylane>=0.41
 Requires-Dist: scipy-openblas32>=0.3.26
-Requires-Dist: pennylane_lightning==0.42.0
+Requires-Dist: pennylane_lightning==0.43.0
 Provides-Extra: gpu
 Requires-Dist: pennylane-lightning-gpu; extra == "gpu"
 Provides-Extra: kokkos
@@ -94,7 +93,7 @@ The Lightning plugin ecosystem provides fast state-vector and tensor-network sim
 
 [PennyLane](https://docs.pennylane.ai) is a cross-platform Python library for quantum machine
 learning, automatic differentiation, and optimization of hybrid quantum-classical computations.
-PennyLane supports Python 3.10 and above.
+PennyLane supports Python 3.11 and above.
 
 ## Backends
 
@@ -207,7 +206,7 @@ enable the device bindings to PennyLane, which are held to their own respective
 
 PennyLane Lightning makes use of the following libraries and tools, which are under their own respective licenses:
 
-- **pybind11:** https://github.com/pybind/pybind11
+- **nanobind:** https://github.com/wjakob/nanobind
 - **Kokkos Core:** https://github.com/kokkos/kokkos
 - **NVIDIA cuQuantum:** https://developer.nvidia.com/cuquantum-sdk
 - **scipy-openblas32:** https://pypi.org/project/scipy-openblas32/

pennylane_lightning_kokkos-0.43.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pennylane_lightning_kokkos-0.43.0.dist-info/RECORD,,
+pennylane_lightning_kokkos-0.43.0.dist-info/WHEEL,sha256=kXhjAk4l4-cEIS1SjPDOm7-791qK4vKG27T_LvSNhyU,136
+pennylane_lightning_kokkos-0.43.0.dist-info/entry_points.txt,sha256=4ZRRai-y45jgpHOGrbMR_6lbxC5RQ-rm7_96_65kVLM,92
+pennylane_lightning_kokkos-0.43.0.dist-info/top_level.txt,sha256=e3OLLST9VXaQtYnH68djXaL2fbc_-6v6THc_InTmY6o,41
+pennylane_lightning_kokkos-0.43.0.dist-info/METADATA,sha256=GyTL22ttgNmEtxMegE4e_GmT-5QDLvVPYgv2YEoLhho,11204
+pennylane_lightning_kokkos-0.43.0.dist-info/licenses/LICENSE,sha256=_zKpiTfJGLmlVz4pw88ztD4wTe2QkkUNBGSaac54sjM,11720
+pennylane_lightning/liblightning_kokkos_catalyst.dylib,sha256=vW2HkwTn11IXBDX_AGl4it6Gp_1w5IDIckqcLPlWLyY,1894640
+pennylane_lightning/lightning_kokkos_ops.cpython-313-darwin.so,sha256=JGKUn4vaL-4d2eoNNCFY6VyFLjIx3hgRHnAEaZHPPFs,2163416
+pennylane_lightning/lightning_kokkos/_state_vector.py,sha256=iVm7Y2w4u4jPCkrXRQzYyP9LKo8C7Wd5ve7HcngyY1A,12787
+pennylane_lightning/lightning_kokkos/_adjoint_jacobian.py,sha256=xLZgfD3WNs2v2khmYHYzA6JJjlXRxvOC24x2EFd1xVg,4700
+pennylane_lightning/lightning_kokkos/_measurements.py,sha256=6LqVSSMdZQKb8UtagmWV8MzTzxzDApLJ-hc50V9kZko,3352
+pennylane_lightning/lightning_kokkos/lightning_kokkos.py,sha256=FEcrfgdavtZmVWs_2Q6nwn9KXGjFjObxeczCnZwPtK8,18163
+pennylane_lightning/lightning_kokkos/__init__.py,sha256=b5bC5e_6CY9RPZQBeUhLE6l6ecAc8ocGCb2S4K_Ym7I,737
+pennylane_lightning/lightning_kokkos/lightning_kokkos.toml,sha256=kYJBmnO5oc0lRnjwfxPNaR5Dpp-ZbyKi3YM8I7JbpG8,7282

{pennylane_lightning_kokkos-0.42.0.dist-info → pennylane_lightning_kokkos-0.43.0.dist-info}/WHEEL

@@ -2,4 +2,5 @@ Wheel-Version: 1.0
 Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp313-cp313-macosx_13_0_arm64
+Generator: delocate 0.13.0
 

pennylane_lightning_kokkos-0.42.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-pennylane_lightning_kokkos-0.42.0.dist-info/RECORD,,
-pennylane_lightning_kokkos-0.42.0.dist-info/WHEEL,sha256=r-2mKvH-F5j5pHBomqkZven0crSnLS17sdD3Sku-PRc,109
-pennylane_lightning_kokkos-0.42.0.dist-info/entry_points.txt,sha256=4ZRRai-y45jgpHOGrbMR_6lbxC5RQ-rm7_96_65kVLM,92
-pennylane_lightning_kokkos-0.42.0.dist-info/top_level.txt,sha256=e3OLLST9VXaQtYnH68djXaL2fbc_-6v6THc_InTmY6o,41
-pennylane_lightning_kokkos-0.42.0.dist-info/METADATA,sha256=eLxvCSuzDMlBMcON4B9-3xOhcSr70WjlxhQsauzPfBY,11255
-pennylane_lightning_kokkos-0.42.0.dist-info/licenses/LICENSE,sha256=_zKpiTfJGLmlVz4pw88ztD4wTe2QkkUNBGSaac54sjM,11720
-pennylane_lightning/liblightning_kokkos_catalyst.dylib,sha256=gHOs-JK-5KHiQsANkmkRCGyFSAGsdOr7hx7zw-bb0aI,1868704
-pennylane_lightning/lightning_kokkos_ops.cpython-313-darwin.so,sha256=jhX-yHTvwliXnkAHKXiPhob7TKdJhlP4wQwpdgNcqDk,2279560
-pennylane_lightning/lightning_kokkos/_state_vector.py,sha256=UNpfehgvrFta2-sDBMbGwlVSfBI9bjw1GLGNSSV_LGA,12654
-pennylane_lightning/lightning_kokkos/_adjoint_jacobian.py,sha256=yUc6dm9xosiltVlCnBovJFvJdPbamhu_sgkex9LPZ5I,4701
-pennylane_lightning/lightning_kokkos/_measurements.py,sha256=6LqVSSMdZQKb8UtagmWV8MzTzxzDApLJ-hc50V9kZko,3352
-pennylane_lightning/lightning_kokkos/lightning_kokkos.py,sha256=Xoe3WvcNCFMGfG47SZ4rTpFyQ27rkZQAenO0u9SWuoE,18286
-pennylane_lightning/lightning_kokkos/__init__.py,sha256=b5bC5e_6CY9RPZQBeUhLE6l6ecAc8ocGCb2S4K_Ym7I,737
-pennylane_lightning/lightning_kokkos/lightning_kokkos.toml,sha256=TiQr1-43aSioFsh1lSnG_t09tktPaEwUSnUd3sNEtGA,7272