Skip to content

PennyLane Quick Reference

Core Concepts

import pennylane as qml
import numpy as np

# -- Device creation -------------------------------------------
dev = qml.device("default.qubit", wires=4)  # statevector
dev = qml.device("lightning.qubit", wires=20)  # fast C++
dev = qml.device("default.mixed", wires=4)  # density matrix

# -- QNode decoration -----------------------------------------
@qml.qnode(dev, diff_method="parameter-shift")  # quantum hardware
@qml.qnode(dev, diff_method="backprop")          # classical sim only
@qml.qnode(dev, interface="torch")               # PyTorch integration
@qml.qnode(dev, interface="jax")                 # JAX integration

# -- Single-qubit gates ---------------------------------------
qml.Hadamard(wires=0)       # H gate
qml.PauliX(wires=0)         # X (NOT)
qml.PauliY(wires=0)         # Y
qml.PauliZ(wires=0)         # Z
qml.S(wires=0)              # S = sqrt(Z)
qml.T(wires=0)              # T = sqrt(S)
qml.RX(theta, wires=0)      # Rx(theta) = exp(-i*theta*X/2)
qml.RY(theta, wires=0)      # Ry(theta)
qml.RZ(theta, wires=0)      # Rz(theta)
qml.Rot(phi, theta, omega, wires=0)  # general single-qubit

# -- Two-qubit gates -------------------------------------------
qml.CNOT(wires=[0, 1])      # controlled-NOT
qml.CZ(wires=[0, 1])        # controlled-Z
qml.SWAP(wires=[0, 1])      # SWAP
qml.CRX(theta, wires=[0, 1])  # controlled-RX
qml.CRY(theta, wires=[0, 1])  # controlled-RY
qml.CRZ(theta, wires=[0, 1])  # controlled-RZ
qml.IsingXX(phi, wires=[0, 1])  # exp(-i*phi*XX/2)
qml.IsingZZ(phi, wires=[0, 1])  # exp(-i*phi*ZZ/2)

# -- Multi-qubit gates ----------------------------------------
qml.Toffoli(wires=[0, 1, 2])    # CCNOT
qml.MultiControlledX(wires=[0,1,2,3])  # multi-controlled X
qml.QubitUnitary(U, wires=[0,1])  # arbitrary unitary matrix

# -- Measurements ---------------------------------------------
qml.expval(qml.PauliZ(0))        # <Z_0>
qml.var(qml.PauliX(0))           # Var[X_0]
qml.probs(wires=[0, 1])          # probability distribution
qml.state()                       # full state vector
qml.density_matrix(wires=[0])    # reduced density matrix
qml.sample(wires=[0, 1])         # bitstring samples
qml.counts(wires=[0, 1])         # bitstring counts

# -- Observables -----------------------------------------------
qml.PauliX(0) @ qml.PauliZ(1)   # tensor product X_0 Z_1
qml.Hermitian(H_matrix, wires=[0,1])  # arbitrary Hermitian
qml.Hamiltonian([1.0, 0.5], [qml.PauliZ(0), qml.PauliX(1)])

# -- Templates ------------------------------------------------
qml.AngleEmbedding(features, wires, rotation='Y')
qml.AmplitudeEmbedding(features, wires, normalize=True)
qml.BasisEmbedding(basis_state, wires)
qml.IQPEmbedding(features, wires)
qml.StronglyEntanglingLayers(weights, wires)
qml.BasicEntanglerLayers(weights, wires)
qml.RandomLayers(weights, wires)

# -- Gradients ------------------------------------------------
grad_fn = qml.grad(circuit)       # gradient function
grads = grad_fn(params)           # compute gradient

# Jacobian
jac = qml.jacobian(circuit)(params)

# -- Built-in optimizers ---------------------------------------
opt = qml.GradientDescentOptimizer(stepsize=0.1)
opt = qml.AdamOptimizer(stepsize=0.01)
opt = qml.QNGOptimizer(stepsize=0.1)  # quantum natural gradient
opt = qml.RotosolveOptimizer()        # coordinate descent

params, cost = opt.step_and_cost(circuit, params)

PennyLane-PyTorch Integration

import pennylane as qml
import torch
import torch.nn as nn

dev = qml.device("default.qubit", wires=4)

@qml.qnode(dev, interface="torch", diff_method="parameter-shift")
def quantum_circuit(inputs, weights):
    qml.AngleEmbedding(inputs, wires=range(4))
    qml.StronglyEntanglingLayers(weights, wires=range(4))
    return qml.expval(qml.PauliZ(0))

# Wrap as nn.Module layer
weight_shapes = {"weights": (3, 4, 3)}
q_layer = qml.qnn.TorchLayer(quantum_circuit, weight_shapes)

# Use in nn.Sequential
model = nn.Sequential(
    nn.Linear(8, 4),
    nn.Tanh(),
    q_layer,               # quantum layer
    nn.Linear(1, 2),
    nn.Softmax(dim=-1)
)

# Training like any PyTorch model
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

Circuit Drawing and Visualization

import pennylane as qml
import numpy as np

dev = qml.device("default.qubit", wires=3)

@qml.qnode(dev)
def my_circuit(params):
    qml.Hadamard(0)
    qml.CRY(params[0], wires=[0, 1])
    qml.CNOT(wires=[1, 2])
    qml.RZ(params[1], wires=2)
    return qml.state()

params = np.array([0.5, 1.2])

# Text drawing
print(qml.draw(my_circuit)(params))

# Matplotlib drawing (Jupyter)
fig, ax = qml.draw_mpl(my_circuit)(params)
fig.savefig("circuit.pdf")