PennyLane Documentation

The pennylane.qchem module provides tools for quantum chemistry, including:

• Performing Hartree-Fock (HF) calculations.
• Constructing molecular Hamiltonians and observables (dipole moment, spin, and particle number).
• Converting between PennyLane and OpenFermion's QubitOperator and FermionOperator.

Note: pennylane.math.decomposition.givens_decomposition has moved to pennylane.math. While still available in pennylane.qchem for backward compatibility, it is recommended to use the new location.

PennyLane uses two primary data structures to represent quantum circuits: QuantumTape and QuantumScript.

• QuantumTape: A queuing context that records quantum operations and measurements. It is used for active queuing and is compatible with autodiff frameworks like Autograd, JAX, and PyTorch. It inherits from AnnotatedQueue and its contents are set upon exiting the context.
• QuantumScript: A purely immutable representation of a quantum circuit. It is constructed via initialization and is more memory-efficient because it can reuse the same operation multiple times without the overhead of a queuing context.

Note: Unless you are developing a PennyLane plugin, you should generally use QNode or the qnode decorator instead of interacting with these classes directly.

In PennyLane, all quantum operations (gates, channels, observables) inherit from the Operator class. An operator is defined by several key components:

• .name: The canonical or PennyLane-specific name.
• .wires: The subsystems (subspace) the operator acts on.
• .parameters: Trainable parameters (e.g., rotation angles) provided as tensor-like objects.
• .hyperparameters: Non-trainable values that influence the operator's action.
• Representations: Operators can be represented as a product of operators (.decomposition()), a linear combination of operators (.terms()), via eigenvalue decomposition (.eigvals() and .diagonalizing_gates()), as a dense matrix (.matrix()), or as a sparse matrix (.sparse_matrix()).

PennyLane's architecture is built around several key components that enable hybrid quantum-classical computing:

• QNode: The central object representing a quantum computation. It encapsulates a quantum function and a device.
• Quantum Function: A Python function containing quantum operations (Operator) and measurements (MeasurementProcess).
• Quantum Tape: A context manager that records a queue of instructions (operations and measurements) required to run a circuit.
• Device: An abstraction (via pennylane.devices.Device) that interprets and executes tapes. Devices can be built-in simulators or external hardware via plugins.
• Operator: Represents quantum gates/dynamics (e.g., Rot, RX). Defined by name, trainable parameters, hyperparameters, and wires.
• MeasurementProcess: Describes how to extract information (e.g., expval).

The pennylane.ftqc module provides tools for tracking and commuting Pauli operations within Clifford circuits and obtaining measurement corrections.

Warning: This module is currently experimental. The API is not stable and may change between releases without notice.

PennyLane documentation is organized into three primary sections:

1. Quickstarts: Located in doc/introduction (reStructuredText format). These are short, referential guides for core functionality. They use minimal code examples and expect users to refer to function/class docstrings for full details.
2. Development Guides: Located in doc/development (reStructuredText format). These focus on how to contribute to the PennyLane codebase.
3. API Documentation: Automatically generated from source code docstrings using sphinx-automodapi. The API is organized by import path rather than absolute path.

Note: Long-form tutorials and quantum machine learning theory are hosted separately at pennylane.ai/qml.

The pennylane.wires module contains the base classes for wire management in PennyLane.

Note: Unless you are developing a PennyLane plugin or extending the core library, you likely do not need to interact with the Wires or AbstractQubit classes directly. Most users interact with wires via integer indices or device-specific wire objects provided by the device API.

The pennylane.kernels subpackage provides tools for working with quantum kernel methods. It includes functions to systematically compute kernel matrices on training and test datasets, as well as postprocessing methods to mitigate device noise and sampling errors.

Key capabilities include:

• Computing the kernel matrix $K_{ij} = k(x_i, x_j)$ for a given dataset.
• Calculating kernel polarity $P(k)$, which measures the similarity between a kernel matrix $K$ and an ideal kernel matrix $K^$ (where $K^_{ij} = y_i y_j$) using the Frobenius inner product.
• Calculating kernel-target alignment $TA(k)$, which is the normalized version of kernel polarity.

For datasets with imbalanced classes, labels are automatically rescaled by the number of datapoints in each class to ensure metrics are not dominated by a single class.

To build the HTML documentation locally, you must install the necessary documentation dependencies and use make.

Note: To build interfaces documentation, PyTorch must be installed.

1. Install documentation requirements:

   pip install --group docs

2. Build the HTML documentation from the top-level directory:

   make docs

The output will be located in the doc/_build/html/ directory.

A complete device implementation typically involves a workflow using setup_execution_config and preprocess_transforms. The preprocess_transforms method turns generic circuits into ones supported by the device, while execute performs the actual computation.

An ideal implementation follows this pattern:

1. Setup the execution configuration.
2. Create a compilation pipeline via preprocessing.
3. Execute the circuit batch.
4. Apply post-processing to the results.

execution_config = dev.setup_execution_config(initial_config)
compile_pipeline = dev.preprocess_transforms(execution_config)
circuit_batch, postprocessing = compile_pipeline(initial_circuit_batch)
results = dev.execute(circuit_batch, execution_config)
final_results = postprocessing(results)