PennyLane-Lightning

0.44.0 · active · verified Sat Apr 11

PennyLane-Lightning provides high-performance C++ quantum simulators that integrate as plugins with the PennyLane quantum machine learning library. The base package includes the `lightning.qubit` device for CPU-based state-vector simulation, with other specialized devices (GPU, Kokkos, Tensor, AMDGPU) available via separate installation packages. It is actively maintained with frequent, typically monthly or bi-monthly, releases.

Warnings

gotcha The `pennylane-lightning` package only provides the `lightning.qubit` CPU device. For GPU-accelerated (`lightning.gpu`), Kokkos-enabled (`lightning.kokkos`), Tensor Network (`lightning.tensor`), or AMDGPU (`lightning.amdgpu`) devices, separate `pennylane-lightning-gpu`, `pennylane-lightning-kokkos`, `pennylane-lightning-tensor`, and `pennylane-lightning-amdgpu` packages must be installed respectively.
Fix: Install the specific package for the desired device, e.g., `pip install pennylane-lightning-gpu`.
breaking Building Catalyst Lightning plugins requires compatibility with specific Catalyst Runtime versions.
Fix: Ensure your Catalyst Runtime version (e.g., v0.11.0 for PennyLane-Lightning v0.41.1) is compatible when using Lightning devices within Catalyst. Refer to the release notes for specific version requirements.
gotcha Specialized devices like `lightning.gpu`, `lightning.kokkos`, and `lightning.amdgpu` have specific hardware and driver requirements (e.g., NVIDIA CUDA, AMD ROCm). They will not function without the correct setup.
Fix: Consult the PennyLane-Lightning documentation for detailed hardware, driver, and CUDA/ROCm toolkit installation instructions before attempting to use these devices.
gotcha Like all state-vector simulators, `lightning.qubit`'s memory consumption scales exponentially with the number of qubits. This can quickly become a bottleneck for circuits with a large number of wires.
Fix: For very large numbers of qubits, consider using tensor network simulators (`lightning.tensor`), or sampling-based approaches, or distributed computing solutions (e.g., `lightning.kokkos` with MPI).
gotcha Support for mid-circuit measurements (MCMs) and their different execution methods (`mcm_method`) was introduced and refined, potentially impacting performance or available features.
Fix: For optimal MCM performance and full feature set, ensure you are using a recent version (0.43.0+) and explicitly specify the `mcm_method` if required, e.g., `qml.device("lightning.qubit", wires=4, mcm_method="device")`.

Install

pip install pennylane-lightning Base package (lightning.qubit)

Imports

qml.device
```
import pennylane as qml
device = qml.device("lightning.qubit", wires=4)
```
PennyLane-Lightning devices are loaded via `qml.device` using their string name, not by direct import of a class from the `pennylane_lightning` package itself. Attempting direct import will fail.

Quickstart

This quickstart demonstrates how to initialize the `lightning.qubit` device and use it within a PennyLane quantum circuit to compute an expectation value and its gradients. Ensure PennyLane is also installed.

import pennylane as qml
import numpy as np

# Create a Lightning Qubit device
dev = qml.device("lightning.qubit", wires=2)

@qml.qnode(dev)
def circuit(x):
    qml.RX(x[0], wires=0)
    qml.RY(x[1], wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

# Run the circuit
params = np.array([0.54, 0.12], requires_grad=True)
result = circuit(params)
print(f"Expectation value: {result}")

# Calculate gradients
dq = qml.grad(circuit)(params)
print(f"Gradients: {dq}")

view raw JSON →