Variational Quantum Time Evolution algorithm.

qiskit/algorithms/__init__.py

@@ -94,6 +94,17 @@
    VQD
 
 
+Variational Quantum Time Evolution
+----------------------------------
+
+Classes used by variational quantum time evolution algorithms - VarQITE and VarQRTE.
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   evolvers.variational
+
+
 Evolvers
 --------
 
@@ -108,11 +119,14 @@
     RealEvolver
     ImaginaryEvolver
     TrotterQRTE
+    VarQITE
+    VarQRTE
     PVQD
     PVQDResult
     EvolutionResult
     EvolutionProblem
 
+
 Factorizers
 -----------
 
@@ -248,6 +262,8 @@
 from .exceptions import AlgorithmError
 from .aux_ops_evaluator import eval_observables
 from .evolvers.trotterization import TrotterQRTE
+from .evolvers.variational.var_qite import VarQITE
+from .evolvers.variational.var_qrte import VarQRTE
 from .evolvers.pvqd import PVQD, PVQDResult
 
 __all__ = [
@@ -273,6 +289,8 @@
     "RealEvolver",
     "ImaginaryEvolver",
     "TrotterQRTE",
+    "VarQITE",
+    "VarQRTE",
     "EvolutionResult",
     "EvolutionProblem",
     "LinearSolverResult",

qiskit/algorithms/evolvers/evolution_problem.py

@@ -35,7 +35,7 @@ def __init__(
         aux_operators: Optional[ListOrDict[OperatorBase]] = None,
         truncation_threshold: float = 1e-12,
         t_param: Optional[Parameter] = None,
-        hamiltonian_value_dict: Optional[Dict[Parameter, complex]] = None,
+        param_value_dict: Optional[Dict[Parameter, complex]] = None,
     ):
         """
         Args:
@@ -50,15 +50,15 @@ def __init__(
                 Used when ``aux_operators`` is provided.
             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.
+            param_value_dict: Maps free parameters in the problem to values. Depending on the
+                algorithm, it might refer to e.g. a Hamiltonian or an initial state.
 
         Raises:
             ValueError: If non-positive time of evolution is provided.
         """
 
         self.t_param = t_param
-        self.hamiltonian_value_dict = hamiltonian_value_dict
+        self.param_value_dict = param_value_dict
         self.hamiltonian = hamiltonian
         self.time = time
         self.initial_state = initial_state
@@ -95,9 +95,9 @@ def validate_params(self) -> None:
             if self.t_param is not None:
                 t_param_set.add(self.t_param)
             hamiltonian_dict_param_set = set()
-            if self.hamiltonian_value_dict is not None:
+            if self.param_value_dict is not None:
                 hamiltonian_dict_param_set = hamiltonian_dict_param_set.union(
-                    set(self.hamiltonian_value_dict.keys())
+                    set(self.param_value_dict.keys())
                 )
             params_set = t_param_set.union(hamiltonian_dict_param_set)
             hamiltonian_param_set = set(self.hamiltonian.parameters)

qiskit/algorithms/evolvers/trotterization/trotter_qrte.py

@@ -187,7 +187,7 @@ def evolve(self, evolution_problem: EvolutionProblem) -> EvolutionResult:
                 f"PauliSumOp | SummedOp, {type(hamiltonian)} provided."
             )
         if isinstance(hamiltonian, OperatorBase):
-            hamiltonian = hamiltonian.bind_parameters(evolution_problem.hamiltonian_value_dict)
+            hamiltonian = hamiltonian.bind_parameters(evolution_problem.param_value_dict)
         if isinstance(hamiltonian, SummedOp):
             hamiltonian = self._summed_op_to_pauli_sum_op(hamiltonian)
         # the evolution gate

qiskit/algorithms/evolvers/variational/__init__.py

@@ -0,0 +1,142 @@
+# 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.
+"""
+Variational Quantum Time Evolutions (:mod:`qiskit.algorithms.evolvers.variational`)
+===================================================================================
+
+Algorithms for performing Variational Quantum Time Evolution of quantum states,
+which can be tailored to near-term devices.
+:class:`~qiskit.algorithms.evolvers.variational.VarQTE` base class exposes an interface, compliant
+with the Quantum Time Evolution Framework in Qiskit Terra, that is implemented by
+:class:`~qiskit.algorithms.VarQRTE` and :class:`~qiskit.algorithms.VarQITE` classes for real and
+imaginary time evolution respectively. The variational approach is taken according to a variational
+principle chosen by a user.
+
+Examples:
+
+.. code-block::
+
+    from qiskit import BasicAer
+    from qiskit.circuit.library import EfficientSU2
+    from qiskit.opflow import SummedOp, I, Z, Y, X
+    from qiskit.algorithms.evolvers.variational import (
+        ImaginaryMcLachlanPrinciple,
+    )
+    from qiskit.algorithms import EvolutionProblem
+    from qiskit.algorithms import VarQITE
+
+    # define a Hamiltonian
+    observable = SummedOp(
+        [
+            0.2252 * (I ^ I),
+            0.5716 * (Z ^ Z),
+            0.3435 * (I ^ Z),
+            -0.4347 * (Z ^ I),
+            0.091 * (Y ^ Y),
+            0.091 * (X ^ X),
+        ]
+    ).reduce()
+
+    # define a parametrized initial state to be evolved
+
+    ansatz = EfficientSU2(observable.num_qubits, reps=1)
+    parameters = ansatz.parameters
+
+    # define values of initial parameters
+    init_param_values = np.zeros(len(ansatz.parameters))
+    for i in range(len(ansatz.parameters)):
+        init_param_values[i] = np.pi / 2
+    param_dict = dict(zip(parameters, init_param_values))
+
+    # define a variational principle
+    var_principle = ImaginaryMcLachlanPrinciple()
+
+    # optionally define a backend
+    backend = BasicAer.get_backend("statevector_simulator")
+
+    # define evolution time
+    time = 1
+
+    # define evolution problem
+    evolution_problem = EvolutionProblem(observable, time, ansatz,
+        param_value_dict=param_dict)
+
+    # instantiate the algorithm
+    var_qite = VarQITE(
+        var_principle, quantum_instance=backend
+    )
+
+    # run the algorithm/evolve the state
+    evolution_result = var_qite.evolve(evolution_problem)
+
+.. currentmodule:: qiskit.algorithms.evolvers.variational
+
+Variational Principles
+----------------------
+
+Variational principles can be used to simulate quantum time evolution by propagating the parameters
+of a parameterized quantum circuit.
+
+They can be divided into two categories:
+
+    1) Variational Quantum Imaginary Time Evolution
+        Given a Hamiltonian, a time and a variational ansatz, the variational principle describes a
+        variational principle according to the normalized Wick-rotated Schroedinger equation.
+
+    2) Variational Quantum Real Time Evolution
+        Given a Hamiltonian, a time and a variational ansatz, the variational principle describes a
+        variational principle according to the Schroedinger equation.
+
+.. autosummary::
+   :toctree: ../stubs/
+   :template: autosummary/class_no_inherited_members.rst
+
+    VariationalPrinciple
+    RealVariationalPrinciple
+    ImaginaryVariationalPrinciple
+    RealMcLachlanPrinciple
+    ImaginaryMcLachlanPrinciple
+
+ODE solvers
+-----------
+ODE solvers that implement the SciPy ODE Solver interface. The Forward Euler Solver is
+a preferred choice in the presence of noise. One might also use solvers provided by SciPy directly,
+e.g. RK45.
+
+.. autosummary::
+   :toctree: ../stubs/
+   :template: autosummary/class_no_inherited_members.rst
+
+   ForwardEulerSolver
+
+"""
+from .solvers.ode.forward_euler_solver import ForwardEulerSolver
+from .var_qte import VarQTE
+from .variational_principles.variational_principle import VariationalPrinciple
+from .variational_principles import RealVariationalPrinciple, ImaginaryVariationalPrinciple
+from .variational_principles.imaginary_mc_lachlan_principle import (
+    ImaginaryMcLachlanPrinciple,
+)
+from .variational_principles.real_mc_lachlan_principle import (
+    RealMcLachlanPrinciple,
+)
+
+
+__all__ = [
+    "ForwardEulerSolver",
+    "VarQTE",
+    "VariationalPrinciple",
+    "RealVariationalPrinciple",
+    "ImaginaryVariationalPrinciple",
+    "RealMcLachlanPrinciple",
+    "ImaginaryMcLachlanPrinciple",
+]

qiskit/algorithms/evolvers/variational/solvers/__init__.py

@@ -0,0 +1,44 @@
+# 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.
+
+"""
+Solvers (:mod:`qiskit.algorithms.evolvers.variational.solvers`)
+===============================================================
+
+This package contains the necessary classes to solve systems of equations arising in the
+Variational Quantum Time Evolution. They include ordinary differential equations (ODE) which
+describe ansatz parameter propagation and systems of linear equations.
+
+
+Systems of Linear Equations Solver
+----------------------------------
+
+.. autosummary::
+   :toctree: ../stubs/
+   :template: autosummary/class_no_inherited_members.rst
+
+    VarQTELinearSolver
+
+
+ODE Solver
+----------
+.. autosummary::
+   :toctree: ../stubs/
+   :template: autosummary/class_no_inherited_members.rst
+
+    VarQTEOdeSolver
+"""
+
+from qiskit.algorithms.evolvers.variational.solvers.ode.var_qte_ode_solver import VarQTEOdeSolver
+from qiskit.algorithms.evolvers.variational.solvers.var_qte_linear_solver import VarQTELinearSolver
+
+__all__ = ["VarQTELinearSolver", "VarQTEOdeSolver"]

qiskit/algorithms/evolvers/variational/solvers/ode/__init__.py

@@ -0,0 +1,13 @@
+# 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.
+
+"""ODE Solvers"""

qiskit/algorithms/evolvers/variational/solvers/ode/abstract_ode_function.py

@@ -0,0 +1,52 @@
+# 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.
+
+"""Abstract class for generating ODE functions."""
+
+from abc import ABC, abstractmethod
+from typing import Iterable, Dict, Optional
+from qiskit.circuit import Parameter
+from ..var_qte_linear_solver import (
+    VarQTELinearSolver,
+)
+
+
+class AbstractOdeFunction(ABC):
+    """Abstract class for generating ODE functions."""
+
+    def __init__(
+        self,
+        varqte_linear_solver: VarQTELinearSolver,
+        error_calculator,
+        param_dict: Dict[Parameter, complex],
+        t_param: Optional[Parameter] = None,
+    ) -> None:
+
+        self._varqte_linear_solver = varqte_linear_solver
+        self._error_calculator = error_calculator
+        self._param_dict = param_dict
+        self._t_param = t_param
+
+    @abstractmethod
+    def var_qte_ode_function(self, time: float, parameters_values: Iterable) -> Iterable:
+        """
+        Evaluates an ODE function for a given time and parameter values. It is used by an ODE
+        solver.
+
+        Args:
+            time: Current time of evolution.
+            parameters_values: Current values of parameters.
+
+        Returns:
+            ODE gradient arising from solving a system of linear equations.
+        """
+        pass