Using PennyLane

Release news

Development

API

Internals

  1. Docs
  2. qml.resource

qml.resource

The resource module provides classes and functionality to track the quantum resources (number of qubits, circuit depth, etc.) required to implement advanced quantum algorithms.

See also

The estimator module for higher level resource estimation of quantum programs.

Circuit Specifications (specs)

specs(qnode[, level, compute_depth])

Provides the specifications of a quantum circuit.

Circuit Specification Classes and Utilities

CircuitSpecs([device_name, ...])

Class for storing specifications of a qnode.

SpecsResources(gate_types, gate_sizes, ...)

Class for storing resource information for a quantum circuit.

resources_from_tape(tape[, compute_depth, ...])

Extracts the resource information from a quantum circuit (tape).

Error Tracking

AlgorithmicError(error)

Abstract base class representing an abstract type of error.

SpectralNormError(error)

Class representing the spectral norm error.

ErrorOperation(*params[, wires, id])

Base class that represents quantum operations which carry some form of algorithmic error.

algo_error(qnode[, level])

Computes the algorithmic errors in a quantum circuit.

Warning

The functions estimate_error, estimate_shots and the classes DoubleFactorization, FirstQuantization have been moved to the pennylane.estimator module. Accessing them from the pennylane.resource module is deprecated and will be removed in v0.45.

Resource Classes

Resources([num_wires, num_gates, ...])

Contains attributes which store key resources such as number of gates, number of wires, shots, depth and gate types.

ResourcesOperation(*params[, wires, id])

Base class that represents quantum gates or channels applied to quantum states and stores the resource requirements of the quantum gate.

Resource Functions

add_in_series(r1, r2)

Add two Resources objects assuming the circuits are executed in series.

add_in_parallel(r1, r2)

Add two Resources objects assuming the circuits are executed in parallel.

mul_in_series(resources, scalar)

Multiply the Resources object by a scalar as if the circuit was repeated that many times in series.

mul_in_parallel(resources, scalar)

Multiply the Resources object by a scalar as if the circuit was repeated that many times in parallel.

substitute(initial_resources, gate_info, ...)

Replaces a specified gate in a Resources object with the contents of another Resources object.

Tracking Resources for Custom Operations

We can use the null.qubit device with pennylane.Tracker to track the resources used in a quantum circuit with custom operations without execution.

from pennylane import numpy as pnp
from pennylane.resource import Resources, ResourcesOperation

class MyCustomAlgorithm(ResourcesOperation):
    num_wires = 2

    def resources(self):
        return Resources(
            num_wires=self.num_wires,
            num_gates=5,
            gate_types={"Hadamard": 2, "CNOT": 1, "PauliZ": 2},
            gate_sizes={1: 4, 2: 1},
            depth=3,
        )

dev = qml.device("null.qubit", wires=[0, 1, 2])

@qml.set_shots(shots=100)
@qml.qnode(dev)
def circuit(theta):
    qml.RZ(theta, wires=0)
    qml.CNOT(wires=[0,1])
    MyCustomAlgorithm(wires=[1, 2])
    return qml.expval(qml.Z(1))

x = pnp.array(1.23, requires_grad=True)

with qml.Tracker(dev) as tracker:
    circuit(x)

We can examine the resources by accessing the resources key:

>>> resources_lst = tracker.history['resources']
>>> print(resources_lst[0])
Total wire allocations: 3
Total gates: 7
Circuit depth: 5

Gate types:
  RZ: 1
  CNOT: 2
  Hadamard: 2
  PauliZ: 2

Measurements:
  expval(PauliZ): 1
Previous
Next