skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
kalarislabs/research-agent-skills91 installs

pennylane

Hardware-agnostic quantum ML framework with automatic differentiation. Use when training quantum circuits via gradients, building hybrid quantum-classical models, or needing device portability across IBM/Google/Rigetti/IonQ. Best for variational algorithms (VQE, QAOA), quantum neural networks, and integration with PyTorch or JAX. For hardware-specific optimizations use qiskit (IBM) or cirq (Google); for open quantum systems use qutip.

How do I install this agent skill?

npx skills add https://github.com/kalarislabs/research-agent-skills --skill pennylane
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    The 'pennylane' skill is a comprehensive documentation and reference guide for the PennyLane quantum machine learning framework. It provides detailed instructions and code examples for quantum circuit construction, hybrid quantum-classical machine learning, and quantum chemistry. The skill follows best practices by using pinned versions for package installations and placeholders for sensitive information like API keys in examples. All external links and packages refer to the official and well-known PennyLane ecosystem.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

What does this agent skill do?

PennyLane

Overview

PennyLane is a quantum computing library that enables training quantum computers like neural networks. It provides automatic differentiation of quantum circuits, device-independent programming, and seamless integration with classical machine learning frameworks.

Installation

PennyLane 0.45.0 requires Python 3.11 or newer. Install using uv with pinned versions for reproducible environments:

uv pip install "pennylane==0.45.0"

For quantum hardware access, install the plugin matching the target provider. Start from a clean environment when adding or upgrading Qiskit because its dependency graph is strict.

# IBM Quantum
uv pip install "pennylane-qiskit==0.45.0"

# Amazon Braket
uv pip install "amazon-braket-pennylane-plugin==1.34.1"

# Google Cirq
uv pip install "pennylane-cirq==0.44.0"

# Rigetti Forest
uv pip install "pennylane-rigetti==0.40.0"

# IonQ
uv pip install "pennylane-ionq==0.45.0"

# High-performance local simulators
uv pip install "pennylane-lightning==0.45.0"

# Catalyst JIT compilation
uv pip install "pennylane-catalyst==0.15.0"

Quick Start

Build a quantum circuit and optimize its parameters:

import pennylane as qml
from pennylane import numpy as np

# Create device
dev = qml.device('default.qubit', wires=2)

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

# Optimize parameters
opt = qml.GradientDescentOptimizer(stepsize=0.1)
params = np.array([0.1, 0.2], requires_grad=True)

for i in range(100):
    params = opt.step(circuit, params)

Core Capabilities

1. Quantum Circuit Construction

Build circuits with gates, measurements, and state preparation. See references/quantum_circuits.md for:

  • Single and multi-qubit gates
  • Controlled operations and conditional logic
  • Mid-circuit measurements and adaptive circuits
  • Various measurement types (expectation, probability, samples)
  • Circuit inspection and debugging

2. Quantum Machine Learning

Create hybrid quantum-classical models. See references/quantum_ml.md for:

  • Integration with PyTorch and JAX
  • Quantum neural networks and variational classifiers
  • Data encoding strategies (angle, amplitude, basis, IQP)
  • Training hybrid models with backpropagation
  • Transfer learning with quantum circuits

3. Quantum Chemistry

Simulate molecules and compute ground state energies. See references/quantum_chemistry.md for:

  • Molecular Hamiltonian generation
  • Variational Quantum Eigensolver (VQE)
  • UCCSD ansatz for chemistry
  • Geometry optimization and dissociation curves
  • Molecular property calculations

4. Device Management

Execute on simulators or quantum hardware. See references/devices_backends.md for:

  • Built-in simulators (default.qubit, lightning.qubit, default.mixed)
  • Hardware plugins (IBM, Amazon Braket, Google, Rigetti, IonQ)
  • Device selection and configuration
  • Performance optimization and caching
  • GPU acceleration and JIT compilation

5. Optimization

Train quantum circuits with various optimizers. See references/optimization.md for:

  • Built-in optimizers (Adam, gradient descent, momentum, RMSProp)
  • Gradient computation methods (backprop, parameter-shift, adjoint)
  • Variational algorithms (VQE, QAOA)
  • Training strategies (learning rate schedules, mini-batches)
  • Handling barren plateaus and local minima

6. Advanced Features

Leverage templates, transforms, and compilation. See references/advanced_features.md for:

  • Circuit templates and layers
  • Transforms and circuit optimization
  • Pulse-level programming
  • Catalyst JIT compilation
  • Noise models and error mitigation
  • Resource estimation

Common Workflows

Train a Variational Classifier

# 1. Define ansatz
@qml.qnode(dev)
def classifier(x, weights):
    # Encode data
    qml.AngleEmbedding(x, wires=range(4))

    # Variational layers
    qml.StronglyEntanglingLayers(weights, wires=range(4))

    return qml.expval(qml.PauliZ(0))

# 2. Train
opt = qml.AdamOptimizer(stepsize=0.01)
weights = np.random.random((3, 4, 3))  # 3 layers, 4 wires

for epoch in range(100):
    for x, y in zip(X_train, y_train):
        weights = opt.step(lambda w: (classifier(x, w) - y)**2, weights)

Run VQE for Molecular Ground State

from pennylane import qchem

# 1. Build Hamiltonian
symbols = ['H', 'H']
geometry = np.array([[0.0, 0.0, -0.66140414], [0.0, 0.0, 0.66140414]])
molecule = qchem.Molecule(symbols, geometry)
H, n_qubits = qchem.molecular_hamiltonian(molecule)
hf_state = qchem.hf_state(electrons=2, orbitals=n_qubits)
singles, doubles = qchem.excitations(electrons=2, orbitals=n_qubits)
s_wires, d_wires = qchem.excitations_to_wires(singles, doubles)

# 2. Define ansatz
@qml.qnode(dev)
def vqe_circuit(params):
    qml.BasisState(hf_state, wires=range(n_qubits))
    qml.UCCSD(params, wires=range(n_qubits), s_wires=s_wires, d_wires=d_wires)
    return qml.expval(H)

# 3. Optimize
opt = qml.AdamOptimizer(stepsize=0.1)
params = np.zeros(len(singles) + len(doubles), requires_grad=True)

for i in range(100):
    params, energy = opt.step_and_cost(vqe_circuit, params)
    print(f"Step {i}: Energy = {energy:.6f} Ha")

Switch Between Devices

# Same circuit, different backends
circuit_def = lambda dev: qml.qnode(dev)(circuit_function)

# Test on simulator
dev_sim = qml.device('default.qubit', wires=4)
result_sim = circuit_def(dev_sim)(params)

# Run on quantum hardware
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=4)
dev_hw = qml.device('qiskit.remote', wires=backend.num_qubits, backend=backend)
result_hw = circuit_def(dev_hw)(params)

Detailed Documentation

For comprehensive coverage of specific topics, consult the reference files:

  • Getting started: references/getting_started.md - Installation, basic concepts, first steps
  • Quantum circuits: references/quantum_circuits.md - Gates, measurements, circuit patterns
  • Quantum ML: references/quantum_ml.md - Hybrid models, framework integration, QNNs
  • Quantum chemistry: references/quantum_chemistry.md - VQE, molecular Hamiltonians, chemistry workflows
  • Devices: references/devices_backends.md - Simulators, hardware plugins, device configuration
  • Optimization: references/optimization.md - Optimizers, gradients, variational algorithms
  • Advanced: references/advanced_features.md - Templates, transforms, JIT compilation, noise

Best Practices

  1. Start with simulators - Test on default.qubit before deploying to hardware
  2. Use parameter-shift for hardware - Backpropagation only works on simulators
  3. Choose appropriate encodings - Match data encoding to problem structure
  4. Initialize carefully - Use small random values to avoid barren plateaus
  5. Monitor gradients - Check for vanishing gradients in deep circuits
  6. Cache devices - Reuse device objects to reduce initialization overhead
  7. Profile circuits - Use qml.specs() to analyze circuit complexity
  8. Test locally - Validate on simulators before submitting to hardware
  9. Use templates - Leverage built-in templates for common circuit patterns
  10. Compile when possible - Use Catalyst JIT for performance-critical code

Resources

Agent operating procedure

  1. Check the environment. Confirm library versions, units, coordinate systems and data formats (FITS, CIF, HDF5, netCDF).
  2. Pin down the inputs. Confirm formats, identifiers and parameters from the data or the user. Ask rather than guess any value that changes the result.
  3. Run a small version first. Run on a small grid, region or subset and check physical plausibility.
  4. Execute the full task using the instructions and references above.
  5. Validate the result. Check units and dimensional consistency, conservation laws or known limits, and numerical convergence.
  6. Report. State what was run (versions, commands, parameters), what was checked, and what is still uncertain.
If this happensDo this
Results violate known physical limitsCheck units, boundary conditions and solver tolerances before reporting.
A function, flag or endpoint in these instructions is missing in the installed versionCheck the installed version's own documentation (help(), --help, official docs), adapt, and tell the user. Never invent an API.
A required input, identifier or parameter is ambiguousAsk the user, or state the assumption explicitly before running.

Integrity rules

  • Never fabricate results, parameters, identifiers, citations or statistics. If something cannot be run or verified, say so plainly.
  • Report uncertainties and numerical tolerances with every quantitative result.
  • Treat version-specific details here as possibly outdated: confirm them against the official documentation for the installed version.
  • Ask before actions that cost money, consume shared GPUs or cloud quota, touch personal or patient data, or cannot be undone.

Related skills

  • cirq: Google quantum computing framework.
  • qiskit: Build, simulate, transpile, and execute quantum circuits with Qiskit and IBM Quantum Runtime.

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/kalarislabs/research-agent-skills/pennylane">View pennylane on skillZs</a>