qiskit-community
diff --git a/‎.pylintdict‎
Lines changed: 1 addition & 0 deletions b/‎.pylintdict‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎qiskit/aqua/algorithms/eigen_solvers/numpy_eigen_solver.py‎
Lines changed: 2 additions & 0 deletions b/‎qiskit/aqua/algorithms/eigen_solvers/numpy_eigen_solver.py‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎qiskit/aqua/operators/legacy/common.py‎
Lines changed: 4 additions & 3 deletions b/‎qiskit/aqua/operators/legacy/common.py‎
Lines changed: 4 additions & 3 deletions
diff --git a/‎qiskit/chemistry/algorithms/excited_states_solvers/__init__.py‎
Lines changed: 25 additions & 0 deletions b/‎qiskit/chemistry/algorithms/excited_states_solvers/__init__.py‎
Lines changed: 25 additions & 0 deletions
diff --git a/‎qiskit/chemistry/algorithms/excited_states_solvers/eigensolver_factories/__init__.py‎
Lines changed: 21 additions & 0 deletions b/‎qiskit/chemistry/algorithms/excited_states_solvers/eigensolver_factories/__init__.py‎
Lines changed: 21 additions & 0 deletions
diff --git a/‎qiskit/chemistry/algorithms/excited_states_solvers/eigensolver_factories/eigensolver_factory.py‎
Lines changed: 34 additions & 0 deletions b/‎qiskit/chemistry/algorithms/excited_states_solvers/eigensolver_factories/eigensolver_factory.py‎
Lines changed: 34 additions & 0 deletions
diff --git a/‎qiskit/chemistry/algorithms/excited_states_solvers/eigensolver_factories/numpy_eigensolver_factory.py‎
Lines changed: 97 additions & 0 deletions b/‎qiskit/chemistry/algorithms/excited_states_solvers/eigensolver_factories/numpy_eigensolver_factory.py‎
Lines changed: 97 additions & 0 deletions
diff --git a/‎qiskit/chemistry/algorithms/excited_states_solvers/excited_states_eigensolver.py‎
Lines changed: 115 additions & 0 deletions b/‎qiskit/chemistry/algorithms/excited_states_solvers/excited_states_eigensolver.py‎
Lines changed: 115 additions & 0 deletions
diff --git a/‎qiskit/chemistry/algorithms/excited_states_solvers/excited_states_solver.py‎
Lines changed: 41 additions & 0 deletions b/‎qiskit/chemistry/algorithms/excited_states_solvers/excited_states_solver.py‎
Lines changed: 41 additions & 0 deletions
@@ -218,6 +218,7 @@ fcompiler
 fd
 fermionic
 fermionicoperator
+fermionictransformation
 fermionicdriver
 fermions
 fi
 
@@ -285,6 +285,8 @@ def _run(self):
             self._ret['eigvecs'] = np.array(eigvecs)
             self._ret['eigvals'] = np.array(eigvals)
             self._ret['energies'] = np.array(energies)
+            # conversion to np.array breaks in case of aux_ops
+            self._ret['aux_ops'] = aux_ops
 
             self._k = k_orig
 
 
@@ -384,7 +384,7 @@ def evolution_instruction(pauli_list, evo_time, num_time_slices,
     return qc.to_instruction()
 
 
-def commutator(op_a, op_b, op_c=None, threshold=1e-12):
+def commutator(op_a, op_b, op_c=None, sign=-1, threshold=1e-12):
     r"""
     Compute commutator of `op_a` and `op_b` or
     the symmetric double commutator of `op_a`, `op_b` and `op_c`.
@@ -401,6 +401,7 @@ def commutator(op_a, op_b, op_c=None, threshold=1e-12):
         op_a (WeightedPauliOperator): operator a
         op_b (WeightedPauliOperator): operator b
         op_c (Optional(WeightedPauliOperator)): operator c
+        sign (int): -1 is anti-commute, 1 is commute
         threshold (float): the truncation threshold
 
     Returns:
@@ -413,7 +414,7 @@ def commutator(op_a, op_b, op_c=None, threshold=1e-12):
     op_ba = op_b * op_a
 
     if op_c is None:
-        res = op_ab - op_ba
+        res = op_ab + sign * op_ba
     else:
         op_ac = op_a * op_c
         op_ca = op_c * op_a
@@ -427,7 +428,7 @@ def commutator(op_a, op_b, op_c=None, threshold=1e-12):
 
         tmp = (op_bac + op_cab + op_acb + op_bca)
         tmp = 0.5 * tmp
-        res = op_abc + op_cba - tmp
+        res = op_abc + op_cba + sign * tmp
 
     res.simplify()
     res.chop(threshold)
 
@@ -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.
+
+"""Excited states calculation algorithms."""
+
+from .excited_states_solver import ExcitedStatesSolver
+from .qeom import QEOM
+from .eigensolver_factories import EigensolverFactory, NumPyEigensolverFactory
+from .excited_states_eigensolver import ExcitedStatesEigensolver
+
+__all__ = ['ExcitedStatesSolver',
+           'ExcitedStatesEigensolver',
+           'EigensolverFactory',
+           'NumPyEigensolverFactory',
+           'QEOM'
+           ]
@@ -0,0 +1,21 @@
+# 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.
+
+"""Factories that create an eigensolver based on a qubit transformation."""
+
+
+from .eigensolver_factory import EigensolverFactory
+from .numpy_eigensolver_factory import NumPyEigensolverFactory
+
+__all__ = ['EigensolverFactory',
+           'NumPyEigensolverFactory'
+           ]
@@ -0,0 +1,34 @@
+# 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.
+
+"""The eigensolver factory for excited states calculation algorithms."""
+
+from abc import ABC, abstractmethod
+from qiskit.aqua.algorithms import Eigensolver
+from qiskit.chemistry.transformations import Transformation
+
+
+class EigensolverFactory(ABC):
+    """A factory to construct a eigensolver based on a qubit operator transformation."""
+
+    @abstractmethod
+    def get_solver(self, transformation: Transformation) -> Eigensolver:
+        """Returns a eigensolver, based on the qubit operator transformation.
+
+        Args:
+            transformation: The qubit operator transformation.
+
+        Returns:
+            An eigensolver suitable to compute the excited states of the molecule transformed
+            by ``transformation``.
+        """
+        raise NotImplementedError
@@ -0,0 +1,97 @@
+# 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.
+
+"""The numpy eigensolver factory for ground+excited states calculation algorithms."""
+
+from typing import Optional, Union, List, Callable
+import numpy as np
+
+from qiskit.aqua.algorithms import Eigensolver, NumPyEigensolver
+from qiskit.chemistry.transformations import FermionicTransformation
+from qiskit.aqua.utils.validation import validate_min
+
+from .eigensolver_factory import EigensolverFactory
+
+
+class NumPyEigensolverFactory(EigensolverFactory):
+    """A factory to construct a NumPyEigensolver."""
+
+    def __init__(self,
+                 filter_criterion: Callable[[Union[List, np.ndarray], float, Optional[List[float]]],
+                                            bool] = None,
+                 k: int = 100,
+                 use_default_filter_criterion: bool = False) -> None:
+        """
+        Args:
+            filter_criterion: callable that allows to filter eigenvalues/eigenstates. The minimum
+                eigensolver is only searching over feasible states and returns an eigenstate that
+                has the smallest eigenvalue among feasible states. The callable has the signature
+                `filter(eigenstate, eigenvalue, aux_values)` and must return a boolean to indicate
+                whether to consider this value or not. If there is no
+                feasible element, the result can even be empty.
+            k: How many eigenvalues are to be computed, has a min. value of 1.
+            use_default_filter_criterion: whether to use the transformation's default filter
+                criterion if ``filter_criterion`` is ``None``.
+        """
+        self._filter_criterion = filter_criterion
+        self._k = k  # pylint:disable=invalid-name
+        self._use_default_filter_criterion = use_default_filter_criterion
+
+    @property
+    def filter_criterion(self) -> Callable[[Union[List, np.ndarray], float, Optional[List[float]]],
+                                           bool]:
+        """ returns filter criterion """
+        return self._filter_criterion
+
+    @filter_criterion.setter
+    def filter_criterion(self, value: Callable[[Union[List, np.ndarray], float,
+                                                Optional[List[float]]], bool]) -> None:
+        """ sets filter criterion """
+        self._filter_criterion = value
+
+    @property
+    def k(self) -> int:
+        """ returns k (number of eigenvalues requested) """
+        return self._k
+
+    @k.setter
+    def k(self, k: int) -> None:
+        """ set k (number of eigenvalues requested) """
+        validate_min('k', k, 1)
+        self._k = k
+
+    @property
+    def use_default_filter_criterion(self) -> bool:
+        """ returns whether to use the default filter criterion """
+        return self._use_default_filter_criterion
+
+    @use_default_filter_criterion.setter
+    def use_default_filter_criterion(self, value: bool) -> None:
+        """ sets whether to use the default filter criterion """
+        self._use_default_filter_criterion = value
+
+    def get_solver(self, transformation: FermionicTransformation) -> Eigensolver:
+        """Returns a NumPyEigensolver with the desired filter
+
+        Args:
+            transformation: a fermionic qubit operator transformation.
+
+        Returns:
+            A NumPyEigensolver suitable to compute the ground state of the molecule
+            transformed by ``transformation``.
+        """
+        filter_criterion = self._filter_criterion
+        if not filter_criterion and self._use_default_filter_criterion:
+            filter_criterion = transformation.get_default_filter_criterion()
+
+        npe = NumPyEigensolver(filter_criterion=filter_criterion, k=self.k)
+        return npe
@@ -0,0 +1,115 @@
+# 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.
+
+"""The calculation of excited states via an Eigensolver algorithm"""
+
+import logging
+
+from typing import List, Union, Optional, Any
+
+from qiskit.aqua.algorithms import Eigensolver
+from qiskit.aqua.operators import WeightedPauliOperator
+from qiskit.chemistry import FermionicOperator
+from qiskit.chemistry.drivers import BaseDriver
+from qiskit.chemistry.results import EigenstateResult
+from qiskit.chemistry.transformations import Transformation
+from qiskit.chemistry.results import ElectronicStructureResult, VibronicStructureResult
+
+from .excited_states_solver import ExcitedStatesSolver
+from .eigensolver_factories import EigensolverFactory
+
+logger = logging.getLogger(__name__)
+
+
+class ExcitedStatesEigensolver(ExcitedStatesSolver):
+    """The calculation of excited states via an Eigensolver algorithm"""
+
+    def __init__(self, transformation: Transformation,
+                 solver: Union[Eigensolver, EigensolverFactory]) -> None:
+        """
+
+        Args:
+            transformation: Qubit Operator Transformation
+            solver: Minimum Eigensolver or MESFactory object.
+        """
+        self._transformation = transformation
+        self._solver = solver
+
+    @property
+    def solver(self) -> Union[Eigensolver, EigensolverFactory]:
+        """Returns the minimum eigensolver or factory."""
+        return self._solver
+
+    @solver.setter
+    def solver(self, solver: Union[Eigensolver, EigensolverFactory]) -> None:
+        """Sets the minimum eigensolver or factory."""
+        self._solver = solver
+
+    @property
+    def transformation(self) -> Transformation:
+        """Returns the transformation used to obtain a qubit operator from the molecule."""
+        return self._transformation
+
+    @transformation.setter
+    def transformation(self, transformation: Transformation) -> None:
+        """Sets the transformation used to obtain a qubit operator from the molecule."""
+        self._transformation = transformation
+
+    def solve(self, driver: BaseDriver,
+              aux_operators: Optional[List[Any]] = None
+              ) -> Union[ElectronicStructureResult, VibronicStructureResult]:
+        """Compute Ground and Excited States properties.
+
+        Args:
+            driver: a chemistry driver object which defines the chemical problem that is to be
+                    solved by this calculation.
+            aux_operators: Additional auxiliary operators to evaluate. Must be of type
+                ``FermionicOperator`` if the qubit transformation is fermionic and of type
+                ``BosonicOperator`` it is bosonic.
+
+        Raises:
+            NotImplementedError: If an operator in ``aux_operators`` is not of type
+                ``FermionicOperator``.
+
+        Returns:
+            An eigenstate result. Depending on the transformation this can be an electronic
+            structure or bosonic result.
+        """
+        if aux_operators is not None:
+            if any(not isinstance(op, (WeightedPauliOperator, FermionicOperator))
+                   for op in aux_operators):
+                raise NotImplementedError('Currently only fermionic problems are supported.')
+
+        # get the operator and auxiliary operators, and transform the provided auxiliary operators
+        # note that ``aux_operators`` contains not only the transformed ``aux_operators`` passed
+        # by the user but also additional ones from the transformation
+        operator, aux_operators = self.transformation.transform(driver, aux_operators)
+
+        if isinstance(self._solver, EigensolverFactory):
+            # this must be called after transformation.transform
+            solver = self._solver.get_solver(self.transformation)
+        else:
+            solver = self._solver
+
+        # if the eigensolver does not support auxiliary operators, reset them
+        if not solver.supports_aux_operators():
+            aux_operators = None
+
+        raw_es_result = solver.compute_eigenvalues(operator, aux_operators)
+
+        eigenstate_result = EigenstateResult()
+        eigenstate_result.raw_result = raw_es_result
+        eigenstate_result.eigenenergies = raw_es_result.eigenvalues
+        eigenstate_result.eigenstates = raw_es_result.eigenstates
+        eigenstate_result.aux_operator_eigenvalues = raw_es_result.aux_operator_eigenvalues
+        result = self.transformation.interpret(eigenstate_result)
+        return result
@@ -0,0 +1,41 @@
+# 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.
+
+""" The excited states calculation interface """
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, Union
+
+from qiskit.chemistry.drivers import BaseDriver
+from qiskit.chemistry import FermionicOperator, BosonicOperator
+from qiskit.chemistry.results import ElectronicStructureResult, VibronicStructureResult
+
+
+class ExcitedStatesSolver(ABC):
+    """The excited states calculation interface"""
+
+    @abstractmethod
+    def solve(self, driver: BaseDriver,
+              aux_operators: Optional[Union[List[FermionicOperator],
+                                            List[BosonicOperator]]] = None
+              ) -> Union[ElectronicStructureResult, VibronicStructureResult]:
+        """Compute the excited states energies of the molecule that was supplied via the driver.
+        Args:
+            driver: a chemistry driver object which defines the chemical problem that is to be
+                    solved by this calculation.
+            aux_operators: Additional auxiliary operators to evaluate. Must be of type
+                ``FermionicOperator`` if the qubit transformation is fermionic and of type
+                ``BosonicOperator`` it is bosonic.
+        Returns:
+            an eigenstate result
+        """
+        raise NotImplementedError()