Merge branch 'main' into drop-base-backend

Cargo.toml

@@ -20,7 +20,7 @@ ahash = "0.7.6"
 num-complex = "0.4"
 
 [dependencies.pyo3]
-version = "0.16.2"
+version = "0.16.3"
 features = ["extension-module", "hashbrown", "num-complex"]
 
 [dependencies.ndarray]

qiskit/algorithms/__init__.py

@@ -93,6 +93,22 @@
    NumPyEigensolver
 
 
+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.
+
+.. autosummary::
+   :toctree: ../stubs/
+   :nosignatures:
+
+    RealEvolver
+    ImaginaryEvolver
+    EvolutionResult
+    EvolutionProblem
+
 Factorizers
 -----------
 
@@ -188,6 +204,9 @@
 """
 
 from .algorithm_result import AlgorithmResult
+from .evolvers import EvolutionResult, EvolutionProblem
+from .evolvers.real.real_evolver import RealEvolver
+from .evolvers.imaginary.imaginary_evolver import ImaginaryEvolver
 from .variational_algorithm import VariationalAlgorithm, VariationalResult
 from .amplitude_amplifiers import Grover, GroverResult, AmplificationProblem, AmplitudeAmplifier
 from .amplitude_estimators import (
@@ -245,6 +264,10 @@
     "MaximumLikelihoodAmplitudeEstimationResult",
     "EstimationProblem",
     "NumPyEigensolver",
+    "RealEvolver",
+    "ImaginaryEvolver",
+    "EvolutionResult",
+    "EvolutionProblem",
     "LinearSolverResult",
     "Eigensolver",
     "EigensolverResult",

qiskit/algorithms/aux_ops_evaluator.py

@@ -16,7 +16,6 @@
 import numpy as np
 
 from qiskit import QuantumCircuit
-from qiskit.algorithms.eigen_solvers.eigen_solver import ListOrDict
 from qiskit.opflow import (
     CircuitSampler,
     ListOp,
@@ -28,6 +27,8 @@
 from qiskit.quantum_info import Statevector
 from qiskit.utils import QuantumInstance
 
+from .list_or_dict import ListOrDict
+
 
 def eval_observables(
     quantum_instance: Union[QuantumInstance, Backend],

qiskit/algorithms/eigen_solvers/eigen_solver.py

@@ -13,15 +13,13 @@
 """The Eigensolver interface"""
 
 from abc import ABC, abstractmethod
-from typing import Dict, Optional, List, Union, Tuple, TypeVar
+from typing import Optional, List, Tuple
 
 import numpy as np
+
 from qiskit.opflow import OperatorBase
 from ..algorithm_result import AlgorithmResult
-
-# Introduced new type to maintain readability.
-_T = TypeVar("_T")  # Pylint does not allow single character class names.
-ListOrDict = Union[List[Optional[_T]], Dict[str, _T]]
+from ..list_or_dict import ListOrDict
 
 
 class Eigensolver(ABC):

qiskit/algorithms/eigen_solvers/numpy_eigen_solver.py

@@ -21,7 +21,8 @@
 from qiskit.opflow import I, ListOp, OperatorBase, StateFn
 from qiskit.utils.validation import validate_min
 from ..exceptions import AlgorithmError
-from .eigen_solver import Eigensolver, EigensolverResult, ListOrDict
+from .eigen_solver import Eigensolver, EigensolverResult
+from ..list_or_dict import ListOrDict
 
 logger = logging.getLogger(__name__)
 

qiskit/algorithms/evolvers/__init__.py

@@ -0,0 +1,21 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Quantum Time Evolution package."""
+
+from .evolution_result import EvolutionResult
+from .evolution_problem import EvolutionProblem
+
+__all__ = [
+    "EvolutionResult",
+    "EvolutionProblem",
+]

qiskit/algorithms/evolvers/evolution_problem.py

@@ -0,0 +1,58 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Evolution problem class."""
+
+from typing import Union, Optional, Dict
+
+from qiskit import QuantumCircuit
+from qiskit.circuit import Parameter
+from qiskit.opflow import OperatorBase, StateFn
+from ..list_or_dict import ListOrDict
+
+
+class EvolutionProblem:
+    """Evolution problem class.
+
+    This class is the input to time evolution algorithms and contains
+    information on e.g. the total evolution time and under which Hamiltonian
+    the state is evolved.
+    """
+
+    def __init__(
+        self,
+        hamiltonian: OperatorBase,
+        time: float,
+        initial_state: Union[StateFn, QuantumCircuit],
+        aux_operators: Optional[ListOrDict[OperatorBase]] = None,
+        t_param: Optional[Parameter] = None,
+        hamiltonian_value_dict: Optional[Dict[Parameter, Union[complex]]] = None,
+    ):
+        """
+        Args:
+            hamiltonian: The Hamiltonian under which to evolve the system.
+            time: Total time of evolution.
+            initial_state: Quantum state to be evolved.
+            aux_operators: Optional list of auxiliary operators to be evaluated with the
+                evolved ``initial_state`` and their expectation values returned.
+            t_param: Time parameter in case of a time-dependent Hamiltonian. This
+                free parameter must be within the ``hamiltonian``.
+            hamiltonian_value_dict: If the Hamiltonian contains free parameters, this
+                dictionary maps all these parameters to values.
+        """
+
+        self.hamiltonian = hamiltonian
+        self.time = time
+        self.initial_state = initial_state
+        self.aux_operators = aux_operators
+        self.t_param = t_param
+        self.hamiltonian_value_dict = hamiltonian_value_dict

qiskit/algorithms/evolvers/evolution_result.py

@@ -0,0 +1,40 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Class for holding evolution result."""
+
+from typing import Optional, Union, Tuple
+
+from qiskit import QuantumCircuit
+from qiskit.algorithms.list_or_dict import ListOrDict
+from qiskit.opflow import StateFn
+from ..algorithm_result import AlgorithmResult
+
+
+class EvolutionResult(AlgorithmResult):
+    """Class for holding evolution result."""
+
+    def __init__(
+        self,
+        evolved_state: Union[StateFn, QuantumCircuit],
+        aux_ops_evaluated: Optional[ListOrDict[Tuple[complex, complex]]] = None,
+    ):
+        """
+        Args:
+            evolved_state: An evolved quantum state.
+            aux_ops_evaluated: Optional list of observables for which expected values on an evolved
+                state are calculated. These values are in fact tuples formatted as (mean, standard
+                deviation).
+        """
+
+        self.evolved_state = evolved_state
+        self.aux_ops_evaluated = aux_ops_evaluated

qiskit/algorithms/evolvers/imaginary/__init__.py

@@ -0,0 +1,11 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.

qiskit/algorithms/evolvers/imaginary/imaginary_evolver.py

@@ -0,0 +1,37 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Interface for Quantum Imaginary Time Evolution."""
+
+from abc import ABC, abstractmethod
+
+from ..evolution_problem import EvolutionProblem
+from ..evolution_result import EvolutionResult
+
+
+class ImaginaryEvolver(ABC):
+    """Interface for Quantum Imaginary Time Evolution."""
+
+    @abstractmethod
+    def evolve(self, evolution_problem: EvolutionProblem) -> EvolutionResult:
+        r"""Perform imaginary time evolution :math:`\exp(-\tau H)|\Psi\rangle`.
+
+        Evolves an initial state :math:`|\Psi\rangle` for an imaginary time :math:`\tau`
+        under a Hamiltonian  :math:`H`, as provided in the ``evolution_problem``.
+
+        Args:
+            evolution_problem: The definition of the evolution problem.
+
+        Returns:
+            Evolution result which includes an evolved quantum state.
+        """
+        raise NotImplementedError()

qiskit/algorithms/evolvers/real/__init__.py

@@ -0,0 +1,11 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.

qiskit/algorithms/evolvers/real/real_evolver.py

@@ -0,0 +1,37 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Interface for Quantum Real Time Evolution."""
+
+from abc import ABC, abstractmethod
+
+from ..evolution_problem import EvolutionProblem
+from ..evolution_result import EvolutionResult
+
+
+class RealEvolver(ABC):
+    """Interface for Quantum Real Time Evolution."""
+
+    @abstractmethod
+    def evolve(self, evolution_problem: EvolutionProblem) -> EvolutionResult:
+        r"""Perform real time evolution :math:`\exp(-i t H)|\Psi\rangle`.
+
+        Evolves an initial state :math:`|\Psi\rangle` for a time :math:`t`
+        under a Hamiltonian  :math:`H`, as provided in the ``evolution_problem``.
+
+        Args:
+            evolution_problem: The definition of the evolution problem.
+
+        Returns:
+            Evolution result which includes an evolved quantum state.
+        """
+        raise NotImplementedError()