scnc
/
qiskit-documentation
mirror of https://github.com/Qiskit/documentation.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qiskit-documentation/docs/api/qiskit/0.46/algorithms.mdx

274 lines
29 KiB
Plaintext
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

---
title: algorithms
description: API reference for qiskit.algorithms
in_page_toc_min_heading_level: 2
python_api_type: module
python_api_name: qiskit.algorithms
---
<span id="module-qiskit.algorithms" />
<span id="qiskit-algorithms" />
<span id="algorithms-qiskit-algorithms" />
# Algorithms
<span id="module-qiskit.algorithms" />
`qiskit.algorithms`
<Admonition title="Deprecated since version 0.25.0" type="danger">
The [`qiskit.algorithms`](#module-qiskit.algorithms "qiskit.algorithms") module has been migrated to an independent package: [https://github.com/qiskit-community/qiskit-algorithms](https://github.com/qiskit-community/qiskit-algorithms). The current import path is deprecated and will be removed no earlier than 3 months after the release date. If your code uses primitives, you can run `pip install qiskit_algorithms` and import `from qiskit_algorithms` instead. If you use opflow/quantum instance-based algorithms, please update your code to use primitives following: [https://qisk.it/algo\_migration](https://qisk.it/algo_migration) before migrating to the new package.
</Admonition>
It contains a collection of quantum algorithms, for use with quantum computers, to carry out research and investigate how to solve problems in different domains on near-term quantum devices with short depth circuits.
Algorithms configuration includes the use of [`optimizers`](qiskit.algorithms.optimizers#module-qiskit.algorithms.optimizers "qiskit.algorithms.optimizers") which were designed to be swappable sub-parts of an algorithm. Any component and may be exchanged for a different implementation of the same component type in order to potentially alter the behavior and outcome of the algorithm.
Quantum algorithms are run via a `QuantumInstance` which must be set with the desired backend where the algorithm’s circuits will be executed and be configured with a number of compile and runtime parameters controlling circuit compilation and execution. It ultimately uses [Terra](https://www.qiskit.org/terra) for the actual compilation and execution of the quantum circuits created by the algorithm and its components.
## Algorithms
It contains a variety of quantum algorithms and these have been grouped by logical function such as minimum eigensolvers and amplitude amplifiers.
### Amplitude Amplifiers
| | |
| --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
| [`AmplificationProblem`](qiskit.algorithms.AmplificationProblem "qiskit.algorithms.AmplificationProblem") | The amplification problem is the input to amplitude amplification algorithms, like Grover. |
| [`AmplitudeAmplifier`](qiskit.algorithms.AmplitudeAmplifier "qiskit.algorithms.AmplitudeAmplifier") | The interface for amplification algorithms. |
| [`Grover`](qiskit.algorithms.Grover "qiskit.algorithms.Grover") | Grover's Search algorithm. |
| [`GroverResult`](qiskit.algorithms.GroverResult "qiskit.algorithms.GroverResult") | Grover Result. |
### Amplitude Estimators
| | |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
| [`AmplitudeEstimator`](qiskit.algorithms.AmplitudeEstimator "qiskit.algorithms.AmplitudeEstimator") | The Amplitude Estimation interface. |
| [`AmplitudeEstimatorResult`](qiskit.algorithms.AmplitudeEstimatorResult "qiskit.algorithms.AmplitudeEstimatorResult") | The results object for amplitude estimation algorithms. |
| [`AmplitudeEstimation`](qiskit.algorithms.AmplitudeEstimation "qiskit.algorithms.AmplitudeEstimation") | The Quantum Phase Estimation-based Amplitude Estimation algorithm. |
| [`AmplitudeEstimationResult`](qiskit.algorithms.AmplitudeEstimationResult "qiskit.algorithms.AmplitudeEstimationResult") | The `AmplitudeEstimation` result object. |
| [`EstimationProblem`](qiskit.algorithms.EstimationProblem "qiskit.algorithms.EstimationProblem") | The estimation problem is the input to amplitude estimation algorithm. |
| [`FasterAmplitudeEstimation`](qiskit.algorithms.FasterAmplitudeEstimation "qiskit.algorithms.FasterAmplitudeEstimation") | The Faster Amplitude Estimation algorithm. |
| [`FasterAmplitudeEstimationResult`](qiskit.algorithms.FasterAmplitudeEstimationResult "qiskit.algorithms.FasterAmplitudeEstimationResult") | The result object for the Faster Amplitude Estimation algorithm. |
| [`IterativeAmplitudeEstimation`](qiskit.algorithms.IterativeAmplitudeEstimation "qiskit.algorithms.IterativeAmplitudeEstimation") | The Iterative Amplitude Estimation algorithm. |
| [`IterativeAmplitudeEstimationResult`](qiskit.algorithms.IterativeAmplitudeEstimationResult "qiskit.algorithms.IterativeAmplitudeEstimationResult") | The `IterativeAmplitudeEstimation` result object. |
| [`MaximumLikelihoodAmplitudeEstimation`](qiskit.algorithms.MaximumLikelihoodAmplitudeEstimation "qiskit.algorithms.MaximumLikelihoodAmplitudeEstimation") | The Maximum Likelihood Amplitude Estimation algorithm. |
| [`MaximumLikelihoodAmplitudeEstimationResult`](qiskit.algorithms.MaximumLikelihoodAmplitudeEstimationResult "qiskit.algorithms.MaximumLikelihoodAmplitudeEstimationResult") | The `MaximumLikelihoodAmplitudeEstimation` result object. |
### Eigensolvers
Algorithms to find eigenvalues of an operator. For chemistry these can be used to find excited states of a molecule, and `qiskit-nature` has some algorithms that leverage chemistry specific knowledge to do this in that application domain.
#### Primitive-based Eigensolvers
These algorithms are based on the Qiskit Primitives, a new execution paradigm that replaces the use of [`QuantumInstance`](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance") in algorithms. To ensure continued support and development, we recommend using the primitive-based Eigensolvers in place of the legacy [`QuantumInstance`](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance")-based ones.
| | |
| ----------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
| [`eigensolvers`](qiskit.algorithms.eigensolvers#module-qiskit.algorithms.eigensolvers "qiskit.algorithms.eigensolvers") | Eigensolvers Package (qiskit.algorithms.eigensolvers) |
#### Legacy Eigensolvers
These algorithms, still based on the [`QuantumInstance`](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance"), are superseded by the primitive-based versions in the section above but are still supported for now.
| | |
| ------------------------------------------------------------------------------------------------ | ---------------------------------------------------- |
| [`Eigensolver`](qiskit.algorithms.Eigensolver "qiskit.algorithms.Eigensolver") | Deprecated: Eigensolver Interface. |
| [`EigensolverResult`](qiskit.algorithms.EigensolverResult "qiskit.algorithms.EigensolverResult") | Deprecated: Eigensolver Result. |
| [`NumPyEigensolver`](qiskit.algorithms.NumPyEigensolver "qiskit.algorithms.NumPyEigensolver") | Deprecated: NumPy Eigensolver algorithm. |
| [`VQD`](qiskit.algorithms.VQD "qiskit.algorithms.VQD") | Deprecated: Variational Quantum Deflation algorithm. |
| [`VQDResult`](qiskit.algorithms.VQDResult "qiskit.algorithms.VQDResult") | Deprecated: VQD Result. |
### Time Evolvers
Algorithms to evolve quantum states in time. Both real and imaginary time evolution is possible with algorithms that support them. For machine learning, Quantum Imaginary Time Evolution might be used to train Quantum Boltzmann Machine Neural Networks for example.
#### Primitive-based Time Evolvers
These algorithms are based on the Qiskit Primitives, a new execution paradigm that replaces the use of [`QuantumInstance`](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance") in algorithms. To ensure continued support and development, we recommend using the primitive-based Time Evolvers in place of the legacy [`QuantumInstance`](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance")-based ones.
| | |
| ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------- |
| [`RealTimeEvolver`](qiskit.algorithms.RealTimeEvolver "qiskit.algorithms.RealTimeEvolver") | Interface for Quantum Real Time Evolution. |
| [`ImaginaryTimeEvolver`](qiskit.algorithms.ImaginaryTimeEvolver "qiskit.algorithms.ImaginaryTimeEvolver") | Interface for Quantum Imaginary Time Evolution. |
| [`TimeEvolutionResult`](qiskit.algorithms.TimeEvolutionResult "qiskit.algorithms.TimeEvolutionResult") | Class for holding time evolution result. |
| [`TimeEvolutionProblem`](qiskit.algorithms.TimeEvolutionProblem "qiskit.algorithms.TimeEvolutionProblem") | Time evolution problem class. |
| [`PVQD`](qiskit.algorithms.PVQD "qiskit.algorithms.PVQD") | The projected Variational Quantum Dynamics (p-VQD) Algorithm. |
| [`PVQDResult`](qiskit.algorithms.PVQDResult "qiskit.algorithms.PVQDResult") | The result object for the p-VQD algorithm. |
| [`SciPyImaginaryEvolver`](qiskit.algorithms.SciPyImaginaryEvolver "qiskit.algorithms.SciPyImaginaryEvolver") | Classical Evolver for imaginary time evolution. |
| [`SciPyRealEvolver`](qiskit.algorithms.SciPyRealEvolver "qiskit.algorithms.SciPyRealEvolver") | Classical Evolver for real time evolution. |
| [`VarQITE`](qiskit.algorithms.VarQITE "qiskit.algorithms.VarQITE") | Variational Quantum Imaginary Time Evolution algorithm. |
| [`VarQRTE`](qiskit.algorithms.VarQRTE "qiskit.algorithms.VarQRTE") | Variational Quantum Real Time Evolution algorithm. |
#### Legacy Time Evolvers
These algorithms, still based on the [`QuantumInstance`](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance"), are superseded by the primitive-based versions in the section above but are still supported for now.
| | |
| --------------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
| [`RealEvolver`](qiskit.algorithms.RealEvolver "qiskit.algorithms.RealEvolver") | Deprecated: Interface for Quantum Real Time Evolution. |
| [`ImaginaryEvolver`](qiskit.algorithms.ImaginaryEvolver "qiskit.algorithms.ImaginaryEvolver") | Deprecated: Interface for Quantum Imaginary Time Evolution. |
| [`TrotterQRTE`](qiskit.algorithms.TrotterQRTE "qiskit.algorithms.TrotterQRTE") | Deprecated: Quantum Real Time Evolution using Trotterization. |
| [`EvolutionResult`](qiskit.algorithms.EvolutionResult "qiskit.algorithms.EvolutionResult") | Deprecated: Class for holding evolution result. |
| [`EvolutionProblem`](qiskit.algorithms.EvolutionProblem "qiskit.algorithms.EvolutionProblem") | Deprecated: Evolution problem class. |
#### Variational Quantum Time Evolution
Classes used by variational quantum time evolution algorithms - [`VarQITE`](qiskit.algorithms.VarQITE "qiskit.algorithms.VarQITE") and [`VarQRTE`](qiskit.algorithms.VarQRTE "qiskit.algorithms.VarQRTE").
| | |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| [`time_evolvers.variational`](qiskit.algorithms.time_evolvers.variational#module-qiskit.algorithms.time_evolvers.variational "qiskit.algorithms.time_evolvers.variational") | Variational Quantum Time Evolutions (qiskit.algorithms.time\_evolvers.variational) |
#### Trotterization-based Quantum Real Time Evolution
Package for primitives-enabled Trotterization-based quantum time evolution algorithm - `TrotterQRTE`.
| | |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| [`time_evolvers.trotterization`](qiskit.algorithms.time_evolvers.trotterization#module-qiskit.algorithms.time_evolvers.trotterization "qiskit.algorithms.time_evolvers.trotterization") | This package contains Trotterization-based Quantum Real Time Evolution algorithm. |
### Gradients
Algorithms to calculate the gradient of a quantum circuit.
| | |
| ----------------------------------------------------------------------------------------------------------- | --------------------------------------- |
| [`gradients`](qiskit.algorithms.gradients#module-qiskit.algorithms.gradients "qiskit.algorithms.gradients") | Gradients (qiskit.algorithms.gradients) |
### Minimum Eigensolvers
Algorithms that can find the minimum eigenvalue of an operator.
#### Primitive-based Minimum Eigensolvers
These algorithms are based on the Qiskit Primitives, a new execution paradigm that replaces the use of [`QuantumInstance`](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance") in algorithms. To ensure continued support and development, we recommend using the primitive-based Minimum Eigensolvers in place of the legacy [`QuantumInstance`](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance")-based ones.
| | |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
| [`minimum_eigensolvers`](qiskit.algorithms.minimum_eigensolvers#module-qiskit.algorithms.minimum_eigensolvers "qiskit.algorithms.minimum_eigensolvers") | Minimum Eigensolvers Package (qiskit.algorithms.minimum\_eigensolvers) |
#### Legacy Minimum Eigensolvers
These algorithms, still based on the [`QuantumInstance`](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance"), are superseded by the primitive-based versions in the section above but are still supported for now.
| | |
| --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
| [`MinimumEigensolver`](qiskit.algorithms.MinimumEigensolver "qiskit.algorithms.MinimumEigensolver") | Deprecated: Minimum Eigensolver Interface. |
| [`MinimumEigensolverResult`](qiskit.algorithms.MinimumEigensolverResult "qiskit.algorithms.MinimumEigensolverResult") | Deprecated: Minimum Eigensolver Result. |
| [`NumPyMinimumEigensolver`](qiskit.algorithms.NumPyMinimumEigensolver "qiskit.algorithms.NumPyMinimumEigensolver") | Deprecated: Numpy Minimum Eigensolver algorithm. |
| [`QAOA`](qiskit.algorithms.QAOA "qiskit.algorithms.QAOA") | Deprecated: Quantum Approximate Optimization Algorithm. |
| [`VQE`](qiskit.algorithms.VQE "qiskit.algorithms.VQE") | Deprecated: Variational Quantum Eigensolver algorithm. |
### Optimizers
Classical optimizers for use by quantum variational algorithms.
| | |
| --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`optimizers`](qiskit.algorithms.optimizers#module-qiskit.algorithms.optimizers "qiskit.algorithms.optimizers") | Optimizers (qiskit.algorithms.optimizers) It contains a variety of classical optimizers for use by quantum variational algorithms, such as VQE. Logically, these optimizers can be divided into two categories: |
### Phase Estimators
Algorithms that estimate the phases of eigenstates of a unitary.
| | |
| --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`HamiltonianPhaseEstimation`](qiskit.algorithms.HamiltonianPhaseEstimation "qiskit.algorithms.HamiltonianPhaseEstimation") | Run the Quantum Phase Estimation algorithm to find the eigenvalues of a Hermitian operator. |
| [`HamiltonianPhaseEstimationResult`](qiskit.algorithms.HamiltonianPhaseEstimationResult "qiskit.algorithms.HamiltonianPhaseEstimationResult") | Store and manipulate results from running HamiltonianPhaseEstimation. |
| [`PhaseEstimationScale`](qiskit.algorithms.PhaseEstimationScale "qiskit.algorithms.PhaseEstimationScale") | Set and use a bound on eigenvalues of a Hermitian operator in order to ensure phases are in the desired range and to convert measured phases into eigenvectors. |
| [`PhaseEstimation`](qiskit.algorithms.PhaseEstimation "qiskit.algorithms.PhaseEstimation") | Run the Quantum Phase Estimation (QPE) algorithm. |
| [`PhaseEstimationResult`](qiskit.algorithms.PhaseEstimationResult "qiskit.algorithms.PhaseEstimationResult") | Store and manipulate results from running PhaseEstimation. |
| [`IterativePhaseEstimation`](qiskit.algorithms.IterativePhaseEstimation "qiskit.algorithms.IterativePhaseEstimation") | Run the Iterative quantum phase estimation (QPE) algorithm. |
### State Fidelities
Algorithms that compute the fidelity of pairs of quantum states.
| | |
| --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| [`state_fidelities`](qiskit.algorithms.state_fidelities#module-qiskit.algorithms.state_fidelities "qiskit.algorithms.state_fidelities") | State Fidelity Interfaces (qiskit.algorithms.state\_fidelities) |
### Exceptions
#### AlgorithmError
<Class id="qiskit.algorithms.AlgorithmError" github="https://github.com/qiskit/qiskit/tree/stable/0.46/qiskit/algorithms/exceptions.py" signature="qiskit.algorithms.AlgorithmError(*message)" modifiers="exception">
For Algorithm specific errors.
Set the error message.
</Class>
### Utility classes
Utility classes used by algorithms (mainly for type-hinting purposes).
| | |
| --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| [`AlgorithmJob`](qiskit.algorithms.AlgorithmJob "qiskit.algorithms.AlgorithmJob")(function, \*args, \*\*kwargs) | This empty class is introduced for typing purposes. |
### Utility functions
Utility functions used by algorithms.
#### eval\_observables
<Function id="qiskit.algorithms.eval_observables" github="https://github.com/qiskit/qiskit/tree/stable/0.46/qiskit/algorithms/aux_ops_evaluator.py" signature="qiskit.algorithms.eval_observables(quantum_instance, quantum_state, observables, expectation, threshold=1e-12)">
Deprecated: Accepts a list or a dictionary of operators and calculates their expectation values - means and standard deviations. They are calculated with respect to a quantum state provided. A user can optionally provide a threshold value which filters mean values falling below the threshold.
This function has been superseded by the `qiskit.algorithms.observables_evaluator.eval_observables()` function. It will be deprecated in a future release and subsequently removed after that.
<Admonition title="Deprecated since version 0.24.0" type="danger">
The function `qiskit.algorithms.aux_ops_evaluator.eval_observables()` is deprecated as of qiskit-terra 0.24.0. It will be removed no earlier than 3 months after the release date. Instead, use the function `qiskit.algorithms.observables_evaluator.estimate_observables`. See [https://qisk.it/algo\_migration](https://qisk.it/algo_migration) for a migration guide.
</Admonition>
**Parameters**
* **quantum\_instance** ([*QuantumInstance*](qiskit.utils.QuantumInstance "qiskit.utils.QuantumInstance") *|*[*Backend*](qiskit.providers.Backend "qiskit.providers.Backend")) – A quantum instance used for calculations.
* **quantum\_state** ([*Statevector*](qiskit.quantum_info.Statevector "qiskit.quantum_info.Statevector") *|*[*QuantumCircuit*](qiskit.circuit.QuantumCircuit "qiskit.circuit.QuantumCircuit") *|*[*OperatorBase*](qiskit.opflow.OperatorBase "qiskit.opflow.OperatorBase")) – An unparametrized quantum circuit representing a quantum state that expectation values are computed against.
* **observables** (*ListOrDict\[*[*OperatorBase*](qiskit.opflow.OperatorBase "qiskit.opflow.OperatorBase")*]*) – A list or a dictionary of operators whose expectation values are to be calculated.
* **expectation** ([*ExpectationBase*](qiskit.opflow.expectations.ExpectationBase "qiskit.opflow.expectations.ExpectationBase")) – An instance of ExpectationBase which defines a method for calculating expectation values.
* **threshold** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")) – A threshold value that defines which mean values should be neglected (helpful for ignoring numerical instabilities close to 0).
**Returns**
A list or a dictionary of tuples (mean, standard deviation).
**Raises**
[**ValueError**](https://docs.python.org/3/library/exceptions.html#ValueError "(in Python v3.12)") – If a `quantum_state` with free parameters is provided.
**Return type**
ListOrDict\[[tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.12)")\[[complex](https://docs.python.org/3/library/functions.html#complex "(in Python v3.12)"), [complex](https://docs.python.org/3/library/functions.html#complex "(in Python v3.12)")]]
</Function>
#### estimate\_observables
<Function id="qiskit.algorithms.estimate_observables" github="https://github.com/qiskit/qiskit/tree/stable/0.46/qiskit/algorithms/observables_evaluator.py" signature="qiskit.algorithms.estimate_observables(estimator, quantum_state, observables, parameter_values=None, threshold=1e-12)">
Accepts a sequence of operators and calculates their expectation values - means and metadata. They are calculated with respect to a quantum state provided. A user can optionally provide a threshold value which filters mean values falling below the threshold.
**Parameters**
* **estimator** ([*BaseEstimator*](qiskit.primitives.BaseEstimator "qiskit.primitives.BaseEstimator")) – An estimator primitive used for calculations.
* **quantum\_state** ([*QuantumCircuit*](qiskit.circuit.QuantumCircuit "qiskit.circuit.QuantumCircuit")) – A (parameterized) quantum circuit preparing a quantum state that expectation values are computed against.
* **observables** (*ListOrDict\[BaseOperator |* [*PauliSumOp*](qiskit.opflow.primitive_ops.PauliSumOp "qiskit.opflow.primitive_ops.PauliSumOp")*]*) – A list or a dictionary of operators whose expectation values are to be calculated.
* **parameter\_values** (*Sequence\[*[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*] | None*) – Optional list of parameters values to evaluate the quantum circuit on.
* **threshold** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")) – A threshold value that defines which mean values should be neglected (helpful for ignoring numerical instabilities close to 0).
**Returns**
A list or a dictionary of tuples (mean, metadata).
**Raises**
[**AlgorithmError**](#qiskit.algorithms.AlgorithmError "qiskit.algorithms.AlgorithmError") – If a primitive job is not successful.
**Return type**
ListOrDict\[[tuple](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.12)")\[[complex](https://docs.python.org/3/library/functions.html#complex "(in Python v3.12)"), [dict](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")\[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), Any]]]
</Function>
Reference in New Issue View Git Blame Copy Permalink