qml.estimator.resource_config.ResourceConfig¶

class ResourceConfig[source]¶

Bases: object

Sets the values of precisions and custom decompositions when estimating resources for a quantum workflow.

The precisions and custom decompositions of resource operators can be modified using the set_precision() and set_decomp() functions of the ResourceConfig class.

Example

This example shows how to set a custom precision value for every instance of the RX gate.

>>> import pennylane.estimator as qre
>>> my_config = qre.ResourceConfig()
>>> my_config.set_precision(qre.RX, precision=1e-5)
>>> res = qre.estimate(
...     qre.RX(),
...     gate_set={"RZ", "T", "Hadamard"},
...     config=my_config,
... )
>>> print(res)
--- Resources: ---
 Total wires: 1
   algorithmic wires: 1
   allocated wires: 0
     zero state: 0
     any state: 0
 Total gates : 28
   'T': 28

The ResourceConfig can also be used to set custom decompositions. The following example shows how to define a custom decomposition for the RX gate.

>>> def custom_RX_decomp(precision):  # RX = H @ RZ @ H
...     h = qre.Hadamard.resource_rep()
...     rz = qre.RZ.resource_rep(precision)
...     return [qre.GateCount(h, 2), qre.GateCount(rz, 1)]
>>>
>>> my_config = qre.ResourceConfig()
>>> my_config.set_decomp(qre.RX, custom_RX_decomp)
>>> res = qre.estimate(
...     qre.RX(precision=None),
...     gate_set={"RZ", "T", "Hadamard"},
...     config=my_config,
... )
>>> print(res)
--- Resources: ---
 Total wires: 1
   algorithmic wires: 1
   allocated wires: 0
     zero state: 0
     any state: 0
 Total gates : 3
   'RZ': 1,
   'Hadamard': 2

Attributes

`adj_custom_decomps`	Returns the dictionary of custom adjoint decompositions.
`ctrl_custom_decomps`	Returns the dictionary of custom controlled decompositions.
`custom_decomps`	Returns the dictionary of custom base decompositions.
`pow_custom_decomps`	Returns the dictionary of custom power decompositions.

adj_custom_decomps¶: Returns the dictionary of custom adjoint decompositions.

ctrl_custom_decomps¶: Returns the dictionary of custom controlled decompositions.

custom_decomps¶: Returns the dictionary of custom base decompositions.

pow_custom_decomps¶: Returns the dictionary of custom power decompositions.

Methods

`set_decomp`(op_type, decomp_func[, decomp_type])	Sets a custom function to override the default resource decomposition.
`set_precision`(op_type, precision[, resource_key])	Sets the precision for a given resource operator.
`set_single_qubit_rot_precision`(precision)	Sets the synthesis precision for all single-qubit rotation gates.

set_decomp(op_type, decomp_func, decomp_type=DecompositionType.BASE)[source]¶

Sets a custom function to override the default resource decomposition.

Parameters:

op_type (type[ResourceOperator]) – the operator class whose decomposition is being overriden.
decomp_func (Callable) – the new resource decomposition function to be set as default.
decomp_type (None | DecompositionType) – the decomposition type to override. Options are "adj", "pow", "ctrl", and "base". Default is "base".

Raises:

ValueError – If decomp_type is not a valid decomposition type.

Note

The new decomposition function decomp_func should have the same signature as the one it replaces. Specifically, the signature should match the resource_keys of the base resource operator class being overriden.

Example

import pennylane.estimator as qre

def custom_res_decomp(**kwargs):
    h = qre.resource_rep(qre.Hadamard)
    s = qre.resource_rep(qre.S)
    return [qre.GateCount(h, 1), qre.GateCount(s, 2)]

>>> print(qre.estimate(qre.X(), gate_set={"Hadamard", "Z", "S"}))
--- Resources: ---
 Total wires: 1
    algorithmic wires: 1
    allocated wires: 0
     zero state: 0
     any state: 0
 Total gates : 4
  'S': 2,
  'Hadamard': 2
>>> config = qre.ResourceConfig()
>>> config.set_decomp(qre.X, custom_res_decomp)
>>> print(qre.estimate(qre.X(), gate_set={"Hadamard", "Z", "S"}, config=config))
--- Resources: ---
 Total wires: 1
    algorithmic wires: 1
    allocated wires: 0
     zero state: 0
     any state: 0
 Total gates : 3
  'S': 2,
  'Hadamard': 1

set_precision(op_type, precision, resource_key='precision')[source]¶

Sets the precision for a given resource operator.

Parameters:

op_type (type[ResourceOperator]) – the operator class for which to set the precision
precision (float | int) – The desired precision tolerance. Must be greater than 0.
resource_key (str) – the name of the specific precision parameter to be updated

Raises:

ValueError – If op_type is not a configurable operator or if setting the precision for it is not supported, or if precision is negative.
ValueError – If resource_key is not a supported parameter for the given op_type.

Example

import pennylane.estimator as qre

config = qre.ResourceConfig()

# Check the default precision
default = config.resource_op_precisions[qre.SelectPauliRot]['precision']
print(f"Default precision for SelectPauliRot: {default}")

# Set a new precision
config.set_precision(qre.SelectPauliRot, precision=1e-5)
new = config.resource_op_precisions[qre.SelectPauliRot]['precision']
print(f"New precision for SelectPauliRot: {new}")

Default precision for SelectPauliRot: 1e-09
New precision for SelectPauliRot: 1e-05

Usage Details

Some resource operators have multiple parameters which tune the precision of the operator’s decomposition. For example, the TrotterVibronic operator has parameters phase_grad_precision and coeff_precision. A dictionary of all such parameters of an operator can be accessed through ResourceConfig.resource_op_precisions:

>>> import pennylane.estimator as qre
>>> my_config = qre.ResourceConfig()
>>> my_config.resource_op_precisions[qre.TrotterVibronic]
{'phase_grad_precision': 1e-06, 'coeff_precision': 0.001}

We can modify the default value of the coeff_precision:

>>> my_config.set_precision(qre.TrotterVibronic, 1e-9, resource_key="coeff_precision")
>>> my_config.resource_op_precisions[qre.TrotterVibronic]
{'phase_grad_precision': 1e-06, 'coeff_precision': 1e-09}

set_single_qubit_rot_precision(precision)[source]¶

Sets the synthesis precision for all single-qubit rotation gates.

This is a convenience method to update the synthesis precision tolerance for all standard single-qubit rotation gates (and their controlled versions) at once. The synthesis precision dictates the precision for compiling rotation gates into a discrete gate set, which in turn affects the number of gates required.

This method updates the precision value for the following operators: RX, RY, RZ, CRX, CRY, CRZ.

Parameters:: precision (float) – The desired synthesis precision tolerance. A smaller value corresponds to a higher precision compilation, which may increase the required gate counts. Must be greater than 0.
Raises:: ValueError – If precision is a negative value.

Example

import pennylane.estimator as qre

config = qre.ResourceConfig()
rot_ops = [qre.RX, qre.RY, qre.RZ, qre.CRX, qre.CRY, qre.CRZ]
print([config.resource_op_precisions[op]['precision'] for op in rot_ops])

config.set_single_qubit_rot_precision(1e-5)
print([config.resource_op_precisions[op]['precision'] for op in rot_ops])

[1e-09, 1e-09, 1e-09, 1e-09, 1e-09, 1e-09]
[1e-05, 1e-05, 1e-05, 1e-05, 1e-05, 1e-05]

code/api/pennylane.estimator.resource_config.ResourceConfig

Download Python script

Download Notebook

View on GitHub

qml.estimator.resource_config.ResourceConfig¶

Attributes

Methods

Usage Details

Contents