Lightning Qubit device¶
The lightning.qubit
device uses a custombuilt backend to
perform fast linear algebra calculations for simulating quantum statevector evolution.
A lightning.qubit
device can be loaded using:
import pennylane as qml
dev = qml.device("lightning.qubit", wires=2)
Check out the LightningQubit installation guide for more information.
Supported operations and observables¶
Supported operations:
Prepares a single computational basis state. 

The controlledNOT operator 

A qubit controlled phase shift. 

Apply an arbitrary fixed unitary to 

alias of 

The controlledRot operator 

The controlledRX operator 

The controlledRY operator 

The controlledRZ operator 

The controlledswap operator 

The controlledY operator 

The controlledZ operator 

Apply an arbitrary diagonal unitary matrix with a dimension that is a power of two. 

Double excitation rotation. 

Double excitation rotation with negative phaseshift outside the rotation subspace. 

Double excitation rotation with positive phaseshift outside the rotation subspace. 

An echoed RZX(pi/2) gate. 

The Hadamard operator 

The Identity operator 

Ising XX coupling gate 

Ising (XX + YY) coupling gate 

Ising YY coupling gate 

Ising ZZ coupling gate 

The iswap operator 

Apply a Pauli X gate controlled on an arbitrary computational basis state. 

Arbitrary multi Z rotation. 

Spinadapted spatial orbital rotation. 

The Pauli X operator 

The Pauli Y operator 

The Pauli Z operator 

Arbitrary single qubit local phase shift 

Phase SWAP gate 

Apply a quantum Fourier transform (QFT). 

Apply the 

Apply a 

Apply an arbitrary unitary matrix with a dimension that is a power of two. 

Arbitrary single qubit rotation 

The single qubit X rotation 

The single qubit Y rotation 

The single qubit Z rotation 

The singlequbit phase gate 

Single excitation rotation. 

Single excitation rotation with negative phaseshift outside the rotation subspace. 

Single excitation rotation with positive phaseshift outside the rotation subspace. 

The square root of iswap operator. 

alias of 

The swap operator 

The singlequbit SquareRoot X operator. 

The singlequbit T gate 

Toffoli (controlledcontrolledX) gate. 
Supported observables:
A symbolic operator representing the exponential of a operator. 

The Hadamard operator 

alias of 

An arbitrary Hermitian observable. 

The Identity operator 

The Pauli X operator 

The Pauli Y operator 

The Pauli Z operator 

Symbolic operator representing the product of operators. 

Observable corresponding to the state projector \(P=\ket{\phi}\bra{\phi}\). 

A Hamiltonian represented directly as a sparse matrix in Compressed Sparse Row (CSR) format. 

Arithmetic operator representing the scalar product of an operator with the given scalar. 

Symbolic operator representing the sum of operators. 
Parallel adjoint differentiation support:
The lightning.qubit
device directly supports the adjoint differentiation method, and enables parallelization over the requested observables (Linux/MacOS support only).
To enable parallel differentiation over observables, ensure the OMP_NUM_THREADS
environment variable is set before starting your Python session, or if already started, before importing packages:
# Option 1: Before starting Python
export OMP_NUM_THREADS=4
python <your_file>.py
# Option 2: Before importing packages
import os
os.environ["OMP_NUM_THREADS"] = 4
import pennylane as qml
Assuming you request multiple expectation values from a QNode, this should automatically parallelize the computation over the requested number of threads. You should ensure that the number of threads does not exceed the available physical cores on your machine.
If you are computing a large number of expectation values, or if you are using a large number of wires on your device, it may be best to limit the number of expectation value calculations to atmost OMP_NUM_THREADS
concurrent executions. This will help save memory, at the cost of additional compute time. To enable this, initialize a lightning.qubit
device with the batch_obs=True
keyword argument, as:
# Before importing packages
import os
os.environ["OMP_NUM_THREADS"] = 4
import pennylane as qml
dev = qml.device("lightning.qubit", wires=2, batch_obs=True)
Markov Chain Monte Carlo sampling support:
The lightning.qubit
device allows users to use the Markov Chain Monte Carlo (MCMC) sampling method to generate approximate samples. To enable the MCMC sampling method for sample generation, initialize a lightning.qubit
device with the mcmc=True
keyword argument, as:
import pennylane as qml
dev = qml.device("lightning.qubit", wires=2, shots=1000, mcmc=True)
By default, the kernel_name
is "Local"
and num_burnin
is 100
. The local kernel conducts a bitflip local transition between states. The local kernel generates a random qubit site and then generates a random number to determine the new bit at that qubit site.
The lightning.qubit
device also supports a "NonZeroRandom"
kernel. This kernel randomly transits between states that have nonzero probability. It can be enabled by initializing the device as:
import pennylane as qml
dev = qml.device("lightning.qubit", wires=2, shots=1000, mcmc=True, kernel_name="NonZeroRandom", num_burnin=200)