Ground state interface

qiskit/chemistry/algorithms/minimum_eigen_solvers/vqe_adapt.py

@@ -36,8 +36,7 @@
 
 
 class VQEAdapt(VQAlgorithm):
-    """
-    The Adaptive VQE algorithm.
+    """DEPRECATED. The Adaptive VQE algorithm.
 
     See https://arxiv.org/abs/1812.11173
     """
@@ -73,6 +72,10 @@ def __init__(self, operator: LegacyBaseOperator,
             ValueError: if var_form_base is not an instance of UCCSD.
             See also: qiskit/chemistry/components/variational_forms/uccsd_adapt.py
         """
+        warnings.warn('The qiskit.chemistry.algorithms.minimum_eigen_solvers.VQEAdapt object is '
+                      'deprecated as of 0.8.0 and will be removed no sooner than 3 months after the'
+                      ' release. You should use qiskit.chemistry.ground_state_calculation.AdaptVQE '
+                      'instead.', DeprecationWarning, stacklevel=2)
         validate_min('threshold', threshold, 1e-15)
         validate_min('delta', delta, 1e-5)
         super().__init__(var_form=var_form_base,

qiskit/chemistry/applications/molecular_ground_state_energy.py

@@ -12,6 +12,7 @@
 
 """ Molecular ground state energy  chemistry application """
 
+import warnings
 from typing import List, Optional, Callable, Union
 
 from qiskit.providers import BaseBackend
@@ -59,6 +60,11 @@ def __init__(self,
                 See also :class:`~qiskit.chemistry.core.Hamiltonian` which has the core
                 processing behind this class.
         """
+
+        warnings.warn('The MolecularGroundStateEnergy class is deprecated as of Qiskit Aqua 0.8.0 '
+                      'and will be removed no earlier than 3 months after the release date. '
+                      'Instead, the GroundStateCalculation class can be used.',
+                      DeprecationWarning, stacklevel=2)
         self._driver = driver
         self._solver = solver
         self._transformation = transformation

qiskit/chemistry/components/variational_forms/uccsd.py

@@ -153,7 +153,7 @@ def __init__(self,
                                            excitation_type=self._excitation_type,)
 
         self._hopping_ops, self._num_parameters = self._build_hopping_operators()
-        self._excitation_pool = None
+        self._excitation_pool = None  # type: Optional[List[WeightedPauliOperator]]
         self._bounds = [(-np.pi, np.pi) for _ in range(self._num_parameters)]
 
         self._logging_construct_circuit = True
@@ -226,14 +226,15 @@ def double_excitations(self):
         return self._double_excitations
 
     @property
-    def excitation_pool(self):
-        """
-        Getter of full list of available excitations (called the pool)
-        Returns:
-            list[WeightedPauliOperator]: excitation pool
-        """
+    def excitation_pool(self) -> List[WeightedPauliOperator]:
+        """Returns the full list of available excitations (called the pool)."""
         return self._excitation_pool
 
+    @excitation_pool.setter
+    def excitation_pool(self, excitation_pool: List[WeightedPauliOperator]) -> None:
+        """Sets the excitation pool."""
+        self._excitation_pool = excitation_pool.copy()
+
     def _build_hopping_operators(self):
         if logger.isEnabledFor(logging.DEBUG):
             TextProgressBar(sys.stderr)
@@ -328,8 +329,9 @@ def manage_hopping_operators(self):
         hopping operators in a so called "excitation pool" and clears the previous list to be empty.
         Furthermore, the depth is asserted to be 1 which is required by the Adaptive VQE algorithm.
         """
-        # store full list of excitations as pool
-        self._excitation_pool = self._hopping_ops.copy()
+        if self._excitation_pool is None:
+            # store full list of excitations as pool
+            self._excitation_pool = self._hopping_ops.copy()
 
         # check depth parameter
         if self._reps != 1:
@@ -339,8 +341,8 @@ def manage_hopping_operators(self):
 
         # reset internal excitation list to be empty
         self._hopping_ops = []
-        self._num_parameters = len(self._hopping_ops) * self._reps
-        self._bounds = [(-np.pi, np.pi) for _ in range(self._num_parameters)]
+        self._num_parameters = 0
+        self._bounds = []
 
     def push_hopping_operator(self, excitation):
         """

qiskit/chemistry/core/chemistry_operator.py

@@ -14,9 +14,11 @@
 Such an operator takes a QMolecule and produces an input for
 a quantum algorithm
 """
+
 from abc import ABC, abstractmethod
+import warnings
 import logging
-from typing import Union, List, Tuple, Optional, cast
+from typing import Dict, Union, List, Tuple, Optional, cast
 import numpy as np
 
 from qiskit.aqua.algorithms import MinimumEigensolverResult, EigensolverResult, AlgorithmResult
@@ -43,6 +45,10 @@ class ChemistryOperator(ABC):
 
     @abstractmethod
     def __init__(self):
+        warnings.warn('The ChemistryOperator is deprecated as of Qiskit Aqua 0.8.0 and will be '
+                      'removed no earlier than 3 months after the release date. Instead, the '
+                      'FermionicTransformation can be used to transform QMolecules and construct '
+                      'ground state result objects.', DeprecationWarning, stacklevel=2)
         self._molecule_info = {}
 
     @abstractmethod
@@ -105,6 +111,13 @@ class MolecularChemistryResult(AlgorithmResult):
     Energies are in Hartree and dipole moments in A.U unless otherwise stated.
     """
 
+    def __init__(self, a_dict: Optional[Dict] = None) -> None:
+        super().__init__(a_dict)
+        warnings.warn('The qiskit.chemistry.chemistry_operator.MolecularChemistryResult object is '
+                      'deprecated as of 0.8.0 and will be removed no sooner than 3 months after the'
+                      ' release. You should use qiskit.chemistry.ground_state_calculation.'
+                      'FermionicGroundStateResult instead.', DeprecationWarning, stacklevel=2)
+
     @property
     def algorithm_result(self) -> AlgorithmResult:
         """ Returns raw algorithm result """
@@ -153,6 +166,16 @@ class MolecularGroundStateResult(MolecularChemistryResult):
     Energies are in Hartree and dipole moments in A.U unless otherwise stated.
     """
 
+    # TODO we need to be able to extract the statevector or the optimal parameters that can
+    # construct the circuit of the GS from here (if the algorithm supports this)
+
+    def __init__(self, a_dict: Optional[Dict] = None) -> None:
+        super().__init__(a_dict)
+        warnings.warn('The qiskit.chemistry.chemistry_operator.MolecularGroundStateResult object '
+                      'is deprecated as of 0.8.0 and will be removed no sooner than 3 months after '
+                      'the release. You should use qiskit.chemistry.ground_state_calculation.'
+                      'FermionicGroundStateResult instead.', DeprecationWarning, stacklevel=2)
+
     @property
     def energy(self) -> Optional[float]:
         """ Returns ground state energy if nuclear_repulsion_energy is available from driver """

qiskit/chemistry/core/hamiltonian.py

@@ -14,7 +14,7 @@
 energy of the electrons and nuclei in a molecule.
 """
 import warnings
-from typing import Optional, List, Union, cast
+from typing import Optional, List, Union, cast, Tuple
 import logging
 from enum import Enum
 
@@ -82,6 +82,9 @@ def __init__(self,
         Raises:
             QiskitChemistryError: Invalid symmetry reduction
         """
+        warnings.warn('The Hamiltonian class is deprecated as of Qiskit Aqua 0.8.0 and will be '
+                      'removed no earlier than 3 months after the release date. Instead, the '
+                      'FermionicTransformation can be used.', DeprecationWarning, stacklevel=2)
         transformation = transformation.value
         qubit_mapping = qubit_mapping.value
         orbital_reduction = orbital_reduction if orbital_reduction is not None else []
@@ -114,7 +117,8 @@ def __init__(self,
         self._ph_y_dipole_shift = 0.0
         self._ph_z_dipole_shift = 0.0
 
-    def run(self, qmolecule):
+    def run(self, qmolecule: QMolecule) -> Tuple[WeightedPauliOperator, WeightedPauliOperator]:
+        """ run method"""
         logger.debug('Processing started...')
         # Save these values for later combination with the quantum computation result
         self._hf_energy = qmolecule.hf_energy
@@ -155,7 +159,8 @@ def run(self, qmolecule):
         if orbitals_list:
             orbitals_list = np.array(orbitals_list)
             orbitals_list = \
-                orbitals_list[(orbitals_list >= 0) & (orbitals_list < qmolecule.num_orbitals)]
+                orbitals_list[(cast(np.ndarray, orbitals_list) >= 0) &
+                              (orbitals_list < qmolecule.num_orbitals)]
 
             freeze_list_alpha = [i for i in orbitals_list if i < num_alpha]
             freeze_list_beta = [i for i in orbitals_list if i < num_beta]

qiskit/chemistry/ground_state_calculation/__init__.py

@@ -0,0 +1,25 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Ground state calculation algorithms."""
+
+from .ground_state_calculation import GroundStateCalculation
+from .adapt_vqe import AdaptVQE
+from .mes_ground_state_calculation import MinimumEigensolverGroundStateCalculation
+from .mes_factories import MESFactory, VQEUCCSDFactory
+
+__all__ = ['GroundStateCalculation',
+           'AdaptVQE',
+           'MinimumEigensolverGroundStateCalculation',
+           'MESFactory',
+           'VQEUCCSDFactory'
+           ]