Algorithms

qiskit.algorithms

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 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(opens in a new tab) 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`	The amplification problem is the input to amplitude amplification algorithms, like Grover.
`AmplitudeAmplifier`	The interface for amplification algorithms.
`Grover`	Grover's Search algorithm.
`GroverResult`	Grover Result.

Amplitude Estimators


`AmplitudeEstimator`	The Amplitude Estimation interface.
`AmplitudeEstimatorResult`	The results object for amplitude estimation algorithms.
`AmplitudeEstimation`	The Quantum Phase Estimation-based Amplitude Estimation algorithm.
`AmplitudeEstimationResult`	The `AmplitudeEstimation` result object.
`EstimationProblem`	The estimation problem is the input to amplitude estimation algorithm.
`FasterAmplitudeEstimation`	The Faster Amplitude Estimation algorithm.
`FasterAmplitudeEstimationResult`	The result object for the Faster Amplitude Estimation algorithm.
`IterativeAmplitudeEstimation`	The Iterative Amplitude Estimation algorithm.
`IterativeAmplitudeEstimationResult`	The `IterativeAmplitudeEstimation` result object.
`MaximumLikelihoodAmplitudeEstimation`	The Maximum Likelihood Amplitude Estimation algorithm.
`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.


`Eigensolver`	The Eigensolver Interface.
`EigensolverResult`	Eigensolver Result.


`NumPyEigensolver`	The NumPy Eigensolver algorithm.
`VQD`	The Variational Quantum Deflation algorithm.

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.


`RealEvolver`	Interface for Quantum Real Time Evolution.
`ImaginaryEvolver`	Interface for Quantum Imaginary Time Evolution.
`TrotterQRTE`	Quantum Real Time Evolution using Trotterization.
`EvolutionResult`	Class for holding evolution result.
`EvolutionProblem`	Evolution problem class.

Factorizers

Algorithms to find factors of a number.


`Shor`	Shor's factoring algorithm.
`ShorResult`	Shor Result.

Linear Solvers

Algorithms to solve linear systems of equations.

linear_solvers Linear solvers (qiskit.algorithms.linear_solvers) It contains classical and quantum algorithms to solve systems of linear equations such as HHL. Although the quantum algorithm accepts a general Hermitian matrix as input, Qiskit's default Hamiltonian evolution is exponential in such cases and therefore the quantum linear solver will not achieve an exponential speedup. Furthermore, the quantum algorithm can find a solution exponentially faster in the size of the system than their classical counterparts (i.e. logarithmic complexity instead of polynomial), meaning that reading the full solution vector would kill such speedup (since this would take linear time in the size of the system). Therefore, to achieve an exponential speedup we can only compute functions from the solution vector (the so called observables) to learn information about the solution. Known efficient implementations of Hamiltonian evolutions or observables are contained in the following subfolders:


`linear_solvers`	Linear solvers (qiskit.algorithms.linear_solvers) It contains classical and quantum algorithms to solve systems of linear equations such as HHL. Although the quantum algorithm accepts a general Hermitian matrix as input, Qiskit's default Hamiltonian evolution is exponential in such cases and therefore the quantum linear solver will not achieve an exponential speedup. Furthermore, the quantum algorithm can find a solution exponentially faster in the size of the system than their classical counterparts (i.e. logarithmic complexity instead of polynomial), meaning that reading the full solution vector would kill such speedup (since this would take linear time in the size of the system). Therefore, to achieve an exponential speedup we can only compute functions from the solution vector (the so called observables) to learn information about the solution. Known efficient implementations of Hamiltonian evolutions or observables are contained in the following subfolders:

Minimum Eigensolvers

Algorithms that can find the minimum eigenvalue of an operator.


`MinimumEigensolver`	The Minimum Eigensolver Interface.
`MinimumEigensolverResult`	Minimum Eigensolver Result.


`NumPyMinimumEigensolver`	The Numpy Minimum Eigensolver algorithm.
`QAOA`	The Quantum Approximate Optimization Algorithm.
`VQE`	The Variational Quantum Eigensolver algorithm.

Optimizers

Classical optimizers for use by quantum variational 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`	Run the Quantum Phase Estimation algorithm to find the eigenvalues of a Hermitian operator.
`HamiltonianPhaseEstimationResult`	Store and manipulate results from running HamiltonianPhaseEstimation.
`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`	Run the Quantum Phase Estimation (QPE) algorithm.
`PhaseEstimationResult`	Store and manipulate results from running PhaseEstimation.
`IterativePhaseEstimation`	Run the Iterative quantum phase estimation (QPE) algorithm.

Exceptions


`AlgorithmError`(*message)	For Algorithm specific errors.

Utility methods

Utility methods used by algorithms.


`eval_observables`(quantum_instance, ...[, ...])	Accepts a list or a dictionary of operators and calculates their expectation values - means and standard deviations.

Was this page helpful?

Report a bug or request content on GitHub.