Portuguese
Idiomas
English
Bengali
French
German
Japanese
Korean
Portuguese
Spanish
Tamil

Utilities (qiskit.utils)

deprecate_arguments(kwarg_map[, category])

Decorator to automatically alias deprecated argument names and warn upon use.

deprecate_function(msg[, stacklevel, category])

Emit a warning prior to calling decorated function.

local_hardware_info()

Basic hardware information about the local machine.

is_main_process()

Checks whether the current process is the main one

apply_prefix(value, unit)

Given a SI unit prefix and value, apply the prefix to convert to standard SI unit.

detach_prefix(value[, decimal])

Given a SI unit value, find the most suitable prefix to scale the value.

wrap_method(cls, name, *[, before, after])

Wrap the functionality the instance- or class method cls.name with additional behaviour before and after.

Algorithm Utilities

summarize_circuits

Summarize circuits based on QuantumCircuit, and five metrics are summarized.

get_entangler_map

Utility method to get an entangler map among qubits.

validate_entangler_map

Validate a user supplied entangler map and converts entries to ints.

has_ibmq

Check if IBMQ is installed

has_aer

check if Aer is installed

name_args

Decorator to convert unnamed arguments to named ones.

algorithm_globals

Class for global properties.

QuantumInstance

Quantum Backend including execution setting.

A QuantumInstance holds the Qiskit backend as well as a number of compile and runtime parameters controlling circuit compilation and execution. Quantum algorithms are run on a device or simulator by passing a QuantumInstance setup with the desired backend etc.

Optional Depedency Checkers (qiskit.utils.optionals)

Qiskit Terra, and many of the other Qiskit components, have several features that are enabled only if certain optional dependencies are satisfied. This module is a collection of objects that can be used to test if certain functionality is available, and optionally raise MissingOptionalLibraryError if the functionality is not available.

Available Testers

Qiskit Components

HAS_AER

Qiskit Aer provides high-performance simulators for the quantum circuits constructed within Qiskit Terra.

HAS_IBMQ

The Qiskit IBMQ Provider is used for accessing IBM Quantum hardware in the IBM cloud.

HAS_IGNIS

Qiskit Ignis provides tools for quantum hardware verification, noise characterization, and error correction.

HAS_TOQM

Qiskit TOQM provides transpiler passes for the Time-optimal Qubit mapping algorithm.

External Python Libraries

HAS_CONSTRAINT

python-constraint <https://github.com/python-constraint/python-constraint>__ is a constraint satisfaction problem solver, used in the :class:`~.CSPLayout transpiler pass.

HAS_CPLEX

The IBM CPLEX Optimizer is a high-performance mathematical programming solver for linear, mixed-integer and quadratic programming. It is required by the BIPMapping transpiler pass.

HAS_CVXPY

CVXPY is a Python package for solving convex optimization problems. It is required for calculating diamond norms with quantum_info.diamond_norm().

HAS_DOCPLEX

IBM Decision Optimization CPLEX Modelling is a library for prescriptive analysis. Like CPLEX, it is required for the BIPMapping transpiler pass.

HAS_FIXTURES

The test suite has additional features that are available if the optional fixtures module is installed. This generally also needs HAS_TESTTOOLS as well. This is generally only needed for Qiskit developers.

HAS_IPYTHON

If the IPython kernel is available, certain additional visualisations and line magics are made available.

HAS_IPYWIDGETS

Monitoring widgets for jobs running on external backends can be provided if ipywidgets is available.

HAS_JAX

Some methods of gradient calculation within opflow.gradients require JAX for autodifferentiation.

HAS_MATPLOTLIB

Qiskit Terra provides several visualisation tools in the visualization module. Almost all of these are built using Matplotlib, which must be installed in order to use them.

HAS_NETWORKX

Internally, Qiskit uses the high-performance retworkx library as a core dependency, but sometimes it can be convenient to convert things into the Python-only NetworkX format. There are converter methods on DAGCircuit if NetworkX is present.

HAS_NLOPT

NLopt is a nonlinear optimization library, used by the global optimizers in the algorithms.optimizers module.

HAS_PIL

PIL is a Python image-manipulation library. Qiskit actually uses the pillow fork of PIL if it is available when generating certain visualizations, for example of both QuantumCircuit and DAGCircuit in certain modes.

HAS_PYDOT

For some graph visualisations, Qiskit uses pydot as an interface to GraphViz (see HAS_GRAPHVIZ).

HAS_PYLATEX

Various LaTeX-based visualizations, especially the circuit drawers, need access to the pylatexenc project to work correctly.

HAS_SEABORN

Qiskit Terra provides several visualisation tools in the visualization module. Some of these are built using Seaborn, which must be installed in order to use them.

HAS_SKLEARN

Some of the gradient functions in opflow.gradients use regularisation methods from Scikit Learn.

HAS_SKQUANT

Some of the optimisers in algorithms.optimizers are based on those found in Scikit Quant, which must be installed to use them.

HAS_SQSNOBFIT

SQSnobFit is a library for the «stable noisy optimization by branch and fit» algorithm. It is used by the SNOBFIT optimizer.

HAS_SYMENGINE

Symengine is a fast C++ backend for the symbolic-manipulation library Sympy. Qiskit uses special methods from Symengine to accelerate its handling of Parameters if available.

HAS_TESTTOOLS

Qiskit Terra’s test suite has more advanced functionality available if the optional testtools library is installed. This is generally only needed for Qiskit developers.

HAS_TWEEDLEDUM

Tweedledum is an extension library for synthesis and optimization of circuits that may involve classical oracles. Qiskit Terra’s PhaseOracle uses this, which is used in turn by amplification algorithms via the AmplificationProblem.

HAS_Z3

Z3 is a theorem prover, used in the CrosstalkAdaptiveSchedule and HoareOptimizer transpiler passes.

External Command-Line Tools

HAS_GRAPHVIZ

For some graph visualisations, Qiskit uses the GraphViz visualisation tool via its pydot interface (see HAS_PYDOT).

HAS_PDFLATEX

Visualisation tools that use LaTeX in their output, such as the circuit drawers, require pdflatex to be available. You will generally need to ensure that you have a working LaTeX installation available, and the qcircuit.tex package.

HAS_PDFTOCAIRO

Visualisation tools that convert LaTeX-generated files into rasterised images use the pdftocairo tool. This is part of the Poppler suite of PDF tools.

Lazy Checker Classes

Each of the lazy checkers is an instance of LazyDependencyManager in one of its two subclasses: LazyImportTester and LazySubprocessTester. These should be imported from utils directly if required, such as:

from qiskit.utils import LazyImportTester
class LazyDependencyManager(*, name=None, callback=None, install=None, msg=None)[código fonte]

A mananger for some optional features that are expensive to import, or to verify the existence of.

These objects can be used as Booleans, such as if x, and will evaluate True if the dependency they test for is available, and False if not. The presence of the dependency will only be tested when the Boolean is evaluated, so it can be used as a runtime test in functions and methods without requiring an import-time test.

These objects also encapsulate the error handling if their dependency is not present, so you can do things such as:

from qiskit.utils import LazyImportManager
HAS_MATPLOTLIB = LazyImportManager("matplotlib")

@HAS_MATPLOTLIB.require_in_call
def my_visualisation():
    ...

def my_other_visualisation():
    # ... some setup ...
    HAS_MATPLOTLIB.require_now("my_other_visualisation")
    ...

def my_third_visualisation():
    if HAS_MATPLOTLIB:
        from matplotlib import pyplot
    else:
        ...

In all of these cases, matplotlib is not imported until the functions are entered. In the case of the decorator, matplotlib is tested for import when the function is called for the first time. In the second and third cases, the loader attempts to import matplotlib when the require_now() method is called, or when the Boolean context is evaluated. For the require methods, an error is raised if the library is not available.

This is the base class, which provides the Boolean context checking and error management. The concrete classes LazyImportTester and LazySubprocessTester provide convenient entry points for testing that certain symbols are importable from modules, or certain command-line tools are available, respectively.

Parâmetros
  • name – the name of this optional dependency.

  • callback – a callback that is called immediately after the availability of the library is tested with the result. This will only be called once.

  • install – how to install this optional dependency. Passed to MissingOptionalLibraryError as the pip_install parameter.

  • msg – an extra message to include in the error raised if this is required.

abstract _is_available()[código fonte]

Subclasses of LazyDependencyManager should override this method to implement the actual test of availability. This method should return a Boolean, where True indicates that the dependency was available. This method will only ever be called once.

Tipo de retorno

bool

disable_locally()[código fonte]

Create a context, during which the value of the dependency manager will be False. This means that within the context, any calls to this object will behave as if the dependency is not available, including raising errors. It is valid to call this method whether or not the dependency has already been evaluated. This is most useful in tests.

require_in_call(feature_or_callable: Callable) Callable[código fonte]
require_in_call(feature_or_callable: str) Callable[[Callable], Callable]

Create a decorator for callables that requires that the dependency is available when the decorated function or method is called.

Parâmetros

feature_or_callable (str or Callable) – the name of the feature that requires these dependencies. If this function is called directly as a decorator (for example @HAS_X.require_in_call as opposed to @HAS_X.require_in_call("my feature")), then the feature name will be taken to be the function name, or class and method name as appropriate.

Retorno

a decorator that will make its argument require this dependency before it is called.

Tipo de retorno

Callable

require_in_instance(feature_or_class: Type) Type[código fonte]
require_in_instance(feature_or_class: str) Callable[[Type], Type]

A class decorator that requires the dependency is available when the class is initialised. This decorator can be used even if the class does not define an __init__ method.

Parâmetros

feature_or_class (str or Type) – the name of the feature that requires these dependencies. If this function is called directly as a decorator (for example @HAS_X.require_in_instance as opposed to @HAS_X.require_in_instance("my feature")), then the feature name will be taken as the name of the class.

Retorno

a class decorator that ensures that the wrapped feature is present if the class is initialised.

Tipo de retorno

Callable

require_now(feature)[código fonte]

Eagerly attempt to import the dependencies in this object, and raise an exception if they cannot be imported.

Parâmetros

feature (str) – the name of the feature that is requiring these dependencies.

Levanta

MissingOptionalLibraryError – if the dependencies cannot be imported.

class LazyImportTester(name_map_or_modules, *, name=None, callback=None, install=None, msg=None)[código fonte]

A lazy dependency tester for importable Python modules. Any required objects will only be imported at the point that this object is tested for its Boolean value.

Parâmetros

name_map_or_modules (Union[str, Dict[str, Iterable[str]], Iterable[str]]) – if a name map, then a dictionary where the keys are modules or packages, and the values are iterables of names to try and import from that module. It should be valid to write from <module> import <name1>, <name2>, .... If simply a string or iterable of strings, then it should be valid to write import <module> for each of them.

Levanta

ValueError – if no modules are given.

class LazySubprocessTester(command, *, name=None, callback=None, install=None, msg=None)[código fonte]

A lazy checker that a command-line tool is available. The command will only be run once, at the point that this object is checked for its Boolean value.

Parâmetros

command (Union[str, Iterable[str]]) – the strings that make up the command to be run. For example, ["pdflatex", "-version"].

Levanta

ValueError – if an empty command is given.